@bendyline/squisq-formats 2.5.1 → 2.6.0

package/dist/{chunk-AD2WT564.js → chunk-Q77KNJIN.js}

@@ -1,8 +1,19 @@
+import {
+  planDataSidecar,
+  sidecarReferenceDoc
+} from "./chunk-DXYWKZ52.js";
+
 // src/csv/index.ts
 import { markdownToDoc } from "@bendyline/squisq/doc";
+import { stringifyMarkdown } from "@bendyline/squisq/markdown";
+import { MemoryContentContainer } from "@bendyline/squisq/storage";
 var DEFAULT_MAX_CSV_CELLS = 1e5;
 var DEFAULT_MAX_CSV_ROWS = 1e4;
 var DEFAULT_MAX_CSV_FIELD_CHARS = 1024 * 1024;
+var SIDECAR_CSV_LIMITS = Object.freeze({
+  maxCells: 2e7,
+  maxRows: 2e6
+});
 async function toText(data) {
   if (typeof data === "string") return data;
   if (typeof Blob !== "undefined" && data instanceof Blob) return data.text();
@@ -122,6 +133,37 @@ async function csvToMarkdownDoc(data, options = {}) {
 async function csvToDoc(data, options = {}) {
   return markdownToDoc(await csvToMarkdownDoc(data, options));
 }
+async function csvToContainer(data, options = {}) {
+  const plan = planDataSidecar(options.sourceName, "data.csv");
+  const mode = options.sidecar ?? "auto";
+  const text = (await toText(data)).replace(/^\uFEFF/, "");
+  const maxInlineRows = options.maxInlineRows ?? 100;
+  const maxInlineBytes = options.maxInlineBytes ?? 256 * 1024;
+  const originalBytes = typeof data === "string" ? new TextEncoder().encode(data).buffer : data instanceof Blob ? await data.arrayBuffer() : data;
+  let spillNeeded = mode === "always";
+  if (!spillNeeded && mode === "auto") {
+    const hasHeader = options.hasHeader ?? true;
+    const lineCount = (text.match(/\n/g) ?? []).length + (text.endsWith("\n") || !text ? 0 : 1);
+    const dataRows = Math.max(lineCount - (hasHeader ? 1 : 0), 0);
+    spillNeeded = originalBytes.byteLength > maxInlineBytes || dataRows > maxInlineRows;
+  }
+  const markdownDoc = spillNeeded ? sidecarReferenceDoc(plan) : await csvToMarkdownDoc(text, options);
+  const container = new MemoryContentContainer();
+  await container.writeDocument(stringifyMarkdown(markdownDoc), plan.markdownFilename);
+  if (spillNeeded) {
+    await container.writeFile(plan.sidecarPath, originalBytes, "text/csv");
+  }
+  return container;
+}
+function serializeCsvRows(rows, options = {}) {
+  const delimiter = validateDelimiter(options.delimiter ?? ",");
+  const newline = options.newline ?? "\n";
+  const handling = options.formulaHandling ?? "preserve";
+  const body = rows.map(
+    (row) => row.map((cell) => escapeCsvField(neutralizeSpreadsheetFormula(cell, handling), delimiter)).join(delimiter)
+  ).join(newline);
+  return options.trailingNewline === false ? body : `${body}${newline}`;
+}
 function escapeCsvField(value, delimiter) {
   if (value.includes('"') || value.includes(delimiter) || /[\r\n]/.test(value)) {
     return `"${value.replace(/"/g, '""')}"`;
@@ -166,8 +208,11 @@ function markdownDocToCsv(doc, options = {}) {
 }
 
 export {
+  SIDECAR_CSV_LIMITS,
   parseCsv,
   csvToMarkdownDoc,
   csvToDoc,
+  csvToContainer,
+  serializeCsvRows,
   markdownDocToCsv
 };

package/dist/{chunk-TVUX3RUC.js → chunk-VDTGQ4MW.js}

@@ -1,7 +1,7 @@
 import {
   convert,
   defaultRegistry
-} from "./chunk-5JQ5NDRC.js";
+} from "./chunk-GRKQTQOF.js";
 import {
   ConversionError
 } from "./chunk-KXOZMWBS.js";

package/dist/{chunk-6RQOV3B3.js → chunk-VPWPEMZJ.js}

@@ -1,6 +1,6 @@
 import {
   extToMime
-} from "./chunk-AONELFLA.js";
+} from "./chunk-B7GEAZBI.js";
 
 // src/html/imageUtils.ts
 function inferMimeType(filename) {

package/dist/{chunk-FIOSE4BO.js → chunk-XJNOZTAY.js}

@@ -5,6 +5,9 @@ import {
   normalizeOoxmlHex,
   sanitizeOfficeHyperlink
 } from "./chunk-A6N6IN3I.js";
+import {
+  extToMime
+} from "./chunk-B7GEAZBI.js";
 import {
   stripHtmlTags
 } from "./chunk-AVOZAKGP.js";
@@ -47,6 +50,9 @@ import {
   requireMainPartPath,
   resolveTarget
 } from "./chunk-S5PCVMKU.js";
+import {
+  renumberFootnotes
+} from "./chunk-BXWNU4T5.js";
 import {
   buildContainer
 } from "./chunk-IIQYS2YH.js";
@@ -56,12 +62,6 @@ import {
   fontAwesomeGlyph,
   obfuscateDocxFont
 } from "./chunk-USU6HTKB.js";
-import {
-  extToMime
-} from "./chunk-AONELFLA.js";
-import {
-  renumberFootnotes
-} from "./chunk-BXWNU4T5.js";
 
 // src/docx/export.ts
 import { resolveFontFamily } from "@bendyline/squisq/schemas";

package/dist/csv/index.d.ts

@@ -1,5 +1,6 @@
 import { MarkdownDocument } from '@bendyline/squisq/markdown';
 import { Doc } from '@bendyline/squisq/schemas';
+import { ContentContainer } from '@bendyline/squisq/storage';
 
 /**
  * @bendyline/squisq-formats CSV Module
@@ -28,6 +29,27 @@ interface CsvImportOptions {
     maxFieldChars?: number;
     /** Cancel during parsing checkpoints. */
     signal?: AbortSignal;
+    /**
+     * Sidecar spill mode — only honored by `csvToContainer`, which can actually
+     * write the sidecar file. `'auto'` (default) spills past the inline
+     * thresholds; `'always'` always sidecars (the CSV-open-as-document mode:
+     * opening a data file means the FILE is the content); `'never'` keeps the
+     * inline table (`csvToMarkdownDoc`'s only behavior).
+     */
+    sidecar?: 'auto' | 'always' | 'never';
+    /** Max data rows kept inline before spilling (container import). Default 100. */
+    maxInlineRows?: number;
+    /** Max source bytes kept inline before spilling (container import). Default 256 KiB. */
+    maxInlineBytes?: number;
+}
+/** Options for {@link csvToContainer}. */
+interface CsvContainerOptions extends CsvImportOptions {
+    /**
+     * Source file name (e.g. `'Q3 Transactions.csv'`) — names the document
+     * (`q3-transactions.md`) and the sidecar path
+     * (`q3-transactions_files/data/Q3 Transactions.csv`). Default `'data.csv'`.
+     */
+    sourceName?: string;
 }
 interface CsvExportOptions {
     /** Field delimiter. Default `,`. */
@@ -56,12 +78,56 @@ interface CsvSafetyLimits {
     maxFieldChars?: number;
     signal?: AbortSignal;
 }
+/**
+ * Generous caps for the DATA-SIDECAR tier — the grid ingest and the
+ * full-body sidecar readers. The conservative `parseCsv` defaults protect
+ * the INLINE pipeline (a 100k-cell markdown table can't reparse anyway),
+ * but sidecar data exists precisely because it is big: it renders windowed
+ * and virtualized, so the ceiling here is the columnar store's ~20M-cell
+ * design wall, not the editor debounce. Every sidecar-path caller passes
+ * these; without them a 20 MB upload silently dead-ends at the parser cap.
+ */
+declare const SIDECAR_CSV_LIMITS: CsvSafetyLimits;
 /** Parse CSV text into a grid of string cells (RFC 4180: quotes, escaped quotes). */
 declare function parseCsv(text: string, delimiter?: string, limits?: CsvSafetyLimits): string[][];
 /** Convert CSV to a MarkdownDocument containing a single table. */
 declare function csvToMarkdownDoc(data: ArrayBuffer | Blob | string, options?: CsvImportOptions): Promise<MarkdownDocument>;
 /** Convert CSV to a squisq Doc. */
 declare function csvToDoc(data: ArrayBuffer | Blob | string, options?: CsvImportOptions): Promise<Doc>;
+/**
+ * Import a CSV into a ContentContainer: the markdown document plus, when the
+ * data crosses the inline thresholds (or `sidecar: 'always'`), the ORIGINAL
+ * bytes as a `<docbasename>_files/data/<name>` sidecar referenced via
+ * `{[dataTable src=…]}` with a body link.
+ *
+ * Below the thresholds the markdown is byte-identical to `csvToMarkdownDoc`'s
+ * output and no sidecar is written.
+ */
+declare function csvToContainer(data: ArrayBuffer | Blob | string, options?: CsvContainerOptions): Promise<ContentContainer>;
+/** Options for {@link serializeCsvRows}. */
+interface SerializeCsvRowsOptions {
+    /** Field delimiter. Default `,`. */
+    delimiter?: string;
+    /** Line terminator. Default `\n`. */
+    newline?: '\r\n' | '\n';
+    /** Emit a terminating newline after the last row. Default true. */
+    trailingNewline?: boolean;
+    /**
+     * Formula neutralization. Default **`'preserve'`** — the OPPOSITE of the
+     * export default, deliberately: this API re-serializes EXISTING data (the
+     * grid's save path), and `SPREADSHEET_FORMULA_PREFIX` matches a leading
+     * `-`/`+`, so blanket escaping would corrupt every negative number in a
+     * re-saved file. Callers neutralize specific cells themselves (the grid
+     * escapes only journal-edited, non-numeric cells).
+     */
+    formulaHandling?: 'escape' | 'preserve';
+}
+/**
+ * Serialize a plain row matrix to CSV text — the write half of `parseCsv`,
+ * used by the grid's sidecar save. RFC-4180 quoting via the same escaper
+ * the exporter uses.
+ */
+declare function serializeCsvRows(rows: readonly (readonly string[])[], options?: SerializeCsvRowsOptions): string;
 /**
  * Serialize one table in a MarkdownDocument to CSV text.
  *
@@ -72,4 +138,4 @@ declare function csvToDoc(data: ArrayBuffer | Blob | string, options?: CsvImport
  */
 declare function markdownDocToCsv(doc: MarkdownDocument, options?: CsvExportOptions): string;
 
-export { type CsvExportOptions, type CsvImportOptions, type CsvSafetyLimits, csvToDoc, csvToMarkdownDoc, markdownDocToCsv, parseCsv };
+export { type CsvContainerOptions, type CsvExportOptions, type CsvImportOptions, type CsvSafetyLimits, SIDECAR_CSV_LIMITS, type SerializeCsvRowsOptions, csvToContainer, csvToDoc, csvToMarkdownDoc, markdownDocToCsv, parseCsv, serializeCsvRows };

package/dist/csv/index.js

@@ -1,12 +1,19 @@
 import {
+  SIDECAR_CSV_LIMITS,
+  csvToContainer,
   csvToDoc,
   csvToMarkdownDoc,
   markdownDocToCsv,
-  parseCsv
-} from "../chunk-AD2WT564.js";
+  parseCsv,
+  serializeCsvRows
+} from "../chunk-Q77KNJIN.js";
+import "../chunk-DXYWKZ52.js";
 export {
+  SIDECAR_CSV_LIMITS,
+  csvToContainer,
   csvToDoc,
   csvToMarkdownDoc,
   markdownDocToCsv,
-  parseCsv
+  parseCsv,
+  serializeCsvRows
 };

package/dist/data/index.d.ts

@@ -0,0 +1,78 @@
+import { DataSourceReader } from '@bendyline/squisq/doc';
+import { ContentContainer } from '@bendyline/squisq/storage';
+import { MarkdownDocument } from '@bendyline/squisq/markdown';
+
+/**
+ * Sidecar data readers — the format implementations behind core's
+ * `DataSourceReader` seam (`resolveDataReferences`).
+ *
+ * Core stays parser-free; these readers decode the actual bytes of a
+ * `{[dataTable src=…]}` sidecar into the bounded `DataSourceTable` window the
+ * projections render. CSV/TSV wrap the RFC-4180 parser, XLSX reuses the
+ * import pipeline's typed region detection (`xlsxToTables`), and parquet
+ * loads hyparquet lazily so its bytes never reach consumers that don't
+ * reference parquet files.
+ */
+
+declare const csvDataReader: DataSourceReader;
+declare const xlsxDataReader: DataSourceReader;
+declare const parquetDataReader: DataSourceReader;
+/** The full reader set for `resolveDataReferences({ readers })`. */
+declare function defaultDataReaders(): DataSourceReader[];
+
+/**
+ * Materialize `{[dataTable src=…]}` sidecar references into inline markdown
+ * tables — the FULL data, not the bounded preview. Used by exports that
+ * embed values (XLSX: a src-referenced block would otherwise contribute no
+ * table and silently vanish from the workbook).
+ *
+ * Never throws: a missing container, unreadable file, or absent reader
+ * degrades to an `onWarning` message and the reference block is left as-is
+ * (its body link simply doesn't survive a tables-only export).
+ */
+
+/**
+ * Returns a copy of `markdownDoc` where every heading annotated with a
+ * resolvable data `src` is followed by the full source table. The input
+ * document is returned unchanged (same object) when nothing materialized.
+ */
+declare function materializeDataReferences(markdownDoc: MarkdownDocument, container: ContentContainer | null | undefined, onWarning?: (message: string) => void): Promise<MarkdownDocument>;
+
+/**
+ * Sidecar naming shared by the spill-capable importers (`xlsxToContainer`,
+ * `csvToContainer`): one place decides the document filename and the
+ * `<docbasename>_files/data/<file>` path a spilled reference points at, so
+ * the markdown `src` param and the container write can never disagree.
+ */
+
+/** Strip any path components from a user-supplied source file name. */
+declare function sanitizeSourceFileName(name: string | undefined, fallback: string): string;
+/**
+ * Doc basename slug for a source file name — the outside-in `slugStem`
+ * rules (NFKD, strip marks, lowercase, non-alphanumeric → `-`), applied to
+ * the name without its extension. `'Q3 Report.xlsx'` → `'q3-report'`.
+ */
+declare function docSlugForFileName(fileName: string): string;
+/** Where a spill-capable import writes its document and sidecar. */
+interface DataSidecarPlan {
+    /** Doc basename slug, e.g. `'q3-report'`. */
+    slug: string;
+    /** Document filename inside the container, e.g. `'q3-report.md'`. */
+    markdownFilename: string;
+    /** Sidecar file name (source name, path components stripped). */
+    fileName: string;
+    /** Container path the `src` param references, e.g. `'q3-report_files/data/Q3 Report.xlsx'`. */
+    sidecarPath: string;
+}
+declare function planDataSidecar(sourceName: string | undefined, fallbackName: string): DataSidecarPlan;
+/**
+ * The reference block a fully-sidecarred data file becomes: an annotated
+ * heading (`# <title> {[dataTable src=…]}`) plus the graceful-degradation
+ * body link. Built as an AST so annotation quoting and link escaping go
+ * through the one stringifier that knows the rules.
+ */
+declare function sidecarReferenceDoc(plan: DataSidecarPlan): MarkdownDocument;
+/** {@link sidecarReferenceDoc} as serialized markdown source. */
+declare function sidecarReferenceMarkdown(plan: DataSidecarPlan): string;
+
+export { type DataSidecarPlan, csvDataReader, defaultDataReaders, docSlugForFileName, materializeDataReferences, parquetDataReader, planDataSidecar, sanitizeSourceFileName, sidecarReferenceDoc, sidecarReferenceMarkdown, xlsxDataReader };

package/dist/data/index.js

@@ -0,0 +1,30 @@
+import {
+  csvDataReader,
+  defaultDataReaders,
+  materializeDataReferences,
+  parquetDataReader,
+  xlsxDataReader
+} from "../chunk-FLR2ARKC.js";
+import "../chunk-OBADJV7C.js";
+import "../chunk-Q77KNJIN.js";
+import {
+  docSlugForFileName,
+  planDataSidecar,
+  sanitizeSourceFileName,
+  sidecarReferenceDoc,
+  sidecarReferenceMarkdown
+} from "../chunk-DXYWKZ52.js";
+import "../chunk-S5PCVMKU.js";
+import "../chunk-7AWFHP5U.js";
+export {
+  csvDataReader,
+  defaultDataReaders,
+  docSlugForFileName,
+  materializeDataReferences,
+  parquetDataReader,
+  planDataSidecar,
+  sanitizeSourceFileName,
+  sidecarReferenceDoc,
+  sidecarReferenceMarkdown,
+  xlsxDataReader
+};

package/dist/docx/index.js

@@ -4,17 +4,17 @@ import {
   docxToDoc,
   docxToMarkdownDoc,
   markdownDocToDocx
-} from "../chunk-FIOSE4BO.js";
+} from "../chunk-XJNOZTAY.js";
 import "../chunk-A6N6IN3I.js";
+import "../chunk-B7GEAZBI.js";
 import "../chunk-AVOZAKGP.js";
 import "../chunk-ILCJ3WFD.js";
 import "../chunk-JU2RHXUB.js";
 import "../chunk-S5PCVMKU.js";
 import "../chunk-7AWFHP5U.js";
+import "../chunk-BXWNU4T5.js";
 import "../chunk-IIQYS2YH.js";
 import "../chunk-USU6HTKB.js";
-import "../chunk-AONELFLA.js";
-import "../chunk-BXWNU4T5.js";
 export {
   docToDocx,
   docxToContainer,

package/dist/epub/index.js

@@ -1,13 +1,13 @@
 import {
   docToEpub,
   markdownDocToEpub
-} from "../chunk-2LT3JL7U.js";
+} from "../chunk-3ITGQRL5.js";
+import "../chunk-VPWPEMZJ.js";
+import "../chunk-B7GEAZBI.js";
 import "../chunk-AVOZAKGP.js";
 import "../chunk-JU2RHXUB.js";
-import "../chunk-USU6HTKB.js";
-import "../chunk-6RQOV3B3.js";
-import "../chunk-AONELFLA.js";
 import "../chunk-BXWNU4T5.js";
+import "../chunk-USU6HTKB.js";
 export {
   docToEpub,
   markdownDocToEpub

package/dist/{export-Boq78GMq.d.ts → export-6iQXd-lQ.d.ts}

@@ -1,5 +1,6 @@
 import { MarkdownInlineNode, MarkdownDocument } from '@bendyline/squisq/markdown';
-import { O as OoxmlOpenOptions } from './reader-B_m1aKZC.js';
+import { O as OoxmlOpenOptions, a as OoxmlPackage } from './reader-B_m1aKZC.js';
+import { ContentContainer } from '@bendyline/squisq/storage';
 import { Doc } from '@bendyline/squisq/schemas';
 
 /**
@@ -38,6 +39,14 @@ interface XlsxCell {
      * cell reads this, and only when it is present.
      */
     richText?: MarkdownInlineNode[];
+    /**
+     * Set when the cell participates in a shared (fill-down) formula group:
+     * `'master'` holds the group's text, `'follower'` inherits by translation.
+     * Consumers that EDIT formulas need this — the in-place patcher refuses
+     * to replace a master (its followers' `si` would dangle) while a
+     * follower may safely leave its group.
+     */
+    sharedFormulaRole?: 'master' | 'follower';
     /**
      * The cell's value as the sheet stores it, before number formatting.
      *
@@ -64,6 +73,21 @@ interface CellRect {
     bottom: number;
     right: number;
 }
+/** A parsed cell address. */
+interface ParsedCellRef {
+    row: number;
+    col: number;
+}
+/**
+ * Parse a full cell ref into zero-based coordinates, rejecting anything that
+ * is not a plain in-range A1 address. `$` anchors are accepted and ignored —
+ * an anchor says how a ref behaves when copied, not where it points.
+ *
+ * Returns null for a malformed ref, a ref past `XFD1048576`, or a range.
+ */
+declare function parseCellRef(ref: string): ParsedCellRef | null;
+/** Format zero-based coordinates as a cell ref (`0, 1` → `"B1"`). */
+declare function formatCellRef(row: number, col: number): string;
 
 /**
  * XLSX → typed tables, for consumers reading a workbook as **data**.
@@ -179,7 +203,38 @@ interface XlsxImportOptions extends OoxmlOpenOptions {
     maxRegionsPerSheet?: number;
     /** Smallest island that stays a table of its own. Default 2 — single cells coalesce. */
     minRegionCells?: number;
+    /**
+     * Sidecar spill mode — only honored by `xlsxToContainer`, which can actually
+     * write the sidecar file the reference points at. `'auto'` (default) spills a
+     * region past the inline thresholds to a `{[dataTable src=…]}` reference;
+     * `'always'` spills every region; `'never'` keeps everything inline
+     * (`xlsxToMarkdownDoc`'s only behavior — a doc-only import has nowhere to
+     * put the bytes, and a `src` with no sidecar is a broken reference).
+     */
+    sidecar?: 'auto' | 'always' | 'never';
+    /** Max data rows a region keeps inline before spilling (container import). Default 100. */
+    maxInlineRows?: number;
+    /** Max cells a region keeps inline before spilling (container import). Default 2000. */
+    maxInlineCells?: number;
+}
+/** Options for {@link xlsxToContainer}. */
+interface XlsxContainerOptions extends XlsxImportOptions {
+    /**
+     * Source file name (e.g. `'Q3 Report.xlsx'`) — names the document
+     * (`q3-report.md`) and the sidecar path
+     * (`q3-report_files/data/Q3 Report.xlsx`). Default `'workbook.xlsx'`.
+     */
+    sourceName?: string;
+}
+interface SheetRef {
+    name: string;
+    path: string;
 }
+/**
+ * List the workbook's sheets — name plus resolved worksheet part path, in
+ * workbook order. Shared by import and the in-place cell patcher.
+ */
+declare function listSheetParts(pkg: OoxmlPackage, mainPart: string): Promise<SheetRef[]>;
 /**
  * Read a workbook as typed tables rather than as a document.
  *
@@ -189,7 +244,48 @@ interface XlsxImportOptions extends OoxmlOpenOptions {
  * number format.
  */
 declare function xlsxToTables(data: ArrayBuffer | Blob, options?: XlsxImportOptions & XlsxTablesOptions): Promise<XlsxTable[]>;
+/** One worksheet's raw cell grid, as parsed (formulas + cached values intact). */
+interface XlsxSheetGrid {
+    name: string;
+    /** Row-major grid; rows may be ragged. Each cell keeps `formula` AND `value`. */
+    cells: XlsxCell[][];
+    merges: CellRect[];
+}
+/** A workbook as raw cell grids, plus the workbook-level calc facts. */
+interface XlsxWorkbookGrids {
+    sheets: XlsxSheetGrid[];
+    date1904: boolean;
+    /**
+     * `<calcPr fullCalcOnLoad="1"/>`: the producer disowned its cached formula
+     * values. A cached-value oracle must skip such workbooks, and a consumer
+     * re-hosting the formulas in a calculation engine should recompute rather
+     * than trust `value`.
+     */
+    fullCalcOnLoad: boolean;
+}
+/**
+ * Read a workbook as raw cell grids — the lowest-level public view.
+ *
+ * Unlike {@link xlsxToTables} (typed regions, formulas dropped) and
+ * {@link xlsxToMarkdownDoc} (rendered for people), this hands over every
+ * parsed cell with its formula and cached value colocated. Two consumers:
+ * the corpus cached-value oracle (compare `formula` results against `value`)
+ * and calculation-engine feeding (`setUserInput`-style APIs need the raw
+ * grid, not a detected region).
+ */
+declare function xlsxToCellGrids(data: ArrayBuffer | Blob, options?: XlsxImportOptions): Promise<XlsxWorkbookGrids>;
 declare function xlsxToMarkdownDoc(data: ArrayBuffer | Blob, options?: XlsxImportOptions): Promise<MarkdownDocument>;
+/**
+ * Import a workbook into a ContentContainer: the markdown document plus, when
+ * a region crossed the inline thresholds (or `sidecar: 'always'`), the
+ * ORIGINAL workbook bytes as a `<docbasename>_files/data/<name>` sidecar that
+ * spilled regions reference via `{[dataTable src=… sheet=… anchor=…]}`.
+ *
+ * Small regions emit byte-identically to `xlsxToMarkdownDoc` — the historical
+ * round-trip contract is untouched below the thresholds, and with
+ * `sidecar: 'never'` the container is just the doc-only import in a box.
+ */
+declare function xlsxToContainer(data: ArrayBuffer | Blob, options?: XlsxContainerOptions): Promise<ContentContainer>;
 
 /**
  * XLSX export — MarkdownDocument → SpreadsheetML (.xlsx).
@@ -267,4 +363,4 @@ declare function markdownDocToXlsx(doc: MarkdownDocument, options?: XlsxExportOp
  */
 declare function docToXlsx(doc: Doc, options?: XlsxExportOptions): Promise<ArrayBuffer>;
 
-export { type XlsxExportOptions as X, type XlsxImportOptions as a, type XlsxTable as b, type XlsxTableColumn as c, type XlsxTablesOptions as d, docToXlsx as e, xlsxToTables as f, gridToTables as g, markdownDocToXlsx as m, xlsxToMarkdownDoc as x };
+export { type CellRect as C, type SheetRef as S, type XlsxExportOptions as X, type XlsxImportOptions as a, type XlsxTable as b, type XlsxTableColumn as c, type XlsxTablesOptions as d, docToXlsx as e, xlsxToTables as f, gridToTables as g, type XlsxCell as h, type XlsxCellKind as i, type XlsxContainerOptions as j, type XlsxSheetGrid as k, type XlsxWorkbookGrids as l, markdownDocToXlsx as m, formatCellRef as n, listSheetParts as o, parseCellRef as p, xlsxToCellGrids as q, xlsxToContainer as r, xlsxToMarkdownDoc as x };

package/dist/html/index.d.ts

@@ -1,6 +1,6 @@
 import { Theme, ThemeRegistry, Doc } from '@bendyline/squisq/schemas';
-import { H as HtmlExportOptions } from '../import-B0gBYUmd.js';
-export { a as HtmlImportOptions, c as collectImagePaths, g as generateExternalHtml, h as htmlToMarkdown, b as htmlToMarkdownDoc, d as htmlToMarkdownDocSync } from '../import-B0gBYUmd.js';
+import { H as HtmlExportOptions } from '../import-C7c9tQHK.js';
+export { a as HtmlImportOptions, c as collectImagePaths, g as generateExternalHtml, h as htmlToMarkdown, b as htmlToMarkdownDoc, d as htmlToMarkdownDocSync } from '../import-C7c9tQHK.js';
 import { HtmlPolicy, MarkdownDocument } from '@bendyline/squisq/markdown';
 
 /**
@@ -183,12 +183,6 @@ interface PlainHtmlBundleOptions {
  * references rewritten from `.md` to `.html`.
  */
 declare function markdownDocsToPlainHtmlBundle(options: PlainHtmlBundleOptions): Promise<Blob>;
-/**
- * Collect every `<a>`-style link URL referenced in a document. Markdown
- * `link` nodes plus any raw HTML `<a href>` tags. Returns the raw URLs
- * as authored, so callers can use them as both the linkMap *key* and
- * the basis for resolution.
- */
 declare function collectLinkRefs(doc: MarkdownDocument): Set<string>;
 
 /**

package/dist/html/index.js

@@ -10,13 +10,13 @@ import {
   markdownDocToPlainHtml,
   markdownDocsToHtmlBundle,
   markdownDocsToPlainHtmlBundle
-} from "../chunk-T4PX33AG.js";
+} from "../chunk-EEDQRZ2M.js";
 import {
   arrayBufferToBase64DataUrl,
   extractFilename,
   inferMimeType
-} from "../chunk-6RQOV3B3.js";
-import "../chunk-AONELFLA.js";
+} from "../chunk-VPWPEMZJ.js";
+import "../chunk-B7GEAZBI.js";
 import "../chunk-BXWNU4T5.js";
 export {
   arrayBufferToBase64DataUrl,

package/dist/{images-ESPQKVTW.js → images-JLBFCDD4.js}

@@ -1,6 +1,6 @@
 import {
   extToMime
-} from "./chunk-AONELFLA.js";
+} from "./chunk-B7GEAZBI.js";
 export {
   extToMime
 };

package/dist/{import-B0gBYUmd.d.ts → import-C7c9tQHK.d.ts}

@@ -41,8 +41,11 @@ interface HtmlExportOptions {
      * Only used in ZIP exports — single HTML uses timer-based playback.
      */
     audio?: Map<string, ArrayBuffer>;
-    /** Rendering mode: 'slideshow' (interactive, default) or 'static' (scrollable) */
-    mode?: 'slideshow' | 'static';
+    /**
+     * Rendering mode: 'slideshow' (interactive, default), 'video' (timed
+     * auto-advance movie playback), or 'static' (scrollable).
+     */
+    mode?: 'slideshow' | 'video' | 'static';
     /** HTML page title (default: 'Squisq Document') */
     title?: string;
     /** Auto-play slideshow on load (default: false) */

package/dist/index.d.ts

@@ -6,13 +6,13 @@ export { PdfExportOptions, PdfImportOptions, configurePdfWorker, docToPdf, markd
 export { HtmlZipExportOptions, docToHtml, docToHtmlZip } from './html/index.js';
 export { EpubExportOptions, docToEpub, markdownDocToEpub } from './epub/index.js';
 export { ExtractedFileTheme, InferSourceFormat, InferThemeOptions, InferredFileTheme, compileExtractedTheme, inferThemeFromFile } from './infer/index.js';
-export { B as BUILTIN_FORMAT_IDS, a as BuiltinFormatOptions, C as ConversionLimits, b as ConversionResult, c as ConvertOptions, d as ConvertSource, D as DEFAULT_CONVERSION_LIMITS, e as DbkFormatOptions, F as FormatDefinition, f as FormatId, g as FormatRegistry, M as MarkdownFormatOptions, N as NormalizedInput, P as PreparedConversion, h as PreparedExportOptions, r as resolveConversionLimits } from './types-bwP9PBSk.js';
+export { B as BUILTIN_FORMAT_IDS, a as BuiltinFormatOptions, C as ConversionLimits, b as ConversionResult, c as ConvertOptions, d as ConvertSource, D as DEFAULT_CONVERSION_LIMITS, e as DbkFormatOptions, F as FormatDefinition, f as FormatId, g as FormatRegistry, M as MarkdownFormatOptions, N as NormalizedInput, P as PreparedConversion, h as PreparedExportOptions, r as resolveConversionLimits } from './types-Dzd_5H2A.js';
 export { ConversionError, ConversionErrorCode, ConversionErrorOptions, convert, createRegistry, defaultFormats, defaultRegistry, prepareConversion } from './registry/index.js';
 export { ImportedOutsideInDocument, OUTSIDE_IN_FORMAT_IDS, OUTSIDE_IN_UPDATE_FROM_MARKDOWN_KEY, OutsideInFormatId, OutsideInLayout, OutsideInMetadata, RenderOutsideInOptions, chooseOutsideInMarkdownPath, importOutsideInDocument, isOutsideInMarkdownEditingEnabled, isOutsideInTargetPath, readOutsideInMetadata, renderOutsideInDocument, resolveOutsideInLayout, withOutsideInMarkdownEditing, withOutsideInMetadata } from './outside-in/index.js';
 export { Z as ZipSafetyError, a as ZipSafetyErrorCode, b as ZipSafetyErrorOptions, c as ZipSafetyLimits } from './zipLimits-BOKCB7qk.js';
-export { H as HtmlExportOptions, a as HtmlImportOptions, c as collectImagePaths, h as htmlToMarkdown, b as htmlToMarkdownDoc, d as htmlToMarkdownDocSync } from './import-B0gBYUmd.js';
+export { H as HtmlExportOptions, a as HtmlImportOptions, c as collectImagePaths, h as htmlToMarkdown, b as htmlToMarkdownDoc, d as htmlToMarkdownDocSync } from './import-C7c9tQHK.js';
 export { P as PptxExportOptions, a as PptxImportOptions, d as docToPptx, m as markdownDocToPptx, p as pptxToMarkdownDoc } from './import-C16E8Y4X.js';
-export { X as XlsxExportOptions, a as XlsxImportOptions, b as XlsxTable, c as XlsxTableColumn, d as XlsxTablesOptions, e as docToXlsx, g as gridToTables, m as markdownDocToXlsx, x as xlsxToMarkdownDoc, f as xlsxToTables } from './export-Boq78GMq.js';
+export { X as XlsxExportOptions, a as XlsxImportOptions, b as XlsxTable, c as XlsxTableColumn, d as XlsxTablesOptions, e as docToXlsx, g as gridToTables, m as markdownDocToXlsx, x as xlsxToMarkdownDoc, f as xlsxToTables } from './export-6iQXd-lQ.js';
 import '@bendyline/squisq/schemas';
 import '@bendyline/squisq/markdown';
 import './reader-B_m1aKZC.js';