@bendyline/squisq-formats 2.5.1 → 2.6.1

package/dist/chunk-CKSTGNVZ.js

@@ -0,0 +1,724 @@
+import {
+  extractPlainText,
+  inlineToPlainText
+} from "./chunk-AVOZAKGP.js";
+import {
+  MAX_COL_INDEX,
+  MAX_ROW_INDEX,
+  colIndex,
+  columnIndexFromLetters,
+  columnLetter,
+  formatCellRef,
+  listSheetParts,
+  numberFormatKind,
+  parseCellRef,
+  readCellStyles,
+  xlsxToMarkdownDoc
+} from "./chunk-OBADJV7C.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,
+  getPartBinary,
+  openPackage,
+  requireMainPartPath
+} from "./chunk-S5PCVMKU.js";
+
+// src/xlsx/index.ts
+import { markdownToDoc } from "@bendyline/squisq/doc";
+
+// 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/patch.ts
+import JSZip from "jszip";
+import { DOMParser as XmldomDOMParser, XMLSerializer as XmldomXMLSerializer } from "@xmldom/xmldom";
+var XLSX_MAIN_PART = "xl/workbook.xml";
+var XlsxPatchRefusal = class extends Error {
+  constructor(code, sheet, ref, message) {
+    super(message);
+    this.name = "XlsxPatchRefusal";
+    this.code = code;
+    this.sheet = sheet;
+    this.ref = ref;
+  }
+};
+function parsePart(text) {
+  const doc = new XmldomDOMParser().parseFromString(text, "application/xml");
+  const errors = doc.getElementsByTagName("parsererror");
+  if (errors.length > 0) {
+    throw new Error(`Invalid XLSX XML part: ${errors[0]?.textContent ?? "parse error"}`);
+  }
+  return doc;
+}
+function serializePart(doc, originalText) {
+  const serialized = new XmldomXMLSerializer().serializeToString(
+    doc
+  );
+  if (serialized.startsWith("<?xml")) return serialized;
+  const decl = /^\uFEFF?<\?xml[^>]*\?>\s*/.exec(originalText);
+  return decl ? decl[0] + serialized : serialized;
+}
+async function readRawPart(pkg, path) {
+  const bytes = await getPartBinary(pkg, path);
+  if (!bytes) throw new Error(`Invalid XLSX package: part "${path}" is missing.`);
+  const text = new TextDecoder().decode(bytes);
+  return { text, doc: parsePart(text) };
+}
+function childElementsNS(parent, local) {
+  const out = [];
+  for (let node = parent.firstChild; node; node = node.nextSibling) {
+    if (node.nodeType !== 1) continue;
+    const el = node;
+    if (el.localName === local && el.namespaceURI === NS_SML) out.push(el);
+  }
+  return out;
+}
+function firstChildNS(parent, local) {
+  return childElementsNS(parent, local)[0] ?? null;
+}
+function findOrCreateRow(doc, sheetData, rowNumber) {
+  let insertBefore = null;
+  for (const row of childElementsNS(sheetData, "row")) {
+    const r = Number.parseInt(row.getAttribute("r") ?? "", 10);
+    if (r === rowNumber) return row;
+    if (Number.isFinite(r) && r > rowNumber && !insertBefore) insertBefore = row;
+  }
+  const created = doc.createElementNS(NS_SML, "row");
+  created.setAttribute("r", String(rowNumber));
+  sheetData.insertBefore(created, insertBefore);
+  return created;
+}
+function findOrCreateCell(doc, row, ref) {
+  const targetCol = colIndex(ref);
+  let insertBefore = null;
+  for (const cell of childElementsNS(row, "c")) {
+    const cellRef = cell.getAttribute("r");
+    if (cellRef === ref) return cell;
+    if (cellRef && colIndex(cellRef) > targetCol && !insertBefore) insertBefore = cell;
+  }
+  const created = doc.createElementNS(NS_SML, "c");
+  created.setAttribute("r", ref);
+  row.insertBefore(created, insertBefore);
+  return created;
+}
+function refuseFormulaCell(cell, sheet, ref) {
+  const f = firstChildNS(cell, "f");
+  if (!f) return;
+  const isSharedFollower = f.getAttribute("t") === "shared" && (f.textContent ?? "").trim() === "";
+  throw new XlsxPatchRefusal(
+    isSharedFollower ? "shared-formula-follower" : "formula-cell",
+    sheet,
+    ref,
+    isSharedFollower ? `${sheet}!${ref} continues a shared (fill-down) formula; formula cells cannot be patched` : `${sheet}!${ref} holds a formula; formula cells cannot be patched`
+  );
+}
+function refuseDateStyled(cell, styles, sheet, ref, value) {
+  if (value === null) return;
+  const styleIndex = Number.parseInt(cell.getAttribute("s") ?? "", 10);
+  if (!Number.isFinite(styleIndex)) return;
+  const style = styles[styleIndex];
+  if (!style) return;
+  const kind = numberFormatKind(style.formatCode);
+  if (kind === "date" || kind === "time" || kind === "datetime") {
+    throw new XlsxPatchRefusal(
+      "date-value-unsupported",
+      sheet,
+      ref,
+      `${sheet}!${ref} is date-formatted; date values are not supported by in-place patching`
+    );
+  }
+}
+function clearCellContent(cell) {
+  for (const local of ["v", "is"]) {
+    for (const el of childElementsNS(cell, local)) cell.removeChild(el);
+  }
+}
+function writeCellValue(doc, cell, value) {
+  clearCellContent(cell);
+  if (value === null) {
+    cell.removeAttribute("t");
+    return;
+  }
+  if (typeof value === "number") {
+    cell.removeAttribute("t");
+    const v = doc.createElementNS(NS_SML, "v");
+    v.appendChild(doc.createTextNode(String(value)));
+    cell.appendChild(v);
+    return;
+  }
+  if (typeof value === "boolean") {
+    cell.setAttribute("t", "b");
+    const v = doc.createElementNS(NS_SML, "v");
+    v.appendChild(doc.createTextNode(value ? "1" : "0"));
+    cell.appendChild(v);
+    return;
+  }
+  cell.setAttribute("t", "inlineStr");
+  const is = doc.createElementNS(NS_SML, "is");
+  const t = doc.createElementNS(NS_SML, "t");
+  if (value !== value.trim())
+    t.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve");
+  t.appendChild(doc.createTextNode(value));
+  is.appendChild(t);
+  cell.appendChild(is);
+}
+function refuseSharedMaster(cell, sheet, ref) {
+  const f = firstChildNS(cell, "f");
+  if (!f) return;
+  if (f.getAttribute("t") === "shared" && (f.textContent ?? "").trim() !== "") {
+    throw new XlsxPatchRefusal(
+      "shared-formula-master",
+      sheet,
+      ref,
+      `${sheet}!${ref} is the master of a shared (fill-down) formula group; replacing it would orphan its followers`
+    );
+  }
+}
+function clearCellFormula(cell) {
+  for (const el of childElementsNS(cell, "f")) cell.removeChild(el);
+}
+function writeCellFormula(doc, cell, formula, cachedValue) {
+  clearCellFormula(cell);
+  clearCellContent(cell);
+  cell.removeAttribute("t");
+  const f = doc.createElementNS(NS_SML, "f");
+  f.appendChild(doc.createTextNode(formula));
+  cell.appendChild(f);
+  if (cachedValue === void 0) return;
+  const v = doc.createElementNS(NS_SML, "v");
+  if (typeof cachedValue === "number") {
+    v.appendChild(doc.createTextNode(String(cachedValue)));
+  } else if (typeof cachedValue === "boolean") {
+    cell.setAttribute("t", "b");
+    v.appendChild(doc.createTextNode(cachedValue ? "1" : "0"));
+  } else {
+    cell.setAttribute("t", "str");
+    v.appendChild(doc.createTextNode(cachedValue));
+  }
+  cell.appendChild(v);
+}
+var AFTER_CALC_PR = /* @__PURE__ */ new Set([
+  "oleSize",
+  "customWorkbookViews",
+  "pivotCaches",
+  "smartTagPr",
+  "smartTagTypes",
+  "webPublishing",
+  "fileRecoveryPr",
+  "webPublishObjects",
+  "extLst"
+]);
+function setFullCalcOnLoad(doc) {
+  const root = doc.documentElement;
+  if (!root) return;
+  const existing = firstChildNS(root, "calcPr");
+  if (existing) {
+    existing.setAttribute("fullCalcOnLoad", "1");
+    return;
+  }
+  const calcPr = doc.createElementNS(NS_SML, "calcPr");
+  calcPr.setAttribute("fullCalcOnLoad", "1");
+  let insertBefore = null;
+  for (let node = root.firstChild; node; node = node.nextSibling) {
+    if (node.nodeType !== 1) continue;
+    const el = node;
+    if (el.namespaceURI === NS_SML && AFTER_CALC_PR.has(el.localName)) {
+      insertBefore = node;
+      break;
+    }
+  }
+  root.insertBefore(calcPr, insertBefore);
+}
+async function patchXlsxCellValues(bytes, patches, options = {}) {
+  const pkg = await openPackage(bytes, options);
+  const mainPart = requireMainPartPath(pkg, XLSX_MAIN_PART, "XLSX");
+  const sheets = await listSheetParts(pkg, mainPart);
+  const styles = await readCellStyles(pkg);
+  const sheetByName = new Map(sheets.map((sheet) => [sheet.name, sheet.path]));
+  for (const patch of patches) {
+    if (!sheetByName.has(patch.sheet)) {
+      throw new XlsxPatchRefusal(
+        "sheet-missing",
+        patch.sheet,
+        patch.ref,
+        `workbook has no sheet named "${patch.sheet}"`
+      );
+    }
+    if (!parseCellRef(patch.ref)) {
+      throw new XlsxPatchRefusal(
+        "cell-ref-invalid",
+        patch.sheet,
+        patch.ref,
+        `"${patch.ref}" is not a valid cell reference`
+      );
+    }
+    const hasValue = patch.value !== void 0;
+    const hasFormula = patch.formula !== void 0;
+    if (hasValue === hasFormula) {
+      throw new XlsxPatchRefusal(
+        "patch-invalid",
+        patch.sheet,
+        patch.ref,
+        `${patch.sheet}!${patch.ref}: a patch carries exactly one of value or formula`
+      );
+    }
+    if (hasFormula && patch.formula.trim() === "") {
+      throw new XlsxPatchRefusal(
+        "patch-invalid",
+        patch.sheet,
+        patch.ref,
+        `${patch.sheet}!${patch.ref}: formula must be non-empty`
+      );
+    }
+    const numericCandidate = hasFormula ? patch.cachedValue : patch.value;
+    if (typeof numericCandidate === "number" && !Number.isFinite(numericCandidate)) {
+      throw new XlsxPatchRefusal(
+        "number-not-finite",
+        patch.sheet,
+        patch.ref,
+        `${patch.sheet}!${patch.ref}: only finite numbers can be written`
+      );
+    }
+  }
+  const touched = /* @__PURE__ */ new Map();
+  for (const patch of patches) {
+    const path = sheetByName.get(patch.sheet);
+    let part = touched.get(path);
+    if (!part) {
+      part = await readRawPart(pkg, path);
+      touched.set(path, part);
+    }
+    const parsed = parseCellRef(patch.ref);
+    const normalizedRef = formatCellRef(parsed.row, parsed.col);
+    const sheetData = firstChildNS(part.doc.documentElement, "sheetData");
+    if (!sheetData) {
+      throw new Error(`Invalid worksheet part "${path}": no <sheetData> element.`);
+    }
+    const row = findOrCreateRow(part.doc, sheetData, parsed.row + 1);
+    const cell = findOrCreateCell(part.doc, row, normalizedRef);
+    if (patch.formula !== void 0) {
+      refuseSharedMaster(cell, patch.sheet, normalizedRef);
+      writeCellFormula(part.doc, cell, patch.formula, patch.cachedValue);
+    } else {
+      refuseFormulaCell(cell, patch.sheet, normalizedRef);
+      refuseDateStyled(cell, styles, patch.sheet, normalizedRef, patch.value ?? null);
+      writeCellValue(part.doc, cell, patch.value ?? null);
+    }
+  }
+  if (touched.size > 0) {
+    const workbook = await readRawPart(pkg, mainPart);
+    setFullCalcOnLoad(workbook.doc);
+    touched.set(mainPart, workbook);
+  }
+  const zip = await JSZip.loadAsync(bytes);
+  for (const [path, part] of touched) {
+    zip.file(path, serializePart(part.doc, part.text));
+  }
+  return zip.generateAsync({
+    type: "arraybuffer",
+    compression: "DEFLATE",
+    compressionOptions: { level: 6 }
+  });
+}
+
+// src/xlsx/index.ts
+async function xlsxToDoc(data, options) {
+  return markdownToDoc(await xlsxToMarkdownDoc(data, options));
+}
+
+export {
+  markdownDocToXlsx,
+  docToXlsx,
+  XlsxPatchRefusal,
+  patchXlsxCellValues,
+  xlsxToDoc
+};