@noy-db/as-xlsx 0.1.0-pre.10

package/dist/index.cjs

@@ -0,0 +1,624 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  XlsxDictAmbiguityError: () => XlsxDictAmbiguityError,
+  colLetter: () => colLetter,
+  download: () => download,
+  fromBytes: () => fromBytes,
+  readXlsx: () => readXlsx,
+  toBytes: () => toBytes,
+  toBytesFromCollection: () => toBytesFromCollection,
+  write: () => write,
+  writeXlsx: () => writeXlsx
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/xlsx.ts
+var import_as_zip = require("@noy-db/as-zip");
+var XML_HEADER = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+var ENCODER = new TextEncoder();
+async function writeXlsx(sheets) {
+  if (sheets.length === 0) {
+    throw new Error("writeXlsx: at least one sheet is required");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const safeSheets = sheets.map((s, i) => {
+    let name = truncateSheetName(s.name || `Sheet${i + 1}`);
+    let n = 1;
+    while (seen.has(name)) {
+      const suffix = `(${n++})`;
+      name = truncateSheetName(name.slice(0, 31 - suffix.length) + suffix);
+    }
+    seen.add(name);
+    return { ...s, name };
+  });
+  const sharedStrings = [];
+  const stringIndex = /* @__PURE__ */ new Map();
+  const internString = (s) => {
+    const existing = stringIndex.get(s);
+    if (existing !== void 0) return existing;
+    const idx = sharedStrings.length;
+    sharedStrings.push(s);
+    stringIndex.set(s, idx);
+    return idx;
+  };
+  const sheetXmls = safeSheets.map((sheet) => {
+    const lines = [
+      XML_HEADER,
+      '<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">',
+      "<sheetData>"
+    ];
+    let rowNum = 0;
+    if (sheet.header && sheet.header.length > 0) {
+      rowNum++;
+      const cells = sheet.header.map((h, i) => {
+        const idx = internString(String(h));
+        return `<c r="${colLetter(i + 1)}${rowNum}" t="s"><v>${idx}</v></c>`;
+      }).join("");
+      lines.push(`<row r="${rowNum}">${cells}</row>`);
+    }
+    for (const row of sheet.rows) {
+      rowNum++;
+      const cells = row.map((value, i) => cellXml(value, i + 1, rowNum, internString)).join("");
+      lines.push(`<row r="${rowNum}">${cells}</row>`);
+    }
+    lines.push("</sheetData>", "</worksheet>");
+    return lines.join("");
+  });
+  const sheetEntries = safeSheets.map((s, i) => ({
+    index: i + 1,
+    id: `rId${i + 1}`,
+    name: s.name,
+    path: `xl/worksheets/sheet${i + 1}.xml`
+  }));
+  const contentTypes = [
+    XML_HEADER,
+    '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">',
+    '<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>',
+    '<Default Extension="xml" ContentType="application/xml"/>',
+    '<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>',
+    ...sheetEntries.map(
+      (s) => `<Override PartName="/${s.path}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`
+    ),
+    '<Override PartName="/xl/sharedStrings.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml"/>',
+    "</Types>"
+  ].join("");
+  const rootRels = XML_HEADER + '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/></Relationships>';
+  const workbookXml = [
+    XML_HEADER,
+    '<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">',
+    "<sheets>",
+    ...sheetEntries.map(
+      (s) => `<sheet name="${escapeXmlAttr(s.name)}" sheetId="${s.index}" r:id="${s.id}"/>`
+    ),
+    "</sheets>",
+    "</workbook>"
+  ].join("");
+  const workbookRels = [
+    XML_HEADER,
+    '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">',
+    ...sheetEntries.map(
+      (s) => `<Relationship Id="${s.id}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet${s.index}.xml"/>`
+    ),
+    `<Relationship Id="rIdSharedStrings" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" Target="sharedStrings.xml"/>`,
+    "</Relationships>"
+  ].join("");
+  const sharedStringsXml = [
+    XML_HEADER,
+    `<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="${sharedStrings.length}" uniqueCount="${sharedStrings.length}">`,
+    ...sharedStrings.map((s) => `<si><t xml:space="preserve">${escapeXmlText(s)}</t></si>`),
+    "</sst>"
+  ].join("");
+  const entries = [
+    { path: "[Content_Types].xml", bytes: ENCODER.encode(contentTypes) },
+    { path: "_rels/.rels", bytes: ENCODER.encode(rootRels) },
+    { path: "xl/workbook.xml", bytes: ENCODER.encode(workbookXml) },
+    { path: "xl/_rels/workbook.xml.rels", bytes: ENCODER.encode(workbookRels) },
+    { path: "xl/sharedStrings.xml", bytes: ENCODER.encode(sharedStringsXml) },
+    ...sheetEntries.map((s, i) => ({ path: s.path, bytes: ENCODER.encode(sheetXmls[i] ?? "") }))
+  ];
+  return await (0, import_as_zip.writeZip)(entries);
+}
+function cellXml(value, colIdx, rowNum, intern) {
+  const ref = `${colLetter(colIdx)}${rowNum}`;
+  if (value === null || value === void 0 || value === "") return `<c r="${ref}"/>`;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return `<c r="${ref}"><v>${value}</v></c>`;
+  }
+  if (typeof value === "boolean") {
+    return `<c r="${ref}" t="b"><v>${value ? 1 : 0}</v></c>`;
+  }
+  const s = value instanceof Date ? value.toISOString() : typeof value === "string" ? value : JSON.stringify(value);
+  const idx = intern(s);
+  return `<c r="${ref}" t="s"><v>${idx}</v></c>`;
+}
+function colLetter(n) {
+  let s = "";
+  let x = n;
+  while (x > 0) {
+    const r = (x - 1) % 26;
+    s = String.fromCharCode(65 + r) + s;
+    x = Math.floor((x - 1) / 26);
+  }
+  return s;
+}
+function truncateSheetName(name) {
+  const cleaned = name.replace(/[:/\\?*[\]]/g, "_");
+  if (cleaned.length <= 31) return cleaned;
+  return cleaned.slice(0, 30) + "\u2026";
+}
+function escapeXmlText(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\r/g, "&#13;");
+}
+function escapeXmlAttr(s) {
+  return escapeXmlText(s).replace(/"/g, "&quot;");
+}
+
+// src/read.ts
+var import_as_zip2 = require("@noy-db/as-zip");
+var import_fast_xml_parser = require("fast-xml-parser");
+var PARSER = new import_fast_xml_parser.XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  parseTagValue: false,
+  parseAttributeValue: false,
+  trimValues: false,
+  isArray: (name) => name === "sheet" || name === "row" || name === "c" || name === "si" || name === "Relationship"
+});
+async function readXlsx(bytes) {
+  const entries = await (0, import_as_zip2.readZip)(bytes);
+  const partByPath = /* @__PURE__ */ new Map();
+  for (const e of entries) partByPath.set(e.path, e.bytes);
+  const sharedStrings = readSharedStrings(partByPath.get("xl/sharedStrings.xml"));
+  const sheetMeta = readWorkbook(partByPath.get("xl/workbook.xml"));
+  const rels = readWorkbookRels(partByPath.get("xl/_rels/workbook.xml.rels"));
+  const sheets = [];
+  for (const meta of sheetMeta) {
+    const target = rels.get(meta.rId);
+    if (target === void 0) {
+      throw new Error(
+        `as-xlsx.readXlsx: workbook references rId="${meta.rId}" but the rels file has no matching target`
+      );
+    }
+    const sheetPath = `xl/${target}`;
+    const sheetBytes = partByPath.get(sheetPath);
+    if (sheetBytes === void 0) {
+      throw new Error(`as-xlsx.readXlsx: missing sheet part ${sheetPath}`);
+    }
+    sheets.push({
+      name: meta.name,
+      rows: readSheet(sheetBytes, sharedStrings)
+    });
+  }
+  return { sheets };
+}
+function decodeXml(bytes) {
+  return new TextDecoder().decode(bytes);
+}
+function parseStrict(xml, where) {
+  const validation = import_fast_xml_parser.XMLValidator.validate(xml);
+  if (validation !== true) {
+    const err = validation.err;
+    throw new Error(
+      `as-xlsx.readXlsx: ${where} is not valid XML (${err.code} at line ${err.line}: ${err.msg})`
+    );
+  }
+  try {
+    return PARSER.parse(xml);
+  } catch (err) {
+    throw new Error(`as-xlsx.readXlsx: failed to parse ${where} (${err.message})`);
+  }
+}
+function readSharedStrings(bytes) {
+  if (bytes === void 0) return [];
+  const parsed = parseStrict(decodeXml(bytes), "xl/sharedStrings.xml");
+  const sst = parsed.sst;
+  if (sst === null || sst === void 0 || typeof sst !== "object") return [];
+  const items = sst.si ?? [];
+  if (!Array.isArray(items)) return [];
+  return items.map((si) => {
+    if (si === null || typeof si !== "object") return "";
+    const t = si.t;
+    return textValue(t);
+  });
+}
+function readWorkbook(bytes) {
+  if (bytes === void 0) {
+    throw new Error("as-xlsx.readXlsx: missing xl/workbook.xml");
+  }
+  const parsed = parseStrict(decodeXml(bytes), "xl/workbook.xml");
+  const workbook = parsed.workbook;
+  if (workbook === null || workbook === void 0 || typeof workbook !== "object") {
+    throw new Error("as-xlsx.readXlsx: xl/workbook.xml has no <workbook> root");
+  }
+  const sheetsObj = workbook.sheets;
+  if (sheetsObj === null || sheetsObj === void 0 || typeof sheetsObj !== "object") {
+    return [];
+  }
+  const sheetEntries = sheetsObj.sheet ?? [];
+  if (!Array.isArray(sheetEntries)) return [];
+  return sheetEntries.map((s) => {
+    const obj = s;
+    return {
+      name: stringAttr(obj["@_name"]),
+      sheetId: stringAttr(obj["@_sheetId"]),
+      rId: stringAttr(obj["@_r:id"]) || stringAttr(obj["@_id"])
+    };
+  });
+}
+function readWorkbookRels(bytes) {
+  if (bytes === void 0) {
+    throw new Error("as-xlsx.readXlsx: missing xl/_rels/workbook.xml.rels");
+  }
+  const parsed = parseStrict(decodeXml(bytes), "xl/_rels/workbook.xml.rels");
+  const root = parsed.Relationships;
+  if (root === null || root === void 0 || typeof root !== "object") {
+    return /* @__PURE__ */ new Map();
+  }
+  const rels = root.Relationship ?? [];
+  if (!Array.isArray(rels)) return /* @__PURE__ */ new Map();
+  const map = /* @__PURE__ */ new Map();
+  for (const r of rels) {
+    const obj = r;
+    const id = stringAttr(obj["@_Id"]);
+    const target = stringAttr(obj["@_Target"]);
+    if (id) map.set(id, target);
+  }
+  return map;
+}
+function readSheet(bytes, sharedStrings) {
+  const parsed = parseStrict(decodeXml(bytes), "sheet");
+  const ws = parsed.worksheet;
+  if (ws === null || ws === void 0 || typeof ws !== "object") return [];
+  const sheetData = ws.sheetData;
+  if (sheetData === null || sheetData === void 0 || typeof sheetData !== "object") return [];
+  const rowEntries = sheetData.row ?? [];
+  if (!Array.isArray(rowEntries)) return [];
+  const rows = [];
+  for (const row of rowEntries) {
+    if (row === null || typeof row !== "object") {
+      rows.push({});
+      continue;
+    }
+    const cells = row.c ?? [];
+    if (!Array.isArray(cells)) {
+      rows.push({});
+      continue;
+    }
+    const out = {};
+    for (const c of cells) {
+      if (c === null || typeof c !== "object") continue;
+      const cellObj = c;
+      const ref = stringAttr(cellObj["@_r"]);
+      if (!ref) continue;
+      const col = letterFromRef(ref);
+      const t = cellObj["@_t"];
+      const v = cellObj["v"];
+      const text = textValue(v);
+      if (text === "") {
+        if (t === "s") {
+          out[col] = "";
+          continue;
+        }
+        continue;
+      }
+      if (t === "s") {
+        const idx = Number(text);
+        if (!Number.isInteger(idx) || idx < 0 || idx >= sharedStrings.length) {
+          throw new Error(
+            `as-xlsx.readXlsx: shared-string reference ${idx} out of range (table has ${sharedStrings.length} entries)`
+          );
+        }
+        out[col] = sharedStrings[idx];
+      } else if (t === "b") {
+        out[col] = text === "1";
+      } else if (t === "str" || t === "inlineStr") {
+        out[col] = text;
+      } else {
+        const n = Number(text);
+        out[col] = Number.isFinite(n) ? n : text;
+      }
+    }
+    rows.push(out);
+  }
+  return rows;
+}
+function letterFromRef(ref) {
+  let i = 0;
+  while (i < ref.length && /[A-Z]/.test(ref[i])) i++;
+  return ref.slice(0, i);
+}
+function textValue(raw) {
+  if (raw === null || raw === void 0) return "";
+  if (typeof raw === "string") return raw;
+  if (typeof raw === "number" || typeof raw === "boolean") return String(raw);
+  if (typeof raw === "object") {
+    const txt = raw["#text"];
+    if (txt !== void 0) return textValue(txt);
+  }
+  return "";
+}
+function stringAttr(raw) {
+  if (raw === void 0 || raw === null) return "";
+  if (typeof raw === "string") return raw;
+  if (typeof raw === "number" || typeof raw === "boolean") return String(raw);
+  return "";
+}
+
+// src/index.ts
+var import_hub = require("@noy-db/hub");
+async function toBytesFromCollection(vault, collectionName) {
+  return toBytes(vault, {
+    sheets: [{ name: collectionName, collection: collectionName }]
+  });
+}
+async function toBytes(vault, options) {
+  vault.assertCanExport("plaintext", "xlsx");
+  if (options.sheets.length === 0) {
+    throw new Error("as-xlsx: at least one sheet is required");
+  }
+  const materialisedSheets = [];
+  for (const sheetOpt of options.sheets) {
+    const collection = vault.collection(sheetOpt.collection);
+    const list = await collection.list();
+    const records = [];
+    for (const item of list) {
+      const r = item;
+      if (sheetOpt.filter && !sheetOpt.filter(r)) continue;
+      records.push(r);
+    }
+    const columns = sheetOpt.columns ?? inferColumns(records);
+    materialisedSheets.push({
+      name: sheetOpt.name,
+      header: columns,
+      rows: records.map((r) => columns.map((c) => r[c] ?? null))
+    });
+  }
+  return writeXlsx(materialisedSheets);
+}
+async function download(vault, options) {
+  const bytes = await toBytes(vault, options);
+  const filename = options.filename ?? "export.xlsx";
+  const blob = new Blob([bytes], {
+    type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+  });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+async function write(vault, path, options) {
+  if (options.acknowledgeRisks !== true) {
+    throw new Error(
+      `as-xlsx.write: acknowledgeRisks: true is required for on-disk plaintext output. This call creates a persistent plaintext xlsx outside noy-db's encrypted storage \u2014 see docs/patterns/as-exports.md \xA7"The three tiers of \\"plaintext out\\""`
+    );
+  }
+  const bytes = await toBytes(vault, options);
+  const { writeFile } = await import("fs/promises");
+  await writeFile(path, bytes);
+}
+function inferColumns(records) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const r of records) {
+    for (const key of Object.keys(r)) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        out.push(key);
+      }
+    }
+  }
+  return out;
+}
+var XlsxDictAmbiguityError = class extends Error {
+  constructor(column, label) {
+    super(
+      `as-xlsx.fromBytes: dict for column "${column}" has ambiguous label "${label}" \u2014 it maps to more than one key across locales. Supply a stricter dict or resolve the label conflict before importing.`
+    );
+    this.column = column;
+    this.label = label;
+    this.name = "XlsxDictAmbiguityError";
+  }
+  column;
+  label;
+};
+async function fromBytes(vault, bytes, options) {
+  vault.assertCanImport("plaintext", "xlsx");
+  const policy = options.policy ?? "merge";
+  const idKey = options.idKey ?? "id";
+  const types = options.fieldTypes ?? {};
+  const headerRowIdx = (options.headerRow ?? 1) - 1;
+  if (headerRowIdx < 0) {
+    throw new Error("as-xlsx.fromBytes: headerRow must be 1-based and >= 1");
+  }
+  const decoded = await readXlsx(bytes);
+  if (decoded.sheets.length === 0) {
+    return emptyXlsxPlan(vault, options.collection, policy, idKey);
+  }
+  const sheet = options.sheet === void 0 ? decoded.sheets[0] : decoded.sheets.find((s) => s.name === options.sheet);
+  if (sheet === void 0) {
+    throw new Error(
+      `as-xlsx.fromBytes: workbook has no sheet named "${options.sheet}". Available: ${decoded.sheets.map((s) => `"${s.name}"`).join(", ")}`
+    );
+  }
+  const allRows = sheet.rows;
+  if (allRows.length <= headerRowIdx) {
+    return emptyXlsxPlan(vault, options.collection, policy, idKey);
+  }
+  const headerRow = allRows[headerRowIdx];
+  const colToField = /* @__PURE__ */ new Map();
+  for (const [col, value] of Object.entries(headerRow)) {
+    const fieldName = headerCellToField(value);
+    if (fieldName === "") continue;
+    colToField.set(col, fieldName);
+  }
+  const invertMaps = /* @__PURE__ */ new Map();
+  const allFields = new Set(colToField.values());
+  for (const field of allFields) {
+    const explicitEntries = options.dicts?.[field];
+    if (explicitEntries !== void 0 && explicitEntries.length > 0) {
+      invertMaps.set(field, buildInversionMap(field, explicitEntries));
+      continue;
+    }
+    try {
+      const vaultEntries = await vault.dictionary(field).list();
+      if (vaultEntries.length > 0) {
+        invertMaps.set(field, buildInversionMap(field, vaultEntries));
+      }
+    } catch {
+    }
+  }
+  const records = [];
+  for (let i = headerRowIdx + 1; i < allRows.length; i++) {
+    const row = allRows[i];
+    const record = {};
+    let hasAny = false;
+    for (const [col, value] of Object.entries(row)) {
+      const field = colToField.get(col);
+      if (field === void 0) continue;
+      const coerced = coerceXlsxCell(value, types[field]);
+      if (coerced !== void 0) {
+        const invMap = invertMaps.get(field);
+        if (invMap !== void 0 && typeof coerced === "string") {
+          record[field] = invMap.get(coerced) ?? coerced;
+        } else {
+          record[field] = coerced;
+        }
+        hasAny = true;
+      }
+    }
+    if (hasAny) records.push(record);
+  }
+  const plan = await (0, import_hub.diffVault)(vault, { [options.collection]: records }, {
+    collections: [options.collection],
+    idKey
+  });
+  return {
+    plan,
+    policy,
+    async apply() {
+      await vault.noydb.transaction((tx) => {
+        const txVault = tx.vault(vault.name);
+        for (const entry of plan.added) {
+          txVault.collection(entry.collection).put(entry.id, entry.record);
+        }
+        if (policy !== "insert-only") {
+          for (const entry of plan.modified) {
+            txVault.collection(entry.collection).put(entry.id, entry.record);
+          }
+        }
+        if (policy === "replace") {
+          for (const entry of plan.deleted) {
+            txVault.collection(entry.collection).delete(entry.id);
+          }
+        }
+      });
+    }
+  };
+}
+async function emptyXlsxPlan(vault, collection, policy, idKey) {
+  const plan = await (0, import_hub.diffVault)(vault, { [collection]: [] }, { collections: [collection], idKey });
+  return { plan, policy, async apply() {
+  } };
+}
+function buildInversionMap(column, entries) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const label of Object.values(entry.labels)) {
+      if (label === "") continue;
+      const existing = map.get(label);
+      if (existing !== void 0 && existing !== entry.key) {
+        throw new XlsxDictAmbiguityError(column, label);
+      }
+      map.set(label, entry.key);
+    }
+  }
+  return map;
+}
+function headerCellToField(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return "";
+}
+function coerceXlsxCell(value, type) {
+  if (value === void 0 || value === null) return void 0;
+  if (type === void 0) return value;
+  if (type === "string") {
+    if (typeof value === "string") return value;
+    if (typeof value === "number" || typeof value === "boolean") return String(value);
+    return void 0;
+  }
+  if (type === "number") {
+    if (typeof value === "number") return value;
+    const n = Number(value);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  if (type === "boolean") {
+    if (typeof value === "boolean") return value;
+    if (value === "true" || value === 1) return true;
+    if (value === "false" || value === 0) return false;
+    return void 0;
+  }
+  if (type === "date") {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      const ms = excelSerialToMs(value);
+      const d = new Date(ms);
+      return d.toISOString();
+    }
+    if (typeof value === "string") {
+      const d = new Date(value);
+      if (!Number.isNaN(d.getTime())) return d.toISOString();
+    }
+    return void 0;
+  }
+  return value;
+}
+function excelSerialToMs(serial) {
+  const EPOCH_OFFSET_DAYS = 25569;
+  const MS_PER_DAY = 864e5;
+  return Math.round((serial - EPOCH_OFFSET_DAYS) * MS_PER_DAY);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  XlsxDictAmbiguityError,
+  colLetter,
+  download,
+  fromBytes,
+  readXlsx,
+  toBytes,
+  toBytesFromCollection,
+  write,
+  writeXlsx
+});
+//# sourceMappingURL=index.cjs.map