@bendyline/squisq-formats 2.5.0 → 2.6.0

package/dist/export-6iQXd-lQ.d.ts

@@ -0,0 +1,366 @@
+import { MarkdownInlineNode, MarkdownDocument } from '@bendyline/squisq/markdown';
+import { O as OoxmlOpenOptions, a as OoxmlPackage } from './reader-B_m1aKZC.js';
+import { ContentContainer } from '@bendyline/squisq/storage';
+import { Doc } from '@bendyline/squisq/schemas';
+
+/**
+ * Shared SpreadsheetML cell model and A1-reference arithmetic.
+ *
+ * Import and export both need to move between a zero-based `(row, col)` grid
+ * and Excel's `"B7"` addressing. That logic used to exist twice — `colIndex`
+ * in `import.ts` and `columnLetter` in `export.ts` — as two halves of the same
+ * bijection that never met. It lives here now, together with the richer cell
+ * record the region splitter needs.
+ *
+ * {@link XlsxCell} carries three things the old plain-string grid could not:
+ * the cell's *kind* (so a header row can be told apart from a data row, and so
+ * export can safely re-emit a number as a number), and its *formula* (so a
+ * round trip through markdown keeps `=B2*C2` rather than freezing the cached
+ * result).
+ */
+
+/** What a cell holds, beyond its display text. */
+type XlsxCellKind = 'empty' | 'string' | 'number' | 'bool' | 'date' | 'error';
+/** A single worksheet cell. */
+interface XlsxCell {
+    /** Display text — the plain string, with all run formatting flattened out. */
+    text: string;
+    /** What the cell holds. `empty` iff `text` is `''`. */
+    kind: XlsxCellKind;
+    /** Formula source WITHOUT the leading `=`, when the cell carries one. */
+    formula?: string;
+    /**
+     * Inline markdown for a cell whose rich text carries formatting worth
+     * keeping — today, superscript/subscript runs (`Fresh<sup>1</sup>`).
+     *
+     * Deliberately additive: `text` remains the flattened string, so region
+     * detection, header sniffing, numeric inference and export placement all
+     * keep working on exactly the value they saw before. Only the markdown table
+     * 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.
+     *
+     * `text` is a rendering for people, and rendering destroys information a
+     * consumer doing arithmetic needs: a percent-formatted `0.15` renders as
+     * `"15.0%"`, a date is a serial rendered as text, and a zero-padded `7`
+     * renders as `"007"`. Anything reading a sheet as *data* — rather than as a
+     * document — must read this instead.
+     *
+     * Normalized rather than literally raw, where a literal value would be
+     * useless: a date arrives as an ISO `YYYY-MM-DD` (or `YYYY-MM-DD HH:MM`)
+     * string rather than an Excel serial, because the serial's meaning depends
+     * on a workbook-level 1900/1904 epoch flag that no downstream consumer
+     * should have to carry. Numbers, booleans and strings are exact.
+     *
+     * Absent for `empty` and `error` cells, which have no value to speak of.
+     */
+    value?: number | boolean | string;
+}
+/** A zero-based, inclusive rectangle of cells. */
+interface CellRect {
+    top: number;
+    left: number;
+    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**.
+ *
+ * `xlsxToMarkdownDoc` renders a workbook for people: it flattens each cell to
+ * the string the sheet displays. That rendering is lossy in exactly the ways
+ * arithmetic cares about — a percent-formatted `0.15` becomes `"15.0%"`, a
+ * date becomes text, a zero-padded `7` becomes `"007"` — so anything that
+ * needs to sum, average or compare must not go through it.
+ *
+ * This module is the other path. It reuses the same region detection (a sheet
+ * is not one table; it is several islands with labels and totals in the gaps)
+ * and emits each island's cells as their underlying values, with the type the
+ * sheet gave them.
+ *
+ * Two kinds of region are deliberately excluded from the result. A
+ * `formulas` companion is presentation — the same cells again, showing their
+ * expressions rather than their results — and a `loose` bucket is stray labels
+ * and notes, which have no columns to speak of. Both are useful to a reader
+ * and meaningless to a query, so a consumer asking for tables gets neither.
+ */
+
+/** One column of a detected table. */
+interface XlsxTableColumn {
+    /** Header text when the region has a header row; otherwise a column letter. */
+    name: string;
+    /**
+     * The dominant cell kind in the column's body, so a consumer can pick a
+     * storage type without re-sniffing. `mixed` when no single kind holds a
+     * majority — the honest answer for a column that really is heterogeneous.
+     */
+    kind: XlsxCellKind | 'mixed';
+}
+/** One data island, as values rather than as display text. */
+interface XlsxTable {
+    /** Worksheet name. */
+    sheet: string;
+    /** A1 address of the region's top-left cell, e.g. `B4`. */
+    anchor: string;
+    /** Caption absorbed from directly above the region, when there was one. */
+    title?: string;
+    columns: XlsxTableColumn[];
+    /** True when row 0 was read as a header and is therefore not a data row. */
+    hasHeader: boolean;
+    /**
+     * Body rows, header excluded. A cell with no value — blank, or an error —
+     * is `null` rather than absent, so every row has the same arity as
+     * `columns`.
+     */
+    rows: (string | number | boolean | null)[][];
+}
+interface XlsxTablesOptions {
+    /** Restrict to one sheet, by zero-based index or by name. */
+    sheet?: number | string;
+    maxRegionsPerSheet?: number;
+    minRegionCells?: number;
+    /** Skip regions with fewer than this many body rows. Default 1. */
+    minRows?: number;
+    signal?: AbortSignal;
+}
+/**
+ * Split one sheet's grid into typed tables.
+ *
+ * Exported separately from the workbook entry point so a caller that already
+ * has a grid — a test, or a consumer streaming sheets itself — does not have
+ * to re-open the package.
+ */
+declare function gridToTables(sheet: string, grid: readonly (readonly XlsxCell[])[], merges?: readonly CellRect[], options?: XlsxTablesOptions): XlsxTable[];
+
+/**
+ * XLSX import — SpreadsheetML (.xlsx) → MarkdownDocument.
+ *
+ * Reuses the shared ooxml/ reader (zip + DOMParser). Reads the workbook's sheet
+ * list, resolves each sheet part via relationships, pulls shared strings, and
+ * turns each worksheet into markdown. By default every sheet is imported, each
+ * preceded by an H1 of the sheet name; pass `options.sheet` (index or name) to
+ * import just one.
+ *
+ * A sheet is NOT one table. It is usually several tables scattered across the
+ * grid with stray labels and notes in the gaps, so by default each worksheet is
+ * split into its contiguous data islands (see `regions.ts`) and every island
+ * becomes its own block:
+ *
+ * ```markdown
+ * ## Q3 Revenue {[dataTable sheet=Sales anchor=B7]}
+ * ```
+ *
+ * The `sheet`/`anchor` params on the heading annotation are what let
+ * `markdownDocToXlsx` put each table back where it came from, so the round trip
+ * reproduces addresses rather than piling everything at A1. A region holding
+ * formulas additionally emits a `role=formulas` companion table, and every
+ * left-over single cell on a sheet collects into one `role=loose` table.
+ *
+ * Pass `{ regions: false }` for the historical behavior: one table per sheet,
+ * spanning the whole used range.
+ */
+
+interface XlsxImportOptions extends OoxmlOpenOptions {
+    /** Which sheet to import (0-based index or sheet name). Default: all sheets. */
+    sheet?: number | string;
+    /**
+     * Split each sheet into its contiguous data islands, one block each, anchored
+     * with `{[dataTable sheet=… anchor=…]}`. Default true. Set false for the
+     * historical one-table-per-sheet output.
+     */
+    regions?: boolean;
+    /**
+     * Emit a `role=formulas` companion table for regions that contain formulas.
+     * Default true. Ignored when `regions` is false.
+     */
+    formulas?: boolean;
+    /** Cap on region tables per sheet before the rest fold into loose cells. Default 64. */
+    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.
+ *
+ * The data counterpart to {@link xlsxToMarkdownDoc}: same package, same sheet
+ * selection, same region detection — but each island's cells arrive as their
+ * underlying values, so a consumer can sum a column without first undoing a
+ * 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).
+ *
+ * Tables-only fidelity (honestly documented): every `table` node in the
+ * markdown AST becomes worksheet cells; all other content (prose, lists,
+ * images, …) is dropped, and headings survive only as sheet names and as the
+ * carrier of placement metadata.
+ *
+ * Placement has two modes, decided per table by `workbookPlan.ts`. A table
+ * whose heading carries `{[dataTable sheet=… anchor=…]}` — what
+ * `xlsxToMarkdownDoc` emits for every data island it finds — is placed on the
+ * named sheet at the named cell, so several mini tables share one worksheet at
+ * their original addresses and formulas ride along. A table with no such
+ * annotation keeps the historical behavior exactly: its own worksheet, named
+ * from the nearest preceding heading, starting at A1.
+ *
+ * Cells are emitted as inline strings (`t="inlineStr"`) by default so no
+ * sharedStrings part is needed and identifier-like numbers remain lossless.
+ * Callers can explicitly opt into conservative numeric inference. The package
+ * is assembled with the shared ooxml/ writer (auto-generates
+ * `[Content_Types].xml` + `_rels`), so only the SpreadsheetML-specific parts
+ * (workbook, worksheets, styles) are written here.
+ *
+ * @example
+ * ```ts
+ * import { parseMarkdown } from '@bendyline/squisq/markdown';
+ * import { markdownDocToXlsx } from '@bendyline/squisq-formats/xlsx';
+ *
+ * const md = parseMarkdown('# Metrics\n\n| A | B |\n| - | - |\n| 1 | 2 |');
+ * const buffer = await markdownDocToXlsx(md);
+ * ```
+ */
+
+/**
+ * Options for XLSX export.
+ */
+interface XlsxExportOptions {
+    /** Cancel at bounded export checkpoints. */
+    signal?: AbortSignal;
+    /** Maximum cells emitted. Default: 100,000. */
+    maxCells?: number;
+    /** Workbook title (written to core properties). */
+    title?: string;
+    /** Workbook author (written to core properties). */
+    author?: string;
+    /** Prefix used for auto-named sheets when no heading precedes a table. Default: "Sheet". */
+    sheetNamePrefix?: string;
+    /**
+     * Emit canonical, Excel-safe number strings as numeric cells.
+     *
+     * Defaults to false for hand-authored documents — markdown tables have no
+     * column schema, so preserving authored text is the only lossless choice —
+     * and to true when the document carries `sheet=` anchors, which only an XLSX
+     * import produces. Leading-zero and >15-significant-digit values remain
+     * strings either way. Set explicitly to override both defaults.
+     */
+    inferNumericCells?: boolean;
+    /**
+     * Called for each non-fatal placement problem (a malformed anchor, an
+     * overlapping region, an unusable loose-cell reference). Export never throws
+     * for these — a hand-edited markdown file must still convert.
+     */
+    onWarning?: (message: string) => void;
+}
+/**
+ * Convert a MarkdownDocument to a .xlsx file (tables-only fidelity).
+ *
+ * Each markdown `table` becomes one worksheet; a document with no tables
+ * yields a single empty sheet (a valid, openable file — never throws).
+ */
+declare function markdownDocToXlsx(doc: MarkdownDocument, options?: XlsxExportOptions): Promise<ArrayBuffer>;
+/**
+ * Convert a squisq Doc to a .xlsx file (via the markdown table model).
+ */
+declare function docToXlsx(doc: Doc, options?: XlsxExportOptions): Promise<ArrayBuffer>;
+
+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-DByrrXeB.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, d as docToXlsx, m as markdownDocToXlsx, x as xlsxToMarkdownDoc } from './export-m0tr9r9d.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';

