@bendyline/squisq 2.8.0 → 2.10.0

package/dist/{chunk-HXMV7WQB.js → chunk-IO5XO6XH.js}

@@ -2,7 +2,7 @@ import {
   assertMarkdownDocumentWithinLimits,
   parseMarkdown,
   toMdast
-} from "./chunk-6MVWWZHL.js";
+} from "./chunk-MIKKUKOD.js";
 import {
   formatFrontmatterYaml,
   getChildren,

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

@@ -259,7 +259,71 @@ function convertInlineChildren(children, parseHtml, applyIconSplit = true) {
     if (node) result.push(node);
   }
   const mentioned = coalesceMentions(result);
-  return applyIconSplit ? splitInlineIcons(mentioned) : mentioned;
+  const split = applyIconSplit ? splitInlineIcons(mentioned) : mentioned;
+  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);
@@ -825,7 +889,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 +1013,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 +1030,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-KEAU5NEM.js → chunk-NFHMHYUV.js}

@@ -1,7 +1,9 @@
 import {
+  buildNarrationScript,
   expectedSyllablesAt,
+  flattenRenderableBlocks,
   wordPosAtExpectedSyllables
-} from "./chunk-V6NV4GDE.js";
+} from "./chunk-DRFJU4MK.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
 };

package/dist/chunk-T3B4WJBR.js

@@ -0,0 +1,167 @@
+// src/proof/types.ts
+var PROOF_DIALECTS = Object.freeze([
+  "American",
+  "British",
+  "Australian",
+  "Canadian",
+  "Indian"
+]);
+
+// src/proof/lintKinds.ts
+var LINT_KIND_CATEGORIES = Object.freeze({
+  // Red — the word itself is wrong.
+  Spelling: "spelling",
+  Typo: "spelling",
+  // Green — the sentence is wrong; there is a definite fix.
+  Agreement: "grammar",
+  BoundaryError: "grammar",
+  Capitalization: "grammar",
+  Eggcorn: "grammar",
+  Grammar: "grammar",
+  Malapropism: "grammar",
+  Miscellaneous: "grammar",
+  Nonstandard: "grammar",
+  Punctuation: "grammar",
+  Repetition: "grammar",
+  Usage: "grammar",
+  WordChoice: "grammar",
+  WordOrder: "grammar",
+  // Blue — the text works but could read better.
+  Enhancement: "style",
+  Formatting: "style",
+  Readability: "style",
+  Redundancy: "style",
+  Regionalism: "style",
+  Style: "style"
+});
+function categorizeLintKind(kind) {
+  return LINT_KIND_CATEGORIES[kind] ?? "style";
+}
+
+// src/proof/masking.ts
+var ANNOTATION_RE = /\{\[[^\n]*?\]\}/g;
+function blankProtectedSpans(text) {
+  const blanked = [];
+  const out = text.replace(ANNOTATION_RE, (match, offset) => {
+    blanked.push({ start: offset, end: offset + match.length });
+    return " ".repeat(match.length);
+  });
+  return { text: out, blanked };
+}
+function dropMaskedFindings(findings, blanked) {
+  if (blanked.length === 0) return [...findings];
+  return findings.filter(
+    (finding) => !blanked.some((range) => finding.start < range.end && finding.end > range.start)
+  );
+}
+
+// src/proof/joining.ts
+var PROOF_JOIN_SEPARATOR = "\n\n";
+function buildJoinedText(segments) {
+  const starts = [];
+  const lengths = [];
+  let text = "";
+  for (const segment of segments) {
+    if (text.length > 0) text += PROOF_JOIN_SEPARATOR;
+    starts.push(text.length);
+    lengths.push(segment.length);
+    text += segment;
+  }
+  return { text, starts, lengths };
+}
+function mapJoinedSpanToSegment(joined, start, end) {
+  if (end <= start) return null;
+  const { starts, lengths } = joined;
+  let lo = 0;
+  let hi = starts.length - 1;
+  let index = -1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    if (starts[mid] <= start) {
+      index = mid;
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  if (index < 0) return null;
+  const segmentStart = starts[index];
+  const segmentEnd = segmentStart + lengths[index];
+  if (start >= segmentEnd || end > segmentEnd) return null;
+  return { segmentIndex: index, start: start - segmentStart, end: end - segmentStart };
+}
+
+// src/proof/frontmatter.ts
+var PROOF_FRONTMATTER_KEYS = Object.freeze({
+  enabled: { canonical: "squisq-proofing", legacy: "proofing" },
+  dialect: { canonical: "squisq-proof-dialect", legacy: "proof-dialect" },
+  dictionary: { canonical: "squisq-proof-dictionary", legacy: "proof-dictionary" }
+});
+var DEFAULT_PROOF_SETTINGS = Object.freeze({
+  enabled: true,
+  dialect: "American"
+});
+function readSetting(frontmatter, keys) {
+  if (!frontmatter) return void 0;
+  return Object.prototype.hasOwnProperty.call(frontmatter, keys.canonical) ? frontmatter[keys.canonical] : frontmatter[keys.legacy];
+}
+function resolveBoolean(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (["true", "yes", "on"].includes(normalized)) return true;
+  if (["false", "no", "off"].includes(normalized)) return false;
+  return void 0;
+}
+function resolveProofDialect(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim().toLowerCase();
+  return PROOF_DIALECTS.find((dialect) => dialect.toLowerCase() === normalized);
+}
+function parseProofDictionary(value) {
+  const raw = [];
+  if (typeof value === "string") {
+    raw.push(...value.split(/[,\s]+/));
+  } else if (Array.isArray(value)) {
+    for (const entry of value) {
+      if (typeof entry === "string") raw.push(...entry.split(/[,\s]+/));
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const words = [];
+  for (const candidate of raw) {
+    const word = candidate.trim();
+    if (word.length === 0 || seen.has(word)) continue;
+    seen.add(word);
+    words.push(word);
+  }
+  return words;
+}
+function formatProofDictionary(words) {
+  const deduped = parseProofDictionary([...words]);
+  return deduped.length > 0 ? deduped.join(", ") : null;
+}
+function readProofingSettings(frontmatter) {
+  return {
+    enabled: resolveBoolean(readSetting(frontmatter, PROOF_FRONTMATTER_KEYS.enabled)),
+    dialect: resolveProofDialect(readSetting(frontmatter, PROOF_FRONTMATTER_KEYS.dialect)),
+    dictionary: parseProofDictionary(readSetting(frontmatter, PROOF_FRONTMATTER_KEYS.dictionary))
+  };
+}
+
+export {
+  PROOF_DIALECTS,
+  LINT_KIND_CATEGORIES,
+  categorizeLintKind,
+  blankProtectedSpans,
+  dropMaskedFindings,
+  PROOF_JOIN_SEPARATOR,
+  buildJoinedText,
+  mapJoinedSpanToSegment,
+  PROOF_FRONTMATTER_KEYS,
+  DEFAULT_PROOF_SETTINGS,
+  resolveProofDialect,
+  parseProofDictionary,
+  formatProofDictionary,
+  readProofingSettings
+};