@bendyline/squisq-formats 2.4.5 → 2.5.0

package/dist/chunk-A6LSCIO5.js

@@ -0,0 +1,1197 @@
+import {
+  extractPlainText,
+  inlineToPlainText
+} from "./chunk-AVOZAKGP.js";
+import {
+  createPackage
+} from "./chunk-ILCJ3WFD.js";
+import {
+  escapeXml,
+  xmlDeclaration
+} from "./chunk-JU2RHXUB.js";
+import {
+  CONTENT_TYPE_XLSX_STYLES,
+  CONTENT_TYPE_XLSX_WORKBOOK,
+  CONTENT_TYPE_XLSX_WORKSHEET,
+  NS_R,
+  NS_SML,
+  REL_OFFICE_DOCUMENT,
+  REL_STYLES,
+  REL_WORKSHEET,
+  baseDirOf,
+  getPartRelationships,
+  getPartXml,
+  openPackage,
+  requireMainPartPath
+} from "./chunk-S5PCVMKU.js";
+
+// src/xlsx/index.ts
+import { markdownToDoc } from "@bendyline/squisq/doc";
+
+// src/xlsx/cells.ts
+var MAX_COL_INDEX = 16383;
+var MAX_ROW_INDEX = 1048575;
+var EMPTY_CELL = Object.freeze({ text: "", kind: "empty" });
+function isOccupied(cell) {
+  return cell.text !== "" || cell.formula !== void 0;
+}
+function columnLetter(index) {
+  let n = index + 1;
+  let letters = "";
+  while (n > 0) {
+    const rem = (n - 1) % 26;
+    letters = String.fromCharCode(65 + rem) + letters;
+    n = Math.floor((n - 1) / 26);
+  }
+  return letters;
+}
+function columnIndexFromLetters(letters) {
+  let n = 0;
+  for (const ch of letters.toUpperCase()) n = n * 26 + (ch.charCodeAt(0) - 64);
+  return n - 1;
+}
+function colIndex(ref) {
+  const m = /^\$?([A-Za-z]+)/.exec(ref);
+  if (!m) return 0;
+  return columnIndexFromLetters(m[1]);
+}
+function parseCellRef(ref) {
+  const m = /^\$?([A-Za-z]{1,3})\$?([0-9]{1,7})$/.exec(ref.trim());
+  if (!m) return null;
+  const col = columnIndexFromLetters(m[1]);
+  const row = Number.parseInt(m[2], 10) - 1;
+  if (!Number.isFinite(row) || row < 0 || row > MAX_ROW_INDEX) return null;
+  if (col < 0 || col > MAX_COL_INDEX) return null;
+  return { row, col };
+}
+function formatCellRef(row, col) {
+  return `${columnLetter(col)}${row + 1}`;
+}
+function parseRangeRef(ref) {
+  const parts = ref.split(":");
+  if (parts.length > 2) return null;
+  const start = parseCellRef(parts[0] ?? "");
+  if (!start) return null;
+  const end = parts.length === 2 ? parseCellRef(parts[1]) : start;
+  if (!end) return null;
+  return {
+    top: Math.min(start.row, end.row),
+    left: Math.min(start.col, end.col),
+    bottom: Math.max(start.row, end.row),
+    right: Math.max(start.col, end.col)
+  };
+}
+var REF_AT = /(\$?)([A-Za-z]{1,3})(\$?)([0-9]{1,7})/y;
+var IDENT_CHAR = /[A-Za-z0-9_.]/;
+function translateFormula(text, dRow, dCol) {
+  if (dRow === 0 && dCol === 0) return text;
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === '"') {
+      const start = i;
+      i++;
+      while (i < text.length) {
+        if (text[i] === '"') {
+          if (text[i + 1] === '"') i += 2;
+          else {
+            i++;
+            break;
+          }
+        } else i++;
+      }
+      out += text.slice(start, i);
+      continue;
+    }
+    if (ch === "'") {
+      const start = i;
+      i++;
+      while (i < text.length) {
+        if (text[i] === "'") {
+          if (text[i + 1] === "'") i += 2;
+          else {
+            i++;
+            break;
+          }
+        } else i++;
+      }
+      out += text.slice(start, i);
+      continue;
+    }
+    if (ch === "[") {
+      const start = i;
+      let depth = 0;
+      while (i < text.length) {
+        if (text[i] === "[") depth++;
+        else if (text[i] === "]") {
+          depth--;
+          if (depth === 0) {
+            i++;
+            break;
+          }
+        }
+        i++;
+      }
+      out += text.slice(start, i);
+      continue;
+    }
+    REF_AT.lastIndex = i;
+    const m = REF_AT.exec(text);
+    if (m) {
+      const before = i > 0 ? text[i - 1] : "";
+      const after = text[i + m[0].length] ?? "";
+      const col = columnIndexFromLetters(m[2]);
+      const row = Number.parseInt(m[4], 10) - 1;
+      const isRef = !IDENT_CHAR.test(before) && !IDENT_CHAR.test(after) && after !== "(" && col <= MAX_COL_INDEX && row >= 0 && row <= MAX_ROW_INDEX;
+      if (isRef) {
+        const nextCol = m[1] === "$" ? col : col + dCol;
+        const nextRow = m[3] === "$" ? row : row + dRow;
+        if (nextCol < 0 || nextCol > MAX_COL_INDEX || nextRow < 0 || nextRow > MAX_ROW_INDEX) {
+          out += "#REF!";
+        } else {
+          out += `${m[1]}${columnLetter(nextCol)}${m[3]}${nextRow + 1}`;
+        }
+        i += m[0].length;
+        continue;
+      }
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
+
+// src/xlsx/regions.ts
+var DEFAULT_MAX_REGIONS = 64;
+var DEFAULT_MAX_CANDIDATES = 2e3;
+var DEFAULT_MIN_REGION_CELLS = 2;
+var DEFAULT_MAX_MASK_CELLS = 4e6;
+var MAX_MERGE_PASSES = 8;
+function throwIfAborted(signal) {
+  signal?.throwIfAborted();
+}
+function intersects(a, b) {
+  return a.left <= b.right && b.left <= a.right && a.top <= b.bottom && b.top <= a.bottom;
+}
+function union(a, b) {
+  return {
+    top: Math.min(a.top, b.top),
+    left: Math.min(a.left, b.left),
+    bottom: Math.max(a.bottom, b.bottom),
+    right: Math.max(a.right, b.right)
+  };
+}
+function area(rect) {
+  return (rect.bottom - rect.top + 1) * (rect.right - rect.left + 1);
+}
+function sliceRect(grid, rect, empty) {
+  const out = [];
+  for (let r = rect.top; r <= rect.bottom; r++) {
+    const row = grid[r] ?? [];
+    const cells = [];
+    for (let c = rect.left; c <= rect.right; c++) cells.push(row[c] ?? empty);
+    out.push(cells);
+  }
+  return out;
+}
+function detectRegions(grid, merges = [], options = {}) {
+  const signal = options.signal;
+  const maxRegions = options.maxRegionsPerSheet ?? DEFAULT_MAX_REGIONS;
+  const maxCandidates = options.maxRegionCandidates ?? DEFAULT_MAX_CANDIDATES;
+  const minCells = options.minRegionCells ?? DEFAULT_MIN_REGION_CELLS;
+  const maxMaskCells = options.maxMaskCells ?? DEFAULT_MAX_MASK_CELLS;
+  const warnings = [];
+  const rows = grid.length;
+  let cols = 0;
+  for (const row of grid) cols = Math.max(cols, row.length);
+  if (rows === 0 || cols === 0) {
+    return { regions: [], strays: [], warnings, degraded: false };
+  }
+  if (rows * cols > maxMaskCells) {
+    warnings.push(
+      `Used range spans ${rows}\xD7${cols} cells, past the ${maxMaskCells}-cell detection limit; imported as a single grid instead.`
+    );
+    return { regions: [], strays: [], warnings, degraded: true };
+  }
+  const mask = new Uint8Array(rows * cols);
+  for (let r = 0; r < rows; r++) {
+    throwIfAborted(signal);
+    const row = grid[r];
+    for (let c = 0; c < row.length; c++) {
+      if (isOccupied(row[c])) mask[r * cols + c] = 1;
+    }
+  }
+  for (const merge of merges) {
+    const anchor = grid[merge.top]?.[merge.left];
+    if (!anchor || !isOccupied(anchor)) continue;
+    const bottom = Math.min(merge.bottom, rows - 1);
+    const right = Math.min(merge.right, cols - 1);
+    for (let r = Math.max(0, merge.top); r <= bottom; r++) {
+      for (let c = Math.max(0, merge.left); c <= right; c++) mask[r * cols + c] = 1;
+    }
+  }
+  const seen = new Uint8Array(rows * cols);
+  let rects = [];
+  const stack = [];
+  for (let r0 = 0; r0 < rows; r0++) {
+    throwIfAborted(signal);
+    for (let c0 = 0; c0 < cols; c0++) {
+      const start = r0 * cols + c0;
+      if (mask[start] === 0 || seen[start] === 1) continue;
+      if (rects.length >= maxCandidates) {
+        warnings.push(
+          `Sheet has more than ${maxCandidates} data islands; imported as a single grid instead.`
+        );
+        return { regions: [], strays: [], warnings, degraded: true };
+      }
+      seen[start] = 1;
+      stack.length = 0;
+      stack.push(start);
+      let top = r0;
+      let bottom = r0;
+      let left = c0;
+      let right = c0;
+      while (stack.length > 0) {
+        const idx = stack.pop();
+        const r = idx / cols | 0;
+        const c = idx - r * cols;
+        if (r < top) top = r;
+        if (r > bottom) bottom = r;
+        if (c < left) left = c;
+        if (c > right) right = c;
+        for (let dr = -1; dr <= 1; dr++) {
+          const nr = r + dr;
+          if (nr < 0 || nr >= rows) continue;
+          for (let dc = -1; dc <= 1; dc++) {
+            const nc = c + dc;
+            if (nc < 0 || nc >= cols) continue;
+            const nIdx = nr * cols + nc;
+            if (mask[nIdx] === 0 || seen[nIdx] === 1) continue;
+            seen[nIdx] = 1;
+            stack.push(nIdx);
+          }
+        }
+      }
+      rects.push({ top, left, bottom, right });
+    }
+  }
+  for (let pass = 0; pass < MAX_MERGE_PASSES; pass++) {
+    throwIfAborted(signal);
+    const out = [];
+    let changed = false;
+    for (const rect of rects) {
+      let current = rect;
+      let hit = -1;
+      for (let i = 0; i < out.length; i++) {
+        if (!intersects(out[i], current)) continue;
+        current = union(out[i], current);
+        if (hit < 0) {
+          hit = i;
+          out[i] = current;
+        } else {
+          out[hit] = current;
+          out.splice(i, 1);
+          i--;
+        }
+        changed = true;
+      }
+      if (hit < 0) out.push(current);
+    }
+    rects = out;
+    if (!changed) break;
+  }
+  rects.sort((a, b) => a.top - b.top || a.left - b.left);
+  const titles = /* @__PURE__ */ new Map();
+  const absorbed = /* @__PURE__ */ new Set();
+  for (let i = 0; i < rects.length; i++) {
+    const body = rects[i];
+    if (absorbed.has(i) || area(body) < minCells) continue;
+    for (let j = 0; j < rects.length; j++) {
+      if (j === i || absorbed.has(j) || titles.has(i)) continue;
+      const cap = rects[j];
+      if (cap.top !== cap.bottom) continue;
+      if (cap.bottom >= body.top) continue;
+      if (body.top - cap.bottom > 2) continue;
+      if (cap.left < body.left || cap.right > body.right) continue;
+      const sole = soleCell(grid, cap);
+      if (sole === null) continue;
+      titles.set(i, sole);
+      absorbed.add(j);
+    }
+  }
+  const regions = [];
+  const strayRects = [];
+  for (let i = 0; i < rects.length; i++) {
+    if (absorbed.has(i)) continue;
+    let rect = rects[i];
+    if (area(rect) < minCells) {
+      strayRects.push(rect);
+      continue;
+    }
+    if (regions.length >= maxRegions) {
+      strayRects.push(rect);
+      continue;
+    }
+    let caption = titles.get(i);
+    if (caption === void 0) {
+      const peeled = peelCaptionRow(grid, rect);
+      if (peeled) {
+        caption = peeled.caption;
+        rect = peeled.rect;
+      }
+    }
+    regions.push(
+      caption === void 0 ? { rect } : { rect, title: caption.text, titleCell: { row: caption.row, col: caption.col } }
+    );
+  }
+  const overflow = rects.filter((r, i) => !absorbed.has(i) && area(r) >= minCells).length;
+  if (overflow > maxRegions) {
+    warnings.push(
+      `Sheet has ${overflow} data islands; the first ${maxRegions} became tables and the rest were folded into the loose-cells table.`
+    );
+  }
+  const strays = [];
+  for (const rect of strayRects) {
+    for (let r = rect.top; r <= rect.bottom; r++) {
+      for (let c = rect.left; c <= rect.right; c++) {
+        const cell = grid[r]?.[c];
+        if (cell && isOccupied(cell)) strays.push({ row: r, col: c, cell });
+      }
+    }
+  }
+  strays.sort((a, b) => a.row - b.row || a.col - b.col);
+  return { regions, strays, warnings, degraded: false };
+}
+function soleCell(grid, rect) {
+  let found = null;
+  for (let r = rect.top; r <= rect.bottom; r++) {
+    for (let c = rect.left; c <= rect.right; c++) {
+      const cell = grid[r]?.[c];
+      if (!cell || cell.text === "") continue;
+      if (found !== null) return null;
+      found = { text: cell.text, row: r, col: c };
+    }
+  }
+  return found;
+}
+function peelCaptionRow(grid, rect) {
+  if (rect.bottom - rect.top < 2) return null;
+  const caption = soleCell(grid, { ...rect, bottom: rect.top });
+  if (caption === null) return null;
+  let below = 0;
+  for (let c = rect.left; c <= rect.right; c++) {
+    if ((grid[rect.top + 1]?.[c]?.text ?? "") !== "") below++;
+  }
+  if (below < 2) return null;
+  return { caption, rect: { ...rect, top: rect.top + 1 } };
+}
+
+// src/xlsx/import.ts
+var XLSX_MAIN_PART = "xl/workbook.xml";
+function attrNS(el, ns, local, fallback) {
+  return el.getAttributeNS(ns, local) ?? el.getAttribute(fallback);
+}
+function resolveTarget(baseDir, target) {
+  if (target.startsWith("/")) return target.replace(/^\//, "");
+  const stack = baseDir ? baseDir.split("/") : [];
+  for (const seg of target.split("/")) {
+    if (seg === "..") stack.pop();
+    else if (seg !== ".") stack.push(seg);
+  }
+  return stack.join("/");
+}
+async function readWorkbook(pkg, mainPart) {
+  const wb = await getPartXml(pkg, mainPart);
+  if (!wb) {
+    throw new Error(`Invalid XLSX package: workbook part "${mainPart}" could not be parsed.`);
+  }
+  const rels = await getPartRelationships(pkg, mainPart);
+  const relById = new Map(rels.map((r) => [r.id, r.target]));
+  const out = [];
+  const sheetEls = wb.getElementsByTagNameNS(NS_SML, "sheet");
+  for (let i = 0; i < sheetEls.length; i++) {
+    const el = sheetEls[i];
+    const name = el.getAttribute("name") ?? `Sheet${i + 1}`;
+    const rid = attrNS(el, NS_R, "id", "r:id");
+    const target = rid ? relById.get(rid) : void 0;
+    if (target) out.push({ name, path: resolveTarget(baseDirOf(mainPart), target) });
+  }
+  const workbookPr = wb.getElementsByTagNameNS(NS_SML, "workbookPr")[0];
+  const date1904Value = workbookPr?.getAttribute("date1904");
+  return {
+    sheets: out,
+    date1904: date1904Value === "1" || date1904Value === "true"
+  };
+}
+function isPhonetic(el, root) {
+  for (let node = el.parentNode; node && node !== root; node = node.parentNode) {
+    if (node.nodeType !== 1) continue;
+    const parent = node;
+    if (parent.localName === "rPh" && parent.namespaceURI === NS_SML) return true;
+  }
+  return false;
+}
+function runVertAlign(run) {
+  const rPr = run.getElementsByTagNameNS(NS_SML, "rPr")[0];
+  if (!rPr) return null;
+  const va = rPr.getElementsByTagNameNS(NS_SML, "vertAlign")[0];
+  const val = va?.getAttribute("val");
+  return val === "superscript" || val === "subscript" ? val : null;
+}
+function readStringItem(root) {
+  const tEls = root.getElementsByTagNameNS(NS_SML, "t");
+  const rich = [];
+  let text = "";
+  let formatted = false;
+  for (let i = 0; i < tEls.length; i++) {
+    const t = tEls[i];
+    if (isPhonetic(t, root)) continue;
+    const value = t.textContent ?? "";
+    if (value === "") continue;
+    text += value;
+    const parent = t.parentNode;
+    const run = parent && parent.localName === "r" ? parent : null;
+    const vertAlign = run ? runVertAlign(run) : null;
+    if (vertAlign) {
+      formatted = true;
+      rich.push({ type: vertAlign, children: [{ type: "text", value }] });
+    } else {
+      rich.push({ type: "text", value });
+    }
+  }
+  return formatted ? { text, rich: mergeAdjacentText(rich) } : { text };
+}
+function mergeAdjacentText(nodes) {
+  const out = [];
+  for (const node of nodes) {
+    const prev = out[out.length - 1];
+    if (node.type === "text" && prev?.type === "text") prev.value += node.value;
+    else out.push(node);
+  }
+  return out;
+}
+async function readSharedStrings(pkg) {
+  const doc = await getPartXml(pkg, "xl/sharedStrings.xml");
+  if (!doc) return [];
+  const siEls = doc.getElementsByTagNameNS(NS_SML, "si");
+  const out = [];
+  for (let i = 0; i < siEls.length; i++) out.push(readStringItem(siEls[i]));
+  return out;
+}
+var BUILTIN_NUMBER_FORMATS = Object.freeze({
+  9: "0%",
+  10: "0.00%",
+  14: "mm-dd-yy",
+  15: "d-mmm-yy",
+  16: "d-mmm",
+  17: "mmm-yy",
+  18: "h:mm AM/PM",
+  19: "h:mm:ss AM/PM",
+  20: "h:mm",
+  21: "h:mm:ss",
+  22: "m/d/yy h:mm",
+  45: "mm:ss",
+  46: "[h]:mm:ss",
+  47: "mmss.0"
+});
+async function readCellStyles(pkg) {
+  const doc = await getPartXml(pkg, "xl/styles.xml");
+  if (!doc) return [];
+  const custom = /* @__PURE__ */ new Map();
+  const numFmtEls = doc.getElementsByTagNameNS(NS_SML, "numFmt");
+  for (let i = 0; i < numFmtEls.length; i++) {
+    const el = numFmtEls[i];
+    const id = Number.parseInt(el.getAttribute("numFmtId") ?? "", 10);
+    const code = el.getAttribute("formatCode");
+    if (Number.isFinite(id) && code) custom.set(id, code);
+  }
+  const cellXfs = doc.getElementsByTagNameNS(NS_SML, "cellXfs")[0];
+  if (!cellXfs) return [];
+  const xfEls = cellXfs.getElementsByTagNameNS(NS_SML, "xf");
+  const out = [];
+  for (let i = 0; i < xfEls.length; i++) {
+    const numFmtId = Number.parseInt(xfEls[i].getAttribute("numFmtId") ?? "0", 10);
+    out.push({
+      numFmtId,
+      formatCode: custom.get(numFmtId) ?? BUILTIN_NUMBER_FORMATS[numFmtId] ?? "General"
+    });
+  }
+  return out;
+}
+function normalizeFormatCode(formatCode) {
+  return formatCode.split(";", 1)[0].replace(/"(?:[^"]|"")*"/g, "").replace(/\\./g, "").replace(/[_*]./g, "").replace(/\[(?!h+\]|m+\]|s+\])[^\]]*\]/gi, "").toLowerCase();
+}
+function numberFormatKind(formatCode) {
+  const normalized = normalizeFormatCode(formatCode);
+  if (normalized === "general") return "general";
+  if (normalized.includes("%")) return "percent";
+  if (/^0+$/.test(normalized)) return "zero-pad";
+  const hasDate = /[yd]/.test(normalized);
+  const hasTime = /[hs]|\[[hms]+\]/.test(normalized);
+  if (hasDate && hasTime) return "datetime";
+  if (hasDate) return "date";
+  if (hasTime) return "time";
+  return "general";
+}
+function twoDigits(value) {
+  return String(value).padStart(2, "0");
+}
+function excelDateText(serial, date1904) {
+  const wholeDays = Math.floor(serial);
+  if (!date1904 && wholeDays === 60) return "1900-02-29";
+  const epoch = date1904 ? Date.UTC(1904, 0, 1) : Date.UTC(1899, 11, 31);
+  const adjustedDays = !date1904 && wholeDays > 60 ? wholeDays - 1 : wholeDays;
+  const date = new Date(epoch + adjustedDays * 864e5);
+  if (!Number.isFinite(date.getTime())) return null;
+  return `${date.getUTCFullYear()}-${twoDigits(date.getUTCMonth() + 1)}-${twoDigits(date.getUTCDate())}`;
+}
+function excelTimeText(serial, includeSeconds, elapsedHours) {
+  const totalSeconds = Math.round((serial - Math.floor(serial)) * 86400);
+  const hours = elapsedHours ? Math.floor(serial * 24) : Math.floor(totalSeconds / 3600) % 24;
+  const minutes = Math.floor(totalSeconds / 60) % 60;
+  const seconds = totalSeconds % 60;
+  return `${twoDigits(hours)}:${twoDigits(minutes)}${includeSeconds ? `:${twoDigits(seconds)}` : ""}`;
+}
+function formattedNumberText(raw, style, date1904) {
+  if (!style) return raw;
+  const value = Number(raw);
+  if (!Number.isFinite(value)) return raw;
+  const normalized = normalizeFormatCode(style.formatCode);
+  const kind = numberFormatKind(style.formatCode);
+  if (kind === "date") return excelDateText(value, date1904) ?? raw;
+  if (kind === "time") {
+    return excelTimeText(value, /s/.test(normalized), /\[[h]+\]/.test(normalized));
+  }
+  if (kind === "datetime") {
+    const date = excelDateText(value, date1904);
+    return date ? `${date} ${excelTimeText(value, /s/.test(normalized), false)}` : raw;
+  }
+  if (kind === "percent") {
+    const decimals = /0\.(0+)%/.exec(normalized)?.[1]?.length ?? 0;
+    return `${(value * 100).toFixed(decimals)}%`;
+  }
+  if (kind === "zero-pad" && Number.isInteger(value)) {
+    const width = normalized.length;
+    const sign = value < 0 ? "-" : "";
+    return `${sign}${String(Math.abs(value)).padStart(width, "0")}`;
+  }
+  return raw;
+}
+function readFormula(cell, row, col, ctx) {
+  const fEls = cell.getElementsByTagNameNS(NS_SML, "f");
+  const f = fEls.length ? fEls[0] : null;
+  if (!f) return "";
+  const text = (f.textContent ?? "").trim();
+  if (f.getAttribute("t") !== "shared") return text;
+  const si = f.getAttribute("si");
+  if (si === null) return text;
+  if (text !== "") {
+    ctx.sharedFormulas.set(si, { text, row, col });
+    return text;
+  }
+  const master = ctx.sharedFormulas.get(si);
+  if (!master) return "";
+  try {
+    return translateFormula(master.text, row - master.row, col - master.col);
+  } catch {
+    return "";
+  }
+}
+function readCell(cell, row, col, ctx) {
+  const formula = readFormula(cell, row, col, ctx);
+  const withFormula = (text2, kind2) => {
+    const out = { text: text2, kind: text2 === "" ? "empty" : kind2 };
+    if (formula !== "") out.formula = formula;
+    return out;
+  };
+  const stringCell = (item) => {
+    const out = withFormula(item.text, "string");
+    if (item.rich && out.kind !== "empty") out.richText = item.rich;
+    return out;
+  };
+  const t = cell.getAttribute("t");
+  if (t === "inlineStr") {
+    const is = cell.getElementsByTagNameNS(NS_SML, "is")[0];
+    return stringCell(is ? readStringItem(is) : { text: "" });
+  }
+  const vEls = cell.getElementsByTagNameNS(NS_SML, "v");
+  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 === "e") return withFormula(v, "error");
+  if (t === "str") return withFormula(v, "string");
+  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);
+}
+async function sheetToCells(pkg, path, shared, styles, date1904) {
+  const doc = await getPartXml(pkg, path);
+  if (!doc) return { cells: [], merges: [] };
+  const ctx = { shared, styles, date1904, sharedFormulas: /* @__PURE__ */ new Map() };
+  const rowEls = doc.getElementsByTagNameNS(NS_SML, "row");
+  const byIndex = /* @__PURE__ */ new Map();
+  let maxContentIdx = -1;
+  let fallbackIdx = 0;
+  for (let r = 0; r < rowEls.length; r++) {
+    const rowEl = rowEls[r];
+    const rowRef = Number.parseInt(rowEl.getAttribute("r") ?? "", 10);
+    const rowIdx = Number.isFinite(rowRef) && rowRef > 0 ? rowRef - 1 : fallbackIdx;
+    fallbackIdx = rowIdx + 1;
+    const cells = rowEl.getElementsByTagNameNS(NS_SML, "c");
+    const rowArr = [];
+    for (let c = 0; c < cells.length; c++) {
+      const cell = cells[c];
+      const ref = cell.getAttribute("r");
+      const idx = ref ? colIndex(ref) : rowArr.length;
+      while (rowArr.length < idx) rowArr.push(EMPTY_CELL);
+      rowArr[idx] = readCell(cell, rowIdx, idx, ctx);
+    }
+    byIndex.set(rowIdx, rowArr);
+    if (rowArr.some(isOccupied)) maxContentIdx = Math.max(maxContentIdx, rowIdx);
+  }
+  const grid = [];
+  for (let i = 0; i <= maxContentIdx; i++) grid.push(byIndex.get(i) ?? []);
+  const merges = [];
+  const mergeEls = doc.getElementsByTagNameNS(NS_SML, "mergeCell");
+  for (let i = 0; i < mergeEls.length; i++) {
+    const rect = parseRangeRef(mergeEls[i].getAttribute("ref") ?? "");
+    if (rect) merges.push(rect);
+  }
+  return { cells: grid, merges };
+}
+function inlineGridToTable(grid) {
+  const maxCols = grid.reduce((m, r) => Math.max(m, r.length), 1);
+  const rows = grid.map((cells, rowIdx) => {
+    const children = [];
+    for (let c = 0; c < maxCols; c++) {
+      children.push({
+        type: "tableCell",
+        ...rowIdx === 0 ? { isHeader: true } : {},
+        children: cells[c] ?? []
+      });
+    }
+    return { type: "tableRow", children };
+  });
+  return { type: "table", children: rows };
+}
+function textGridToTable(grid) {
+  return inlineGridToTable(
+    grid.map((row) => row.map((value) => value ? [{ type: "text", value }] : []))
+  );
+}
+function cellsToTable(cells) {
+  return inlineGridToTable(cells.map((row) => row.map(cellInline)));
+}
+function inferHeader(cells) {
+  if (cells.length < 2) return false;
+  const first = cells[0];
+  if (first.length === 0) return false;
+  return first.every((cell) => cell.kind === "string");
+}
+function formulasTable(cells, rect) {
+  if (!cells.some((row) => row.some((cell) => cell.formula))) return null;
+  const header = [];
+  for (let c = rect.left; c <= rect.right; c++) header.push(columnLetter(c));
+  const body = cells.map((row) => row.map((cell) => cell.formula ? `=${cell.formula}` : ""));
+  return textGridToTable([header, ...body]);
+}
+function cellInline(cell) {
+  return cell.richText ?? (cell.text ? [{ type: "text", value: cell.text }] : []);
+}
+function textInline(value) {
+  return value ? [{ type: "text", value }] : [];
+}
+function looseTable(strays) {
+  const withFormula = strays.some((s) => s.cell.formula);
+  const header = withFormula ? ["Cell", "Value", "Formula"] : ["Cell", "Value"];
+  const body = strays.map((s) => {
+    const ref = textInline(formatCellRef(s.row, s.col));
+    const value = cellInline(s.cell);
+    return withFormula ? [ref, value, textInline(s.cell.formula ? `=${s.cell.formula}` : "")] : [ref, value];
+  });
+  return inlineGridToTable([header.map(textInline), ...body]);
+}
+function annotatedHeading(depth, text, params) {
+  return {
+    type: "heading",
+    depth,
+    children: [{ type: "text", value: text }],
+    templateAnnotation: { template: "dataTable", params }
+  };
+}
+async function xlsxToMarkdownDoc(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 children = [];
+  const single = selected.length === 1 && options.sheet !== void 0;
+  const useRegions = options.regions !== false;
+  const withFormulas = options.formulas !== false;
+  for (const sheet of selected) {
+    const { cells, merges } = await sheetToCells(pkg, sheet.path, shared, styles, date1904);
+    if (!single) {
+      children.push({ type: "heading", depth: 1, children: [{ type: "text", value: sheet.name }] });
+    }
+    if (cells.length === 0) continue;
+    if (!useRegions) {
+      children.push(cellsToTable(cells));
+      continue;
+    }
+    const plan = detectRegions(cells, merges, {
+      ...options.maxRegionsPerSheet !== void 0 ? { maxRegionsPerSheet: options.maxRegionsPerSheet } : {},
+      ...options.minRegionCells !== void 0 ? { minRegionCells: options.minRegionCells } : {},
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    for (const warning of plan.warnings) console.warn(`XLSX import: ${sheet.name}: ${warning}`);
+    if (plan.degraded || plan.regions.length === 0 && plan.strays.length === 0) {
+      children.push(cellsToTable(cells));
+      continue;
+    }
+    const depth = single ? 1 : 2;
+    for (const region of plan.regions) {
+      const slice = sliceRect(cells, region.rect, EMPTY_CELL);
+      const anchor = formatCellRef(region.rect.top, region.rect.left);
+      const title = region.title ?? `${sheet.name} \u2014 ${anchor}`;
+      children.push(
+        annotatedHeading(depth, title, {
+          sheet: sheet.name,
+          anchor,
+          // Omit the common case: `headerRow=true` is what a GFM table already
+          // says. (`headerRow`, not `header` — `dataTable` already declares a
+          // `headers` input, and two params one letter apart in the same
+          // annotation is a trap for anyone reading or editing the markdown.)
+          ...inferHeader(slice) ? {} : { headerRow: "false" },
+          // A caption promoted into the heading has left its cell behind;
+          // record where, so the reverse path can put the text back.
+          ...region.titleCell ? { titleAnchor: formatCellRef(region.titleCell.row, region.titleCell.col) } : {}
+        }),
+        cellsToTable(slice)
+      );
+      if (!withFormulas) continue;
+      const formulas = formulasTable(slice, region.rect);
+      if (!formulas) continue;
+      children.push(
+        annotatedHeading(depth, `${title} \u2014 formulas`, {
+          sheet: sheet.name,
+          anchor,
+          role: "formulas"
+        }),
+        formulas
+      );
+    }
+    if (plan.strays.length > 0) {
+      children.push(
+        annotatedHeading(depth, `${sheet.name} \u2014 loose cells`, {
+          sheet: sheet.name,
+          role: "loose"
+        }),
+        looseTable(plan.strays)
+      );
+    }
+  }
+  return { type: "document", children };
+}
+
+// src/xlsx/export.ts
+import { docToMarkdown } from "@bendyline/squisq/doc";
+
+// src/xlsx/workbookPlan.ts
+function hasRichCellContent(nodes) {
+  return nodes.some(
+    (n) => n.type === "superscript" || n.type === "subscript" || "children" in n && Array.isArray(n.children) && hasRichCellContent(n.children)
+  );
+}
+var KEY_STRIDE = MAX_COL_INDEX + 1;
+function cellKey(row, col) {
+  return row * KEY_STRIDE + col;
+}
+function keyRow(key) {
+  return Math.floor(key / KEY_STRIDE);
+}
+function keyCol(key) {
+  return key - keyRow(key) * KEY_STRIDE;
+}
+function tableToGrid(table) {
+  return table.children.map(
+    (row) => row.children.map((cell) => extractPlainText(cell.children))
+  );
+}
+function tableToRichGrid(table) {
+  return table.children.map(
+    (row) => row.children.map((cell) => hasRichCellContent(cell.children) ? cell.children : void 0)
+  );
+}
+function readRole(raw) {
+  return raw === "formulas" || raw === "loose" ? raw : "values";
+}
+function collectEntries(nodes) {
+  const entries = [];
+  let pending = null;
+  for (const node of nodes) {
+    if (node.type === "heading") {
+      pending = node;
+      continue;
+    }
+    if (node.type !== "table") continue;
+    const params = pending?.templateAnnotation?.params ?? {};
+    const sheetKey = typeof params.sheet === "string" && params.sheet !== "" ? params.sheet : null;
+    entries.push({
+      table: node,
+      headingText: pending ? extractPlainText(pending.children) : "",
+      params,
+      sheetKey,
+      role: readRole(params.role)
+    });
+    pending = null;
+  }
+  return entries;
+}
+function groupEntries(entries) {
+  const groups = [];
+  const bySheet = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.sheetKey !== null) {
+      let group = bySheet.get(entry.sheetKey);
+      if (!group) {
+        group = { candidate: entry.sheetKey, entries: [], anchored: true };
+        bySheet.set(entry.sheetKey, group);
+        groups.push(group);
+      }
+      group.entries.push(entry);
+      continue;
+    }
+    groups.push({ candidate: entry.headingText || null, entries: [entry], anchored: false });
+  }
+  return groups;
+}
+function place(cells, row, col, cell, clashes) {
+  const key = cellKey(row, col);
+  if (cells.has(key)) clashes.push(formatCellRef(row, col));
+  cells.set(key, cell);
+}
+function overlayFormula(cells, row, col, formula) {
+  const key = cellKey(row, col);
+  const existing = cells.get(key);
+  cells.set(key, { text: existing?.text ?? "", formula });
+}
+function formulaSource(raw) {
+  const trimmed = raw.trim();
+  return trimmed.startsWith("=") ? trimmed.slice(1) : trimmed;
+}
+function placeValues(entry, cells, warnings, sheetName, clashes) {
+  const grid = tableToGrid(entry.table);
+  const richGrid = tableToRichGrid(entry.table);
+  const anchorRaw = entry.params.anchor ?? "A1";
+  let anchor = parseCellRef(anchorRaw);
+  if (!anchor) {
+    warnings.push(
+      `Sheet "${sheetName}": anchor "${anchorRaw}" is not a valid cell reference; placed at A1 instead.`
+    );
+    anchor = { row: 0, col: 0 };
+  }
+  const height = grid.length;
+  const width = grid.reduce((m, r) => Math.max(m, r.length), 0);
+  if (anchor.row + height - 1 > MAX_ROW_INDEX || anchor.col + width - 1 > MAX_COL_INDEX) {
+    warnings.push(
+      `Sheet "${sheetName}": a table anchored at ${anchorRaw} runs past the end of the sheet; placed at A1 instead.`
+    );
+    anchor = { row: 0, col: 0 };
+  }
+  const titleRef = entry.params.titleAnchor;
+  if (titleRef !== void 0 && entry.headingText !== "") {
+    const at = parseCellRef(titleRef);
+    if (at) place(cells, at.row, at.col, { text: entry.headingText }, clashes);
+  }
+  for (let r = 0; r < grid.length; r++) {
+    const row = grid[r];
+    for (let c = 0; c < row.length; c++) {
+      const text = row[c];
+      if (text === "") continue;
+      const rich = richGrid[r]?.[c];
+      place(cells, anchor.row + r, anchor.col + c, rich ? { text, rich } : { text }, clashes);
+    }
+  }
+}
+function placeFormulas(entry, cells, warnings, sheetName) {
+  const grid = tableToGrid(entry.table);
+  if (grid.length < 2) return;
+  const anchorRaw = entry.params.anchor ?? "A1";
+  const anchor = parseCellRef(anchorRaw);
+  if (!anchor) {
+    warnings.push(
+      `Sheet "${sheetName}": formulas block anchor "${anchorRaw}" is not a valid cell reference; skipped.`
+    );
+    return;
+  }
+  const columns = grid[0].map((letters) => {
+    const trimmed = letters.trim();
+    if (!/^[A-Za-z]{1,3}$/.test(trimmed)) return -1;
+    const col = columnIndexFromLetters(trimmed);
+    return col >= 0 && col <= MAX_COL_INDEX ? col : -1;
+  });
+  for (let r = 1; r < grid.length; r++) {
+    const row = grid[r];
+    for (let c = 0; c < row.length; c++) {
+      const raw = row[c];
+      if (raw.trim() === "") continue;
+      const mapped = columns[c];
+      const col = mapped !== void 0 && mapped >= 0 ? mapped : anchor.col + c;
+      const targetRow = anchor.row + r - 1;
+      if (targetRow > MAX_ROW_INDEX) continue;
+      overlayFormula(cells, targetRow, col, formulaSource(raw));
+    }
+  }
+}
+function placeLoose(entry, cells, warnings, sheetName, clashes) {
+  const grid = tableToGrid(entry.table);
+  const richGrid = tableToRichGrid(entry.table);
+  let skipped = 0;
+  for (let r = 1; r < grid.length; r++) {
+    const row = grid[r];
+    const ref = (row[0] ?? "").trim();
+    if (ref === "") continue;
+    const at = parseCellRef(ref);
+    if (!at) {
+      skipped++;
+      continue;
+    }
+    const text = row[1] ?? "";
+    const formula = formulaSource(row[2] ?? "");
+    const rich = richGrid[r]?.[1];
+    const planned = { text };
+    if (formula !== "") planned.formula = formula;
+    if (rich) planned.rich = rich;
+    place(cells, at.row, at.col, planned, clashes);
+  }
+  if (skipped > 0) {
+    warnings.push(
+      `Sheet "${sheetName}": ${skipped} loose-cell row(s) had an invalid cell reference and were skipped.`
+    );
+  }
+}
+function planWorkbook(doc, options) {
+  const warnings = [];
+  const groups = groupEntries(collectEntries(doc.children));
+  const used = /* @__PURE__ */ new Set();
+  const sheets = [];
+  groups.forEach((group, index) => {
+    const fallback = `${options.sheetNamePrefix}${index + 1}`;
+    const name = options.sanitize(group.candidate ?? fallback, used, fallback);
+    const cells = /* @__PURE__ */ new Map();
+    const clashes = [];
+    for (const entry of group.entries) {
+      if (entry.role === "values") placeValues(entry, cells, warnings, name, clashes);
+    }
+    for (const entry of group.entries) {
+      if (entry.role === "formulas") placeFormulas(entry, cells, warnings, name);
+    }
+    for (const entry of group.entries) {
+      if (entry.role === "loose") placeLoose(entry, cells, warnings, name, clashes);
+    }
+    if (clashes.length > 0) {
+      const shown = clashes.slice(0, 5).join(", ");
+      const rest = clashes.length > 5 ? ", and more" : "";
+      warnings.push(
+        `Sheet "${name}": ${clashes.length} overlapping cell(s) (${shown}${rest}); the later block won.`
+      );
+    }
+    sheets.push({ name, cells, anchored: group.anchored });
+  });
+  let cellCount = 0;
+  for (const sheet of sheets) cellCount += sheet.cells.size;
+  return { sheets, warnings, cellCount };
+}
+
+// src/xlsx/export.ts
+var NUMERIC_RE = /^-?\d+(\.\d+)?$/;
+function isSafeNumericCell(value) {
+  if (!NUMERIC_RE.test(value)) return false;
+  const unsigned = value.startsWith("-") ? value.slice(1) : value;
+  const [integer] = unsigned.split(".");
+  if (integer.length > 1 && integer.startsWith("0")) return false;
+  const significantDigits = unsigned.replace(".", "").replace(/^0+/, "");
+  if (significantDigits.length > 15) return false;
+  return Number.isFinite(Number(value));
+}
+function cleanSheetName(raw) {
+  return raw.replace(/[[\]:*?/\\]/g, "").trim().slice(0, 31).trim().replace(/^'+|'+$/g, "");
+}
+function sanitizeSheetName(candidate, used, fallback) {
+  let base = cleanSheetName(candidate) || cleanSheetName(fallback) || "Sheet";
+  let name = base;
+  let n = 2;
+  while (used.has(name.toLocaleLowerCase("en-US"))) {
+    const suffix = String(n++);
+    base = base.slice(0, 31 - suffix.length);
+    name = `${base}${suffix}`;
+  }
+  used.add(name.toLocaleLowerCase("en-US"));
+  return name;
+}
+var ERROR_VALUE_RE = /^#[A-Z0-9_/]+[!?]?$/;
+function cellXml(cell, ref, inferNumericCells) {
+  const { text, formula } = cell;
+  if (formula !== void 0 && formula !== "") {
+    const f = `<f>${escapeXml(formula)}</f>`;
+    if (text === "") return `<c r="${ref}">${f}</c>`;
+    if (isSafeNumericCell(text)) return `<c r="${ref}">${f}<v>${escapeXml(text)}</v></c>`;
+    if (ERROR_VALUE_RE.test(text)) return `<c r="${ref}" t="e">${f}<v>${escapeXml(text)}</v></c>`;
+    return `<c r="${ref}" t="str">${f}<v>${escapeXml(text)}</v></c>`;
+  }
+  if (inferNumericCells && isSafeNumericCell(text)) {
+    return `<c r="${ref}"><v>${escapeXml(text)}</v></c>`;
+  }
+  if (cell.rich) {
+    return `<c r="${ref}" t="inlineStr"><is>${richRunsXml(cell.rich)}</is></c>`;
+  }
+  return `<c r="${ref}" t="inlineStr"><is><t xml:space="preserve">${escapeXml(text)}</t></is></c>`;
+}
+function richRunsXml(nodes) {
+  const runs = [];
+  const emit = (text, vertAlign) => {
+    if (text === "") return;
+    const rPr = vertAlign ? `<rPr><vertAlign val="${vertAlign}"/></rPr>` : "";
+    runs.push(`<r>${rPr}<t xml:space="preserve">${escapeXml(text)}</t></r>`);
+  };
+  const walk = (list, vertAlign) => {
+    for (const node of list) {
+      if (node.type === "superscript" || node.type === "subscript") {
+        walk(node.children, node.type === "superscript" ? "superscript" : "subscript");
+      } else if ("children" in node && Array.isArray(node.children)) {
+        walk(node.children, vertAlign);
+      } else {
+        emit(inlineToPlainText(node), vertAlign);
+      }
+    }
+  };
+  walk(nodes, null);
+  return runs.join("");
+}
+function worksheetXml(sheet, inferNumericCells) {
+  const keys = [...sheet.cells.keys()].sort((a, b) => a - b);
+  const rows = [];
+  let maxRow = 0;
+  let maxCol = 0;
+  let i = 0;
+  while (i < keys.length) {
+    const rowIdx = keyRow(keys[i]);
+    let cellsXml = "";
+    while (i < keys.length && keyRow(keys[i]) === rowIdx) {
+      const key = keys[i];
+      const col = keyCol(key);
+      if (col > maxCol) maxCol = col;
+      cellsXml += cellXml(
+        sheet.cells.get(key),
+        `${columnLetter(col)}${rowIdx + 1}`,
+        inferNumericCells
+      );
+      i++;
+    }
+    if (rowIdx > maxRow) maxRow = rowIdx;
+    rows.push(`<row r="${rowIdx + 1}">${cellsXml}</row>`);
+  }
+  const dimension = keys.length > 0 ? `A1:${columnLetter(maxCol)}${maxRow + 1}` : "A1";
+  return `${xmlDeclaration()}
+<worksheet xmlns="${NS_SML}" xmlns:r="${NS_R}"><dimension ref="${dimension}"/><sheetData>${rows.join("")}</sheetData></worksheet>`;
+}
+function workbookXml(sheets, hasFormulas) {
+  const sheetEls = sheets.map(
+    (sheet, i) => `<sheet name="${escapeXml(sheet.name)}" sheetId="${i + 1}" r:id="rId${i + 1}"/>`
+  ).join("");
+  const calcPr = hasFormulas ? `<calcPr calcId="0" fullCalcOnLoad="1"/>` : "";
+  return `${xmlDeclaration()}
+<workbook xmlns="${NS_SML}" xmlns:r="${NS_R}"><sheets>${sheetEls}</sheets>${calcPr}</workbook>`;
+}
+function stylesXml() {
+  return `${xmlDeclaration()}
+<styleSheet xmlns="${NS_SML}"><fonts count="1"><font><sz val="11"/><name val="Calibri"/></font></fonts><fills count="1"><fill><patternFill patternType="none"/></fill></fills><borders count="1"><border/></borders><cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs><cellXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/></cellXfs></styleSheet>`;
+}
+async function markdownDocToXlsx(doc, options = {}) {
+  options.signal?.throwIfAborted();
+  const prefix = cleanSheetName(options.sheetNamePrefix ?? "Sheet") || "Sheet";
+  const maxCells = options.maxCells ?? 1e5;
+  if (!Number.isSafeInteger(maxCells) || maxCells < 0) {
+    throw new RangeError("maxCells must be a non-negative safe integer");
+  }
+  const plan = planWorkbook(doc, { sheetNamePrefix: prefix, sanitize: sanitizeSheetName });
+  for (const warning of plan.warnings) options.onWarning?.(warning);
+  if (plan.cellCount > maxCells) {
+    throw new RangeError(`XLSX export exceeds the ${maxCells}-cell safety limit`);
+  }
+  let sheets = plan.sheets;
+  if (sheets.length === 0) {
+    sheets = [
+      {
+        name: sanitizeSheetName(`${prefix}1`, /* @__PURE__ */ new Set(), "Sheet1"),
+        cells: /* @__PURE__ */ new Map(),
+        anchored: false
+      }
+    ];
+  }
+  const anchored = sheets.some((sheet) => sheet.anchored);
+  const inferNumericCells = options.inferNumericCells ?? anchored;
+  const hasFormulas = sheets.some((sheet) => {
+    for (const cell of sheet.cells.values()) if (cell.formula) return true;
+    return false;
+  });
+  const pkg = createPackage();
+  sheets.forEach((sheet, i) => {
+    if ((i & 31) === 0) options.signal?.throwIfAborted();
+    const sheetPath = `xl/worksheets/sheet${i + 1}.xml`;
+    pkg.addPart(sheetPath, worksheetXml(sheet, inferNumericCells), CONTENT_TYPE_XLSX_WORKSHEET);
+    pkg.addRelationship("xl/workbook.xml", {
+      id: `rId${i + 1}`,
+      type: REL_WORKSHEET,
+      target: `worksheets/sheet${i + 1}.xml`
+    });
+  });
+  pkg.addPart("xl/styles.xml", stylesXml(), CONTENT_TYPE_XLSX_STYLES);
+  pkg.addRelationship("xl/workbook.xml", {
+    id: `rId${sheets.length + 1}`,
+    type: REL_STYLES,
+    target: "styles.xml"
+  });
+  pkg.addPart("xl/workbook.xml", workbookXml(sheets, hasFormulas), CONTENT_TYPE_XLSX_WORKBOOK);
+  pkg.addRelationship("", {
+    id: "rId1",
+    type: REL_OFFICE_DOCUMENT,
+    target: "xl/workbook.xml"
+  });
+  if (options.title || options.author) {
+    pkg.setCoreProperties({
+      title: options.title,
+      creator: options.author,
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      modified: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  return pkg.toArrayBuffer();
+}
+async function docToXlsx(doc, options) {
+  return markdownDocToXlsx(docToMarkdown(doc), options);
+}
+
+// src/xlsx/index.ts
+async function xlsxToDoc(data, options) {
+  return markdownToDoc(await xlsxToMarkdownDoc(data, options));
+}
+
+export {
+  xlsxToMarkdownDoc,
+  markdownDocToXlsx,
+  docToXlsx,
+  xlsxToDoc
+};