package/dist/index.js

@@ -1,13 +1,24 @@
+import {
+  collectImagePaths,
+  docToHtml,
+  docToHtmlZip,
+  htmlToMarkdown,
+  htmlToMarkdownDoc,
+  htmlToMarkdownDocSync
+} from "./chunk-EEDQRZ2M.js";
 import {
   docToEpub,
   markdownDocToEpub
-} from "./chunk-2LT3JL7U.js";
+} from "./chunk-3ITGQRL5.js";
 import {
   BUILTIN_FORMAT_IDS
 } from "./chunk-2P5HJAQL.js";
 import {
   inferThemeFromFile
-} from "./chunk-KMBBO5H7.js";
+} from "./chunk-7DQP2I57.js";
+import {
+  compileExtractedTheme
+} from "./chunk-2JJ5RFDZ.js";
 import {
   OUTSIDE_IN_FORMAT_IDS,
   OUTSIDE_IN_UPDATE_FROM_MARKDOWN_KEY,
@@ -20,7 +31,7 @@ import {
   resolveOutsideInLayout,
   withOutsideInMarkdownEditing,
   withOutsideInMetadata
-} from "./chunk-5PUIFU5I.js";
+} from "./chunk-VDTGQ4MW.js";
 import {
   DEFAULT_CONVERSION_LIMITS,
   convert,
@@ -29,41 +40,45 @@ import {
   defaultRegistry,
   prepareConversion,
   resolveConversionLimits
-} from "./chunk-JTGWQK5V.js";
+} from "./chunk-GRKQTQOF.js";
 import {
   ConversionError
 } from "./chunk-KXOZMWBS.js";
 import "./chunk-WATAOG4Y.js";
