@bendyline/squisq-formats 2.5.0 → 2.5.1

package/NOTICE.md

@@ -10,7 +10,7 @@ Third-party components remain under their respective license terms.
 | ---------------- | ------- | ----------------------- | ---------------------------------- |
 | @pdf-lib/fontkit | 1.1.1   | MIT                     | https://github.com/Hopding/fontkit |
 | @pdf-lib/upng    | 1.0.1   | MIT                     | https://github.com/Hopding/upng    |
-| @xmldom/xmldom   | 0.9.11  | MIT                     | https://github.com/xmldom/xmldom   |
+| @xmldom/xmldom   | 0.9.12  | MIT                     | https://github.com/xmldom/xmldom   |
 | jszip            | 3.10.1  | MIT OR GPL-3.0-or-later | https://github.com/Stuk/jszip      |
 | pdf-lib          | 1.17.1  | MIT                     | https://pdf-lib.js.org             |
 | pdfjs-dist       | 4.10.38 | Apache-2.0              | https://mozilla.github.io/pdf.js   |

package/dist/{chunk-A6LSCIO5.js → chunk-RX55T5HO.js}

@@ -387,6 +387,113 @@ function peelCaptionRow(grid, rect) {
   return { caption, rect: { ...rect, top: rect.top + 1 } };
 }
 
