@ricsam/excel-to-formula-engine 0.0.0 → 0.1.1

package/dist/index.cjs

@@ -0,0 +1,1611 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// index.ts
+var exports_excel_to_formula_engine = {};
+__export(exports_excel_to_formula_engine, {
+  columnIndexToLabel: () => columnIndexToLabel,
+  columnLabelToIndex: () => columnLabelToIndex,
+  convertWorkbook: () => convertWorkbook,
+  excelSerialToIso: () => excelSerialToIso,
+  excelToFormulaEngine: () => excelToFormulaEngine,
+  excelToFormulaEngineDetailed: () => excelToFormulaEngineDetailed,
+  findUnsupportedFunctions: () => findUnsupportedFunctions,
+  offsetFormulaReferences: () => offsetFormulaReferences,
+  parseA1: () => parseA1,
+  parseA1Range: () => parseA1Range,
+  toA1: () => toA1,
+  translateFormula: () => translateFormula
+});
+module.exports = __toCommonJS(exports_excel_to_formula_engine);
+
+// src/xlsx/package.ts
+var import_fflate = require("fflate");
+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,
+  processEntities: true
+});
+async function readXlsxPackage(source) {
+  const bytes = await toBytes(source);
+  let unzipped;
+  try {
+    unzipped = import_fflate.unzipSync(bytes);
+  } catch (cause) {
+    throw new Error("Could not read the file as an .xlsx package. Legacy .xls files and " + "password-protected workbooks are not supported.", { cause });
+  }
+  const files = new Map;
+  for (const [path, content] of Object.entries(unzipped)) {
+    files.set(normalizePath(path), content);
+  }
+  if (!files.has("xl/workbook.xml")) {
+    throw new Error("The file is a zip archive but does not contain xl/workbook.xml, so it " + "is not an Excel workbook.");
+  }
+  const xmlCache = new Map;
+  return {
+    files,
+    text(path) {
+      const content = files.get(normalizePath(path));
+      return content ? import_fflate.strFromU8(content) : undefined;
+    },
+    xml(path) {
+      const key = normalizePath(path);
+      if (xmlCache.has(key)) {
+        return xmlCache.get(key);
+      }
+      const content = files.get(key);
+      const parsed = content ? parser.parse(import_fflate.strFromU8(content)) : undefined;
+      xmlCache.set(key, parsed);
+      return parsed;
+    },
+    has(path) {
+      return files.has(normalizePath(path));
+    },
+    list(prefix) {
+      const normalized = normalizePath(prefix);
+      return Array.from(files.keys()).filter((path) => path.startsWith(normalized));
+    }
+  };
+}
+function normalizePath(path) {
+  return path.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+async function toBytes(source) {
+  if (source instanceof Uint8Array) {
+    return source;
+  }
+  if (source instanceof ArrayBuffer) {
+    return new Uint8Array(source);
+  }
+  return new Uint8Array(await source.arrayBuffer());
+}
+function asArray(value) {
+  if (value === undefined || value === null) {
+    return [];
+  }
+  return Array.isArray(value) ? value : [value];
+}
+function attr(node, name) {
+  if (!node || typeof node !== "object") {
+    return;
+  }
+  const value = node[`@${name}`];
+  return value === undefined || value === null ? undefined : String(value);
+}
+function numAttr(node, name) {
+  const raw = attr(node, name);
+  if (raw === undefined) {
+    return;
+  }
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+function boolAttr(node, name, fallback = false) {
+  const raw = attr(node, name);
+  if (raw === undefined) {
+    return fallback;
+  }
+  return raw === "1" || raw.toLowerCase() === "true";
+}
+function textOf(node) {
+  if (node === undefined || node === null) {
+    return "";
+  }
+  if (typeof node === "string") {
+    return node;
+  }
+  if (typeof node === "number" || typeof node === "boolean") {
+    return String(node);
+  }
+  if (typeof node === "object") {
+    const value = node["#text"];
+    return value === undefined || value === null ? "" : String(value);
+  }
+  return "";
+}
+
+// src/a1.ts
+var A1_CELL = /^\$?([A-Za-z]+)\$?(\d+)$/;
+function columnLabelToIndex(label) {
+  let index = 0;
+  for (let i = 0;i < label.length; i++) {
+    index = index * 26 + (label.toUpperCase().charCodeAt(i) - 64);
+  }
+  return index - 1;
+}
+function columnIndexToLabel(index) {
+  let label = "";
+  let remaining = index + 1;
+  while (remaining > 0) {
+    const rest = (remaining - 1) % 26;
+    label = String.fromCharCode(65 + rest) + label;
+    remaining = Math.floor((remaining - rest) / 26);
+  }
+  return label;
+}
+function parseA1(reference) {
+  const match = A1_CELL.exec(reference.trim());
+  if (!match || match[1] === undefined || match[2] === undefined) {
+    return;
+  }
+  return {
+    colIndex: columnLabelToIndex(match[1]),
+    rowIndex: Number.parseInt(match[2], 10) - 1
+  };
+}
+function toA1({ colIndex, rowIndex }) {
+  return `${columnIndexToLabel(colIndex)}${rowIndex + 1}`;
+}
+var EXCEL_MAX_ROW_INDEX = 1048575;
+var EXCEL_MAX_COL_INDEX = 16383;
+function parseA1Range(reference) {
+  const trimmed = reference.trim().replace(/\$/g, "");
+  const [rawStart, rawEnd] = trimmed.split(":");
+  if (rawStart === undefined) {
+    return;
+  }
+  if (rawEnd === undefined) {
+    const cell = parseA1(rawStart);
+    return cell ? { start: cell, end: cell } : undefined;
+  }
+  const startCell = parseA1(rawStart);
+  const endCell = parseA1(rawEnd);
+  if (startCell && endCell) {
+    return { start: startCell, end: endCell };
+  }
+  if (/^[A-Za-z]+$/.test(rawStart) && /^[A-Za-z]+$/.test(rawEnd)) {
+    return {
+      start: { colIndex: columnLabelToIndex(rawStart), rowIndex: 0 },
+      end: {
+        colIndex: columnLabelToIndex(rawEnd),
+        rowIndex: EXCEL_MAX_ROW_INDEX
+      }
+    };
+  }
+  if (/^\d+$/.test(rawStart) && /^\d+$/.test(rawEnd)) {
+    return {
+      start: { colIndex: 0, rowIndex: Number.parseInt(rawStart, 10) - 1 },
+      end: {
+        colIndex: EXCEL_MAX_COL_INDEX,
+        rowIndex: Number.parseInt(rawEnd, 10) - 1
+      }
+    };
+  }
+  return;
+}
+function toSpreadsheetRange(range) {
+  return {
+    start: { col: range.start.colIndex, row: range.start.rowIndex },
+    end: {
+      col: { type: "number", value: range.end.colIndex },
+      row: { type: "number", value: range.end.rowIndex }
+    }
+  };
+}
+function rangeReferenceToSpreadsheetRange(reference) {
+  const parsed = parseA1Range(reference);
+  return parsed ? toSpreadsheetRange(parsed) : undefined;
+}
+
+// src/xlsx/worksheet.ts
+function parseWorksheet(pkg, partPath, sharedStrings) {
+  const root = pkg.xml(partPath);
+  const worksheet = root?.["worksheet"];
+  const result = {
+    cells: [],
+    merges: [],
+    columnWidths: {},
+    rowHeights: {},
+    conditionalFormats: [],
+    hyperlinks: {}
+  };
+  if (!worksheet) {
+    return result;
+  }
+  parseCells(worksheet, sharedStrings, result);
+  parseColumns(worksheet, result);
+  parsePanes(worksheet, result);
+  parseMerges(worksheet, result);
+  parseConditionalFormats(worksheet, result);
+  parseHyperlinks(pkg, partPath, worksheet, result);
+  return result;
+}
+function parseCells(worksheet, sharedStrings, result) {
+  const sheetData = worksheet["sheetData"];
+  const shared = new Map;
+  for (const rawRow of asArray(sheetData?.["row"])) {
+    const row = rawRow;
+    const rowNumber = numAttr(row, "r");
+    const height = numAttr(row, "ht");
+    if (rowNumber !== undefined && height !== undefined) {
+      result.rowHeights[rowNumber - 1] = height;
+    }
+    for (const rawCell of asArray(row["c"])) {
+      const cell = rawCell;
+      const reference = attr(cell, "r");
+      if (!reference) {
+        continue;
+      }
+      const address = parseA1(reference);
+      if (!address) {
+        continue;
+      }
+      const styleIndex = numAttr(cell, "s");
+      const type = attr(cell, "t") ?? "n";
+      const formula = readFormula(cell, address, shared);
+      const { kind, value } = readValue(cell, type, sharedStrings);
+      if (kind === "empty" && formula === undefined && styleIndex === undefined) {
+        continue;
+      }
+      result.cells.push({
+        reference,
+        colIndex: address.colIndex,
+        rowIndex: address.rowIndex,
+        kind,
+        value,
+        formula: formula?.formula,
+        formulaOffset: formula?.offset,
+        styleIndex
+      });
+    }
+  }
+}
+function readFormula(cell, address, shared) {
+  const node = cell["f"];
+  if (node === undefined || node === null) {
+    return;
+  }
+  const body = textOf(node);
+  const type = attr(node, "t");
+  const si = attr(node, "si");
+  if (type === "shared" && si !== undefined) {
+    if (body) {
+      shared.set(si, {
+        formula: body,
+        colIndex: address.colIndex,
+        rowIndex: address.rowIndex
+      });
+      return { formula: body };
+    }
+    const master = shared.get(si);
+    if (!master) {
+      return;
+    }
+    return {
+      formula: master.formula,
+      offset: {
+        cols: address.colIndex - master.colIndex,
+        rows: address.rowIndex - master.rowIndex
+      }
+    };
+  }
+  return body ? { formula: body } : undefined;
+}
+function readValue(cell, type, sharedStrings) {
+  if (type === "inlineStr") {
+    const inline = cell["is"];
+    return { kind: "string", value: readRichText(inline) };
+  }
+  const raw = cell["v"];
+  if (raw === undefined || raw === null) {
+    return { kind: "empty", value: undefined };
+  }
+  const text = textOf(raw);
+  switch (type) {
+    case "s": {
+      const index = Number.parseInt(text, 10);
+      return { kind: "string", value: sharedStrings[index] ?? "" };
+    }
+    case "str":
+      return { kind: "string", value: text };
+    case "b":
+      return { kind: "boolean", value: text === "1" };
+    case "e":
+      return { kind: "error", value: text };
+    case "d":
+      return { kind: "date", value: text };
+    default: {
+      const parsed = Number(text);
+      return Number.isFinite(parsed) ? { kind: "number", value: parsed } : { kind: "string", value: text };
+    }
+  }
+}
+function readRichText(node) {
+  if (node === undefined || node === null) {
+    return "";
+  }
+  if (typeof node === "string") {
+    return node;
+  }
+  const record = node;
+  const runs = asArray(record["r"]);
+  if (runs.length > 0) {
+    return runs.map((run) => textOf(run["t"])).join("");
+  }
+  if (record["t"] !== undefined) {
+    return textOf(record["t"]);
+  }
+  return textOf(record);
+}
+function parseColumns(worksheet, result) {
+  for (const rawCol of asArray(worksheet["cols"]?.["col"])) {
+    const col = rawCol;
+    const min = numAttr(col, "min");
+    const max = numAttr(col, "max");
+    const width = numAttr(col, "width");
+    if (min === undefined || max === undefined || width === undefined) {
+      continue;
+    }
+    if (max - min > 1024) {
+      continue;
+    }
+    for (let index = min;index <= max; index++) {
+      result.columnWidths[index - 1] = width;
+    }
+  }
+}
+function parsePanes(worksheet, result) {
+  const sheetViews = worksheet["sheetViews"];
+  const sheetView = asArray(sheetViews?.["sheetView"])[0];
+  const pane = sheetView?.["pane"];
+  if (!pane) {
+    return;
+  }
+  if (attr(pane, "state") !== "frozen") {
+    return;
+  }
+  result.frozen = {
+    cols: numAttr(pane, "xSplit") ?? 0,
+    rows: numAttr(pane, "ySplit") ?? 0
+  };
+}
+function parseMerges(worksheet, result) {
+  for (const merge of asArray(worksheet["mergeCells"]?.["mergeCell"])) {
+    const ref = attr(merge, "ref");
+    if (ref) {
+      result.merges.push(ref);
+    }
+  }
+}
+function parseConditionalFormats(worksheet, result) {
+  for (const rawBlock of asArray(worksheet["conditionalFormatting"])) {
+    const block = rawBlock;
+    const sqref = attr(block, "sqref");
+    if (!sqref) {
+      continue;
+    }
+    const ranges = sqref.split(/\s+/).filter(Boolean);
+    for (const rawRule of asArray(block["cfRule"])) {
+      const rule = rawRule;
+      const type = attr(rule, "type");
+      if (!type) {
+        continue;
+      }
+      const colorScaleNode = rule["colorScale"];
+      result.conditionalFormats.push({
+        ranges,
+        type,
+        operator: attr(rule, "operator"),
+        formulas: asArray(rule["formula"]).map((formula) => textOf(formula)),
+        text: attr(rule, "text"),
+        dxfId: numAttr(rule, "dxfId"),
+        priority: numAttr(rule, "priority") ?? 0,
+        rank: numAttr(rule, "rank"),
+        bottom: boolAttr(rule, "bottom"),
+        percent: boolAttr(rule, "percent"),
+        stopIfTrue: boolAttr(rule, "stopIfTrue"),
+        colorScale: colorScaleNode ? {
+          cfvo: asArray(colorScaleNode["cfvo"]).map((cfvo) => ({
+            type: attr(cfvo, "type") ?? "min",
+            val: attr(cfvo, "val")
+          })),
+          colors: asArray(colorScaleNode["color"]).map((color) => attr(color, "rgb"))
+        } : undefined
+      });
+    }
+  }
+}
+function parseHyperlinks(pkg, partPath, worksheet, result) {
+  const links = asArray(worksheet["hyperlinks"]?.["hyperlink"]);
+  if (links.length === 0) {
+    return;
+  }
+  const relationships = readRelationships(pkg, partPath);
+  for (const rawLink of links) {
+    const link = rawLink;
+    const ref = attr(link, "ref");
+    if (!ref) {
+      continue;
+    }
+    const id = attr(link, "r:id") ?? attr(link, "id");
+    const location = attr(link, "location");
+    const target = id ? relationships.get(id) : undefined;
+    const href = target ? location ? `${target}#${location}` : target : location;
+    if (!href) {
+      continue;
+    }
+    const start = parseA1(ref.split(":")[0] ?? ref);
+    if (start) {
+      result.hyperlinks[toA1(start)] = href;
+    }
+  }
+}
+function readRelationships(pkg, partPath) {
+  const slash = partPath.lastIndexOf("/");
+  const dir = slash === -1 ? "" : partPath.slice(0, slash);
+  const file = slash === -1 ? partPath : partPath.slice(slash + 1);
+  const relsPath = `${dir}/_rels/${file}.rels`;
+  const map = new Map;
+  const root = pkg.xml(relsPath);
+  const container = root?.["Relationships"];
+  if (!container) {
+    return map;
+  }
+  for (const relationship of asArray(container["Relationship"])) {
+    const id = attr(relationship, "Id");
+    const target = attr(relationship, "Target");
+    if (id && target) {
+      map.set(id, target);
+    }
+  }
+  return map;
+}
+
+// src/xlsx/workbook.ts
+function parseSharedStrings(pkg) {
+  const root = pkg.xml("xl/sharedStrings.xml");
+  const sst = root?.["sst"];
+  if (!sst) {
+    return [];
+  }
+  return asArray(sst["si"]).map((entry) => readRichText(entry));
+}
+function parseWorkbook(pkg) {
+  const root = pkg.xml("xl/workbook.xml");
+  const workbook = root?.["workbook"];
+  if (!workbook) {
+    return { sheets: [], definedNames: [], date1904: false };
+  }
+  const relationships = readRelationships(pkg, "xl/workbook.xml");
+  const sheets = [];
+  for (const rawSheet of asArray(workbook["sheets"]?.["sheet"])) {
+    const sheet = rawSheet;
+    const name = attr(sheet, "name");
+    const id = attr(sheet, "r:id") ?? attr(sheet, "id");
+    if (!name || !id) {
+      continue;
+    }
+    const target = relationships.get(id);
+    if (!target) {
+      continue;
+    }
+    sheets.push({
+      name,
+      partPath: resolvePart(target),
+      state: attr(sheet, "state") ?? "visible"
+    });
+  }
+  const definedNames = [];
+  for (const rawName of asArray(workbook["definedNames"]?.["definedName"])) {
+    const node = rawName;
+    const name = attr(node, "name");
+    if (!name) {
+      continue;
+    }
+    definedNames.push({
+      name,
+      formula: textContent(node),
+      localSheetId: numAttr(node, "localSheetId"),
+      hidden: attr(node, "hidden") === "1"
+    });
+  }
+  const pr = workbook["workbookPr"];
+  const date1904 = attr(pr, "date1904") === "1" || attr(pr, "date1904") === "true";
+  return { sheets, definedNames, date1904 };
+}
+function parseTables(pkg, worksheetPartPath) {
+  const relationships = readRelationships(pkg, worksheetPartPath);
+  const tables = [];
+  for (const target of relationships.values()) {
+    if (!target.includes("tables/")) {
+      continue;
+    }
+    const partPath = resolvePart(target, worksheetPartPath);
+    const root = pkg.xml(partPath);
+    const table = root?.["table"];
+    if (!table) {
+      continue;
+    }
+    const ref = attr(table, "ref");
+    const name = attr(table, "name") ?? attr(table, "displayName");
+    if (!ref || !name) {
+      continue;
+    }
+    tables.push({
+      name,
+      displayName: attr(table, "displayName") ?? name,
+      ref,
+      headerRowCount: numAttr(table, "headerRowCount") ?? 1,
+      totalsRowCount: numAttr(table, "totalsRowCount") ?? 0,
+      columnNames: asArray(table["tableColumns"]?.["tableColumn"]).map((column) => attr(column, "name") ?? "")
+    });
+  }
+  return tables;
+}
+function textContent(node) {
+  const value = node["#text"];
+  if (value === undefined || value === null) {
+    return "";
+  }
+  return String(value);
+}
+function resolvePart(target, fromPart = "xl/workbook.xml") {
+  if (target.startsWith("/")) {
+    return target.slice(1);
+  }
+  const slash = fromPart.lastIndexOf("/");
+  const baseDir = slash === -1 ? "" : fromPart.slice(0, slash);
+  const segments = baseDir ? baseDir.split("/") : [];
+  for (const segment of target.split("/")) {
+    if (segment === "." || segment === "") {
+      continue;
+    }
+    if (segment === "..") {
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  return segments.join("/");
+}
+
+// src/xlsx/styles.ts
+var BUILTIN_FORMATS = {
+  0: "General",
+  1: "0",
+  2: "0.00",
+  3: "#,##0",
+  4: "#,##0.00",
+  9: "0%",
+  10: "0.00%",
+  11: "0.00E+00",
+  12: "# ?/?",
+  13: "# ??/??",
+  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",
+  37: "#,##0 ;(#,##0)",
+  38: "#,##0 ;[Red](#,##0)",
+  39: "#,##0.00;(#,##0.00)",
+  40: "#,##0.00;[Red](#,##0.00)",
+  45: "mm:ss",
+  46: "[h]:mm:ss",
+  47: "mmss.0",
+  48: "##0.0E+0",
+  49: "@"
+};
+var BUILTIN_DATE_FORMAT_IDS = new Set([
+  14,
+  15,
+  16,
+  17,
+  18,
+  19,
+  20,
+  21,
+  22,
+  45,
+  46,
+  47
+]);
+function parseStyles(pkg) {
+  const root = pkg.xml("xl/styles.xml");
+  const styleSheet = root?.["styleSheet"];
+  if (!styleSheet) {
+    return { formats: [], differentialFormats: [] };
+  }
+  const theme = parseThemeColors(pkg);
+  const indexedColors = parseIndexedColors(styleSheet);
+  const numberFormats = new Map;
+  for (const numFmt of asArray(styleSheet["numFmts"]?.["numFmt"])) {
+    const id = numAttr(numFmt, "numFmtId");
+    const code = attr(numFmt, "formatCode");
+    if (id !== undefined && code !== undefined) {
+      numberFormats.set(id, code);
+    }
+  }
+  const fonts = asArray(styleSheet["fonts"]?.["font"]);
+  const fills = asArray(styleSheet["fills"]?.["fill"]);
+  const borders = asArray(styleSheet["borders"]?.["border"]);
+  const cellXfs = asArray(styleSheet["cellXfs"]?.["xf"]);
+  const formats = cellXfs.map((rawXf) => {
+    const xf = rawXf;
+    const style = {};
+    if (boolAttr(xf, "applyFont", true)) {
+      const font = fonts[numAttr(xf, "fontId") ?? -1];
+      if (font) {
+        applyFont(style, font, theme, indexedColors);
+      }
+    }
+    if (boolAttr(xf, "applyFill", true)) {
+      const fill = fills[numAttr(xf, "fillId") ?? -1];
+      if (fill) {
+        applyFill(style, fill, theme, indexedColors);
+      }
+    }
+    if (boolAttr(xf, "applyBorder", true)) {
+      const border = borders[numAttr(xf, "borderId") ?? -1];
+      if (border) {
+        applyBorder(style, border, theme, indexedColors);
+      }
+    }
+    if (boolAttr(xf, "applyAlignment", true)) {
+      const alignment = xf["alignment"];
+      if (alignment && boolAttr(alignment, "wrapText")) {
+        style.wrapText = true;
+      }
+    }
+    const numFmtId = numAttr(xf, "numFmtId") ?? 0;
+    const numberFormat = numberFormats.get(numFmtId) ?? BUILTIN_FORMATS[numFmtId];
+    return {
+      style,
+      numberFormat: numberFormat === "General" ? undefined : numberFormat,
+      isDateFormat: isDateFormat(numFmtId, numberFormat)
+    };
+  });
+  const differentialFormats = asArray(styleSheet["dxfs"]?.["dxf"]).map((dxf) => {
+    const style = {};
+    const node = dxf;
+    if (node["font"]) {
+      applyFont(style, node["font"], theme, indexedColors);
+    }
+    if (node["fill"]) {
+      applyFill(style, node["fill"], theme, indexedColors);
+    }
+    if (node["border"]) {
+      applyBorder(style, node["border"], theme, indexedColors);
+    }
+    return style;
+  });
+  return { formats, differentialFormats };
+}
+function applyFont(style, font, theme, indexedColors) {
+  if (font["b"] !== undefined && isOn(font["b"])) {
+    style.bold = true;
+  }
+  if (font["i"] !== undefined && isOn(font["i"])) {
+    style.italic = true;
+  }
+  if (font["u"] !== undefined && isOn(font["u"])) {
+    style.underline = true;
+  }
+  const size = numAttr(font["sz"], "val");
+  if (size !== undefined) {
+    style.fontSize = Math.round(size * (96 / 72));
+  }
+  const color = resolveColor(font["color"], theme, indexedColors);
+  if (color) {
+    style.color = color;
+  }
+}
+function applyFill(style, fill, theme, indexedColors) {
+  const pattern = fill["patternFill"];
+  if (!pattern) {
+    return;
+  }
+  const patternType = attr(pattern, "patternType");
+  if (patternType === "none" || patternType === undefined) {
+    return;
+  }
+  const color = resolveColor(pattern["fgColor"], theme, indexedColors) ?? resolveColor(pattern["bgColor"], theme, indexedColors);
+  if (color) {
+    style.backgroundColor = color;
+  }
+}
+var BORDER_SIDES = ["top", "right", "bottom", "left"];
+function applyBorder(style, border, theme, indexedColors) {
+  const sides = {};
+  let color;
+  let any = false;
+  for (const side of BORDER_SIDES) {
+    const node = border[side];
+    const borderStyle = node ? attr(node, "style") : undefined;
+    if (!node || borderStyle === undefined || borderStyle === "none") {
+      continue;
+    }
+    sides[side] = true;
+    any = true;
+    color ??= resolveColor(node["color"], theme, indexedColors);
+  }
+  if (any) {
+    style.borderSides = sides;
+    style.borderColor = color ?? "#000000";
+  }
+}
+function isOn(node) {
+  const val = attr(node, "val");
+  return val === undefined || val === "1" || val.toLowerCase() === "true";
+}
+function isDateFormat(numFmtId, code) {
+  if (BUILTIN_DATE_FORMAT_IDS.has(numFmtId)) {
+    return true;
+  }
+  if (!code) {
+    return false;
+  }
+  const stripped = code.replace(/\[[^\]]*\]/g, "").replace(/"[^"]*"/g, "").replace(/\\./g, "");
+  return /[dmyhs]/i.test(stripped) && !/^[^dmyhs]*$/i.test(stripped);
+}
+function resolveColor(node, theme, indexedColors) {
+  if (!node || typeof node !== "object") {
+    return;
+  }
+  const rgb = attr(node, "rgb");
+  if (rgb) {
+    return applyTint(argbToHex(rgb), numAttr(node, "tint"));
+  }
+  const themeIndex = numAttr(node, "theme");
+  if (themeIndex !== undefined) {
+    const base = theme[themeIndex];
+    if (base) {
+      return applyTint(base, numAttr(node, "tint"));
+    }
+  }
+  const indexed = numAttr(node, "indexed");
+  if (indexed !== undefined) {
+    const base = indexedColors[indexed];
+    if (base) {
+      return applyTint(base, numAttr(node, "tint"));
+    }
+  }
+  return;
+}
+function argbToHex(argb) {
+  const value = argb.replace(/^#/, "");
+  const rgb = value.length === 8 ? value.slice(2) : value;
+  return `#${rgb.toLowerCase()}`;
+}
+function applyTint(hex, tint) {
+  if (!tint) {
+    return hex;
+  }
+  const value = hex.replace("#", "");
+  const channels = [0, 2, 4].map((offset) => Number.parseInt(value.slice(offset, offset + 2), 16));
+  const tinted = channels.map((channel) => {
+    const next = tint < 0 ? channel * (1 + tint) : channel * (1 - tint) + 255 * tint;
+    return Math.max(0, Math.min(255, Math.round(next)));
+  });
+  return `#${tinted.map((c) => c.toString(16).padStart(2, "0")).join("")}`;
+}
+function parseThemeColors(pkg) {
+  const themePath = pkg.list("xl/theme/").find((path) => path.endsWith(".xml"));
+  if (!themePath) {
+    return [];
+  }
+  const text = pkg.text(themePath);
+  if (!text) {
+    return [];
+  }
+  const scheme = /<a:clrScheme[\s\S]*?<\/a:clrScheme>/.exec(text)?.[0];
+  if (!scheme) {
+    return [];
+  }
+  const colors = [];
+  const entry = /<a:(dk1|lt1|dk2|lt2|accent[1-6]|hlink|folHlink)>([\s\S]*?)<\/a:\1>/g;
+  let match;
+  while ((match = entry.exec(scheme)) !== null) {
+    const body = match[2] ?? "";
+    const srgb = /<a:srgbClr val="([0-9A-Fa-f]{6})"/.exec(body)?.[1];
+    const sys = /<a:sysClr[^>]*lastClr="([0-9A-Fa-f]{6})"/.exec(body)?.[1];
+    colors.push(`#${(srgb ?? sys ?? "000000").toLowerCase()}`);
+  }
+  if (colors.length >= 4) {
+    const [dk1, lt1, dk2, lt2, ...rest] = colors;
+    return [lt1, dk1, lt2, dk2, ...rest];
+  }
+  return colors;
+}
+function parseIndexedColors(styleSheet) {
+  const colors = asArray(styleSheet["colors"]?.["indexedColors"]?.["rgbColor"]);
+  if (colors.length > 0) {
+    return colors.map((color) => argbToHex(attr(color, "rgb") ?? "FF000000"));
+  }
+  return DEFAULT_INDEXED_COLORS;
+}
+var DEFAULT_INDEXED_COLORS = [
+  "#000000",
+  "#ffffff",
+  "#ff0000",
+  "#00ff00",
+  "#0000ff",
+  "#ffff00",
+  "#ff00ff",
+  "#00ffff",
+  "#000000",
+  "#ffffff",
+  "#ff0000",
+  "#00ff00",
+  "#0000ff",
+  "#ffff00",
+  "#ff00ff",
+  "#00ffff",
+  "#800000",
+  "#008000",
+  "#000080",
+  "#808000",
+  "#800080",
+  "#008080",
+  "#c0c0c0",
+  "#808080",
+  "#9999ff",
+  "#993366",
+  "#ffffcc",
+  "#ccffff",
+  "#660066",
+  "#ff8080",
+  "#0066cc",
+  "#ccccff",
+  "#000080",
+  "#ff00ff",
+  "#ffff00",
+  "#00ffff",
+  "#800080",
+  "#800000",
+  "#008080",
+  "#0000ff",
+  "#00ccff",
+  "#ccffff",
+  "#ccffcc",
+  "#ffff99",
+  "#99ccff",
+  "#ff99cc",
+  "#cc99ff",
+  "#ffcc99",
+  "#3366ff",
+  "#33cccc",
+  "#99cc00",
+  "#ffcc00",
+  "#ff9900",
+  "#ff6600",
+  "#666699",
+  "#969696",
+  "#003366",
+  "#339966",
+  "#003300",
+  "#333300",
+  "#993300",
+  "#993366",
+  "#333399",
+  "#333333"
+];
+
+// src/translate/formula.ts
+var import_formula_engine = require("@ricsam/formula-engine");
+var supportedFunctionNames;
+function getSupportedFunctions() {
+  if (!supportedFunctionNames) {
+    const names = new Set;
+    for (const descriptor of import_formula_engine.getFormulaFunctionCatalog()) {
+      names.add(descriptor.name.toUpperCase());
+      for (const alias of descriptor.aliases ?? []) {
+        names.add(alias.toUpperCase());
+      }
+    }
+    supportedFunctionNames = names;
+  }
+  return supportedFunctionNames;
+}
+var XLFN_PREFIX = /_xlfn\.(_xlws\.)?/g;
+var IMPLICIT_INTERSECTION = /(?<![\w$"'\]\[])@(?=[A-Za-z_\\])/g;
+var THIS_ROW_REFERENCE = /(?:'((?:[^']|'')+)'|([A-Za-z_\\][\w.\\]*))?\[\[#This ?Row\],\s*\[([^\]]*)\](?:\s*:\s*\[([^\]]*)\])?\]/gi;
+function translateFormula(rawFormula, options = {}) {
+  const diagnostics = [];
+  let body = rawFormula.startsWith("=") ? rawFormula.slice(1) : rawFormula;
+  body = body.replace(XLFN_PREFIX, "");
+  body = body.replace(IMPLICIT_INTERSECTION, "");
+  body = contractThisRowReferences(body, options.containingTableName);
+  for (const name of findUnsupportedFunctions(body)) {
+    diagnostics.push({
+      severity: "warning",
+      code: "unsupported-function",
+      message: `The engine does not implement ${name}(). The formula was imported ` + `unchanged and will evaluate to an error.`,
+      sheetName: options.sheetName,
+      cellReference: options.cellReference,
+      source: rawFormula
+    });
+  }
+  return { formula: `=${body}`, diagnostics };
+}
+function findUnsupportedFunctions(formulaBody) {
+  const supported = getSupportedFunctions();
+  const found = new Set;
+  let inString = false;
+  let identifier = "";
+  for (let i = 0;i < formulaBody.length; i++) {
+    const char = formulaBody[i];
+    if (inString) {
+      if (char === '"') {
+        if (formulaBody[i + 1] === '"') {
+          i++;
+        } else {
+          inString = false;
+        }
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      identifier = "";
+      continue;
+    }
+    if (/[A-Za-z0-9_.]/.test(char)) {
+      identifier += char;
+      continue;
+    }
+    if (char === "(" && identifier.length > 0) {
+      const name = identifier.toUpperCase();
+      if (/^[A-Z_][A-Z0-9_.]*$/.test(name) && !supported.has(name)) {
+        found.add(name);
+      }
+    }
+    identifier = "";
+  }
+  return Array.from(found);
+}
+function offsetFormulaReferences(formulaBody, deltaCols, deltaRows) {
+  if (deltaCols === 0 && deltaRows === 0) {
+    return formulaBody;
+  }
+  const reference = /(\$?)([A-Za-z]{1,3})(\$?)(\d{1,7})(?![\w(])/g;
+  let result = "";
+  let lastIndex = 0;
+  let inString = false;
+  for (let i = 0;i < formulaBody.length; i++) {
+    if (formulaBody[i] === '"') {
+      if (inString && formulaBody[i + 1] === '"') {
+        i++;
+        continue;
+      }
+      inString = !inString;
+    }
+    if (inString) {
+      continue;
+    }
+    reference.lastIndex = i;
+    const match = reference.exec(formulaBody);
+    if (!match || match.index !== i) {
+      continue;
+    }
+    const [whole, colAbs, colLabel, rowAbs, rowDigits] = match;
+    const before = i > 0 ? formulaBody[i - 1] : "";
+    if (/[A-Za-z0-9_.]/.test(before)) {
+      continue;
+    }
+    result += formulaBody.slice(lastIndex, i);
+    result += shiftReference(colAbs, colLabel, rowAbs, rowDigits, deltaCols, deltaRows);
+    lastIndex = i + whole.length;
+    i = lastIndex - 1;
+  }
+  result += formulaBody.slice(lastIndex);
+  return result;
+}
+function shiftReference(colAbs, colLabel, rowAbs, rowDigits, deltaCols, deltaRows) {
+  const colIndex = columnLabelToIndex2(colLabel);
+  const rowIndex = Number.parseInt(rowDigits, 10) - 1;
+  const newColIndex = colAbs ? colIndex : colIndex + deltaCols;
+  const newRowIndex = rowAbs ? rowIndex : rowIndex + deltaRows;
+  if (newColIndex < 0 || newRowIndex < 0) {
+    return "#REF!";
+  }
+  return `${colAbs}${columnIndexToLabel2(newColIndex)}${rowAbs}${newRowIndex + 1}`;
+}
+function columnLabelToIndex2(label) {
+  let index = 0;
+  for (let i = 0;i < label.length; i++) {
+    index = index * 26 + (label.toUpperCase().charCodeAt(i) - 64);
+  }
+  return index - 1;
+}
+function columnIndexToLabel2(index) {
+  let label = "";
+  let remaining = index + 1;
+  while (remaining > 0) {
+    const rest = (remaining - 1) % 26;
+    label = String.fromCharCode(65 + rest) + label;
+    remaining = Math.floor((remaining - rest) / 26);
+  }
+  return label;
+}
+function contractThisRowReferences(formulaBody, containingTableName) {
+  return formulaBody.replace(THIS_ROW_REFERENCE, (whole, quotedTable, bareTable, startCol, endCol) => {
+    const tableName = quotedTable ? String(quotedTable).replace(/''/g, "'") : bareTable ? String(bareTable) : undefined;
+    const columns = endCol === undefined ? `[${startCol}]` : `[${startCol}]:[${endCol}]`;
+    const isPlainSingleColumn = endCol === undefined && /^[^[\]@#'"]+$/.test(String(startCol));
+    const reference = isPlainSingleColumn ? `@${startCol}` : `@${columns}`;
+    if (tableName && containingTableName && tableName.toLowerCase() === containingTableName.toLowerCase()) {
+      return `[${reference}]`;
+    }
+    if (!tableName) {
+      return `[${reference}]`;
+    }
+    const quoted = quotedTable ? `'${String(quotedTable)}'` : tableName;
+    return `${quoted}[${reference}]`;
+  });
+}
+
+// src/translate/conditional-format.ts
+var import_formula_engine2 = require("@ricsam/formula-engine");
+function translateConditionalFormat(rule, options) {
+  const diagnostics = [];
+  const areas = [];
+  for (const reference of rule.ranges) {
+    const range = rangeReferenceToSpreadsheetRange(reference);
+    if (range) {
+      areas.push({ sheetName: options.sheetName, range });
+    }
+  }
+  if (areas.length === 0) {
+    return { diagnostics };
+  }
+  const anchor = rule.ranges[0]?.split(":")[0]?.replace(/\$/g, "") ?? "A1";
+  if (rule.type === "colorScale") {
+    return translateColorScale(rule, areas, options, diagnostics);
+  }
+  const condition = buildFormulaCondition(rule, anchor, options, diagnostics);
+  if (!condition) {
+    return { diagnostics };
+  }
+  return { result: { areas, condition }, diagnostics };
+}
+function buildFormulaCondition(rule, anchor, options, diagnostics) {
+  const color = ruleColor(rule, options);
+  if (!color) {
+    diagnostics.push({
+      severity: "warning",
+      code: "unsupported-conditional-format",
+      message: `A ${rule.type} rule was skipped because its format has no fill or ` + `font colour the engine can apply.`,
+      sheetName: options.sheetName
+    });
+    return;
+  }
+  const expression = buildExpression(rule, anchor, options, diagnostics);
+  if (!expression) {
+    return;
+  }
+  const translated = translateFormula(expression, {
+    sheetName: options.sheetName,
+    cellReference: anchor
+  });
+  diagnostics.push(...translated.diagnostics);
+  return { type: "formula", formula: translated.formula, color };
+}
+function buildExpression(rule, anchor, options, diagnostics) {
+  const [first, second] = rule.formulas;
+  switch (rule.type) {
+    case "expression":
+      return first ? `=${first}` : undefined;
+    case "cellIs":
+      return cellIsExpression(rule.operator, anchor, first, second);
+    case "containsText":
+      return rule.text === undefined ? undefined : `=IFERROR(FIND(${quote(rule.text)},${anchor})>0,FALSE)`;
+    case "notContainsText":
+      return rule.text === undefined ? undefined : `=IFERROR(FIND(${quote(rule.text)},${anchor})>0,FALSE)=FALSE`;
+    case "beginsWith":
+      return rule.text === undefined ? undefined : `=EXACT(LEFT(${anchor},${rule.text.length}),${quote(rule.text)})`;
+    case "endsWith":
+      return rule.text === undefined ? undefined : `=EXACT(RIGHT(${anchor},${rule.text.length}),${quote(rule.text)})`;
+    case "containsBlanks":
+      return `=LEN(${anchor})=0`;
+    case "notContainsBlanks":
+      return `=LEN(${anchor})>0`;
+    default:
+      diagnostics.push({
+        severity: "warning",
+        code: "unsupported-conditional-format",
+        message: `The engine cannot express a "${rule.type}" conditional formatting ` + `rule, so it was skipped.`,
+        sheetName: options.sheetName
+      });
+      return;
+  }
+}
+function cellIsExpression(operator, anchor, first, second) {
+  if (first === undefined) {
+    return;
+  }
+  switch (operator) {
+    case "equal":
+      return `=${anchor}=${first}`;
+    case "notEqual":
+      return `=${anchor}<>${first}`;
+    case "greaterThan":
+      return `=${anchor}>${first}`;
+    case "greaterThanOrEqual":
+      return `=${anchor}>=${first}`;
+    case "lessThan":
+      return `=${anchor}<${first}`;
+    case "lessThanOrEqual":
+      return `=${anchor}<=${first}`;
+    case "between":
+      return second === undefined ? undefined : `=AND(${anchor}>=${first},${anchor}<=${second})`;
+    case "notBetween":
+      return second === undefined ? undefined : `=OR(${anchor}<${first},${anchor}>${second})`;
+    default:
+      return;
+  }
+}
+function translateColorScale(rule, areas, options, diagnostics) {
+  const scale = rule.colorScale;
+  if (!scale || scale.cfvo.length < 2 || scale.colors.length < 2) {
+    return { diagnostics };
+  }
+  if (scale.cfvo.length > 2) {
+    diagnostics.push({
+      severity: "info",
+      code: "unsupported-conditional-format",
+      message: "A three-colour scale was imported as a two-colour gradient between " + "its lowest and highest stops; the midpoint colour was dropped.",
+      sheetName: options.sheetName
+    });
+  }
+  const firstStop = scale.cfvo[0];
+  const lastStop = scale.cfvo[scale.cfvo.length - 1];
+  const firstColor = toLch(scale.colors[0]);
+  const lastColor = toLch(scale.colors[scale.colors.length - 1]);
+  if (!firstColor || !lastColor) {
+    return { diagnostics };
+  }
+  const min = firstStop.type === "num" && firstStop.val !== undefined ? {
+    type: "number",
+    color: firstColor,
+    valueFormula: `=${firstStop.val}`
+  } : { type: "lowest_value", color: firstColor };
+  const max = lastStop.type === "num" && lastStop.val !== undefined ? {
+    type: "number",
+    color: lastColor,
+    valueFormula: `=${lastStop.val}`
+  } : { type: "highest_value", color: lastColor };
+  if (firstStop.type !== "num" && firstStop.type !== "min" || lastStop.type !== "num" && lastStop.type !== "max") {
+    diagnostics.push({
+      severity: "info",
+      code: "unsupported-conditional-format",
+      message: `A colour scale using "${firstStop.type}"/"${lastStop.type}" stops was ` + "imported as a gradient across the range's own lowest and highest " + "values.",
+      sheetName: options.sheetName
+    });
+  }
+  return {
+    result: { areas, condition: { type: "gradient", min, max } },
+    diagnostics
+  };
+}
+function ruleColor(rule, options) {
+  if (rule.dxfId === undefined) {
+    return;
+  }
+  const format = options.differentialFormats[rule.dxfId];
+  if (!format) {
+    return;
+  }
+  const hex = format.backgroundColor ?? format.color;
+  return hex ? import_formula_engine2.hexToLch(hex) : undefined;
+}
+function toLch(argb) {
+  if (!argb) {
+    return;
+  }
+  const value = argb.replace(/^#/, "");
+  const rgb = value.length === 8 ? value.slice(2) : value;
+  if (!/^[0-9A-Fa-f]{6}$/.test(rgb)) {
+    return;
+  }
+  return import_formula_engine2.hexToLch(`#${rgb.toLowerCase()}`);
+}
+function quote(text) {
+  return `"${text.replace(/"/g, '""')}"`;
+}
+
+// src/translate/dates.ts
+var DAY_MS = 86400000;
+var EPOCH_1900_UTC = Date.UTC(1899, 11, 30);
+var EPOCH_1904_UTC = Date.UTC(1904, 0, 1);
+function excelSerialToIso(serial, date1904 = false) {
+  if (!Number.isFinite(serial)) {
+    return String(serial);
+  }
+  const epoch = date1904 ? EPOCH_1904_UTC : EPOCH_1900_UTC;
+  const adjusted = !date1904 && serial < 60 && serial >= 1 ? serial + 1 : serial;
+  const wholeDays = Math.floor(adjusted);
+  const fraction = adjusted - wholeDays;
+  const ms = epoch + wholeDays * DAY_MS + Math.round(fraction * DAY_MS);
+  const date = new Date(ms);
+  if (Number.isNaN(date.getTime())) {
+    return String(serial);
+  }
+  const iso = date.toISOString();
+  if (fraction === 0) {
+    return iso.slice(0, 10);
+  }
+  if (wholeDays === 0) {
+    return iso.slice(11, 19);
+  }
+  return iso.slice(0, 19).replace("T", " ");
+}
+
+// src/convert.ts
+var BUILTIN_DEFINED_NAMES = new Set([
+  "_xlnm.print_area",
+  "_xlnm.print_titles",
+  "_xlnm._filterdatabase",
+  "_xlnm.criteria",
+  "_xlnm.extract",
+  "_xlnm.database",
+  "_xlnm.sheet_title"
+]);
+async function convertWorkbook(source, options = {}) {
+  const {
+    styles: importStyles = true,
+    conditionalFormatting: importConditionalFormatting = true,
+    tables: importTables = true,
+    definedNames: importDefinedNames = true,
+    cellMetadata: importCellMetadata = true,
+    convertDates = true
+  } = options;
+  const diagnostics = [];
+  const pkg = await readXlsxPackage(source);
+  const sharedStrings = parseSharedStrings(pkg);
+  const { sheets: sheetEntries, definedNames, date1904 } = parseWorkbook(pkg);
+  const styleTable = parseStyles(pkg);
+  const selected = options.sheets ? sheetEntries.filter((entry) => options.sheets.includes(entry.name)) : sheetEntries;
+  const sheets = [];
+  const tables = [];
+  const cellStyles = [];
+  const conditionalStyles = [];
+  const importedSheetNames = new Set;
+  for (const entry of selected) {
+    const worksheet = parseWorksheet(pkg, entry.partPath, sharedStrings);
+    importedSheetNames.add(entry.name);
+    const sheetTables = importTables ? parseTables(pkg, entry.partPath) : [];
+    const tableRanges = sheetTables.map((table) => ({ name: table.displayName, range: parseA1Range(table.ref) })).filter((entryTable) => entryTable.range !== undefined);
+    const tableAt = (colIndex, rowIndex) => tableRanges.find(({ range }) => colIndex >= range.start.colIndex && colIndex <= range.end.colIndex && rowIndex >= range.start.rowIndex && rowIndex <= range.end.rowIndex)?.name;
+    const content = new Map;
+    const cellMetadata = new Map;
+    const styleGroups = new Map;
+    for (const cell of worksheet.cells) {
+      const format = cell.styleIndex === undefined ? undefined : styleTable.formats[cell.styleIndex];
+      const value = cellValue(cell, format, {
+        convertDates,
+        date1904,
+        sheetName: entry.name,
+        diagnostics,
+        containingTableName: tableAt(cell.colIndex, cell.rowIndex)
+      });
+      if (value !== undefined) {
+        content.set(cell.reference, value);
+      }
+      if (importStyles && cell.styleIndex !== undefined && format) {
+        if (Object.keys(format.style).length > 0) {
+          const group = styleGroups.get(cell.styleIndex);
+          if (group) {
+            group.push(cell);
+          } else {
+            styleGroups.set(cell.styleIndex, [cell]);
+          }
+        }
+      }
+      if (importCellMetadata) {
+        const metadata = {};
+        if (format?.numberFormat) {
+          metadata.numberFormat = format.numberFormat;
+        }
+        const hyperlink = worksheet.hyperlinks[cell.reference];
+        if (hyperlink) {
+          metadata.hyperlink = hyperlink;
+        }
+        if (Object.keys(metadata).length > 0) {
+          cellMetadata.set(cell.reference, metadata);
+        }
+      }
+    }
+    if (importStyles) {
+      for (const [styleIndex, cells] of styleGroups) {
+        const format = styleTable.formats[styleIndex];
+        if (!format) {
+          continue;
+        }
+        cellStyles.push({
+          areas: coalesceCellsIntoAreas(entry.name, cells),
+          style: format.style
+        });
+      }
+    }
+    if (importConditionalFormatting) {
+      const ordered = [...worksheet.conditionalFormats].sort((a, b) => b.priority - a.priority);
+      for (const rule of ordered) {
+        const { result, diagnostics: ruleDiagnostics } = translateConditionalFormat(rule, {
+          sheetName: entry.name,
+          differentialFormats: styleTable.differentialFormats
+        });
+        diagnostics.push(...ruleDiagnostics);
+        if (result) {
+          conditionalStyles.push(result);
+        }
+      }
+    }
+    if (importTables) {
+      for (const table of sheetTables) {
+        const converted = convertTable(table, entry.name, diagnostics);
+        if (converted) {
+          tables.push(converted);
+        }
+      }
+    }
+    const sheetMetadata = {};
+    if (Object.keys(worksheet.columnWidths).length > 0) {
+      sheetMetadata.columnWidths = worksheet.columnWidths;
+    }
+    if (Object.keys(worksheet.rowHeights).length > 0) {
+      sheetMetadata.rowHeights = worksheet.rowHeights;
+    }
+    if (worksheet.merges.length > 0) {
+      sheetMetadata.merges = worksheet.merges;
+    }
+    if (worksheet.frozen) {
+      sheetMetadata.frozen = worksheet.frozen;
+    }
+    if (entry.state !== "visible") {
+      sheetMetadata.visible = false;
+    }
+    sheets.push({
+      name: entry.name,
+      content,
+      cellMetadata: cellMetadata.size > 0 ? cellMetadata : undefined,
+      sheetMetadata: Object.keys(sheetMetadata).length > 0 ? sheetMetadata : undefined
+    });
+  }
+  const namedExpressions = importDefinedNames ? convertDefinedNames(definedNames, sheetEntries.map((entry) => entry.name), importedSheetNames, diagnostics) : [];
+  const data = {
+    sheets,
+    tables: tables.length > 0 ? tables : undefined,
+    namedExpressions: namedExpressions.length > 0 ? namedExpressions : undefined,
+    cellStyles: cellStyles.length > 0 ? cellStyles : undefined,
+    conditionalStyles: conditionalStyles.length > 0 ? conditionalStyles : undefined,
+    workbookMetadata: {
+      fileName: options.fileName,
+      sheetOrder: sheetEntries.map((entry) => entry.name),
+      diagnostics: diagnostics.length > 0 ? diagnostics : undefined
+    }
+  };
+  return { data, diagnostics };
+}
+function cellValue(cell, format, context) {
+  if (cell.formula !== undefined) {
+    const body = cell.formulaOffset ? offsetFormulaReferences(cell.formula, cell.formulaOffset.cols, cell.formulaOffset.rows) : cell.formula;
+    const translated = translateFormula(body, {
+      sheetName: context.sheetName,
+      cellReference: cell.reference,
+      containingTableName: context.containingTableName
+    });
+    context.diagnostics.push(...translated.diagnostics);
+    return translated.formula;
+  }
+  switch (cell.kind) {
+    case "number": {
+      const value = cell.value;
+      if (context.convertDates && format?.isDateFormat) {
+        return excelSerialToIso(value, context.date1904);
+      }
+      return value;
+    }
+    case "boolean":
+      return cell.value;
+    case "string":
+      return cell.value;
+    case "date":
+      return cell.value;
+    case "error":
+      return cell.value;
+    case "empty":
+      return;
+  }
+}
+function convertTable(table, sheetName, diagnostics) {
+  const parsed = parseA1Range(table.ref);
+  if (!parsed) {
+    diagnostics.push({
+      severity: "warning",
+      code: "skipped-table",
+      message: `Table "${table.displayName}" has an unreadable range (${table.ref}).`,
+      sheetName
+    });
+    return;
+  }
+  if (table.headerRowCount === 0) {
+    diagnostics.push({
+      severity: "warning",
+      code: "skipped-table",
+      message: `Table "${table.displayName}" has no header row, which the engine ` + `requires for structured references, so it was skipped.`,
+      sheetName
+    });
+    return;
+  }
+  const numCols = parsed.end.colIndex - parsed.start.colIndex + 1;
+  const dataRows = parsed.end.rowIndex - parsed.start.rowIndex + 1 - table.headerRowCount - table.totalsRowCount;
+  if (numCols <= 0 || dataRows < 0) {
+    diagnostics.push({
+      severity: "warning",
+      code: "skipped-table",
+      message: `Table "${table.displayName}" has an empty range (${table.ref}).`,
+      sheetName
+    });
+    return;
+  }
+  return {
+    name: table.displayName,
+    sheetName,
+    start: toA1(parsed.start),
+    numRows: { type: "number", value: dataRows },
+    numCols
+  };
+}
+function convertDefinedNames(definedNames, sheetNames, importedSheetNames, diagnostics) {
+  const result = [];
+  for (const definedName of definedNames) {
+    if (BUILTIN_DEFINED_NAMES.has(definedName.name.toLowerCase())) {
+      continue;
+    }
+    if (definedName.hidden || definedName.formula.trim() === "") {
+      continue;
+    }
+    if (definedName.formula.includes("#REF!")) {
+      diagnostics.push({
+        severity: "warning",
+        code: "skipped-defined-name",
+        message: `Defined name "${definedName.name}" refers to a deleted range.`,
+        source: definedName.formula
+      });
+      continue;
+    }
+    const sheetName = definedName.localSheetId === undefined ? undefined : sheetNames[definedName.localSheetId];
+    if (sheetName !== undefined && !importedSheetNames.has(sheetName)) {
+      continue;
+    }
+    const translated = translateFormula(definedName.formula);
+    diagnostics.push(...translated.diagnostics);
+    result.push({
+      name: definedName.name,
+      expression: translated.formula.slice(1),
+      sheetName
+    });
+  }
+  return result;
+}
+function coalesceCellsIntoAreas(sheetName, cells) {
+  const byRow = new Map;
+  for (const cell of cells) {
+    const row = byRow.get(cell.rowIndex);
+    if (row) {
+      row.push(cell.colIndex);
+    } else {
+      byRow.set(cell.rowIndex, [cell.colIndex]);
+    }
+  }
+  const runs = [];
+  for (const [rowIndex, columns] of byRow) {
+    columns.sort((a, b) => a - b);
+    let startCol = columns[0];
+    let previous = startCol;
+    for (let i = 1;i < columns.length; i++) {
+      const current = columns[i];
+      if (current === previous + 1) {
+        previous = current;
+        continue;
+      }
+      runs.push({ rowIndex, startCol, endCol: previous });
+      startCol = current;
+      previous = current;
+    }
+    runs.push({ rowIndex, startCol, endCol: previous });
+  }
+  runs.sort((a, b) => a.startCol - b.startCol || a.endCol - b.endCol || a.rowIndex - b.rowIndex);
+  const areas = [];
+  let index = 0;
+  while (index < runs.length) {
+    const first = runs[index];
+    let lastRow = first.rowIndex;
+    let next = index + 1;
+    while (next < runs.length && runs[next].startCol === first.startCol && runs[next].endCol === first.endCol && runs[next].rowIndex === lastRow + 1) {
+      lastRow = runs[next].rowIndex;
+      next++;
+    }
+    areas.push({
+      sheetName,
+      range: toSpreadsheetRange({
+        start: { colIndex: first.startCol, rowIndex: first.rowIndex },
+        end: { colIndex: first.endCol, rowIndex: lastRow }
+      })
+    });
+    index = next;
+  }
+  return areas;
+}
+
+// index.ts
+async function excelToFormulaEngine(source, options) {
+  const { data } = await convertWorkbook(source, withFileName(source, options));
+  return data;
+}
+async function excelToFormulaEngineDetailed(source, options) {
+  return convertWorkbook(source, withFileName(source, options));
+}
+function withFileName(source, options) {
+  if (options?.fileName !== undefined) {
+    return options;
+  }
+  const name = typeof File !== "undefined" && source instanceof File ? source.name : undefined;
+  return name ? { ...options, fileName: name } : { ...options };
+}
+
+//# debugId=B8C6694D236575E064756E2164756E21