-import {
-  compileExtractedTheme
-} from "./chunk-2JJ5RFDZ.js";
 import {
   docToDocx,
   docxToDoc,
   docxToMarkdownDoc,
   markdownDocToDocx
-} from "./chunk-FIOSE4BO.js";
+} from "./chunk-XJNOZTAY.js";
 import {
   docToPptx,
   markdownDocToPptx,
   pptxToDoc,
   pptxToMarkdownDoc
-} from "./chunk-FMQWNPCV.js";
+} from "./chunk-AGGNLRHV.js";
 import "./chunk-6N2J7C2B.js";
+import "./chunk-VPWPEMZJ.js";
 import "./chunk-A6N6IN3I.js";
+import "./chunk-B7GEAZBI.js";
 import {
   docToXlsx,
   markdownDocToXlsx,
-  xlsxToDoc,
-  xlsxToMarkdownDoc
-} from "./chunk-A6LSCIO5.js";
+  xlsxToDoc
+} from "./chunk-CKSTGNVZ.js";
 import "./chunk-AVOZAKGP.js";
+import {
+  gridToTables,
+  xlsxToMarkdownDoc,
+  xlsxToTables
+} from "./chunk-OBADJV7C.js";
 import {
   csvToDoc,
   csvToMarkdownDoc,
   markdownDocToCsv,
   parseCsv
-} from "./chunk-AD2WT564.js";
+} from "./chunk-Q77KNJIN.js";
+import "./chunk-DXYWKZ52.js";
 import "./chunk-OK622ILP.js";
 import "./chunk-ILCJ3WFD.js";
 import "./chunk-JU2RHXUB.js";
