@bendyline/squisq 1.5.2 → 2.0.1

package/dist/chunk-TFJVXUHH.js

@@ -0,0 +1,2358 @@
+import {
+  SHAPE_NAMES,
+  TEMPLATE_ALIASES,
+  buildNarrationScript,
+  deriveTemplateInputs,
+  flattenBlocks,
+  flattenRenderableBlocks,
+  getBlockBodyText,
+  getPinnedBlockMeta,
+  isDataFence,
+  isShapeName,
+  lintTemplateParams,
+  markdownToDoc,
+  nearestName,
+  normalizeShapeKind,
+  parseDataFence,
+  parseNarrationTimingJson,
+  parseStandaloneAnnotation,
+  readCustomThemesFromFrontmatter,
+  resolveTemplateName,
+  templateRegistry,
+  writeCustomTemplatesToFrontmatter,
+  writeCustomThemesToFrontmatter
+} from "./chunk-X6DUONGT.js";
+import {
+  ASCII_TREE_VOCAB,
+  ASCII_VOCAB,
+  UNICODE_TREE_VOCAB,
+  UNICODE_VOCAB,
+  arrowDirection,
+  detectAsciiDiagram,
+  isHoriz,
+  isJunction,
+  isVert,
+  toGrid,
+  traceBoxes
+} from "./chunk-5UYI3RJB.js";
+import {
+  resolveMediaSchedule
+} from "./chunk-FVJUUTEM.js";
+import {
+  FRONTMATTER_CUSTOM_TEMPLATES_KEY,
+  FRONTMATTER_CUSTOM_THEMES_KEY,
+  hexHueDegrees,
+  resolveTheme
+} from "./chunk-W4O2TX5I.js";
+import {
+  parseMarkdown
+} from "./chunk-66QO7XFB.js";
+import {
+  KNOWN_BLOCK_META_KEYS,
+  coerceAnnotationValues,
+  serializeAnnotation
+} from "./chunk-R2YZTCLO.js";
+import {
+  extractPlainText,
+  getChildren,
+  readFrontmatterThemeId
+} from "./chunk-AMIR72JP.js";
+import {
+  estimateTimeFromText
+} from "./chunk-3E5F2XMR.js";
+
+// src/doc/utils/animationUtils.ts
+function getAnimationStyle(animation, _currentTime = 0) {
+  if (!animation || animation.type === "none") {
+    return { className: "", style: {} };
+  }
+  const className = getAnimationClassName(animation);
+  const style = getAnimationCSSVars(animation);
+  return { className, style };
+}
+function getAnimationClassName(animation) {
+  const { type, direction, panDirection } = animation;
+  switch (type) {
+    case "fadeIn":
+      return "anim-fadeIn";
+    case "fadeOut":
+      return "anim-fadeOut";
+    case "slowZoom":
+      if (panDirection === "left") return "anim-slowZoom-panLeft";
+      if (panDirection === "right") return "anim-slowZoom-panRight";
+      if (direction === "out") return "anim-slowZoom-out";
+      return "anim-slowZoom-in";
+    case "zoomIn":
+      return "anim-zoomIn";
+    case "zoomOut":
+      return "anim-zoomOut";
+    case "panLeft":
+      return "anim-panLeft";
+    case "panRight":
+      return "anim-panRight";
+    case "typewriter":
+      return "anim-typewriter";
+    default:
+      return "";
+  }
+}
+function getAnimationCSSVars(animation) {
+  const vars = {};
+  if (animation.duration !== void 0) {
+    vars["--anim-duration"] = `${animation.duration}s`;
+  }
+  if (animation.delay !== void 0) {
+    vars["--anim-delay"] = `${animation.delay}s`;
+  }
+  if (animation.easing) {
+    vars["--anim-easing"] = animation.easing;
+  }
+  return vars;
+}
+function getDefaultAnimationDuration(type) {
+  switch (type) {
+    case "slowZoom":
+    case "panLeft":
+    case "panRight":
+      return 8;
+    // Long, slow animations
+    case "typewriter":
+      return 3;
+    case "fadeIn":
+    case "fadeOut":
+      return 1;
+    case "zoomIn":
+    case "zoomOut":
+      return 0.5;
+    default:
+      return 1;
+  }
+}
+function getTransitionClass(type, entering, direction) {
+  if (type === "cut") return "";
+  const mode = entering ? "enter" : "exit";
+  return `transition-${getTransitionVisualClass(type, direction)}-${mode}`;
+}
+var TRANSITION_VISUAL_CLASS_BY_TYPE = {
+  airplane: "airplane",
+  blinds: "blindsHorizontal",
+  box: "box",
+  checker: "checkerboard",
+  checkerboard: "checkerboard",
+  circle: "shapeCircle",
+  clock: "clock",
+  comb: "combHorizontal",
+  conveyor: "conveyor",
+  cover: "coverLeft",
+  crush: "crush",
+  cube: "cube",
+  curtains: "curtains",
+  cut: "cut",
+  diamond: "shapeDiamond",
+  dissolve: "dissolve",
+  doors: "doors",
+  drape: "drape",
+  fade: "fade",
+  fallOver: "fallOver",
+  ferris: "ferrisWheel",
+  ferrisWheel: "ferrisWheel",
+  flash: "flash",
+  flip: "flip",
+  flyThrough: "flyThrough",
+  flythrough: "flyThrough",
+  fracture: "fracture",
+  gallery: "gallery",
+  glitter: "glitter",
+  honeycomb: "honeycomb",
+  morph: "morph",
+  newsflash: "newsflash",
+  orbit: "orbit",
+  origami: "origami",
+  pageCurl: "pageCurl",
+  pageCurlDouble: "pageCurlDouble",
+  pageCurlSingle: "pageCurlSingle",
+  pan: "panLeft",
+  peelOff: "peelOff",
+  plus: "shapePlus",
+  prestige: "prestige",
+  prism: "prism",
+  pull: "pullLeft",
+  push: "pushLeft",
+  random: "random",
+  randomBar: "randomBarsHorizontal",
+  randomBars: "randomBarsVertical",
+  reveal: "revealLeft",
+  ripple: "ripple",
+  rotate: "rotate",
+  shape: "shapeCircle",
+  shred: "shred",
+  slideDown: "slideDown",
+  slideLeft: "slideLeft",
+  slideRight: "slideRight",
+  slideUp: "slideUp",
+  split: "splitHorizontal",
+  strips: "stripsLeft",
+  switch: "switch",
+  uncover: "uncoverLeft",
+  vortex: "vortex",
+  warp: "warp",
+  wedge: "wedge",
+  wheel: "wheel",
+  wheelReverse: "wheelReverse",
+  wind: "wind",
+  window: "window",
+  wipe: "wipeLeft",
+  zoom: "zoom"
+};
+function getTransitionVisualClass(type, direction) {
+  switch (type) {
+    case "randomBars":
+    case "randomBar":
+      return axisClass("randomBars", direction, type === "randomBar" ? "Horizontal" : "Vertical");
+    case "comb":
+      return axisClass("comb", direction, "Horizontal");
+    case "blinds":
+      return axisClass("blinds", direction, "Horizontal");
+    case "split":
+      return axisClass("split", direction, "Horizontal");
+    case "push":
+      return directionalClass("push", direction, "Left");
+    case "wipe":
+      return directionalClass("wipe", direction, "Left");
+    case "cover":
+      return directionalClass("cover", direction, "Left");
+    case "uncover":
+      return directionalClass("uncover", direction, "Left");
+    case "pull":
+      return directionalClass("pull", direction, "Left");
+    case "reveal":
+      return directionalClass("reveal", direction, "Left");
+    case "strips":
+      return directionalClass("strips", direction, "Left");
+    case "pan":
+      return directionalClass("pan", direction, "Left");
+    default:
+      return TRANSITION_VISUAL_CLASS_BY_TYPE[type];
+  }
+}
+function directionalClass(prefix, direction, fallback) {
+  const suffix = directionSuffix(direction, fallback);
+  return `${prefix}${suffix}`;
+}
+function axisClass(prefix, direction, fallback) {
+  const suffix = axisSuffix(direction, fallback);
+  return `${prefix}${suffix}`;
+}
+function directionSuffix(direction, fallback) {
+  switch (direction) {
+    case "right":
+      return "Right";
+    case "up":
+      return "Up";
+    case "down":
+      return "Down";
+    case "left":
+    default:
+      return fallback;
+  }
+}
+function axisSuffix(direction, fallback) {
+  switch (direction) {
+    case "vertical":
+    case "up":
+    case "down":
+      return "Vertical";
+    case "horizontal":
+    case "left":
+    case "right":
+      return "Horizontal";
+    default:
+      return fallback;
+  }
+}
+function getAnimationProgress(animation, currentTime, slideDuration) {
+  const delay = animation.delay || 0;
+  const duration = animation.duration || slideDuration;
+  if (currentTime < delay) return 0;
+  if (currentTime >= delay + duration) return 1;
+  return (currentTime - delay) / duration;
+}
+
+// src/doc/utils/imageTreatment.ts
+var SEPIA_HUE_DEGREES = 40;
+var clamp01 = (v) => Math.max(0, Math.min(1, v));
+var r2 = (v) => Math.round(v * 100) / 100;
+function cssFilterForTreatment(treatment, blur) {
+  const parts = [];
+  if (blur != null && blur > 0) {
+    parts.push(`blur(${Math.round(blur)}px)`);
+  }
+  if (treatment && treatment.type !== "none") {
+    const s = clamp01(treatment.strength ?? 0.6);
+    switch (treatment.type) {
+      case "mono":
+        parts.push(`grayscale(${r2(s)})`, `contrast(${r2(1 + 0.05 * s)})`);
+        break;
+      case "duotone": {
+        const hue = hexHueDegrees(treatment.color ?? "#3d5a80");
+        parts.push(
+          "grayscale(1)",
+          `sepia(${r2(Math.max(0.35, s))})`,
+          `hue-rotate(${Math.round(hue - SEPIA_HUE_DEGREES)}deg)`,
+          `saturate(${r2(1 + s)})`
+        );
+        break;
+      }
+      case "warm":
+        parts.push(`sepia(${r2(0.4 * s)})`, `saturate(${r2(1 + 0.15 * s)})`);
+        break;
+      case "cool":
+        parts.push(
+          `saturate(${r2(1 - 0.25 * s)})`,
+          `hue-rotate(${Math.round(-12 * s)}deg)`,
+          `contrast(${r2(1 + 0.06 * s)})`
+        );
+        break;
+    }
+  }
+  return parts.length > 0 ? parts.join(" ") : void 0;
+}
+
+// src/doc/docToMarkdown.ts
+var TRANSITION_PARAM_KEYS = ["transition", "transitionDuration", "transitionDirection"];
+function docToMarkdown(doc) {
+  const children = [];
+  const blockIds = new Set(flattenBlocks(doc.blocks).map((b) => b.id));
+  const docMediaByBlock = /* @__PURE__ */ new Map();
+  const homelessDocMedia = [];
+  for (const clip of doc.documentMedia ?? []) {
+    if (clip.origin && blockIds.has(clip.origin.blockId)) {
+      const list = docMediaByBlock.get(clip.origin.blockId) ?? [];
+      list.push(clip);
+      docMediaByBlock.set(clip.origin.blockId, list);
+    } else {
+      homelessDocMedia.push(clip);
+    }
+  }
+  for (const clip of homelessDocMedia) {
+    children.push(synthesizeMediaParagraph(clip));
+  }
+  function emitBlock(block) {
+    if (block.sourceHeading) {
+      const heading = ensureAnnotation(block, block.sourceHeading);
+      children.push(heading);
+    } else if (block.standaloneAnnotation) {
+      children.push(synthesizeAnnotationParagraph(block));
+    }
+    const clips = [...block.media ?? [], ...docMediaByBlock.get(block.id) ?? []];
+    if (clips.length > 0) {
+      const contents = [...block.contents ?? []];
+      const anchored = clips.filter((clip) => clip.origin).sort((a, b) => a.origin.index - b.origin.index);
+      for (const clip of anchored) {
+        contents.splice(
+          Math.min(clip.origin.index, contents.length),
+          0,
+          synthesizeMediaParagraph(clip)
+        );
+      }
+      for (const clip of clips.filter((c) => !c.origin).reverse()) {
+        contents.unshift(synthesizeMediaParagraph(clip));
+      }
+      children.push(...contents);
+    } else if (block.contents) {
+      children.push(...block.contents);
+    }
+    if (block.children) {
+      for (const child of block.children) {
+        emitBlock(child);
+      }
+    }
+  }
+  for (const block of doc.blocks) {
+    emitBlock(block);
+  }
+  const customPayload = writeCustomTemplatesToFrontmatter(doc.customTemplates);
+  let frontmatter = doc.frontmatter;
+  if (customPayload) {
+    frontmatter = { ...frontmatter ?? {}, [FRONTMATTER_CUSTOM_TEMPLATES_KEY]: customPayload };
+  } else if (frontmatter && FRONTMATTER_CUSTOM_TEMPLATES_KEY in frontmatter) {
+    const { [FRONTMATTER_CUSTOM_TEMPLATES_KEY]: _drop, ...rest } = frontmatter;
+    void _drop;
+    frontmatter = rest;
+  }
+  const customThemesPayload = writeCustomThemesToFrontmatter(doc.customThemes);
+  if (customThemesPayload) {
+    frontmatter = { ...frontmatter ?? {}, [FRONTMATTER_CUSTOM_THEMES_KEY]: customThemesPayload };
+  } else if (frontmatter && FRONTMATTER_CUSTOM_THEMES_KEY in frontmatter) {
+    const { [FRONTMATTER_CUSTOM_THEMES_KEY]: _dropTheme, ...rest } = frontmatter;
+    void _dropTheme;
+    frontmatter = rest;
+  }
+  return {
+    type: "document",
+    children,
+    ...frontmatter && Object.keys(frontmatter).length > 0 ? { frontmatter } : {}
+  };
+}
+function synthesizeAnnotationParagraph(block) {
+  const text = serializeAnnotation(block.sourceAnnotation?.template, block.templateOverrides);
+  return { type: "paragraph", children: [{ type: "text", value: text }] };
+}
+function synthesizeMediaParagraph(clip) {
+  if (clip.origin?.raw) {
+    return { type: "paragraph", children: [{ type: "text", value: clip.origin.raw }] };
+  }
+  const params = { src: clip.src };
+  if (clip.anchor === "document") params.anchor = "document";
+  if (clip.startAt) params.startAt = String(clip.startAt);
+  if (clip.clipStart != null) params.clipStart = String(clip.clipStart);
+  if (clip.clipEnd != null) params.clipEnd = String(clip.clipEnd);
+  if (clip.spillover) params.spillover = "true";
+  return {
+    type: "paragraph",
+    children: [{ type: "text", value: serializeAnnotation(clip.kind, params) }]
+  };
+}
+function ensureAnnotation(block, heading) {
+  const { attributes, transitionParams } = ensureTransitionMetadata(block, heading);
+  const hasExplicitTemplate = block.template && block.template !== "sectionHeader" && block.autoTemplate !== true;
+  const hasOverrides = block.templateOverrides && Object.keys(block.templateOverrides).length > 0;
+  let templateAnnotation = heading.templateAnnotation;
+  if (!templateAnnotation && (hasExplicitTemplate || hasOverrides || transitionParams)) {
+    templateAnnotation = {
+      ...hasExplicitTemplate ? { template: block.template ?? "sectionHeader" } : {},
+      ...hasOverrides ? { params: block.templateOverrides } : {}
+    };
+  }
+  if (transitionParams) {
+    templateAnnotation = {
+      ...templateAnnotation ?? {},
+      params: {
+        ...templateAnnotation?.params ?? {},
+        ...transitionParams
+      }
+    };
+  }
+  if (attributes === heading.attributes && templateAnnotation === heading.templateAnnotation) {
+    return heading;
+  }
+  return { ...heading, children: [...heading.children], attributes, templateAnnotation };
+}
+function ensureTransitionMetadata(block, heading) {
+  const transition = block.transition;
+  if (!transition) {
+    return { attributes: heading.attributes, transitionParams: void 0 };
+  }
+  const attrs = removeTransitionParams(heading.attributes) ?? {};
+  const attributes = {
+    ...attrs,
+    blockMeta: {
+      ...attrs.blockMeta ?? {},
+      transition
+    }
+  };
+  return {
+    attributes,
+    transitionParams: {
+      transition: transition.type,
+      ...transition.duration !== void 0 ? { transitionDuration: String(transition.duration) } : {},
+      ...transition.direction ? { transitionDirection: transition.direction } : {}
+    }
+  };
+}
+function removeTransitionParams(attrs) {
+  if (!attrs?.params) return attrs;
+  const params = { ...attrs.params };
+  for (const key of TRANSITION_PARAM_KEYS) delete params[key];
+  return {
+    ...attrs,
+    ...Object.keys(params).length > 0 ? { params } : { params: void 0 }
+  };
+}
+
+// src/doc/resolveDocTheme.ts
+function resolveThemeForDoc(doc, explicitId, registry) {
+  const id = explicitId ?? doc?.themeId ?? readFrontmatterThemeId(doc?.frontmatter);
+  const inline = doc?.customThemes ?? readCustomThemesFromFrontmatter(doc?.frontmatter);
+  const custom = id ? inline?.find((t) => t.id === id) : void 0;
+  if (custom) return custom;
+  return resolveTheme(id, registry);
+}
+
+// src/doc/applyNarrationTiming.ts
+var MIN_BLOCK_SIMILARITY = 0.5;
+var MIN_V1_SCRIPT_SIMILARITY = 0.8;
+var PIN_CONFLICT_TOLERANCE_SEC = 1;
+function blockSpokenText(block) {
+  const title = block.title ? block.title.trim() : "";
+  const body = getBlockBodyText(block);
+  if (title && body) return `${title}
+${body}`;
+  return title || body;
+}
+function matchSidecarBlocks(flat, timing) {
+  const ranges = /* @__PURE__ */ new Map();
+  const remainingBlocks = new Set(flat.map((b) => b.id));
+  const remainingSidecar = [];
+  const byId = new Map(flat.map((b) => [b.id, b]));
+  for (const entry of timing.blocks) {
+    if (entry.blockId && byId.has(entry.blockId) && remainingBlocks.has(entry.blockId)) {
+      ranges.set(entry.blockId, { startSec: entry.startSec, endSec: entry.endSec });
+      remainingBlocks.delete(entry.blockId);
+    } else {
+      remainingSidecar.push(entry);
+    }
+  }
+  if (remainingSidecar.length > 0 && remainingBlocks.size > 0) {
+    const candidates = [];
+    for (const entry of remainingSidecar) {
+      const slice = timing.sourceText.slice(entry.charStart, entry.charEnd);
+      for (const block of flat) {
+        if (!remainingBlocks.has(block.id)) continue;
+        const score = scoreTextSimilarity(slice, blockSpokenText(block));
+        if (score >= MIN_BLOCK_SIMILARITY) candidates.push({ score, entry, blockId: block.id });
+      }
+    }
+    candidates.sort((a, b) => b.score - a.score || a.entry.blockIndex - b.entry.blockIndex);
+    const usedEntries = /* @__PURE__ */ new Set();
+    for (const candidate of candidates) {
+      if (usedEntries.has(candidate.entry) || !remainingBlocks.has(candidate.blockId)) continue;
+      ranges.set(candidate.blockId, {
+        startSec: candidate.entry.startSec,
+        endSec: candidate.entry.endSec
+      });
+      usedEntries.add(candidate.entry);
+      remainingBlocks.delete(candidate.blockId);
+    }
+    const leftoverEntries = remainingSidecar.filter((e) => !usedEntries.has(e));
+    if (leftoverEntries.length > 0 && leftoverEntries.length === remainingBlocks.size) {
+      const leftoverBlocks = flat.filter((b) => remainingBlocks.has(b.id));
+      leftoverEntries.sort((a, b) => a.blockIndex - b.blockIndex);
+      leftoverBlocks.forEach((block, i) => {
+        const entry = leftoverEntries[i];
+        ranges.set(block.id, { startSec: entry.startSec, endSec: entry.endSec });
+      });
+    }
+  }
+  return ranges;
+}
+function proportionalRanges(doc, timing) {
+  const script = buildNarrationScript(doc);
+  if (script.blocks.length === 0) return null;
+  if (scoreTextSimilarity(script.sourceText, timing.sourceText) < MIN_V1_SCRIPT_SIMILARITY) {
+    return null;
+  }
+  const ranges = /* @__PURE__ */ new Map();
+  const starts = script.blocks.map(
+    (range) => estimateTimeFromText(script.sourceText, range.charStart, timing.duration)
+  );
+  script.blocks.forEach((range, i) => {
+    ranges.set(range.blockId, {
+      startSec: starts[i],
+      endSec: i + 1 < starts.length ? starts[i + 1] : timing.duration
+    });
+  });
+  return ranges;
+}
+function retimeBlocks(blocks, ctx) {
+  return blocks.map((block) => {
+    const range = ctx.ranges.get(block.id);
+    const pinned = getPinnedBlockMeta(block);
+    const next = { ...block };
+    if (range && pinned.duration == null && pinned.startTime == null) {
+      next.startTime = ctx.clipStart + range.startSec;
+      next.duration = Math.max(0, range.endSec - range.startSec);
+      ctx.cursor = Math.max(ctx.cursor, next.startTime + next.duration);
+    } else if (range) {
+      const pinnedStart = pinned.startTime ?? block.startTime;
+      const pinnedDuration = pinned.duration ?? block.duration;
+      const narrStart = ctx.clipStart + range.startSec;
+      const narrDuration = Math.max(0, range.endSec - range.startSec);
+      if (Math.abs(pinnedStart - narrStart) > PIN_CONFLICT_TOLERANCE_SEC || Math.abs(pinnedDuration - narrDuration) > PIN_CONFLICT_TOLERANCE_SEC) {
+        ctx.diagnostics.push({
+          severity: "info",
+          code: "narration-pin-conflict",
+          message: `Block timing is pinned (duration=/startTime=) but the recorded narration says ~${narrDuration.toFixed(1)}s starting at ~${narrStart.toFixed(1)}s. The pin wins; remove it to follow the narration.`,
+          blockId: block.id
+        });
+      }
+      ctx.cursor = Math.max(ctx.cursor, pinnedStart + pinnedDuration);
+    } else {
+      next.startTime = ctx.cursor;
+      ctx.cursor += next.duration;
+    }
+    if (block.children && block.children.length > 0) {
+      next.children = retimeBlocks(block.children, ctx);
+    }
+    return next;
+  });
+}
+async function applyNarrationTiming(doc, container) {
+  const clips = (doc.documentMedia ?? []).filter((c) => c.anchor === "document");
+  for (const clip of clips) {
+    if (!clip.src) continue;
+    const sidecarData = await container.readFile(`${clip.src}.timing.json`);
+    if (!sidecarData) continue;
+    const timing = parseNarrationTimingJson(sidecarData);
+    if (!timing) continue;
+    const flat = flattenRenderableBlocks(doc.blocks);
+    const ranges = timing.blocks.length > 0 ? matchSidecarBlocks(flat, timing) : proportionalRanges(doc, timing);
+    if (!ranges || ranges.size === 0) continue;
+    const ctx = {
+      clipStart: clip.startAt,
+      ranges,
+      diagnostics: [],
+      cursor: 0
+    };
+    const blocks = retimeBlocks(doc.blocks, ctx);
+    const duration = Math.max(clip.startAt + timing.duration, ctx.cursor);
+    const retimed = {
+      ...doc,
+      blocks,
+      duration,
+      ...ctx.diagnostics.length > 0 ? { diagnostics: [...doc.diagnostics ?? [], ...ctx.diagnostics] } : {}
+    };
+    return { doc: retimed, applied: true, clipSrc: clip.src };
+  }
+  return { doc, applied: false };
+}
+
+// src/doc/audioMapping.ts
+function parseTimingJson(data) {
+  try {
+    const text = new TextDecoder().decode(data);
+    const parsed = JSON.parse(text);
+    if (parsed && typeof parsed.sourceText === "string" && typeof parsed.duration === "number") {
+      return {
+        sourceText: parsed.sourceText,
+        bookmarks: Array.isArray(parsed.bookmarks) ? parsed.bookmarks : [],
+        duration: parsed.duration
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function normalizeToWords(text) {
+  const words = text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 2);
+  return new Set(words);
+}
+function scoreTextSimilarity(a, b) {
+  const wordsA = normalizeToWords(a);
+  const wordsB = normalizeToWords(b);
+  if (wordsA.size === 0 || wordsB.size === 0) return 0;
+  let intersection = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w)) intersection++;
+  }
+  const union = (/* @__PURE__ */ new Set([...wordsA, ...wordsB])).size;
+  return union > 0 ? intersection / union : 0;
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function blockToPlainText(block) {
+  const parts = [];
+  if (block.title) parts.push(block.title);
+  if (block.contents) {
+    for (const node of block.contents) {
+      parts.push(extractPlainText(node));
+    }
+  }
+  return parts.join("\n");
+}
+function flattenForAudio(blocks) {
+  const result = [];
+  for (const block of blocks) {
+    if (block.children && block.children.length > 0) {
+      result.push(...flattenForAudio(block.children));
+    } else {
+      result.push(block);
+    }
+  }
+  return result;
+}
+var AUDIO_ONLY_EXTENSIONS = [".mp3", ".wav", ".ogg", ".m4a"];
+var AMBIGUOUS_EXTENSIONS = [".webm", ".mp4"];
+function isNarrationAudioPath(path) {
+  const lower = path.toLowerCase();
+  if (AUDIO_ONLY_EXTENSIONS.some((ext) => lower.endsWith(ext))) return true;
+  if (AMBIGUOUS_EXTENSIONS.some((ext) => lower.endsWith(ext))) {
+    return lower.startsWith("audio/");
+  }
+  return false;
+}
+function stripAudioExtension(filename) {
+  const lower = filename.toLowerCase();
+  for (const ext of [...AUDIO_ONLY_EXTENSIONS, ...AMBIGUOUS_EXTENSIONS]) {
+    if (lower.endsWith(ext)) return filename.slice(0, -ext.length);
+  }
+  return filename;
+}
+function parseConsolidatedTiming(data) {
+  try {
+    const text = new TextDecoder().decode(data);
+    const parsed = JSON.parse(text);
+    if (parsed && parsed.version === 2 && parsed.sections) {
+      return parsed.sections;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function discoverNarrationAudio(container) {
+  const files = await container.listFiles();
+  const audioFiles = files.filter((f) => isNarrationAudioPath(f.path));
+  const results = [];
+  let consolidatedSections = null;
+  const consolidatedData = await container.readFile("timing.json");
+  if (consolidatedData) {
+    consolidatedSections = parseConsolidatedTiming(consolidatedData);
+  }
+  for (const file of audioFiles) {
+    const filename = file.path.split("/").pop() ?? file.path;
+    let timing = null;
+    if (consolidatedSections) {
+      const audioBase = stripAudioExtension(filename);
+      for (const [sectionName, sectionTiming] of Object.entries(consolidatedSections)) {
+        if (audioBase.endsWith(`-${sectionName}`)) {
+          timing = sectionTiming;
+          break;
+        }
+      }
+    }
+    if (!timing) {
+      const timingPath = `${file.path}.timing.json`;
+      const timingData = await container.readFile(timingPath);
+      if (timingData) {
+        timing = parseTimingJson(timingData);
+      }
+    }
+    results.push({ path: file.path, filename, timing });
+  }
+  return results;
+}
+function resolveFromAnnotations(blocks, audioFiles) {
+  const matches = [];
+  const flat = flattenForAudio(blocks);
+  for (const block of flat) {
+    const audioRef = block.templateOverrides?.audio;
+    if (!audioRef) continue;
+    const audio = audioFiles.find(
+      (m) => m.filename === audioRef || m.path === audioRef || m.path.endsWith(`/${audioRef}`)
+    );
+    if (audio) {
+      matches.push({ block, audio });
+    }
+  }
+  return matches;
+}
+var MIN_CONTENT_SIMILARITY = 0.35;
+var MIN_FILENAME_SIMILARITY = 0.5;
+function autoMatchBlocks(blocks, audioFiles) {
+  const flat = flattenForAudio(blocks);
+  if (flat.length === 0 || audioFiles.length === 0) return [];
+  const scoredPairs = [];
+  for (let audioIndex = 0; audioIndex < audioFiles.length; audioIndex++) {
+    const audio = audioFiles[audioIndex];
+    for (let bi = 0; bi < flat.length; bi++) {
+      const block = flat[bi];
+      const blockText = blockToPlainText(block);
+      if (!blockText.trim()) continue;
+      let score = 0;
+      if (audio.timing?.sourceText) {
+        score = scoreTextSimilarity(audio.timing.sourceText, blockText);
+      }
+      if (score < MIN_CONTENT_SIMILARITY && block.title) {
+        const titleSlug = slugify(block.title);
+        const fileSlug = slugify(stripAudioExtension(audio.filename));
+        if (fileSlug.includes(titleSlug) && titleSlug.length >= 3) {
+          score = Math.max(score, MIN_FILENAME_SIMILARITY + 0.1);
+        }
+      }
+      if (score >= MIN_CONTENT_SIMILARITY) {
+        scoredPairs.push({ block, blockIndex: bi, audio, audioIndex, score });
+      }
+    }
+  }
+  scoredPairs.sort((a, b) => b.score - a.score);
+  const usedBlocks = /* @__PURE__ */ new Set();
+  const usedAudio = /* @__PURE__ */ new Set();
+  const matches = [];
+  for (const pair of scoredPairs) {
+    if (usedBlocks.has(pair.blockIndex) || usedAudio.has(pair.audioIndex)) continue;
+    usedBlocks.add(pair.blockIndex);
+    usedAudio.add(pair.audioIndex);
+    matches.push({ block: pair.block, audio: pair.audio, score: pair.score });
+  }
+  return matches;
+}
+async function resolveAudioMapping(doc, container) {
+  const narration = await applyNarrationTiming(doc, container);
+  doc = narration.doc;
+  const audioFiles = await discoverNarrationAudio(container);
+  const scheduledSrcs = new Set(resolveMediaSchedule(doc).map((clip) => clip.src));
+  const available = audioFiles.filter((f) => !scheduledSrcs.has(f.path));
+  if (available.length === 0) return doc;
+  let matches = resolveFromAnnotations(doc.blocks, available);
+  if (matches.length === 0 && !narration.applied) {
+    matches = autoMatchBlocks(doc.blocks, available).map((m) => ({
+      block: m.block,
+      audio: m.audio
+    }));
+  }
+  if (matches.length === 0) return doc;
+  const flat = flattenForAudio(doc.blocks);
+  const blockOrder = new Map(flat.map((b, i) => [b.id, i]));
+  matches.sort((a, b) => (blockOrder.get(a.block.id) ?? 0) - (blockOrder.get(b.block.id) ?? 0));
+  const segments = [];
+  const blockToSegment = /* @__PURE__ */ new Map();
+  let startTime = 0;
+  for (let i = 0; i < matches.length; i++) {
+    const { block, audio } = matches[i];
+    const duration = audio.timing?.duration ?? 30;
+    segments.push({
+      src: audio.path,
+      name: block.title ?? block.id,
+      duration,
+      startTime
+    });
+    blockToSegment.set(block.id, i);
+    startTime += duration;
+  }
+  const newBlocks = assignSegmentIndices(doc.blocks, blockToSegment);
+  return {
+    ...doc,
+    blocks: newBlocks,
+    // A narration take owns the overall duration; explicit per-block
+    // segments only ever extend it.
+    duration: narration.applied ? Math.max(doc.duration, startTime) : startTime,
+    audio: { segments }
+  };
+}
+function assignSegmentIndices(blocks, blockToSegment, inheritedSegment) {
+  return blocks.map((block) => {
+    const segment = blockToSegment.get(block.id) ?? inheritedSegment ?? block.audioSegment;
+    const newBlock = {
+      ...block,
+      audioSegment: segment
+    };
+    if (block.children) {
+      newBlock.children = assignSegmentIndices(block.children, blockToSegment, segment);
+    }
+    return newBlock;
+  });
+}
+
+// src/doc/validate.ts
+function validateMarkdownSource(source, options) {
+  return validateMarkdownDoc(parseMarkdown(source), options);
+}
+function validateMarkdownDoc(markdownDoc, options) {
+  const doc = markdownToDoc(markdownDoc);
+  const diagnostics = [...doc.diagnostics ?? []];
+  const blocks = flattenBlocks(doc.blocks);
+  const knownTemplates = collectKnownTemplates(doc, options);
+  const customNames = new Set(doc.customTemplates?.map((t) => t.name) ?? []);
+  const visit = (block, parent) => {
+    checkTemplate(block, parent, knownTemplates, diagnostics);
+    checkAttributeCoercion(block, parent, diagnostics);
+    checkConflictingAnnotationKeys(block, diagnostics);
+    checkTemplateInputs(block, parent, customNames, diagnostics);
+    checkPossibleDataFences(block, diagnostics);
+    if (isDrawingBlock(block)) checkDrawingConnectors(block, diagnostics);
+    for (const child of block.children ?? []) visit(child, block);
+  };
+  for (const block of doc.blocks) visit(block, void 0);
+  checkUnrecognizedAnnotations(markdownDoc, diagnostics);
+  if (options?.assets) {
+    const hasAsset = normalizeAssetCheck(options.assets);
+    checkAssets(markdownDoc, blocks, hasAsset, diagnostics);
+  }
+  diagnostics.sort(
+    (a, b) => (a.line ?? Number.MAX_SAFE_INTEGER) - (b.line ?? Number.MAX_SAFE_INTEGER)
+  );
+  return {
+    diagnostics,
+    errorCount: diagnostics.filter((d) => d.severity === "error").length,
+    warningCount: diagnostics.filter((d) => d.severity === "warning").length,
+    infoCount: diagnostics.filter((d) => d.severity === "info").length,
+    doc
+  };
+}
+function collectKnownTemplates(doc, options) {
+  return /* @__PURE__ */ new Set([
+    ...Object.keys(templateRegistry),
+    ...Object.keys(TEMPLATE_ALIASES),
+    ...doc.customTemplates?.map((t) => t.name) ?? [],
+    ...options?.extraTemplates ?? []
+  ]);
+}
+function isDrawingBlock(block) {
+  return resolveTemplateName(block.template ?? "") === "drawing";
+}
+function checkTemplate(block, parent, known, diagnostics) {
+  const requested = block.sourceHeading?.templateAnnotation?.template ?? block.sourceAnnotation?.template;
+  if (!requested) return;
+  if (parent && isDrawingBlock(parent)) {
+    if (isShapeName(requested)) return;
+    const suggestion2 = nearestName(requested, new Set(SHAPE_NAMES), {
+      map: resolveTemplateName
+    });
+    diagnostics.push({
+      severity: "warning",
+      code: "unknown-shape",
+      message: `Unknown shape "${requested}" in drawing \u2014 the child will be skipped` + (suggestion2 ? `. Did you mean "${suggestion2}"?` : ""),
+      blockId: block.id,
+      ...lineOf(block)
+    });
+    return;
+  }
+  if (isShapeName(requested)) {
+    diagnostics.push({
+      severity: "warning",
+      code: "shape-outside-drawing",
+      message: `Shape "${requested}" is only recognized on a child heading of a {[drawing]} block`,
+      blockId: block.id,
+      ...lineOf(block)
+    });
+    return;
+  }
+  if (known.has(requested) || known.has(resolveTemplateName(requested))) return;
+  const suggestion = nearestName(requested, known, { map: resolveTemplateName });
+  diagnostics.push({
+    severity: "warning",
+    code: "unknown-template",
+    message: `Unknown template "${requested}" \u2014 the block will render as a plain fallback card` + (suggestion ? `. Did you mean "${suggestion}"?` : ""),
+    blockId: block.id,
+    ...lineOf(block)
+  });
+}
+function checkTemplateInputs(block, parent, customNames, diagnostics) {
+  const requested = block.sourceHeading?.templateAnnotation?.template;
+  if (!requested) return;
+  if (parent && isDrawingBlock(parent)) return;
+  if (isShapeName(requested)) return;
+  const canonical = resolveTemplateName(requested);
+  if (customNames.has(requested) || customNames.has(canonical)) return;
+  const params = block.sourceHeading?.templateAnnotation?.params ?? {};
+  for (const finding of lintTemplateParams(canonical, params)) {
+    if (finding.kind === "missing-input" && isInputSatisfiable(canonical, block, finding.key)) {
+      continue;
+    }
+    diagnostics.push({
+      severity: "warning",
+      code: finding.kind,
+      message: `Block "${block.id}": ${finding.message}`,
+      blockId: block.id,
+      ...lineOf(block)
+    });
+  }
+}
+function isInputSatisfiable(canonical, block, key) {
+  if (block.templateData && key in block.templateData) return true;
+  if (block[key] != null) return true;
+  const derived = deriveTemplateInputs(canonical, block.title ?? "", block.contents);
+  return derived != null && key in derived;
+}
+var NUMERIC_SHAPE_KEYS = ["x", "y", "width", "height", "w", "h", "strokeWidth", "borderRadius"];
+function checkAttributeCoercion(block, parent, diagnostics) {
+  const params = block.sourceHeading?.attributes?.params;
+  if (params) {
+    const { warnings } = coerceAnnotationValues(params);
+    for (const warning of warnings) {
+      diagnostics.push({
+        severity: "warning",
+        code: "invalid-attribute",
+        message: `Block "${block.id}": ${warning}`,
+        blockId: block.id,
+        ...lineOf(block)
+      });
+    }
+  }
+  if (parent && isDrawingBlock(parent) && isShapeName(block.template)) {
+    const overrides = block.templateOverrides ?? {};
+    for (const key of NUMERIC_SHAPE_KEYS) {
+      const raw = overrides[key];
+      if (raw == null) continue;
+      const value = raw.replace(/,\s*$/, "").trim();
+      if (value !== "" && !Number.isFinite(Number(value))) {
+        diagnostics.push({
+          severity: "warning",
+          code: "invalid-attribute",
+          message: `Drawing shape "${block.id}": "${key}" is not a number (${JSON.stringify(raw)})`,
+          blockId: block.id,
+          ...lineOf(block)
+        });
+      }
+    }
+  }
+}
+function checkConflictingAnnotationKeys(block, diagnostics) {
+  const annotationParams = block.sourceHeading?.templateAnnotation?.params;
+  const pandocParams = block.sourceHeading?.attributes?.params;
+  if (!annotationParams || !pandocParams) return;
+  for (const key of Object.keys(KNOWN_BLOCK_META_KEYS)) {
+    const fromAnnotation = annotationParams[key];
+    const fromPandoc = pandocParams[key];
+    if (fromAnnotation == null || fromPandoc == null || fromAnnotation === fromPandoc) continue;
+    diagnostics.push({
+      severity: "info",
+      code: "conflicting-annotation-key",
+      message: `"${key}" is set in both {[\u2026]} (${fromAnnotation}) and {\u2026} (${fromPandoc}) \u2014 the {\u2026} value wins.`,
+      blockId: block.id,
+      ...lineOf(block)
+    });
+  }
+}
+function checkDrawingConnectors(block, diagnostics) {
+  const children = block.children ?? [];
+  const ids = new Set(children.map((c) => c.id));
+  for (const child of children) {
+    const kind = normalizeShapeKind(child.sourceHeading?.templateAnnotation?.template);
+    if (kind !== "line" && kind !== "arrow") continue;
+    const overrides = child.templateOverrides ?? {};
+    for (const key of ["from", "to"]) {
+      const raw = overrides[key];
+      if (raw == null) continue;
+      const ref = raw.replace(/,\s*$/, "").trim();
+      if (ref && !ids.has(ref)) {
+        diagnostics.push({
+          severity: "warning",
+          code: "unresolved-connection",
+          message: `Drawing connector "${child.id}" references unknown ${key} "${ref}"`,
+          blockId: child.id,
+          ...lineOf(child)
+        });
+      }
+    }
+  }
+}
+function checkPossibleDataFences(block, diagnostics) {
+  const annotated = !!(block.sourceHeading?.templateAnnotation?.template || block.sourceAnnotation?.template);
+  if (!annotated) return;
+  for (const node of block.contents ?? []) {
+    if (node.type !== "code") continue;
+    const lang = node.lang?.toLowerCase();
+    if (lang !== "json" && lang !== "yaml" && lang !== "yml") continue;
+    if (isDataFence(node)) continue;
+    const result = parseDataFence(node);
+    if (!result.data || Object.keys(result.data).length === 0) continue;
+    diagnostics.push({
+      severity: "info",
+      code: "possible-data-fence",
+      message: `This ${lang} block renders as code \u2014 add "data" to the fence (\`\`\`${lang} data) if it's meant as template input.`,
+      blockId: block.id,
+      ...node.position ? { line: node.position.start.line } : lineOf(block)
+    });
+  }
+}
+var ANNOTATION_LIKE_RE = /\{\[/;
+function checkUnrecognizedAnnotations(markdownDoc, diagnostics) {
+  const walk = (node, headingLine, topLevel) => {
+    if (node.type === "heading") {
+      const heading = node;
+      const text = extractPlainText(heading);
+      if (ANNOTATION_LIKE_RE.test(text)) {
+        diagnostics.push({
+          severity: "warning",
+          code: "unparsed-annotation",
+          message: `Heading "${truncate(text)}" contains "{[\u2026]}" text that was not recognized \u2014 check the quoting, or whether the token is a known inline icon`,
+          ...heading.position ? { line: heading.position.start.line } : {}
+        });
+      }
+      return;
+    }
+    if (node.type === "paragraph" && topLevel) {
+      const parsed = parseStandaloneAnnotation(node);
+      if (parsed && parsed.template != null) return;
+    }
+    if (node.type === "text" && ANNOTATION_LIKE_RE.test(node.value)) {
+      diagnostics.push({
+        severity: "warning",
+        code: "unparsed-annotation",
+        message: `Body text contains "{[\u2026]}" \u2014 template annotations are recognized on headings and as standalone paragraphs (or the token is not a known inline icon)`,
+        ...node.position ? { line: node.position.start.line } : headingLine != null ? { line: headingLine } : {}
+      });
+      return;
+    }
+    if (node.type === "code") return;
+    for (const child of getChildren(node)) {
+      walk(child, headingLine, false);
+    }
+  };
+  for (const child of markdownDoc.children) {
+    walk(child, child.position?.start.line, true);
+  }
+}
+function normalizeAssetCheck(assets) {
+  if (typeof assets === "function") return assets;
+  return (path) => assets.has(path) || assets.has(path.replace(/^\.\//, ""));
+}
+var URL_SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
+function isBundleRelative(url) {
+  return url.length > 0 && !URL_SCHEME_RE.test(url) && !url.startsWith("//") && !url.startsWith("#");
+}
+var ASSET_PARAM_KEYS = ["src", "imageSrc", "videoSrc", "poster", "backgroundImage"];
+function checkAssets(markdownDoc, blocks, hasAsset, diagnostics) {
+  const report = (url, line, blockId) => {
+    if (!isBundleRelative(url) || hasAsset(url)) return;
+    diagnostics.push({
+      severity: "warning",
+      code: "missing-asset",
+      message: `Referenced asset "${url}" was not found in the bundle`,
+      ...blockId ? { blockId } : {},
+      ...line != null ? { line } : {}
+    });
+  };
+  const walk = (node) => {
+    if (node.type === "image") {
+      report(node.url, node.position?.start.line);
+    }
+    if (node.type === "htmlBlock" || node.type === "htmlInline") {
+      walkHtmlImages(node.htmlChildren, (src) => report(src, node.position?.start.line));
+    }
+    for (const child of getChildren(node)) walk(child);
+  };
+  for (const child of markdownDoc.children) walk(child);
+  for (const block of blocks) {
+    const sources = [
+      block.templateOverrides,
+      block.templateData
+    ];
+    for (const source of sources) {
+      if (!source) continue;
+      for (const key of ASSET_PARAM_KEYS) {
+        const value = source[key];
+        if (typeof value === "string") {
+          report(value, block.sourceHeading?.position?.start.line, block.id);
+        }
+      }
+      const images = source["images"];
+      const list = typeof images === "string" ? images.split(",").map((s) => s.trim()) : Array.isArray(images) ? images.filter((i) => typeof i === "string") : [];
+      for (const img of list) {
+        report(img, block.sourceHeading?.position?.start.line, block.id);
+      }
+    }
+  }
+}
+function walkHtmlImages(nodes, report) {
+  for (const node of nodes) {
+    if (node.type !== "htmlElement") continue;
+    if (node.tagName === "img" && node.attributes.src) {
+      report(node.attributes.src);
+    }
+    walkHtmlImages(node.children, report);
+  }
+}
+function lineOf(block) {
+  const line = block.sourceHeading?.position?.start.line;
+  return line != null ? { line } : {};
+}
+function truncate(text, max = 40) {
+  return text.length <= max ? text : `${text.slice(0, max)}\u2026`;
+}
+
+// src/doc/asciiDiagram/render.ts
+var SIDE_MARGIN = 1;
+function renderAsciiDiagram(diagram, options = {}) {
+  const vocab = (options.style ?? diagram.style) === "ascii" ? ASCII_VOCAB : UNICODE_VOCAB;
+  if (diagram.nodes.length === 0) return "";
+  const placed = layoutNodes(diagram.nodes, diagram.edges);
+  const canvas = new Canvas();
+  const drawOrder = [...placed.values()].sort(
+    (a, b) => a.depth - b.depth || a.rect.r0 - b.rect.r0 || a.rect.c0 - b.rect.c0
+  );
+  for (const p of drawOrder) drawBox(canvas, p, vocab);
+  drawEdges(canvas, diagram.edges, placed, vocab);
+  return canvas.emit();
+}
+function computeSideDegrees(nodes, edges) {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const deg = /* @__PURE__ */ new Map();
+  for (const n of nodes) deg.set(n.id, { top: 0, bottom: 0, left: 0, right: 0 });
+  const rectOf = (n) => ({
+    r0: n.row,
+    c0: n.col,
+    r1: n.row + n.hRows - 1,
+    c1: n.col + n.wCols - 1
+  });
+  for (const e of edges) {
+    const s = byId.get(e.source);
+    const t = byId.get(e.target);
+    if (!s || !t || s === t) continue;
+    const { exit, enter } = pickSides(rectOf(s), rectOf(t));
+    deg.get(e.source)[exit]++;
+    deg.get(e.target)[enter]++;
+  }
+  return deg;
+}
+function layoutNodes(nodes, edges) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const node of nodes) byId.set(node.id, node);
+  const sideDeg = computeSideDegrees(nodes, edges);
+  const childIds = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const node of nodes) {
+    if (node.containerId && byId.has(node.containerId) && node.containerId !== node.id) {
+      const list = childIds.get(node.containerId) ?? [];
+      list.push(node.id);
+      childIds.set(node.containerId, list);
+    } else {
+      roots.push(node.id);
+    }
+  }
+  const placed = /* @__PURE__ */ new Map();
+  const translateSubtree = (id, dRows, dCols) => {
+    const p = placed.get(id);
+    if (p) p.rect = shiftRect(p.rect, dRows, dCols);
+    for (const childId of childIds.get(id) ?? []) translateSubtree(childId, dRows, dCols);
+  };
+  const placeSiblings = (ids, layoutUnit) => {
+    const order = [...ids].sort((a, b) => {
+      const na = byId.get(a);
+      const nb = byId.get(b);
+      return na.row - nb.row || na.col - nb.col || na.id.localeCompare(nb.id);
+    });
+    const placedRects = [];
+    for (const id of order) {
+      let rect = layoutUnit(id);
+      let guard = 0;
+      for (; ; ) {
+        const hit = placedRects.find((p) => overlapsWithMargin(rect, p, SIDE_MARGIN));
+        if (!hit || guard++ > 64) break;
+        const dxRight = hit.c1 + SIDE_MARGIN + 1 - rect.c0;
+        const dyDown = hit.r1 + SIDE_MARGIN + 1 - rect.r0;
+        if (dxRight < dyDown) {
+          translateSubtree(id, 0, dxRight);
+          rect = shiftRect(rect, 0, dxRight);
+        } else {
+          translateSubtree(id, dyDown, 0);
+          rect = shiftRect(rect, dyDown, 0);
+        }
+      }
+      placedRects.push(rect);
+    }
+    return placedRects;
+  };
+  const layoutSubtree = (id, depth) => {
+    const node = byId.get(id);
+    const labelLines = node.label.length > 0 ? node.label.split("\n") : [];
+    const children = childIds.get(id) ?? [];
+    if (children.length === 0) {
+      const innerW = labelLines.reduce((w, l) => Math.max(w, l.length), 0);
+      const deg = sideDeg.get(id) ?? { top: 0, bottom: 0, left: 0, right: 0 };
+      const horizDeg = Math.max(deg.top, deg.bottom);
+      const vertDeg = Math.max(deg.left, deg.right);
+      const wCols = Math.max(node.wCols, innerW + 4, 3, horizDeg > 0 ? 2 * horizDeg + 1 : 0);
+      const hRows = Math.max(
+        node.hRows,
+        labelLines.length + 2,
+        3,
+        vertDeg > 0 ? 2 * vertDeg + 1 : 0
+      );
+      const rect2 = {
+        r0: node.row,
+        c0: node.col,
+        r1: node.row + hRows - 1,
+        c1: node.col + wCols - 1
+      };
+      placed.set(id, { node, rect: rect2, labelLines, isContainer: false, depth });
+      return rect2;
+    }
+    const childRects = placeSiblings(children, (childId) => layoutSubtree(childId, depth + 1));
+    const bbox = unionRects(childRects);
+    const extraRows = Math.max(0, labelLines.length - 1);
+    const titleLen = (labelLines[0] ?? "").length;
+    const rect = {
+      r0: bbox.r0 - 2 - extraRows,
+      c0: bbox.c0 - 2,
+      r1: bbox.r1 + 2,
+      c1: bbox.c1 + 2
+    };
+    const minW = titleLen > 0 ? titleLen + 6 : 3;
+    if (rect.c1 - rect.c0 + 1 < minW) rect.c1 = rect.c0 + minW - 1;
+    if (rect.c1 - rect.c0 + 1 < node.wCols) rect.c1 = rect.c0 + node.wCols - 1;
+    placed.set(id, { node, rect, labelLines, isContainer: true, depth });
+    return rect;
+  };
+  placeSiblings(roots, (id) => layoutSubtree(id, 0));
+  let minR = Infinity;
+  let minC = Infinity;
+  for (const p of placed.values()) {
+    minR = Math.min(minR, p.rect.r0);
+    minC = Math.min(minC, p.rect.c0);
+  }
+  const dR = minR < 0 ? -minR : 0;
+  const dC = minC < 0 ? -minC : 0;
+  if (dR > 0 || dC > 0) {
+    for (const p of placed.values()) p.rect = shiftRect(p.rect, dR, dC);
+  }
+  return placed;
+}
+function overlapsWithMargin(a, b, margin) {
+  return a.r0 - margin <= b.r1 && b.r0 - margin <= a.r1 && a.c0 - margin <= b.c1 && b.c0 - margin <= a.c1;
+}
+function shiftRect(rect, dRows, dCols) {
+  return { r0: rect.r0 + dRows, c0: rect.c0 + dCols, r1: rect.r1 + dRows, c1: rect.c1 + dCols };
+}
+function unionRects(rects) {
+  return rects.reduce((acc, r) => ({
+    r0: Math.min(acc.r0, r.r0),
+    c0: Math.min(acc.c0, r.c0),
+    r1: Math.max(acc.r1, r.r1),
+    c1: Math.max(acc.c1, r.c1)
+  }));
+}
+var Canvas = class {
+  constructor() {
+    this.rows = [];
+    this.kinds = [];
+  }
+  ensure(r, c) {
+    while (this.rows.length <= r) {
+      this.rows.push([]);
+      this.kinds.push([]);
+    }
+    const row = this.rows[r];
+    const kindRow = this.kinds[r];
+    while (row.length <= c) {
+      row.push(" ");
+      kindRow.push("empty");
+    }
+  }
+  kindAt(r, c) {
+    return this.kinds[r]?.[c] ?? "empty";
+  }
+  /** Unconditional write (boxes, labels, junction upgrades). */
+  set(r, c, ch, kind) {
+    if (r < 0 || c < 0) return;
+    this.ensure(r, c);
+    this.rows[r][c] = ch;
+    this.kinds[r][c] = kind;
+  }
+  /** Edge-aware write: respects borders, upgrades crossings, lets arrows win. */
+  drawEdgeCell(r, c, ch, kind, vocab) {
+    if (r < 0 || c < 0) return;
+    this.ensure(r, c);
+    const existing = this.kinds[r][c];
+    if (existing === "border" || existing === "label" || existing === "junction") return;
+    if (kind === "arrow") {
+      this.rows[r][c] = ch;
+      this.kinds[r][c] = kind;
+      return;
+    }
+    if (existing === "arrow") return;
+    if (existing === "line-h" && kind === "line-v" || existing === "line-v" && kind === "line-h") {
+      this.rows[r][c] = vocab.cross;
+      this.kinds[r][c] = "turn";
+      return;
+    }
+    if (existing === "empty") {
+      this.rows[r][c] = ch;
+      this.kinds[r][c] = kind;
+    }
+  }
+  emit() {
+    const lines = this.rows.map((row) => row.join("").replace(/\s+$/u, ""));
+    while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+    return lines.join("\n");
+  }
+};
+function drawBox(canvas, p, vocab) {
+  const { rect, labelLines, isContainer } = p;
+  const innerW = rect.c1 - rect.c0 - 1;
+  canvas.set(rect.r0, rect.c0, vocab.tl, "border");
+  canvas.set(rect.r0, rect.c1, vocab.tr, "border");
+  const title = isContainer && labelLines.length > 0 ? ` ${labelLines[0]} ` : null;
+  if (title && title.length <= innerW - 2) {
+    const left = Math.floor((innerW - title.length) / 2);
+    for (let i = 0; i < innerW; i++) {
+      const inTitle = i >= left && i < left + title.length;
+      const ch = inTitle ? title[i - left] : vocab.h;
+      canvas.set(rect.r0, rect.c0 + 1 + i, ch, inTitle ? "label" : "border");
+    }
+  } else {
+    for (let c = rect.c0 + 1; c <= rect.c1 - 1; c++) canvas.set(rect.r0, c, vocab.h, "border");
+  }
+  canvas.set(rect.r1, rect.c0, vocab.bl, "border");
+  canvas.set(rect.r1, rect.c1, vocab.br, "border");
+  for (let c = rect.c0 + 1; c <= rect.c1 - 1; c++) canvas.set(rect.r1, c, vocab.h, "border");
+  for (let r = rect.r0 + 1; r <= rect.r1 - 1; r++) {
+    canvas.set(r, rect.c0, vocab.v, "border");
+    canvas.set(r, rect.c1, vocab.v, "border");
+  }
+  const interiorLines = isContainer ? labelLines.slice(1) : labelLines;
+  if (interiorLines.length > 0) {
+    const innerH = rect.r1 - rect.r0 - 1;
+    const startRow = isContainer ? rect.r0 + 1 : rect.r0 + 1 + Math.max(0, Math.floor((innerH - interiorLines.length) / 2));
+    interiorLines.forEach((line, i) => {
+      const pad = Math.max(0, Math.floor((innerW - line.length) / 2));
+      for (let j = 0; j < line.length && pad + j < innerW; j++) {
+        canvas.set(startRow + i, rect.c0 + 1 + pad + j, line[j], "label");
+      }
+    });
+  }
+}
+function drawEdges(canvas, edges, placed, vocab) {
+  const sorted = [...edges].sort(
+    (a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target) || (a.label ?? "").localeCompare(b.label ?? "")
+  );
+  const skip = /* @__PURE__ */ new Set();
+  const plans = [];
+  for (let i = 0; i < sorted.length; i++) {
+    if (skip.has(i)) continue;
+    const e = sorted[i];
+    if (!placed.has(e.source) || !placed.has(e.target)) continue;
+    let biDir = false;
+    if (e.directed) {
+      const j = sorted.findIndex(
+        (o, k) => k > i && !skip.has(k) && o.directed && o.source === e.target && o.target === e.source && (o.label ?? "") === (e.label ?? "")
+      );
+      if (j >= 0) {
+        skip.add(j);
+        biDir = true;
+      }
+    }
+    const sides = pickSides(
+      placed.get(e.source).rect,
+      placed.get(e.target).rect
+    );
+    plans.push({
+      edge: e,
+      sourceId: e.source,
+      targetId: e.target,
+      exitSide: sides.exit,
+      enterSide: sides.enter,
+      biDir
+    });
+  }
+  const attachment = assignAttachments(plans, placed);
+  const sideLabelRequests = [];
+  plans.forEach(
+    (plan, i) => routeEdge(
+      canvas,
+      plan,
+      i,
+      placed,
+      attachment,
+      vocab,
+      (candidates, label) => sideLabelRequests.push({ candidates, label })
+    )
+  );
+  for (const req of sideLabelRequests) {
+    let done = false;
+    for (const side of ["right", "left"]) {
+      if (done) break;
+      for (const { row, col } of req.candidates) {
+        if (canvas.kindAt(row, col) !== "line-v") continue;
+        const startCol = side === "right" ? col + 2 : col - 1 - req.label.length;
+        if (startCol < 0) continue;
+        const gapCol = side === "right" ? col + 1 : col - 1;
+        let free = canvas.kindAt(row, gapCol) === "empty";
+        for (let i = 0; free && i < req.label.length; i++) {
+          if (canvas.kindAt(row, startCol + i) !== "empty") free = false;
+        }
+        if (free && side === "left" && startCol > 0) {
+          free = canvas.kindAt(row, startCol - 1) === "empty";
+        }
+        if (!free) continue;
+        for (let i = 0; i < req.label.length; i++) {
+          canvas.set(row, startCol + i, req.label[i], "label");
+        }
+        done = true;
+        break;
+      }
+    }
+  }
+}
+function pickSides(s, t) {
+  if (t.r0 > s.r1) return { exit: "bottom", enter: "top" };
+  if (t.r1 < s.r0) return { exit: "top", enter: "bottom" };
+  if (t.c0 > s.c1) return { exit: "right", enter: "left" };
+  if (t.c1 < s.c0) return { exit: "left", enter: "right" };
+  const gaps = [
+    { side: "top", gap: Math.abs(s.r0 - t.r0) },
+    { side: "bottom", gap: Math.abs(t.r1 - s.r1) },
+    { side: "left", gap: Math.abs(s.c0 - t.c0) },
+    { side: "right", gap: Math.abs(t.c1 - s.c1) }
+  ];
+  gaps.sort((a, b) => a.gap - b.gap);
+  return { exit: gaps[0].side, enter: gaps[0].side };
+}
+function assignAttachments(plans, placed) {
+  const bySide = /* @__PURE__ */ new Map();
+  plans.forEach((plan, i) => {
+    const exitKey = `${plan.sourceId}|${plan.exitSide}`;
+    const enterKey = `${plan.targetId}|${plan.enterSide}`;
+    bySide.set(exitKey, [
+      ...bySide.get(exitKey) ?? [],
+      { key: `${i}:exit`, otherId: plan.targetId }
+    ]);
+    bySide.set(enterKey, [
+      ...bySide.get(enterKey) ?? [],
+      { key: `${i}:enter`, otherId: plan.sourceId }
+    ]);
+  });
+  const result = /* @__PURE__ */ new Map();
+  for (const [sideKey, list] of [...bySide.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+    const [nodeId, side] = sideKey.split("|");
+    const node = placed.get(nodeId);
+    list.sort((a, b) => {
+      const ra = placed.get(a.otherId).rect;
+      const rb = placed.get(b.otherId).rect;
+      return ra.r0 - rb.r0 || ra.c0 - rb.c0 || a.otherId.localeCompare(b.otherId);
+    });
+    const horizontal = side === "top" || side === "bottom";
+    const from = horizontal ? node.rect.c0 + 1 : node.rect.r0 + 1;
+    const to = horizontal ? node.rect.c1 - 1 : node.rect.r1 - 1;
+    const inner = Math.max(1, to - from + 1);
+    const k = list.length;
+    if (k === 1) {
+      result.set(list[0].key, { pos: from + Math.floor((inner - 1) / 2), index: 0, count: 1 });
+    } else {
+      const span = 2 * k - 1;
+      const start = from + Math.max(0, Math.floor((inner - span) / 2));
+      list.forEach((req, i) => {
+        result.set(req.key, { pos: Math.min(to, start + 2 * i), index: i, count: k });
+      });
+    }
+  }
+  return result;
+}
+function routeEdge(canvas, plan, planIdx, placed, attachment, vocab, deferSideLabel) {
+  const s = placed.get(plan.sourceId).rect;
+  const t = placed.get(plan.targetId).rect;
+  const exitSlot = attachment.get(`${planIdx}:exit`);
+  const enterSlot = attachment.get(`${planIdx}:enter`);
+  const exitPos = exitSlot.pos;
+  const enterPos = enterSlot.pos;
+  const basis = enterSlot.count > exitSlot.count ? enterSlot : exitSlot;
+  const stagger = basis.index - Math.floor((basis.count - 1) / 2);
+  const junction = (r, c, side) => {
+    const ch = side === "top" ? vocab.stemUp : side === "bottom" ? vocab.stemDown : side === "left" ? vocab.stemLeft : vocab.stemRight;
+    canvas.set(r, c, ch, "junction");
+  };
+  const args = {
+    canvas,
+    directed: plan.edge.directed,
+    biDir: plan.biDir,
+    label: plan.edge.label,
+    vocab,
+    junction,
+    stagger,
+    deferSideLabel
+  };
+  if (plan.exitSide === "bottom" && plan.enterSide === "top") {
+    drawVertical(args, s, t, exitPos, enterPos, 1);
+  } else if (plan.exitSide === "top" && plan.enterSide === "bottom") {
+    drawVertical(args, s, t, exitPos, enterPos, -1);
+  } else if (plan.exitSide === "right" && plan.enterSide === "left") {
+    drawHorizontal(args, s, t, exitPos, enterPos, 1);
+  } else if (plan.exitSide === "left" && plan.enterSide === "right") {
+    drawHorizontal(args, s, t, exitPos, enterPos, -1);
+  } else {
+    drawNested(args, s, t, plan.exitSide);
+  }
+}
+function middleOut(from, to) {
+  const lo = Math.min(from, to);
+  const hi = Math.max(from, to);
+  const rows = [];
+  for (let r = lo; r <= hi; r++) rows.push(r);
+  const mid = Math.floor((lo + hi) / 2);
+  return rows.sort((a, b) => Math.abs(a - mid) - Math.abs(b - mid) || a - b);
+}
+function clamp(value, lo, hi) {
+  return Math.max(lo, Math.min(hi, value));
+}
+function drawVertical(args, s, t, exitCol, enterCol, dir) {
+  const { canvas, directed, biDir, label, vocab, junction, stagger } = args;
+  const exitRow = dir === 1 ? s.r1 : s.r0;
+  const enterRow = dir === 1 ? t.r0 : t.r1;
+  const firstFree = exitRow + dir;
+  const lastFree = enterRow - dir;
+  const gap = (lastFree - firstFree) * dir + 1;
+  const drawV = (col, rA, rB) => {
+    const lo = Math.min(rA, rB);
+    const hi = Math.max(rA, rB);
+    for (let r = lo; r <= hi; r++) canvas.drawEdgeCell(r, col, vocab.v, "line-v", vocab);
+  };
+  const straightOk = exitCol >= t.c0 + 1 && exitCol <= t.c1 - 1 && exitCol >= s.c0 + 1 && exitCol <= s.c1 - 1;
+  if (straightOk || gap < 2) {
+    const sCol = clamp(exitCol, s.c0 + 1, s.c1 - 1);
+    const tCol = clamp(exitCol, t.c0 + 1, t.c1 - 1);
+    junction(exitRow, sCol, dir === 1 ? "bottom" : "top");
+    junction(enterRow, tCol, dir === 1 ? "top" : "bottom");
+    if (sCol === tCol && gap >= 1) {
+      drawV(sCol, firstFree, lastFree);
+      if (directed) {
+        canvas.drawEdgeCell(
+          lastFree,
+          sCol,
+          dir === 1 ? vocab.arrowDown : vocab.arrowUp,
+          "arrow",
+          vocab
+        );
+      }
+      if (biDir && gap >= 2) {
+        canvas.drawEdgeCell(
+          firstFree,
+          sCol,
+          dir === 1 ? vocab.arrowUp : vocab.arrowDown,
+          "arrow",
+          vocab
+        );
+      }
+      if (label) {
+        args.deferSideLabel(
+          middleOut(firstFree, lastFree).map((row) => ({ row, col: sCol })),
+          label
+        );
+      }
+    }
+    return;
+  }
+  const midRow = clamp(
+    Math.floor((exitRow + enterRow) / 2) + stagger,
+    Math.min(firstFree, lastFree),
+    Math.max(firstFree, lastFree)
+  );
+  junction(exitRow, exitCol, dir === 1 ? "bottom" : "top");
+  junction(enterRow, enterCol, dir === 1 ? "top" : "bottom");
+  if (Math.abs(midRow - exitRow) >= 2) drawV(exitCol, firstFree, midRow - dir);
+  if (Math.abs(enterRow - midRow) >= 2) drawV(enterCol, midRow + dir, lastFree);
+  let labelEmbedded = false;
+  if (exitCol === enterCol) {
+    canvas.drawEdgeCell(midRow, exitCol, vocab.v, "line-v", vocab);
+  } else {
+    const goingRight = enterCol > exitCol;
+    const exitTurn = dir === 1 ? goingRight ? vocab.turnUpRight : vocab.turnUpLeft : goingRight ? vocab.turnDownRight : vocab.turnDownLeft;
+    const enterTurn = dir === 1 ? goingRight ? vocab.turnDownLeft : vocab.turnDownRight : goingRight ? vocab.turnUpLeft : vocab.turnUpRight;
+    canvas.drawEdgeCell(midRow, exitCol, exitTurn, "turn", vocab);
+    canvas.drawEdgeCell(midRow, enterCol, enterTurn, "turn", vocab);
+    const lo = Math.min(exitCol, enterCol);
+    const hi = Math.max(exitCol, enterCol);
+    let segment = [];
+    for (let c = lo + 1; c <= hi - 1; c++) segment.push(vocab.h);
+    if (label && segment.length >= label.length + 4) {
+      const text = ` ${label} `;
+      const left = Math.floor((segment.length - text.length) / 2);
+      segment = segment.map((ch, i) => i >= left && i < left + text.length ? text[i - left] : ch);
+      labelEmbedded = true;
+    }
+    segment.forEach((ch, i) => {
+      canvas.drawEdgeCell(midRow, lo + 1 + i, ch, ch === vocab.h ? "line-h" : "label", vocab);
+    });
+  }
+  if (directed) {
+    canvas.drawEdgeCell(
+      lastFree,
+      enterCol,
+      dir === 1 ? vocab.arrowDown : vocab.arrowUp,
+      "arrow",
+      vocab
+    );
+  }
+  if (biDir) {
+    canvas.drawEdgeCell(
+      firstFree,
+      exitCol,
+      dir === 1 ? vocab.arrowUp : vocab.arrowDown,
+      "arrow",
+      vocab
+    );
+  }
+  if (label && !labelEmbedded) {
+    const candidates = [];
+    if (exitCol === enterCol) {
+      for (const row of middleOut(firstFree, lastFree)) candidates.push({ row, col: exitCol });
+    } else {
+      const exitLegLen = (midRow - dir - firstFree) * dir + 1;
+      const enterLegLen = (lastFree - (midRow + dir)) * dir + 1;
+      if (exitLegLen >= 1) {
+        for (const row of middleOut(firstFree, midRow - dir)) {
+          candidates.push({ row, col: exitCol });
+        }
+      }
+      if (enterLegLen >= 1) {
+        for (const row of middleOut(midRow + dir, lastFree)) {
+          candidates.push({ row, col: enterCol });
+        }
+      }
+    }
+    if (candidates.length > 0) args.deferSideLabel(candidates, label);
+  }
+}
+function drawHorizontal(args, s, t, exitRow, enterRow, dir) {
+  const { canvas, directed, biDir, label, vocab, junction } = args;
+  const exitCol = dir === 1 ? s.c1 : s.c0;
+  const enterCol = dir === 1 ? t.c0 : t.c1;
+  const firstFree = exitCol + dir;
+  const lastFree = enterCol - dir;
+  const gap = (lastFree - firstFree) * dir + 1;
+  const drawH = (row, cA, cB, hostLabel) => {
+    const lo = Math.min(cA, cB);
+    const hi = Math.max(cA, cB);
+    let segment = [];
+    for (let c = lo; c <= hi; c++) segment.push(vocab.h);
+    if (hostLabel && label && segment.length >= label.length + 4) {
+      const text = ` ${label} `;
+      const left = Math.floor((segment.length - text.length) / 2);
+      segment = segment.map((ch, i) => i >= left && i < left + text.length ? text[i - left] : ch);
+    }
+    segment.forEach((ch, i) => {
+      canvas.drawEdgeCell(row, lo + i, ch, ch === vocab.h ? "line-h" : "label", vocab);
+    });
+  };
+  const straightOk = exitRow >= t.r0 + 1 && exitRow <= t.r1 - 1 && exitRow >= s.r0 + 1 && exitRow <= s.r1 - 1;
+  if (straightOk || gap < 2) {
+    const sRow = clamp(exitRow, s.r0 + 1, s.r1 - 1);
+    const tRow = clamp(exitRow, t.r0 + 1, t.r1 - 1);
+    junction(sRow, exitCol, dir === 1 ? "right" : "left");
+    junction(tRow, enterCol, dir === 1 ? "left" : "right");
+    if (sRow === tRow && gap >= 1) {
+      drawH(sRow, firstFree, lastFree, true);
+      if (directed) {
+        canvas.drawEdgeCell(
+          sRow,
+          lastFree,
+          dir === 1 ? vocab.arrowRight : vocab.arrowLeft,
+          "arrow",
+          vocab
+        );
+      }
+      if (biDir && gap >= 2) {
+        canvas.drawEdgeCell(
+          sRow,
+          firstFree,
+          dir === 1 ? vocab.arrowLeft : vocab.arrowRight,
+          "arrow",
+          vocab
+        );
+      }
+    }
+    return;
+  }
+  const midCol = clamp(
+    Math.floor((exitCol + enterCol) / 2) + args.stagger,
+    Math.min(firstFree, lastFree),
+    Math.max(firstFree, lastFree)
+  );
+  junction(exitRow, exitCol, dir === 1 ? "right" : "left");
+  junction(enterRow, enterCol, dir === 1 ? "left" : "right");
+  if (Math.abs(midCol - exitCol) >= 2) drawH(exitRow, firstFree, midCol - dir, true);
+  if (Math.abs(enterCol - midCol) >= 2) drawH(enterRow, midCol + dir, lastFree, false);
+  if (exitRow === enterRow) {
+    canvas.drawEdgeCell(exitRow, midCol, vocab.h, "line-h", vocab);
+  } else {
+    const goingDown = enterRow > exitRow;
+    const exitTurn = dir === 1 ? goingDown ? vocab.turnDownLeft : vocab.turnUpLeft : goingDown ? vocab.turnDownRight : vocab.turnUpRight;
+    const enterTurn = dir === 1 ? goingDown ? vocab.turnUpRight : vocab.turnDownRight : goingDown ? vocab.turnUpLeft : vocab.turnDownLeft;
+    canvas.drawEdgeCell(exitRow, midCol, exitTurn, "turn", vocab);
+    canvas.drawEdgeCell(enterRow, midCol, enterTurn, "turn", vocab);
+    const lo = Math.min(exitRow, enterRow);
+    const hi = Math.max(exitRow, enterRow);
+    for (let r = lo + 1; r <= hi - 1; r++) {
+      canvas.drawEdgeCell(r, midCol, vocab.v, "line-v", vocab);
+    }
+  }
+  if (directed) {
+    canvas.drawEdgeCell(
+      enterRow,
+      lastFree,
+      dir === 1 ? vocab.arrowRight : vocab.arrowLeft,
+      "arrow",
+      vocab
+    );
+  }
+  if (biDir) {
+    canvas.drawEdgeCell(
+      exitRow,
+      firstFree,
+      dir === 1 ? vocab.arrowLeft : vocab.arrowRight,
+      "arrow",
+      vocab
+    );
+  }
+}
+function drawNested(args, s, t, side) {
+  const { canvas, directed, vocab, junction } = args;
+  if (side === "top" || side === "bottom") {
+    const overlapLo = Math.max(s.c0 + 1, t.c0 + 1);
+    const overlapHi = Math.min(s.c1 - 1, t.c1 - 1);
+    if (overlapLo > overlapHi) return;
+    const col = Math.floor((overlapLo + overlapHi) / 2);
+    const sRow = side === "top" ? s.r0 : s.r1;
+    const tRow = side === "top" ? t.r0 : t.r1;
+    if (sRow === tRow) return;
+    junction(sRow, col, side);
+    junction(tRow, col, side);
+    const lo = Math.min(sRow, tRow);
+    const hi = Math.max(sRow, tRow);
+    for (let r = lo + 1; r <= hi - 1; r++) canvas.drawEdgeCell(r, col, vocab.v, "line-v", vocab);
+    if (directed && hi - lo >= 2) {
+      const arrowRow = tRow > sRow ? tRow - 1 : tRow + 1;
+      canvas.drawEdgeCell(
+        arrowRow,
+        col,
+        tRow > sRow ? vocab.arrowDown : vocab.arrowUp,
+        "arrow",
+        vocab
+      );
+    }
+  } else {
+    const overlapLo = Math.max(s.r0 + 1, t.r0 + 1);
+    const overlapHi = Math.min(s.r1 - 1, t.r1 - 1);
+    if (overlapLo > overlapHi) return;
+    const row = Math.floor((overlapLo + overlapHi) / 2);
+    const sCol = side === "left" ? s.c0 : s.c1;
+    const tCol = side === "left" ? t.c0 : t.c1;
+    if (sCol === tCol) return;
+    junction(row, sCol, side);
+    junction(row, tCol, side);
+    const lo = Math.min(sCol, tCol);
+    const hi = Math.max(sCol, tCol);
+    for (let c = lo + 1; c <= hi - 1; c++) canvas.drawEdgeCell(row, c, vocab.h, "line-h", vocab);
+    if (directed && hi - lo >= 2) {
+      const arrowCol = tCol > sCol ? tCol - 1 : tCol + 1;
+      canvas.drawEdgeCell(
+        row,
+        arrowCol,
+        tCol > sCol ? vocab.arrowRight : vocab.arrowLeft,
+        "arrow",
+        vocab
+      );
+    }
+  }
+}
+
+// src/doc/asciiDiagram/repair.ts
+var MIN_REPAIR_BOXES = 2;
+var MAX_EDGE_ROW_GAP = 8;
+var MAX_EDGE_COL_GAP = 12;
+var BAND_ROW_GAP = 4;
+var BAND_COL_GAP = 4;
+function isRepairableDiagram(text) {
+  if (detectAsciiDiagram(text).isDiagram) return false;
+  const grid = toGrid(text);
+  const rects = traceBoxes(grid, true);
+  return dedupeRects(rects).length >= MIN_REPAIR_BOXES;
+}
+function repairAsciiDiagram(text) {
+  const grid = toGrid(text);
+  const rects = dedupeRects(traceBoxes(grid, true));
+  if (rects.length < MIN_REPAIR_BOXES) return null;
+  const nodes = buildNodes(grid, rects);
+  const edges = recoverEdges(grid, rects, nodes);
+  const style = detectGridStyle(grid);
+  const diagram = { nodes, edges, style, warnings: ["repaired"] };
+  return { diagram, art: renderAsciiDiagram(diagram) };
+}
+function dedupeRects(rects) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const r of rects) {
+    const key = `${r.r0},${r.c0},${r.r1},${r.c1}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(r);
+  }
+  return out.sort((a, b) => a.r0 - b.r0 || a.c0 - b.c0);
+}
+function buildNodes(grid, rects) {
+  const W = grid[0]?.length ?? 0;
+  const labels = rects.map(() => []);
+  const index = new Map(rects.map((r, i) => [r, i]));
+  const bands = [];
+  for (const r of rects) {
+    let band = bands.find((bd) => bd.some((x) => x.r0 <= r.r1 && r.r0 <= x.r1));
+    if (!band) {
+      band = [];
+      bands.push(band);
+    }
+    band.push(r);
+  }
+  for (const band of bands) {
+    band.sort((a, b) => a.c0 - b.c0);
+    const minR = Math.min(...band.map((b) => b.r0 + 1));
+    const maxR = Math.max(...band.map((b) => b.r1 - 1));
+    for (let r = minR; r <= maxR; r++) {
+      const inRow = band.filter((b) => r > b.r0 && r < b.r1);
+      if (inRow.length === 0) continue;
+      const rowText = grid[r].join("");
+      const segs = rowText.split(/[│┃║]/).map(cleanLabelText).filter((s) => s.length > 0);
+      if (segs.length === inRow.length) {
+        inRow.forEach((b, i) => {
+          const idx = index.get(b);
+          if (idx !== void 0 && segs[i]) labels[idx].push(segs[i]);
+        });
+      } else {
+        for (const b of inRow) {
+          const idx = index.get(b);
+          if (idx === void 0) continue;
+          const t = cleanLabelText(grid[r].slice(b.c0 + 1, Math.min(b.c1, W)).join(""));
+          if (t) labels[idx].push(t);
+        }
+      }
+    }
+  }
+  const bandRow = /* @__PURE__ */ new Map();
+  const orderedBands = [...bands].sort(
+    (a, b) => Math.min(...a.map((x) => x.r0)) - Math.min(...b.map((x) => x.r0))
+  );
+  let rowCursor = 0;
+  for (const band of orderedBands) {
+    bandRow.set(band, rowCursor);
+    const bandHeight = Math.max(...band.map((b) => b.r1 - b.r0 + 1));
+    rowCursor += bandHeight + BAND_ROW_GAP;
+  }
+  const rectBand = /* @__PURE__ */ new Map();
+  for (const band of bands) for (const r of band) rectBand.set(r, band);
+  const fittedW = rects.map(
+    (rect, i) => Math.max(rect.c1 - rect.c0 + 1, ...labels[i].map((l) => l.length + 4), 3)
+  );
+  const rectIndex = new Map(rects.map((r, i) => [r, i]));
+  const bandCol = /* @__PURE__ */ new Map();
+  for (const band of bands) {
+    const ordered = [...band].sort((a, b) => a.c0 - b.c0);
+    let colCursor = Math.min(...band.map((b) => b.c0));
+    for (const r of ordered) {
+      bandCol.set(r, colCursor);
+      colCursor += (fittedW[rectIndex.get(r) ?? 0] ?? 3) + BAND_COL_GAP;
+    }
+  }
+  const parentIdx = rects.map((_, i) => smallestContainer(rects, i));
+  const usedIds = /* @__PURE__ */ new Map();
+  const nodes = rects.map((rect, i) => {
+    let id = slugify2(labels[i][0] ?? "");
+    const n = usedIds.get(id) ?? 0;
+    usedIds.set(id, n + 1);
+    if (n > 0) id = `${id}-${n + 1}`;
+    const band = rectBand.get(rect);
+    const nested = parentIdx[i] >= 0;
+    const row = band && !nested ? bandRow.get(band) ?? rect.r0 : rect.r0;
+    const col = !nested ? bandCol.get(rect) ?? rect.c0 : rect.c0;
+    return {
+      id,
+      label: labels[i].join("\n"),
+      col,
+      row,
+      wCols: rect.c1 - rect.c0 + 1,
+      hRows: rect.r1 - rect.r0 + 1
+    };
+  });
+  nodes.forEach((node, i) => {
+    if (parentIdx[i] >= 0) node.containerId = nodes[parentIdx[i]].id;
+  });
+  return nodes;
+}
+function cleanLabelText(seg) {
+  let out = "";
+  for (const ch of seg) {
+    const code = ch.codePointAt(0) ?? 0;
+    const box = code >= 9472 && code <= 9599;
+    if (box || arrowDirection(ch) !== null) out += " ";
+    else out += ch;
+  }
+  return out.replace(/\s+/g, " ").trim();
+}
+function smallestContainer(rects, i) {
+  const child = rects[i];
+  let best = -1;
+  let bestArea = Infinity;
+  for (let j = 0; j < rects.length; j++) {
+    if (j === i) continue;
+    const p = rects[j];
+    if (p.r0 < child.r0 && p.c0 < child.c0 && p.r1 > child.r1 && p.c1 > child.c1) {
+      const a = (p.r1 - p.r0) * (p.c1 - p.c0);
+      if (a < bestArea) {
+        bestArea = a;
+        best = j;
+      }
+    }
+  }
+  return best;
+}
+function slugify2(s) {
+  const slug2 = s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug2 || "node";
+}
+function recoverEdges(grid, rects, nodes) {
+  const H = grid.length;
+  const W = grid[0]?.length ?? 0;
+  const at = (r, c) => r >= 0 && r < H && c >= 0 && c < W ? grid[r][c] : " ";
+  const isConnector = (ch) => isVert(ch) || isHoriz(ch) || isJunction(ch) || arrowDirection(ch) !== null;
+  const colOverlap = (a, b) => Math.max(a.c0, b.c0) <= Math.min(a.c1, b.c1);
+  const rowOverlap = (a, b) => Math.max(a.r0, b.r0) <= Math.min(a.r1, b.r1);
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (s, t, directed) => {
+    if (s === t) return;
+    const key = `${nodes[s].id}|${nodes[t].id}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    edges.push({ source: nodes[s].id, target: nodes[t].id, directed });
+  };
+  for (let i = 0; i < rects.length; i++) {
+    for (let j = 0; j < rects.length; j++) {
+      if (i === j) continue;
+      const A = rects[i];
+      const B = rects[j];
+      if (A.r1 < B.r0 && B.r0 - A.r1 <= MAX_EDGE_ROW_GAP && colOverlap(A, B)) {
+        const lo = Math.max(A.c0, B.c0);
+        const hi = Math.min(A.c1, B.c1);
+        if (gapHasConnector(at, A.r1 + 1, B.r0 - 1, lo - 1, hi + 1, isConnector) && !boxBetweenVert(rects, i, j, lo, hi)) {
+          const directed = gapHasArrow(at, A.r1 + 1, B.r0, lo - 1, hi + 1, "down");
+          push(i, j, directed);
+        }
+      }
+      if (A.c1 < B.c0 && B.c0 - A.c1 <= MAX_EDGE_COL_GAP && rowOverlap(A, B) && i < j) {
+        const lo = Math.max(A.r0, B.r0);
+        const hi = Math.min(A.r1, B.r1);
+        const rightArrow = gapHasArrow(at, lo - 1, hi + 1, A.c1 + 1, B.c0, "right");
+        const leftArrow = gapHasArrow(at, lo - 1, hi + 1, A.c1 + 1, B.c0, "left");
+        if ((rightArrow || leftArrow) && !boxBetweenHoriz(rects, i, j, lo, hi)) {
+          if (leftArrow && !rightArrow) push(j, i, true);
+          else push(i, j, true);
+        }
+      }
+    }
+  }
+  return edges;
+}
+function gapHasConnector(at, r0, r1, c0, c1, isConnector) {
+  for (let r = r0; r <= r1; r++)
+    for (let c = c0; c <= c1; c++) if (isConnector(at(r, c))) return true;
+  return false;
+}
+function gapHasArrow(at, r0, r1, c0, c1, dir) {
+  for (let r = r0; r <= r1; r++) {
+    for (let c = c0; c <= c1; c++) {
+      if (arrowDirection(at(r, c)) === dir) return true;
+    }
+  }
+  return false;
+}
+function boxBetweenVert(rects, i, j, lo, hi) {
+  const A = rects[i];
+  const B = rects[j];
+  return rects.some((k, ki) => {
+    if (ki === i || ki === j) return false;
+    return k.r0 > A.r1 && k.r1 < B.r0 && Math.max(k.c0, lo) <= Math.min(k.c1, hi);
+  });
+}
+function boxBetweenHoriz(rects, i, j, lo, hi) {
+  const A = rects[i];
+  const B = rects[j];
+  return rects.some((k, ki) => {
+    if (ki === i || ki === j) return false;
+    return k.c0 > A.c1 && k.c1 < B.c0 && Math.max(k.r0, lo) <= Math.min(k.r1, hi);
+  });
+}
+function detectGridStyle(grid) {
+  let unicode = 0;
+  let ascii = 0;
+  for (const row of grid) {
+    for (const ch of row) {
+      const code = ch.codePointAt(0) ?? 0;
+      if (code >= 9472 && code <= 9599) unicode++;
+      else if (ch === "+" || ch === "|" || ch === "-") ascii++;
+    }
+  }
+  return ascii > unicode ? "ascii" : "unicode";
+}
+
+// src/doc/asciiTimeline/render.ts
+var UNICODE_VOCAB2 = {
+  rail: "\u2500",
+  arrow: "\u25BA",
+  marker: {
+    filled: "\u25CF",
+    hollow: "\u25CB",
+    diamond: "\u25C6"
+  }
+};
+var ASCII_VOCAB2 = {
+  rail: "-",
+  arrow: ">",
+  marker: {
+    filled: "*",
+    hollow: "o",
+    // The parser's ASCII vocabulary has no distinct diamond point. Folding
+    // it to `*` is the canonical ASCII representation and is byte-stable.
+    diamond: "*"
+  }
+};
+var MIN_AXIS_WIDTH = 48;
+var MAX_COORDINATE_AXIS_WIDTH = 64;
+var EVENT_SPACING = 3;
+var TERMINAL_RAIL_LENGTH = 3;
+function renderAsciiTimeline(timeline, options = {}) {
+  const style = options.style ?? timeline.style;
+  const vocab = style === "ascii" ? ASCII_VOCAB2 : UNICODE_VOCAB2;
+  const { tracks, links } = prepareTimeline(timeline, style);
+  if (tracks.length === 0) return "";
+  const globalStart = Math.min(...tracks.map((track) => track.startColumn));
+  const globalEnd = Math.max(...tracks.map((track) => track.endColumn));
+  const globalSpan = Math.max(1, globalEnd - globalStart);
+  const axisWidth = Math.max(
+    MIN_AXIS_WIDTH,
+    Math.min(MAX_COORDINATE_AXIS_WIDTH, Math.ceil(globalSpan)),
+    ...tracks.map((track) => track.events.length * EVENT_SPACING)
+  );
+  const prefixes = tracks.map((track) => renderTrackPrefix(track));
+  const prefixWidth = Math.max(...prefixes.map(displayWidth));
+  const lines = [];
+  tracks.forEach((track, index) => {
+    if (index > 0) lines.push("");
+    lines.push(
+      ...renderTrack(
+        track,
+        style,
+        vocab,
+        prefixes[index],
+        prefixWidth,
+        axisWidth,
+        globalStart,
+        globalSpan
+      )
+    );
+  });
+  if (links.length > 0) {
+    lines.push("");
+    for (const link of links) lines.push(renderLink(link, style));
+  }
+  return lines.join("\n");
+}
+function renderTrack(track, style, vocab, prefix, prefixWidth, axisWidth, globalStart, globalSpan) {
+  const paddedPrefix = `${prefix}${" ".repeat(Math.max(0, prefixWidth - displayWidth(prefix)))}`;
+  const positioned = positionEvents(track.events, axisWidth, globalStart, globalSpan);
+  const rail = Array.from({ length: axisWidth + 1 }, () => vocab.rail);
+  for (const { event, offset } of positioned) rail[offset] = vocab.marker[event.marker];
+  const callouts = positioned.map(({ event, offset }) => ({
+    event,
+    column: prefixWidth + offset,
+    text: renderEventPayload(event)
+  }));
+  const pointer = style === "ascii" ? { above: "^", below: "v" } : { above: "\u25B2", below: "\u25BC" };
+  const above = renderCalloutLanes(
+    callouts.filter(({ event }) => event.side === "above"),
+    pointer.above
+  );
+  const below = renderCalloutLanes(
+    callouts.filter(({ event }) => event.side === "below"),
+    pointer.below
+  );
+  const axis = `${paddedPrefix}${rail.join("")}${vocab.rail.repeat(TERMINAL_RAIL_LENGTH)}${vocab.arrow}${track.endLabel ? ` ${track.endLabel}` : ""}`;
+  return [...above, axis, ...below];
+}
+function renderEventPayload(event) {
+  const body = event.description ? `${event.label} :: ${event.description}` : event.label;
+  const descriptionSide = event.descriptionSide ? ` descriptionSide=${event.descriptionSide}` : "";
+  const callout = event.callout === false ? " callout=false" : "";
+  return `${body} {#${event.id} column=${formatCoordinate(event.column)}${descriptionSide}${callout}}`;
+}
+function renderTrackPrefix(track) {
+  const metadata = `{#${track.id} start=${formatCoordinate(track.startColumn)} end=${formatCoordinate(track.endColumn)}}`;
+  return track.label ? `${track.label} ${metadata}: ` : `${metadata}: `;
+}
+function positionEvents(events, axisWidth, globalStart, globalSpan) {
+  let previous = -1;
+  return events.map((event, index) => {
+    const ideal = Math.round((event.column - globalStart) / globalSpan * axisWidth);
+    const remaining = events.length - index - 1;
+    const latest = Math.max(0, axisWidth - remaining);
+    const offset = Math.max(previous + 1, Math.min(latest, Math.max(0, ideal)));
+    previous = offset;
+    return { event, offset };
+  });
+}
+function renderCalloutLanes(callouts, pointer) {
+  const lanes = [];
+  const laneEnds = [];
+  for (const callout of callouts) {
+    const end = callout.column + 2 + displayWidth(callout.text);
+    let lane = laneEnds.findIndex((laneEnd) => callout.column > laneEnd + 1);
+    if (lane < 0) {
+      lane = lanes.length;
+      lanes.push([]);
+      laneEnds.push(-1);
+    }
+    lanes[lane].push(callout);
+    laneEnds[lane] = end;
+  }
+  return lanes.map((lane) => {
+    const chars = [];
+    for (const callout of lane) {
+      while (chars.length < callout.column) chars.push(" ");
+      chars.push(pointer, " ", ...Array.from(callout.text));
+    }
+    return chars.join("").trimEnd();
+  });
+}
+function displayWidth(value) {
+  return Array.from(value).length;
+}
+function renderLink(link, style) {
+  const arrow = style === "ascii" ? "->" : "\u2192";
+  return `branch: ${link.source} ${arrow} ${link.target}${link.label ? ` : ${link.label}` : ""}`;
+}
+function prepareTimeline(timeline, style) {
+  const sourceTracks = timeline.tracks.map((track, index) => ({ track, index })).filter(({ track }) => Array.isArray(track.events) && track.events.length > 0).sort(
+    (a, b) => finiteOr(a.track.row, a.index) - finiteOr(b.track.row, b.index) || a.index - b.index || a.track.id.localeCompare(b.track.id)
+  );
+  const usedTrackIds = /* @__PURE__ */ new Set();
+  const usedEventIds = /* @__PURE__ */ new Set();
+  const endpointIds = /* @__PURE__ */ new Map();
+  const labelIds = /* @__PURE__ */ new Map();
+  const tracks = [];
+  let fallbackIndex = 0;
+  for (const { track } of sourceTracks) {
+    const trackLabel = canonicalInlineText(track.label);
+    const endLabel = canonicalInlineText(track.endLabel);
+    const trackId = uniqueId(
+      canonicalId(track.id, canonicalId(trackLabel, `track_${tracks.length + 1}`)),
+      usedTrackIds
+    );
+    const sortedEvents = track.events.map((event, index) => ({ event, index })).sort(
+      (a, b) => finiteOr(a.event.column, a.index) - finiteOr(b.event.column, b.index) || a.index - b.index || a.event.id.localeCompare(b.event.id)
+    );
+    const events = [];
+    for (let index = 0; index < sortedEvents.length; index++) {
+      const event = sortedEvents[index].event;
+      const fallbackLabel = `Event ${index + 1}`;
+      const label = canonicalInlineText(event.label) || fallbackLabel;
+      const idBase = canonicalId(event.id, canonicalId(label, `event_${++fallbackIndex}`));
+      const id = uniqueId(idBase, usedEventIds);
+      const description = canonicalInlineText(event.description);
+      const descriptionSide = description && (event.descriptionSide === "above" || event.descriptionSide === "below") ? event.descriptionSide : void 0;
+      const column = canonicalCoordinate(event.column, index);
+      const side = event.side === "below" ? "below" : event.side === "above" ? "above" : index % 2 === 0 ? "above" : "below";
+      const marker = canonicalMarker(event.marker, style);
+      events.push({
+        id,
+        label,
+        ...description ? { description } : {},
+        ...descriptionSide ? { descriptionSide } : {},
+        column,
+        side,
+        ...event.callout === false ? { callout: false } : {},
+        marker
+      });
+      if (event.id && !endpointIds.has(event.id)) endpointIds.set(event.id, id);
+      endpointIds.set(id, id);
+      labelIds.set(slug(label), id);
+    }
+    const eventColumns = events.map((event) => event.column);
+    const fallbackStart = eventColumns.length > 0 ? Math.min(...eventColumns) : 0;
+    const fallbackEnd = eventColumns.length > 0 ? Math.max(...eventColumns) : fallbackStart + 1;
+    tracks.push({
+      id: trackId,
+      ...trackLabel ? { label: trackLabel } : {},
+      ...endLabel ? { endLabel } : {},
+      startColumn: canonicalCoordinate(track.startColumn, fallbackStart),
+      endColumn: canonicalCoordinate(track.endColumn, fallbackEnd),
+      events
+    });
+  }
+  const resolveEndpoint = (value) => endpointIds.get(value) ?? labelIds.get(slug(value));
+  const links = [];
+  for (const link of Array.isArray(timeline.links) ? timeline.links : []) {
+    const source = resolveEndpoint(link.source);
+    const target = resolveEndpoint(link.target);
+    if (!source || !target) continue;
+    const label = canonicalBranchText(link.label);
+    links.push({ source, target, ...label ? { label } : {} });
+  }
+  links.sort(
+    (a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target) || (a.label ?? "").localeCompare(b.label ?? "")
+  );
+  return { tracks, links };
+}
+function canonicalMarker(marker, style) {
+  if (marker === "hollow") return "hollow";
+  if (marker === "diamond" && style !== "ascii") return "diamond";
+  return "filled";
+}
+function canonicalInlineText(value) {
+  if (!value) return "";
+  const normalized = value.normalize("NFC").replace(/[\r\n\t]+/g, " ").replace(/[\u25cf\u25cb\u25c9\u25c6\u25c7\u2022]+/gu, "\xB7").replace(/\*/g, "\u2217").replace(/::/g, "\u2236").replace(/\s+/g, " ").trim();
+  return normalized.replace(
+    /^[\u2500\u2501\u2550\u254c\u254d\u2504\u2505\u2508\u2509-]+/u,
+    (run) => Array.from(run, (character) => character === "-" ? "\u2212" : "\u2013").join("")
+  );
+}
+function canonicalBranchText(value) {
+  return canonicalInlineText(value).replace(/\s+/g, " ").trim();
+}
+function canonicalId(value, fallback) {
+  const normalized = (value ?? "").normalize("NFC").replace(/[\r\n\t\s]+/g, "_").replace(/[^A-Za-z0-9_.~-]+/g, "_").replace(/^_+|_+$/g, "");
+  return normalized || fallback;
+}
+function uniqueId(base, used) {
+  if (!used.has(base)) {
+    used.add(base);
+    return base;
+  }
+  let suffix = 2;
+  let candidate = `${base}_${suffix}`;
+  while (used.has(candidate)) candidate = `${base}_${++suffix}`;
+  used.add(candidate);
+  return candidate;
+}
+function slug(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "event";
+}
+function finiteOr(value, fallback) {
+  return Number.isFinite(value) ? value : fallback;
+}
+function canonicalCoordinate(value, fallback) {
+  const finite = finiteOr(value, fallback);
+  return Math.max(0, Object.is(finite, -0) ? 0 : finite);
+}
+function formatCoordinate(value) {
+  return String(Object.is(value, -0) ? 0 : value);
+}
+
+// src/doc/treeview/render.ts
+function renderTree(tree, options = {}) {
+  const vocab = (options.style ?? tree.style) === "ascii" ? ASCII_TREE_VOCAB : UNICODE_TREE_VOCAB;
+  const lines = [];
+  const label = (node) => node.comment ? `${node.label}  # ${node.comment}` : node.label;
+  const walk = (nodes, prefix) => {
+    nodes.forEach((node, i) => {
+      const last = i === nodes.length - 1;
+      lines.push(prefix + (last ? vocab.elbow : vocab.tee) + label(node));
+      walk(node.children, prefix + (last ? vocab.gap : vocab.rail));
+    });
+  };
+  for (const root of tree.roots) {
+    lines.push(label(root));
+    walk(root.children, "");
+  }
+  return lines.join("\n");
+}
+
+export {
+  getAnimationStyle,
+  getDefaultAnimationDuration,
+  getTransitionClass,
+  getAnimationProgress,
+  cssFilterForTreatment,
+  docToMarkdown,
+  resolveThemeForDoc,
+  applyNarrationTiming,
+  scoreTextSimilarity,
+  resolveAudioMapping,
+  validateMarkdownSource,
+  validateMarkdownDoc,
+  renderAsciiDiagram,
+  isRepairableDiagram,
+  repairAsciiDiagram,
+  renderAsciiTimeline,
+  renderTree
+};
+//# sourceMappingURL=chunk-TFJVXUHH.js.map