@bendyline/squisq 2.13.7 → 2.13.9

package/dist/{chunk-DOKSRBW2.js → chunk-3BIKSQTM.js}

@@ -9,7 +9,7 @@ import {
   expectedSyllablesAt,
   flattenRenderableBlocks,
   wordPosAtExpectedSyllables
-} from "./chunk-TTJZXUQA.js";
+} from "./chunk-L3VQQ3WT.js";
 
 // src/narration/types.ts
 var DEFAULT_FEATURE_CONFIG = Object.freeze({

package/dist/{chunk-TTJZXUQA.js → chunk-L3VQQ3WT.js}

@@ -32,7 +32,7 @@ import {
   profileBlockContents,
   renderMarkdownBlocksHtml,
   treeToTemplateData
-} from "./chunk-NGQ5TJVX.js";
+} from "./chunk-R2J7CQJZ.js";
 import {
   anchorPoint,
   base64ToUtf8,
@@ -12615,6 +12615,7 @@ export {
   videoWithCaption,
   videoPullQuote,
   dataTable,
+  normalizeChartTable,
   buildChartData,
   BLOCK_MEDIA_LAYOUT_POLICIES,
   getBlockMediaLayoutPolicy,
@@ -12661,6 +12662,7 @@ export {
   parseYamlSubset,
   findFirstTable,
   extractTableData,
+  detectPromotableBodyAnnotation,
   getPinnedBlockMeta,
   markdownToDoc,
   flattenBlocks,

package/dist/{chunk-MWJSEKM3.js → chunk-QVNMPBS3.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-FTN6SGW5.js";
 import {
   applySavedPresentation
-} from "./chunk-CJYN3MTX.js";
+} from "./chunk-VMKRN7TB.js";
 import {
   SHAPE_NAMES,
   buildChartData,
@@ -31,7 +31,7 @@ import {
   templateRegistry,
   writeCustomTemplatesToFrontmatter,
   writeCustomThemesToFrontmatter
-} from "./chunk-TTJZXUQA.js";
+} from "./chunk-L3VQQ3WT.js";
 import {
   ASCII_TREE_VOCAB,
   ASCII_VOCAB,
@@ -54,7 +54,7 @@ import {
   toCells,
   toGrid,
   traceBoxes
-} from "./chunk-NGQ5TJVX.js";
+} from "./chunk-R2J7CQJZ.js";
 import {
   iconMarker
 } from "./chunk-7ZAAICW4.js";
@@ -5282,12 +5282,13 @@ function renderAsciiDiagram(diagram2, options = {}) {
   const vocab = (options.style ?? diagram2.style) === "ascii" ? ASCII_VOCAB : UNICODE_VOCAB;
   if (diagram2.nodes.length === 0) return "";
   const placed = layoutNodes(diagram2.nodes, diagram2.edges);
+  const routes = planRoutesWithRoom(diagram2.edges, placed);
   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, diagram2.edges, placed, vocab);
+  drawEdges(canvas, routes, placed, vocab);
   return canvas.emit();
 }
 function computeSideDegrees(nodes, edges) {
@@ -5527,7 +5528,40 @@ function drawBox(canvas, p, vocab) {
     });
   }
 }
-function drawEdges(canvas, edges, placed, vocab) {
+var OPPOSITE_SIDE = {
+  top: "bottom",
+  bottom: "top",
+  left: "right",
+  right: "left"
+};
+function planRoutesWithRoom(edges, placed) {
+  const maxInserts = 4 * edges.length + 8;
+  for (let inserted = 0; ; inserted++) {
+    const { routes, room } = planRoutes(edges, placed);
+    if (!room || inserted >= maxInserts) return routes;
+    insertLine(placed, room);
+  }
+}
+function insertLine(placed, { axis, after }) {
+  const bump = (v) => v > after ? v + 1 : v;
+  for (const p of placed.values()) {
+    const r = p.rect;
+    p.rect = axis === "row" ? { ...r, r0: bump(r.r0), r1: bump(r.r1) } : { ...r, c0: bump(r.c0), c1: bump(r.c1) };
+  }
+}
+function roomBeside(side, rect) {
+  switch (side) {
+    case "bottom":
+      return { axis: "row", after: rect.r1 };
+    case "top":
+      return { axis: "row", after: rect.r0 - 1 };
+    case "right":
+      return { axis: "col", after: rect.c1 };
+    case "left":
+      return { axis: "col", after: rect.c0 - 1 };
+  }
+}
+function planRoutes(edges, placed) {
   const sorted = [...edges].sort(
     (a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target) || (a.label ?? "").localeCompare(b.label ?? "")
   );
@@ -5561,6 +5595,20 @@ function drawEdges(canvas, edges, placed, vocab) {
     });
   }
   const attachment = assignAttachments(plans, placed);
+  const straight = resolveStraightRuns(plans, placed, attachment);
+  const jogs = assignJogStaggers(plans, placed, attachment, straight);
+  let room = jogs.room;
+  plans.forEach((plan, i) => {
+    if (room || routeAxis(plan) === null) return;
+    const s = placed.get(plan.sourceId).rect;
+    const t = placed.get(plan.targetId).rect;
+    const lane = jogLane(plan, s, t);
+    const needed = straight[i] ? plan.biDir ? 2 : 1 : 2;
+    if (freeLines(lane) < needed) room = roomBeside(plan.exitSide, s);
+  });
+  return { routes: { plans, attachment, straight, staggers: jogs.staggers }, room };
+}
+function drawEdges(canvas, { plans, attachment, straight, staggers }, placed, vocab) {
   const sideLabelRequests = [];
   plans.forEach(
     (plan, i) => routeEdge(
@@ -5569,6 +5617,7 @@ function drawEdges(canvas, edges, placed, vocab) {
       i,
       placed,
       attachment,
+      { straight: straight[i], stagger: staggers[i] },
       vocab,
       (candidates, label) => sideLabelRequests.push({ candidates, label })
     )
@@ -5645,12 +5694,14 @@ function assignAttachments(plans, placed) {
   for (const [sideKey, list2] of [...bySide.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
     const [nodeId, side] = sideKey.split("|");
     const node = placed.get(nodeId);
+    const horizontal = side === "top" || side === "bottom";
     list2.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 along = horizontal ? ra.c0 + ra.c1 - (rb.c0 + rb.c1) : ra.r0 + ra.r1 - (rb.r0 + rb.r1);
+      const across = horizontal ? ra.r0 - rb.r0 : ra.c0 - rb.c0;
+      return along || across || 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);
@@ -5685,15 +5736,128 @@ function assignAttachments(plans, placed) {
   }
   return result;
 }
-function routeEdge(canvas, plan, planIdx, placed, attachment, vocab, deferSideLabel) {
+function routeAxis(plan) {
+  if (plan.enterSide !== OPPOSITE_SIDE[plan.exitSide]) return null;
+  return plan.exitSide === "bottom" || plan.exitSide === "top" ? "vertical" : "horizontal";
+}
+function jogLane(plan, s, t) {
+  const [exitLine, enterLine] = plan.exitSide === "bottom" ? [s.r1, t.r0] : plan.exitSide === "top" ? [s.r0, t.r1] : plan.exitSide === "right" ? [s.c1, t.c0] : [s.c0, t.c1];
+  const dir = plan.exitSide === "bottom" || plan.exitSide === "right" ? 1 : -1;
+  return {
+    dir,
+    mid: Math.floor((exitLine + enterLine) / 2),
+    firstFree: exitLine + dir,
+    lastFree: enterLine - dir
+  };
+}
+function freeLines(lane) {
+  return (lane.lastFree - lane.firstFree) * lane.dir + 1;
+}
+function straightRunFits(s, t, exitPos, vertical) {
+  return vertical ? exitPos >= t.c0 + 1 && exitPos <= t.c1 - 1 && exitPos >= s.c0 + 1 && exitPos <= s.c1 - 1 : exitPos >= t.r0 + 1 && exitPos <= t.r1 - 1 && exitPos >= s.r0 + 1 && exitPos <= s.r1 - 1;
+}
+function resolveStraightRuns(plans, placed, attachment) {
+  const rectOf = (id) => placed.get(id).rect;
+  const slot = (i, end) => attachment.get(`${i}:${end}`);
+  const axes = plans.map(routeAxis);
+  const straight = plans.map(
+    (plan, i) => axes[i] !== null && straightRunFits(
+      rectOf(plan.sourceId),
+      rectOf(plan.targetId),
+      slot(i, "exit").pos,
+      axes[i] === "vertical"
+    )
+  );
+  const cellOn = (j, side) => {
+    const plan = plans[j];
+    if (axes[j] === null) return null;
+    if (`${plan.sourceId}|${plan.exitSide}` === side) return slot(j, "exit").pos;
+    if (`${plan.targetId}|${plan.enterSide}` !== side) return null;
+    const t = rectOf(plan.targetId);
+    const lane = jogLane(plan, rectOf(plan.sourceId), t);
+    if (!straight[j] && freeLines(lane) >= 2) return slot(j, "enter").pos;
+    return axes[j] === "vertical" ? clamp2(slot(j, "exit").pos, t.c0 + 1, t.c1 - 1) : clamp2(slot(j, "exit").pos, t.r0 + 1, t.r1 - 1);
+  };
+  const clashes = (side, cell, self) => plans.some((_, j) => {
+    const other = j === self ? null : cellOn(j, side);
+    return other !== null && Math.abs(other - cell) <= 1;
+  });
+  for (let changed = true; changed; ) {
+    changed = false;
+    plans.forEach((plan, i) => {
+      if (!straight[i]) return;
+      const targetSide = `${plan.targetId}|${plan.enterSide}`;
+      if (!clashes(targetSide, slot(i, "exit").pos, i)) return;
+      const s = rectOf(plan.sourceId);
+      const t = rectOf(plan.targetId);
+      const port = slot(i, "enter").pos;
+      const realign = straightRunFits(s, t, port, axes[i] === "vertical") && !clashes(`${plan.sourceId}|${plan.exitSide}`, port, i) && !clashes(targetSide, port, i);
+      if (realign) slot(i, "exit").pos = port;
+      else straight[i] = false;
+      changed = true;
+    });
+  }
+  return straight;
+}
+function assignJogStaggers(plans, placed, attachment, straight) {
+  const staircases = /* @__PURE__ */ new Map();
+  const staggers = plans.map((plan, i) => {
+    const exit = attachment.get(`${i}:exit`);
+    const enter = attachment.get(`${i}:enter`);
+    const basis = enter.count > exit.count ? enter : exit;
+    const s = placed.get(plan.sourceId).rect;
+    const t = placed.get(plan.targetId).rect;
+    const lane = jogLane(plan, s, t);
+    if (routeAxis(plan) !== null && !straight[i] && freeLines(lane) >= 2) {
+      const fanIn = basis === enter;
+      const heading = Math.sign(enter.pos - exit.pos);
+      const key = fanIn ? `${plan.targetId}|${plan.enterSide}|${heading}` : `${plan.sourceId}|${plan.exitSide}|${heading}`;
+      const jog = {
+        planIdx: i,
+        outerness: fanIn ? -enter.pos * heading : exit.pos * heading,
+        toward: fanIn ? lane.dir : lane.dir === 1 ? -1 : 1,
+        lane,
+        fanIn,
+        room: fanIn ? roomBeside(plan.enterSide, t) : roomBeside(plan.exitSide, s)
+      };
+      staircases.set(key, [...staircases.get(key) ?? [], jog]);
+    }
+    return basis.index - Math.floor((basis.count - 1) / 2);
+  });
+  let room = null;
+  for (const jogs of staircases.values()) {
+    if (jogs.length < 2) continue;
+    jogs.sort((a, b) => b.outerness - a.outerness || a.planIdx - b.planIdx);
+    const half = Math.floor((jogs.length - 1) / 2);
+    const lines = jogs.map((jog, rank) => jog.lane.mid + jog.toward * (half - rank));
+    const shift = jogs[0].fanIn ? staircaseShift(jogs, lines, { spareArrowLine: true, spareExitLine: true }) : staircaseShift(jogs, lines, { spareArrowLine: true }) ?? staircaseShift(jogs, lines, {});
+    if (shift === null) {
+      room ?? (room = jogs[0].room);
+      continue;
+    }
+    jogs.forEach((jog, k) => {
+      staggers[jog.planIdx] = lines[k] + shift - jog.lane.mid;
+    });
+  }
+  return { staggers, room };
+}
+function staircaseShift(jogs, lines, spare) {
+  let lo = -Infinity;
+  let hi = Infinity;
+  jogs.forEach(({ lane }, k) => {
+    const first = spare.spareExitLine ? lane.firstFree + lane.dir : lane.firstFree;
+    const last = spare.spareArrowLine ? lane.lastFree - lane.dir : lane.lastFree;
+    lo = Math.max(lo, Math.min(first, last) - lines[k]);
+    hi = Math.min(hi, Math.max(first, last) - lines[k]);
+    if ((last - first) * lane.dir < 0) hi = -Infinity;
+  });
+  return lo <= hi ? clamp2(0, lo, hi) : null;
+}
+function routeEdge(canvas, plan, planIdx, placed, attachment, shape, 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 exitPos = attachment.get(`${planIdx}:exit`).pos;
+  const enterPos = attachment.get(`${planIdx}:enter`).pos;
   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");
@@ -5705,7 +5869,8 @@ function routeEdge(canvas, plan, planIdx, placed, attachment, vocab, deferSideLa
     label: normalizeEdgeLabel(plan.edge.label),
     vocab,
     junction,
-    stagger,
+    straight: shape.straight,
+    stagger: shape.stagger,
     deferSideLabel
   };
   if (plan.exitSide === "bottom" && plan.enterSide === "top") {
@@ -5743,8 +5908,7 @@ function drawVertical(args, s, t, exitCol, enterCol, dir) {
     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) {
+  if (args.straight || gap < 2) {
     const sCol = clamp2(exitCol, s.c0 + 1, s.c1 - 1);
     const tCol = clamp2(exitCol, t.c0 + 1, t.c1 - 1);
     junction(exitRow, sCol, dir === 1 ? "bottom" : "top");
@@ -5877,8 +6041,7 @@ function drawHorizontal(args, s, t, exitRow, enterRow, dir) {
       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) {
+  if (args.straight || gap < 2) {
     const sRow = clamp2(exitRow, s.r0 + 1, s.r1 - 1);
     const tRow = clamp2(exitRow, t.r0 + 1, t.r1 - 1);
     junction(sRow, exitCol, dir === 1 ? "right" : "left");