+// src/xlsx/tables.ts
+function columnLetter2(index) {
+  let n = index;
+  let out = "";
+  do {
+    out = String.fromCharCode(65 + n % 26) + out;
+    n = Math.floor(n / 26) - 1;
+  } while (n >= 0);
+  return out;
+}
+function a1(row, col) {
+  return `${columnLetter2(col)}${row + 1}`;
+}
+function regionHasHeader(cells) {
+  if (cells.length < 2) return false;
+  const first = cells[0];
+  if (!first || first.length === 0) return false;
+  return first.every((cell) => cell.kind === "string");
+}
+function cellValue(cell) {
+  if (cell.kind === "empty" || cell.kind === "error") return null;
+  if (cell.value !== void 0) return cell.value;
+  return cell.text === "" ? null : cell.text;
+}
+function dominantKind(kinds) {
+  const counts = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (const kind of kinds) {
+    if (kind === "empty") continue;
+    counts.set(kind, (counts.get(kind) ?? 0) + 1);
+    total += 1;
+  }
+  if (total === 0) return "empty";
+  let best = "string";
+  let bestCount = 0;
+  for (const [kind, count] of counts) {
+    if (count > bestCount) {
+      best = kind;
+      bestCount = count;
+    }
+  }
+  return bestCount * 2 > total ? best : "mixed";
+}
+function sliceRegion(grid, rect) {
+  const out = [];
+  for (let r = rect.top; r <= rect.bottom; r++) {
+    const row = [];
+    for (let c = rect.left; c <= rect.right; c++) {
+      row.push(grid[r]?.[c] ?? { text: "", kind: "empty" });
+    }
+    out.push(row);
+  }
+  return out;
+}
+function regionToTable(sheet, grid, rect, title, minRows) {
+  const cells = sliceRegion(grid, rect);
+  if (cells.length === 0) return null;
+  const hasHeader = regionHasHeader(cells);
+  const body = hasHeader ? cells.slice(1) : cells;
+  if (body.length < minRows) return null;
+  if (!body.some((row) => row.some(isOccupied))) return null;
+  const width = cells.reduce((max, row) => Math.max(max, row.length), 0);
+  const columns = [];
+  for (let c = 0; c < width; c++) {
+    const header = hasHeader ? cells[0]?.[c]?.text ?? "" : "";
+    columns.push({
+      name: header.trim() || columnLetter2(rect.left + c),
+      kind: dominantKind(body.map((row) => row[c]?.kind ?? "empty"))
+    });
+  }
+  return {
+    sheet,
+    anchor: a1(rect.top, rect.left),
+    ...title ? { title } : {},
+    columns,
+    hasHeader,
+    rows: body.map(
+      (row) => Array.from({ length: width }, (_, c) => cellValue(row[c] ?? { text: "", kind: "empty" }))
+    )
+  };
+}
+function gridToTables(sheet, grid, merges = [], options = {}) {
+  if (grid.length === 0) return [];
+  const minRows = options.minRows ?? 1;
+  const plan = detectRegions(grid, merges, {
+    ...options.maxRegionsPerSheet !== void 0 ? { maxRegionsPerSheet: options.maxRegionsPerSheet } : {},
+    ...options.minRegionCells !== void 0 ? { minRegionCells: options.minRegionCells } : {},
+    ...options.signal ? { signal: options.signal } : {}
+  });
+  if (plan.degraded || plan.regions.length === 0) {
+    const rect = {
+      top: 0,
+      left: 0,
+      bottom: grid.length - 1,
+      right: grid.reduce((max, row) => Math.max(max, row.length), 1) - 1
+    };
+    const whole = regionToTable(sheet, grid, rect, void 0, minRows);
+    return whole ? [whole] : [];
+  }
+  const out = [];
+  for (const region of plan.regions) {
+    const table = regionToTable(sheet, grid, region.rect, region.title, minRows);
+    if (table) out.push(table);
+  }
+  return out;
+}
+
 // src/xlsx/import.ts
 var XLSX_MAIN_PART = "xl/workbook.xml";
 function attrNS(el, ns, local, fallback) {
@@ -553,6 +660,16 @@ function excelTimeText(serial, includeSeconds, elapsedHours) {
   const seconds = totalSeconds % 60;
   return `${twoDigits(hours)}:${twoDigits(minutes)}${includeSeconds ? `:${twoDigits(seconds)}` : ""}`;
 }
+function dateValueText(serial, kind, style, date1904) {
+  if (!Number.isFinite(serial)) return null;
+  const normalized = style ? normalizeFormatCode(style.formatCode) : "";
+  if (kind === "time")
+    return excelTimeText(serial, /s/.test(normalized), /\[[h]+\]/.test(normalized));
+  const date = excelDateText(serial, date1904);
+  if (!date) return null;
+  if (kind === "datetime") return `${date} ${excelTimeText(serial, /s/.test(normalized), false)}`;
+  return date;
+}
 function formattedNumberText(raw, style, date1904) {
   if (!style) return raw;
   const value = Number(raw);
@@ -600,13 +717,14 @@ function readFormula(cell, row, col, ctx) {
 }
 function readCell(cell, row, col, ctx) {
   const formula = readFormula(cell, row, col, ctx);
-  const withFormula = (text2, kind2) => {
+  const withFormula = (text2, kind2, value) => {
     const out = { text: text2, kind: text2 === "" ? "empty" : kind2 };
     if (formula !== "") out.formula = formula;
+    if (value !== void 0 && out.kind !== "empty") out.value = value;
     return out;
   };
   const stringCell = (item) => {
-    const out = withFormula(item.text, "string");
+    const out = withFormula(item.text, "string", item.text);
     if (item.rich && out.kind !== "empty") out.richText = item.rich;
     return out;
   };
@@ -619,14 +737,19 @@ function readCell(cell, row, col, ctx) {
   const v = vEls.length ? vEls[0].textContent ?? "" : "";
   if (v === "") return withFormula("", "empty");
   if (t === "s") return stringCell(ctx.shared[Number.parseInt(v, 10)] ?? { text: "" });
-  if (t === "b") return withFormula(v === "1" ? "TRUE" : "FALSE", "bool");
+  if (t === "b") return withFormula(v === "1" ? "TRUE" : "FALSE", "bool", v === "1");
   if (t === "e") return withFormula(v, "error");
-  if (t === "str") return withFormula(v, "string");
+  if (t === "str") return withFormula(v, "string", v);
   const style = ctx.styles[Number.parseInt(cell.getAttribute("s") ?? "0", 10)];
   const text = formattedNumberText(v, style, ctx.date1904);
   const dateLike = style ? numberFormatKind(style.formatCode) : "general";
   const kind = dateLike === "date" || dateLike === "time" || dateLike === "datetime" ? "date" : "number";
-  return withFormula(text, kind);
+  const numeric = Number(v);
+  if (kind === "date") {
+    const iso = dateValueText(numeric, dateLike, style, ctx.date1904);
+    return withFormula(text, kind, iso ?? text);
+  }
+  return withFormula(text, kind, Number.isFinite(numeric) ? numeric : v);
 }
 async function sheetToCells(pkg, path, shared, styles, date1904) {
   const doc = await getPartXml(pkg, path);
@@ -723,6 +846,26 @@ function annotatedHeading(depth, text, params) {
     templateAnnotation: { template: "dataTable", params }
   };
 }
+async function xlsxToTables(data, options = {}) {
+  const pkg = await openPackage(data, options);
+  const mainPart = requireMainPartPath(pkg, XLSX_MAIN_PART, "XLSX");
+  const [{ sheets, date1904 }, shared, styles] = await Promise.all([
+    readWorkbook(pkg, mainPart),
+    readSharedStrings(pkg),
+    readCellStyles(pkg)
+  ]);
+  let selected = sheets;
+  if (options.sheet !== void 0) {
+    const picked = typeof options.sheet === "number" ? sheets[options.sheet] : sheets.find((s) => s.name === options.sheet);
+    selected = picked ? [picked] : [];
+  }
+  const out = [];
+  for (const sheet of selected) {
+    const { cells, merges } = await sheetToCells(pkg, sheet.path, shared, styles, date1904);
+    out.push(...gridToTables(sheet.name, cells, merges, options));
+  }
+  return out;
+}
 async function xlsxToMarkdownDoc(data, options = {}) {
   const pkg = await openPackage(data, options);
   const mainPart = requireMainPartPath(pkg, XLSX_MAIN_PART, "XLSX");
@@ -1190,6 +1333,8 @@ async function xlsxToDoc(data, options) {
 }
 
 export {
+  gridToTables,
+  xlsxToTables,
   xlsxToMarkdownDoc,
   markdownDocToXlsx,
   docToXlsx,

package/dist/{chunk-5PUIFU5I.js → chunk-TVUX3RUC.js}

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

package/dist/export-Boq78GMq.d.ts

@@ -0,0 +1,270 @@
+import { MarkdownInlineNode, MarkdownDocument } from '@bendyline/squisq/markdown';
+import { O as OoxmlOpenOptions } from './reader-B_m1aKZC.js';
+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[];
+    /**
+     * 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;
+}
+
+/**
+ * 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;
+}
+/**
+ * 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[]>;
+declare function xlsxToMarkdownDoc(data: ArrayBuffer | Blob, options?: XlsxImportOptions): Promise<MarkdownDocument>;
+
+/**
+ * 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 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 };

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-bwP9PBSk.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 { 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-Boq78GMq.js';
 import '@bendyline/squisq/schemas';
 import '@bendyline/squisq/markdown';
 import './reader-B_m1aKZC.js';

package/dist/index.js

@@ -20,7 +20,7 @@ import {
   resolveOutsideInLayout,
   withOutsideInMarkdownEditing,
   withOutsideInMetadata
-} from "./chunk-5PUIFU5I.js";
+} from "./chunk-TVUX3RUC.js";
 import {
   DEFAULT_CONVERSION_LIMITS,
   convert,
@@ -29,7 +29,7 @@ import {
   defaultRegistry,
   prepareConversion,
   resolveConversionLimits
-} from "./chunk-JTGWQK5V.js";
+} from "./chunk-5JQ5NDRC.js";
 import {
   ConversionError
 } from "./chunk-KXOZMWBS.js";
@@ -53,10 +53,12 @@ import "./chunk-6N2J7C2B.js";
 import "./chunk-A6N6IN3I.js";
 import {
   docToXlsx,
+  gridToTables,
   markdownDocToXlsx,
   xlsxToDoc,
-  xlsxToMarkdownDoc
-} from "./chunk-A6LSCIO5.js";
+  xlsxToMarkdownDoc,
+  xlsxToTables
+} from "./chunk-RX55T5HO.js";
 import "./chunk-AVOZAKGP.js";
 import {
   csvToDoc,
@@ -117,6 +119,7 @@ export {
   docToXlsx,
   docxToDoc,
   docxToMarkdownDoc,
+  gridToTables,
   htmlToMarkdown,
   htmlToMarkdownDoc,
   htmlToMarkdownDocSync,
@@ -143,5 +146,6 @@ export {
   withOutsideInMarkdownEditing,
   withOutsideInMetadata,
   xlsxToDoc,
-  xlsxToMarkdownDoc
+  xlsxToMarkdownDoc,
+  xlsxToTables
 };

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

@@ -1,13 +1,13 @@
 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-bwP9PBSk.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-Boq78GMq.js';
 import '../csv/index.js';
 import '../pdf/index.js';
 import '../import-B0gBYUmd.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-TVUX3RUC.js";
+import "../chunk-5JQ5NDRC.js";
 import "../chunk-KXOZMWBS.js";
 import "../chunk-7AWFHP5U.js";
 export {

package/dist/registry/index.d.ts

@@ -1,5 +1,5 @@
-import { f as FormatId, g as FormatRegistry, F as FormatDefinition, d as ConvertSource, c as ConvertOptions, b as ConversionResult, P as PreparedConversion } from '../types-DByrrXeB.js';
-export { B as BUILTIN_FORMAT_IDS, a as BuiltinFormatOptions, C as ConversionLimits, D as DEFAULT_CONVERSION_LIMITS, e as DbkFormatOptions, M as MarkdownFormatOptions, N as NormalizedInput, h as PreparedExportOptions, r as resolveConversionLimits } from '../types-DByrrXeB.js';
+import { f as FormatId, g as FormatRegistry, F as FormatDefinition, d as ConvertSource, c as ConvertOptions, b as ConversionResult, P as PreparedConversion } from '../types-bwP9PBSk.js';
+export { B as BUILTIN_FORMAT_IDS, a as BuiltinFormatOptions, C as ConversionLimits, D as DEFAULT_CONVERSION_LIMITS, e as DbkFormatOptions, M as MarkdownFormatOptions, N as NormalizedInput, h as PreparedExportOptions, r as resolveConversionLimits } from '../types-bwP9PBSk.js';
 import '@bendyline/squisq/schemas';
 import '@bendyline/squisq/transform';
 import '@bendyline/squisq/markdown';
@@ -8,7 +8,7 @@ import '../docx/index.js';
 import '../reader-B_m1aKZC.js';
 import '../zipLimits-BOKCB7qk.js';
 import '../import-C16E8Y4X.js';
-import '../export-m0tr9r9d.js';
+import '../export-Boq78GMq.js';
 import '../csv/index.js';
 import '../pdf/index.js';
 import '../import-B0gBYUmd.js';

package/dist/registry/index.js

@@ -9,7 +9,7 @@ import {
   defaultRegistry,
   prepareConversion,
   resolveConversionLimits
-} from "../chunk-JTGWQK5V.js";
+} from "../chunk-5JQ5NDRC.js";
 import {
   ConversionError
 } from "../chunk-KXOZMWBS.js";

package/dist/{types-DByrrXeB.d.ts → types-bwP9PBSk.d.ts}

@@ -4,7 +4,7 @@ import { ParseOptions, StringifyOptions, MarkdownDocument } from '@bendyline/squ
 import { ContentContainer } from '@bendyline/squisq/storage';
 import { DocxImportOptions, DocxExportOptions } from './docx/index.js';
 import { a as PptxImportOptions, P as PptxExportOptions } from './import-C16E8Y4X.js';
-import { a as XlsxImportOptions, X as XlsxExportOptions } from './export-m0tr9r9d.js';
+import { a as XlsxImportOptions, X as XlsxExportOptions } from './export-Boq78GMq.js';
 import { CsvImportOptions, CsvExportOptions } from './csv/index.js';
 import { PdfImportOptions, PdfExportOptions } from './pdf/index.js';
 import { a as HtmlImportOptions, H as HtmlExportOptions } from './import-B0gBYUmd.js';

package/dist/xlsx/index.d.ts

@@ -1,6 +1,6 @@
 import { Doc } from '@bendyline/squisq/schemas';
-import { a as XlsxImportOptions } from '../export-m0tr9r9d.js';
-export { X as XlsxExportOptions, d as docToXlsx, m as markdownDocToXlsx, x as xlsxToMarkdownDoc } from '../export-m0tr9r9d.js';
+import { a as XlsxImportOptions } from '../export-Boq78GMq.js';
+export { X as XlsxExportOptions, 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';
 import '@bendyline/squisq/markdown';
 import '../reader-B_m1aKZC.js';
 import '../zipLimits-BOKCB7qk.js';

package/dist/xlsx/index.js

@@ -1,9 +1,11 @@
 import {
   docToXlsx,
+  gridToTables,
   markdownDocToXlsx,
   xlsxToDoc,
-  xlsxToMarkdownDoc
-} from "../chunk-A6LSCIO5.js";
+  xlsxToMarkdownDoc,
+  xlsxToTables
+} from "../chunk-RX55T5HO.js";
 import "../chunk-AVOZAKGP.js";
 import "../chunk-ILCJ3WFD.js";
 import "../chunk-JU2RHXUB.js";
@@ -11,7 +13,9 @@ import "../chunk-S5PCVMKU.js";
 import "../chunk-7AWFHP5U.js";
 export {
   docToXlsx,
+  gridToTables,
   markdownDocToXlsx,
   xlsxToDoc,
-  xlsxToMarkdownDoc
+  xlsxToMarkdownDoc,
+  xlsxToTables
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bendyline/squisq-formats",
-  "version": "2.5.0",
+  "version": "2.5.1",
   "description": "Document format converters — DOCX, PDF, OOXML import/export",
   "license": "MIT",
   "author": "Bendyline",
@@ -112,7 +112,7 @@
   "dependencies": {
     "@pdf-lib/fontkit": "1.1.1",
     "@pdf-lib/upng": "1.0.1",
-    "@xmldom/xmldom": "0.9.11",
+    "@xmldom/xmldom": "0.9.12",
     "@bendyline/squisq": "2.10.0",
     "jszip": "3.10.1",
     "pdf-lib": "1.17.1",

package/dist/export-m0tr9r9d.d.ts

@@ -1,130 +0,0 @@
-import { MarkdownDocument } from '@bendyline/squisq/markdown';
-import { O as OoxmlOpenOptions } from './reader-B_m1aKZC.js';
-import { Doc } from '@bendyline/squisq/schemas';
-
-/**
- * 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;
-}
-declare function xlsxToMarkdownDoc(data: ArrayBuffer | Blob, options?: XlsxImportOptions): Promise<MarkdownDocument>;
-
-/**
- * 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 XlsxExportOptions as X, type XlsxImportOptions as a, docToXlsx as d, markdownDocToXlsx as m, xlsxToMarkdownDoc as x };