@@ -77,20 +92,10 @@ import {
   markdownDocToPdf,
   pdfToDoc,
   pdfToMarkdownDoc
-} from "./chunk-M7XPXGXW.js";
+} from "./chunk-ROF7SSQP.js";
+import "./chunk-BXWNU4T5.js";
 import "./chunk-IIQYS2YH.js";
 import "./chunk-USU6HTKB.js";
-import {
-  collectImagePaths,
-  docToHtml,
-  docToHtmlZip,
-  htmlToMarkdown,
-  htmlToMarkdownDoc,
-  htmlToMarkdownDocSync
-} from "./chunk-T4PX33AG.js";
-import "./chunk-6RQOV3B3.js";
-import "./chunk-AONELFLA.js";
-import "./chunk-BXWNU4T5.js";
 export {
   BUILTIN_FORMAT_IDS,
   ConversionError,
@@ -117,6 +122,7 @@ export {
   docToXlsx,
   docxToDoc,
   docxToMarkdownDoc,
+  gridToTables,
   htmlToMarkdown,
   htmlToMarkdownDoc,
   htmlToMarkdownDocSync,
@@ -143,5 +149,6 @@ export {
   withOutsideInMarkdownEditing,
   withOutsideInMetadata,
   xlsxToDoc,
-  xlsxToMarkdownDoc
+  xlsxToMarkdownDoc,
+  xlsxToTables
 };

package/dist/infer/index.js

@@ -1,17 +1,17 @@
 import {
   inferThemeFromFile
-} from "../chunk-KMBBO5H7.js";
+} from "../chunk-7DQP2I57.js";
+import {
+  colorHintsFromExtraction,
+  compileExtractedTheme,
+  extractedThemeToPartial
+} from "../chunk-2JJ5RFDZ.js";
 import "../chunk-KXOZMWBS.js";
 import {
   extractDocxTheme,
   extractPptxTheme,
   extractXlsxTheme
 } from "../chunk-WATAOG4Y.js";
-import {
-  colorHintsFromExtraction,
-  compileExtractedTheme,
-  extractedThemeToPartial
-} from "../chunk-2JJ5RFDZ.js";
 import "../chunk-OK622ILP.js";
 import "../chunk-S5PCVMKU.js";
 import "../chunk-7AWFHP5U.js";

package/dist/materialize-A34OZGEU.js

@@ -0,0 +1,11 @@
+import {
+  materializeDataReferences
+} from "./chunk-FLR2ARKC.js";
+import "./chunk-OBADJV7C.js";
+import "./chunk-Q77KNJIN.js";
+import "./chunk-DXYWKZ52.js";
+import "./chunk-S5PCVMKU.js";
+import "./chunk-7AWFHP5U.js";
+export {
+  materializeDataReferences
+};

package/dist/outside-in/index.d.ts

@@ -1,16 +1,16 @@
 import { MarkdownDocument } from '@bendyline/squisq/markdown';
 import { ContentContainer } from '@bendyline/squisq/storage';
-import { c as ConvertOptions, b as ConversionResult } from '../types-DByrrXeB.js';
+import { c as ConvertOptions, b as ConversionResult } from '../types-Dzd_5H2A.js';
 import '@bendyline/squisq/schemas';
 import '@bendyline/squisq/transform';
 import '../docx/index.js';
 import '../reader-B_m1aKZC.js';
 import '../zipLimits-BOKCB7qk.js';
 import '../import-C16E8Y4X.js';
-import '../export-m0tr9r9d.js';
+import '../export-6iQXd-lQ.js';
 import '../csv/index.js';
 import '../pdf/index.js';
-import '../import-B0gBYUmd.js';
+import '../import-C7c9tQHK.js';
 import '../epub/index.js';
 import '../container/index.js';
 

package/dist/outside-in/index.js

@@ -10,8 +10,8 @@ import {
   resolveOutsideInLayout,
   withOutsideInMarkdownEditing,
   withOutsideInMetadata
-} from "../chunk-5PUIFU5I.js";
-import "../chunk-JTGWQK5V.js";
+} from "../chunk-VDTGQ4MW.js";
+import "../chunk-GRKQTQOF.js";
 import "../chunk-KXOZMWBS.js";
 import "../chunk-7AWFHP5U.js";
 export {

package/dist/pdf/index.js

@@ -5,10 +5,10 @@ import {
   pdfToContainer,
   pdfToDoc,
   pdfToMarkdownDoc
-} from "../chunk-M7XPXGXW.js";
+} from "../chunk-ROF7SSQP.js";
+import "../chunk-BXWNU4T5.js";
 import "../chunk-IIQYS2YH.js";
 import "../chunk-USU6HTKB.js";
-import "../chunk-BXWNU4T5.js";
 export {
   configurePdfWorker,
   docToPdf,