@bendyline/squisq 2.9.0 → 2.11.0

package/dist/{chunk-6MVWWZHL.js → chunk-UBFT2CDQ.js}

@@ -6,7 +6,7 @@ import {
   quoteAttrValue,
   splitKeyValueToken,
   tokenizeAttrTokens
-} from "./chunk-NBKAXPSX.js";
+} from "./chunk-TMOHAFYE.js";
 import {
   resolveIcon
 } from "./chunk-7N4G32LG.js";
@@ -259,7 +259,72 @@ function convertInlineChildren(children, parseHtml, applyIconSplit = true) {
     if (node) result.push(node);
   }
   const mentioned = coalesceMentions(result);
-  return applyIconSplit ? splitInlineIcons(mentioned) : mentioned;
+  const repaired = recombineDirectiveTokens(mentioned);
+  const split = applyIconSplit ? splitInlineIcons(repaired) : repaired;
+  return foldPairedInlineHtml(split);
+}
+var PAIRED_INLINE_HTML = /* @__PURE__ */ new Map([
+  ["sup", "superscript"],
+  ["sub", "subscript"]
+]);
+function bareOpenTag(rawHtml) {
+  const m = /^<([a-zA-Z][a-zA-Z0-9]*)\s*>$/.exec(rawHtml);
+  return m ? m[1].toLowerCase() : null;
+}
+function bareCloseTag(rawHtml) {
+  const m = /^<\/([a-zA-Z][a-zA-Z0-9]*)\s*>$/.exec(rawHtml);
+  return m ? m[1].toLowerCase() : null;
+}
+function foldPairedInlineHtml(nodes) {
+  if (!nodes.some((n) => n.type === "htmlInline")) return nodes;
+  const root = [];
+  const stack = [];
+  const top = () => stack[stack.length - 1]?.children ?? root;
+  for (const node of nodes) {
+    if (node.type !== "htmlInline") {
+      top().push(node);
+      continue;
+    }
+    const open = bareOpenTag(node.rawHtml);
+    const foldType = open ? PAIRED_INLINE_HTML.get(open) : void 0;
+    if (open && foldType) {
+      stack.push({ tag: open, type: foldType, open: node, children: [] });
+      continue;
+    }
+    const close = bareCloseTag(node.rawHtml);
+    let closeIndex = -1;
+    if (close) {
+      for (let i = stack.length - 1; i >= 0; i--) {
+        if (stack[i].tag === close) {
+          closeIndex = i;
+          break;
+        }
+      }
+    }
+    if (close && closeIndex >= 0) {
+      while (stack.length - 1 > closeIndex) {
+        const orphan = stack.pop();
+        top().push(orphan.open, ...orphan.children);
+      }
+      const frame = stack.pop();
+      top().push({
+        type: frame.type,
+        children: frame.children,
+        ...spanPosition(frame.open, node)
+      });
+      continue;
+    }
+    top().push(node);
+  }
+  while (stack.length > 0) {
+    const orphan = stack.pop();
+    top().push(orphan.open, ...orphan.children);
+  }
+  return root;
+}
+function spanPosition(open, close) {
+  if (!open.position || !close.position) return {};
+  return { position: { start: open.position.start, end: close.position.end } };
 }
 function splitInlineIcons(nodes) {
   const recombined = recombineDirectiveTokens(nodes);
@@ -277,24 +342,38 @@ function recombineDirectiveTokens(nodes) {
   const out = [];
   for (let i = 0; i < nodes.length; i++) {
     const cur = nodes[i];
-    const next = nodes[i + 1];
-    const after = nodes[i + 2];
-    if (cur?.type === "text" && next?.type === "textDirective" && after?.type === "text" && /\{\[[a-zA-Z0-9_-]+$/.test(cur.value) && /^\]\}/.test(after.value)) {
-      const directive = next;
-      const directiveName = directive.name ?? "";
-      const merged = {
-        type: "text",
-        value: cur.value + ":" + directiveName + after.value,
-        ...cur.position ? { position: cur.position } : {}
-      };
-      out.push(merged);
-      i += 2;
-      continue;
+    if (cur?.type === "text") {
+      let value = cur.value;
+      let j = i;
+      while (hasUnclosedAnnotationSpan(value) && nodes[j + 1]?.type === "textDirective") {
+        const directive = nodes[j + 1];
+        value += ":" + (directive.name ?? "");
+        j += 1;
+        const following = nodes[j + 1];
+        if (following?.type === "text") {
+          value += following.value;
+          j += 1;
+        }
+      }
+      if (j !== i) {
+        out.push({
+          type: "text",
+          value,
+          ...cur.position ? { position: cur.position } : {}
+        });
+        i = j;
+        continue;
+      }
     }
     out.push(cur);
   }
   return out;
 }
+function hasUnclosedAnnotationSpan(text) {
+  const open = text.lastIndexOf("{[");
+  if (open === -1) return false;
+  return !text.includes("]}", open);
+}
 var ICON_TOKEN_RE = /\{\[([a-zA-Z0-9_:-]+)\]\}/g;
 function splitTextOnIcons(value, position) {
   if (!value) return [];
@@ -825,7 +904,12 @@ function tableCellToMdast(cell) {
 function inlineChildrenToMdast(nodes) {
   const out = [];
   for (const n of nodes) {
-    if (n.type === "mention") {
+    if (n.type === "superscript" || n.type === "subscript") {
+      const tag = n.type === "superscript" ? "sup" : "sub";
+      out.push({ type: "html", value: `<${tag}>`, ...mdastPosField(n.position) });
+      out.push(...inlineChildrenToMdast(n.children));
+      out.push({ type: "html", value: `</${tag}>` });
+    } else if (n.type === "mention") {
       out.push({ type: "text", value: "@" });
       out.push({
         type: "link",
@@ -944,6 +1028,13 @@ function inlineToMdast(node) {
         children: [{ type: "text", value: node.displayName }],
         ...mdastPosField(node.position)
       };
+    case "superscript":
+    case "subscript":
+      return {
+        type: "text",
+        value: inlineNodesToPlainText(node.children),
+        ...mdastPosField(node.position)
+      };
     case "inlineIcon":
       return {
         type: "text",
@@ -954,6 +1045,16 @@ function inlineToMdast(node) {
       return { type: "text", value: "" };
   }
 }
+function inlineNodesToPlainText(nodes) {
+  let out = "";
+  for (const node of nodes) {
+    if ("value" in node && typeof node.value === "string") out += node.value;
+    else if ("children" in node && Array.isArray(node.children)) {
+      out += inlineNodesToPlainText(node.children);
+    }
+  }
+  return out;
+}
 function escapeHtmlText(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }

package/dist/{chunk-FCG3BIZN.js → chunk-UNVHAK3A.js}

@@ -230,7 +230,11 @@ var EXTENSION_MIME_MAP = {
   ".ogg": "audio/ogg",
   ".css": "text/css",
   ".html": "text/html",
-  ".js": "application/javascript"
+  ".js": "application/javascript",
+  ".csv": "text/csv",
+  ".tsv": "text/tab-separated-values",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".parquet": "application/vnd.apache.parquet"
 };
 function guessMimeType(path) {
   const dot = path.lastIndexOf(".");

package/dist/{chunk-HEYR3TPL.js → chunk-ZWID3HM5.js}

@@ -1,7 +1,9 @@
 import {
+  buildNarrationScript,
   expectedSyllablesAt,
+  flattenRenderableBlocks,
   wordPosAtExpectedSyllables
-} from "./chunk-W2GIFNLN.js";
+} from "./chunk-ZYCSRDSX.js";
 
 // src/narration/types.ts
 var DEFAULT_FEATURE_CONFIG = Object.freeze({
@@ -872,6 +874,105 @@ function proportionalAlignment(script, effectiveDuration, takeDuration, c, detec
   return { words, blocks, detectedSyllables, cost: 0 };
 }
 
+// src/narration/advanceTiming.ts
+var EMPTY_ADVANCE_LOG = Object.freeze([]);
+function recordSlideShown(log, blockId, atMs) {
+  if (!blockId || !Number.isFinite(atMs)) return log;
+  for (const entry of log) {
+    if (entry.blockId === blockId) return log;
+  }
+  const floor = log.length > 0 ? log[log.length - 1].atMs : 0;
+  return [...log, { blockId, atMs: Math.max(atMs, floor, 0) }];
+}
+function clampDuration(durationSec) {
+  return Number.isFinite(durationSec) && durationSec >= 0 ? durationSec : 0;
+}
+function firstShownSeconds(advances, knownIds, duration) {
+  const shown = /* @__PURE__ */ new Map();
+  let cursor = 0;
+  for (const advance of advances) {
+    if (!knownIds.has(advance.blockId) || shown.has(advance.blockId)) continue;
+    const raw = Number.isFinite(advance.atMs) ? advance.atMs / 1e3 : cursor;
+    const t = Math.min(duration, Math.max(cursor, raw));
+    shown.set(advance.blockId, t);
+    cursor = t;
+  }
+  const first = shown.keys().next();
+  if (!first.done) shown.set(first.value, 0);
+  return shown;
+}
+function buildAdvanceTimingJson(doc, advances, durationSec, options) {
+  const duration = clampDuration(durationSec);
+  const flat = flattenRenderableBlocks(doc.blocks);
+  const script = buildNarrationScript(doc, options?.script);
+  const scriptById = new Map(script.blocks.map((range) => [range.blockId, range]));
+  const shown = firstShownSeconds(advances, new Set(flat.map((block) => block.id)), duration);
+  const starts = new Array(flat.length);
+  let boundary = duration;
+  for (let i = flat.length - 1; i >= 0; i--) {
+    const at = shown.get(flat[i].id);
+    if (at !== void 0) {
+      starts[i] = at;
+      boundary = at;
+    } else {
+      starts[i] = boundary;
+    }
+  }
+  const blocks = [];
+  let charCursor = 0;
+  for (let i = 0; i < flat.length; i++) {
+    const block = flat[i];
+    const range = scriptById.get(block.id);
+    const charStart = range ? range.charStart : charCursor;
+    const charEnd = range ? range.charEnd : charCursor;
+    charCursor = charEnd;
+    const startSec = starts[i];
+    const rawEnd = i + 1 < flat.length ? starts[i + 1] : duration;
+    blocks.push({
+      blockId: block.id,
+      ...block.title ? { heading: block.title } : {},
+      blockIndex: i,
+      charStart,
+      charEnd,
+      startSec,
+      endSec: Math.max(startSec, Math.min(rawEnd, duration))
+    });
+  }
+  return {
+    version: 3,
+    sourceText: script.sourceText,
+    duration,
+    // No word-level timings exist on this path — the presenter gave us block
+    // boundaries, not speech. Bookmarks are documented as per-WORD, so filling
+    // them with block starts would misreport what was measured.
+    bookmarks: [],
+    blocks,
+    // `cameraOffsetSec` is deliberately omitted: a dual take already encodes
+    // its skew in the camera clip's `startAt`/`clipStart` attributes, and a
+    // second copy here invites a double correction.
+    generator: {
+      name: options?.generatorName ?? "squisq-recorder",
+      method: "presenter-advance"
+    }
+  };
+}
+function advanceCoverage(doc, advances) {
+  const flat = flattenRenderableBlocks(doc.blocks);
+  const seen = new Set(advances.map((advance) => advance.blockId));
+  const unshownHeadings = [];
+  let shown = 0;
+  for (const block of flat) {
+    if (seen.has(block.id)) shown++;
+    else unshownHeadings.push(block.title || block.id);
+  }
+  return {
+    total: flat.length,
+    shown,
+    unshown: flat.length - shown,
+    unshownHeadings
+  };
+}
+
 export {
   DEFAULT_FEATURE_CONFIG,
   DEFAULT_VAD_CONFIG,
@@ -896,5 +997,9 @@ export {
   reanchorSession,
   traceWordPosAt,
   downsampleTrace,
-  alignNarration
+  alignNarration,
+  EMPTY_ADVANCE_LOG,
+  recordSlideShown,
+  buildAdvanceTimingJson,
+  advanceCoverage
 };