ooxml-core 1.19.2 → 1.20.0

package/dist/automation/index.mjs

@@ -236,6 +236,12 @@ function parseLiteFragment(xml, container, namespaces) {
     }
     if (lt < 0) break;
     const next = source2.charCodeAt(lt + 1);
+    if (next === 33) {
+      const after = skipCommentOrCdata(source2, lt, top);
+      if (after < 0) return void 0;
+      pos = after;
+      continue;
+    }
     if (next === 47) {
       const gt = source2.indexOf(">", lt);
       if (gt < 0 || stack2.length < 2 || source2.slice(lt + 2, gt).trimEnd() !== top.tagName)
@@ -256,6 +262,25 @@ function parseLiteFragment(xml, container, namespaces) {
   }
   return stack2.length === 1 ? root : void 0;
 }
+var DECLARATIONS = /<!DOCTYPE|<!ENTITY/i;
+function skipCommentOrCdata(source2, lt, parent) {
+  if (source2.startsWith("<!--", lt)) {
+    const end = source2.indexOf("-->", lt + 4);
+    if (end < 0) return -1;
+    const body = source2.slice(lt + 4, end);
+    if (body.includes("--") || body.endsWith("-") || DECLARATIONS.test(body)) return -1;
+    return end + 3;
+  }
+  if (source2.startsWith("<![CDATA[", lt)) {
+    const end = source2.indexOf("]]>", lt + 9);
+    if (end < 0) return -1;
+    const text8 = source2.slice(lt + 9, end);
+    if (DECLARATIONS.test(text8)) return -1;
+    parent.childNodes.push(text8);
+    return end + 3;
+  }
+  return -1;
+}
 function startTag(source2, from, namespaces) {
   const n = source2.length;
   let i2 = from;
@@ -23716,6 +23741,37 @@ function formatValue(value3, format5, options2 = {}) {
 function isDateFormat(format5) {
   return compileFormat(format5).isDate;
 }
+var DAY_PARTS = /* @__PURE__ */ new Set([
+  "y",
+  "yyyy",
+  "e",
+  "g",
+  "b",
+  "bbbb",
+  "m",
+  "mm",
+  "mmm",
+  "mmmm",
+  "mmmmm",
+  "d",
+  "dd",
+  "ddd",
+  "dddd"
+]);
+function dateTimeParts(format5, value3) {
+  const section3 = chooseSection(compileFormat(format5), value3)?.section;
+  if (section3?.kind !== "date") return void 0;
+  let date2 = false;
+  let time = false;
+  for (const token of section3.tokens) {
+    if (token.t === "elapsed") return void 0;
+    if (token.t === "date") {
+      if (DAY_PARTS.has(token.part)) date2 = true;
+      else time = true;
+    } else if (token.t === "ampm" || token.t === "subsec") time = true;
+  }
+  return date2 || time ? { date: date2, time } : void 0;
+}
 
 // xlsx/numfmt/input-date.ts
 var MONTH_NAMES = [
@@ -29669,21 +29725,50 @@ function rootNamespaces(xml) {
   for (const match2 of (root[2] ?? "").matchAll(DECLARATION3)) out[match2[1] ?? ""] = match2[3] ?? "";
   return out;
 }
+var SPECIAL = /<[!?]/g;
+var SECTIONS = [
+  ["<!--", "-->"],
+  ["<![CDATA[", "]]>"],
+  ["<?", "?>"]
+];
+function blankComments(xml) {
+  if (!xml.includes("<!--") && !xml.includes("<![CDATA[")) return xml;
+  const pieces = [];
+  let copied = 0;
+  SPECIAL.lastIndex = 0;
+  for (let match2 = SPECIAL.exec(xml); match2; match2 = SPECIAL.exec(xml)) {
+    const at2 = match2.index;
+    const section3 = SECTIONS.find(([open2]) => xml.startsWith(open2, at2));
+    if (!section3) return void 0;
+    const [open, close4] = section3;
+    const end = xml.indexOf(close4, at2 + open.length);
+    if (end < 0) return void 0;
+    const after = end + close4.length;
+    if (open !== "<?") {
+      pieces.push(xml.slice(copied, at2), " ".repeat(after - at2));
+      copied = after;
+    }
+    SPECIAL.lastIndex = after;
+  }
+  pieces.push(xml.slice(copied));
+  return pieces.join("");
+}
 function splitSheetData(xml) {
-  if (xml.includes("<!--") || xml.includes("<![CDATA[")) return void 0;
-  const namespaces = rootNamespaces(xml);
-  const open = OPEN.exec(xml);
+  const plain5 = blankComments(xml);
+  if (plain5 === void 0) return void 0;
+  const namespaces = rootNamespaces(plain5);
+  const open = OPEN.exec(plain5);
   if (!namespaces || !open) return void 0;
   const prefix3 = (open[1] ?? "").slice(0, -1);
   const ns = namespaces[prefix3];
   if (prefix3 && ns === void 0) return void 0;
   const tagName2 = `${open[1] ?? ""}sheetData`;
-  const openEnd = xml.indexOf(">", open.index);
+  const openEnd = plain5.indexOf(">", open.index);
   if (openEnd < 0) return void 0;
-  const attributes = xml.slice(open.index + tagName2.length + 1, openEnd);
+  const attributes = plain5.slice(open.index + tagName2.length + 1, openEnd);
   if (attributes.trimEnd().endsWith("/") || attributes.includes("xmlns")) return void 0;
-  const close4 = xml.indexOf(`</${tagName2}`, openEnd);
-  if (close4 < 0 || OPEN.test(xml.slice(openEnd))) return void 0;
+  const close4 = plain5.indexOf(`</${tagName2}`, openEnd);
+  if (close4 < 0 || OPEN.test(plain5.slice(openEnd))) return void 0;
   const container = new LiteElement(tagName2, "sheetData", ns || null);
   const data = parseLiteFragment(xml.slice(openEnd + 1, close4), container, namespaces);
   if (!data) return void 0;
@@ -49024,7 +49109,7 @@ function setColumnWidth(ctx, s, cols, width, measure2) {
   ctx.run(
     "Column width",
     "view",
-    [{ kind: "sheet", sheet: s }],
+    [{ kind: "parts", sheet: s, parts: ["columns"] }],
     () => editColumns(sheet, cols, (info) => {
       const next = widths.get(info.min);
       if (next === void 0) {
@@ -49059,7 +49144,7 @@ function setRowHeight(ctx, s, rows, height) {
   ctx.run(
     "Row height",
     "view",
-    [{ kind: "sheet", sheet: s }],
+    [{ kind: "rowInfo", sheet: s, rows }],
     () => {
       for (const row3 of rows) {
         const info = { ...sheet.rowInfo.get(row3) };
@@ -49089,7 +49174,9 @@ function setHidden(ctx, s, axis, indices, hidden) {
   ctx.run(
     `${hidden ? "Hide" : "Unhide"} ${noun}`,
     "view",
-    [{ kind: "sheet", sheet: s }],
+    [
+      axis === "col" ? { kind: "parts", sheet: s, parts: ["columns"] } : { kind: "rowInfo", sheet: s, rows: indices }
+    ],
     () => {
       if (axis === "col") {
         editColumns(sheet, indices, (info) => {
@@ -49683,6 +49770,19 @@ function shiftEdgeCells(sheet, spec2, phase) {
   return out;
 }
 
+// xlsx/edit/history-rows.ts
+function captureRowInfo(sheet, rows) {
+  return [...new Set(rows)].map((row3) => {
+    const info = sheet.rowInfo.get(row3);
+    return [row3, info && structuredClone(info)];
+  });
+}
+function restoreRowInfo(sheet, entries) {
+  for (const [row3, info] of entries)
+    if (info) sheet.rowInfo.set(row3, structuredClone(info));
+    else sheet.rowInfo.delete(row3);
+}
+
 // xlsx/edit/history.ts
 var SETTING_KEYS = [
   "structureLocked",
@@ -49767,6 +49867,8 @@ function captureScope(workbook, scope, before) {
   if (!sheet) throw new RangeError(`No sheet at index ${scope.sheet}`);
   if (scope.kind === "sheet")
     return { kind: "sheet", sheet: scope.sheet, data: structuredClone(sheet) };
+  if (scope.kind === "rowInfo")
+    return { kind: "rowInfo", sheet: scope.sheet, rows: captureRowInfo(sheet, scope.rows) };
   if (scope.kind === "parts") {
     const data = {};
     for (const part of scope.parts) if (sheet[part] !== void 0) data[part] = sheet[part];
@@ -49818,6 +49920,7 @@ function restoreSnapshot(workbook, snapshot) {
   }
   const sheet = workbook.sheets[snapshot.sheet];
   if (!sheet) return;
+  if (snapshot.kind === "rowInfo") return restoreRowInfo(sheet, snapshot.rows);
   if (snapshot.kind === "parts") {
     const target2 = sheet;
     const data = structuredClone(snapshot.data);
@@ -52427,12 +52530,13 @@ function span2(from, to) {
 }
 function outlineRows(ctx, s, from, to, delta) {
   const sheet = sheetAt(ctx.workbook, s);
+  const rows = span2(from, to);
   ctx.run(
     delta > 0 ? "Group rows" : "Ungroup rows",
     "structure",
-    [{ kind: "sheet", sheet: s }],
+    [{ kind: "rowInfo", sheet: s, rows }],
     () => {
-      for (const row3 of span2(from, to)) {
+      for (const row3 of rows) {
         const info = { ...sheet.rowInfo.get(row3) };
         const level2 = nextLevel(info.outlineLevel, delta);
         if (level2) info.outlineLevel = level2;
@@ -52452,7 +52556,7 @@ function outlineColumns(ctx, s, from, to, delta) {
   ctx.run(
     delta > 0 ? "Group columns" : "Ungroup columns",
     "structure",
-    [{ kind: "sheet", sheet: s }],
+    [{ kind: "parts", sheet: s, parts: ["columns"] }],
     () => editColumns(sheet, span2(from, to), (info) => {
       const level2 = nextLevel(info.outlineLevel, delta);
       if (level2) info.outlineLevel = level2;
@@ -52475,7 +52579,7 @@ function setDefaultColumnWidth(ctx, s, width) {
   ctx.run(
     "Standard width",
     "format",
-    [{ kind: "sheet", sheet: s }],
+    [{ kind: "parts", sheet: s, parts: ["defaultColWidth"] }],
     () => {
       if (width === void 0) Reflect.deleteProperty(sheet, "defaultColWidth");
       else sheet.defaultColWidth = width;
@@ -55049,10 +55153,11 @@ function autoGrowRows(ctx, s, rows, measure2 = approximateMeasure) {
     updates.push([row3, next]);
   }
   if (!updates.length) return [];
+  const changed = updates.map(([row3]) => row3);
   ctx.run(
     "Row height",
     "view",
-    [{ kind: "sheet", sheet: s }],
+    [{ kind: "rowInfo", sheet: s, rows: changed }],
     () => {
       for (const [row3, height] of updates) {
         const info = { ...sheet.rowInfo.get(row3) };
@@ -55064,7 +55169,7 @@ function autoGrowRows(ctx, s, rows, measure2 = approximateMeasure) {
     },
     { sheet: s, structural: true }
   );
-  return updates.map(([row3]) => row3);
+  return changed;
 }
 var MAX_REFIT_ROWS = 1e4;
 function rowsToRefit(sheet, ranges) {
@@ -55820,11 +55925,84 @@ function createEditSession(workbook, options2 = {}) {
   };
 }
 
+// automation/xlsx-read.ts
+var INSPECT_LIST_LIMIT = 500;
+function sheetSummaries(workbook) {
+  return workbook.sheets.map((sheet, index3) => {
+    const used = usedRange(sheet);
+    const omitted2 = sheet.tables.length - INSPECT_LIST_LIMIT;
+    return {
+      index: index3,
+      name: sheet.name,
+      state: sheet.state,
+      usedRange: used ? formatRange(used) : null,
+      rows: used ? used.end.row - used.start.row + 1 : 0,
+      columns: used ? used.end.col - used.start.col + 1 : 0,
+      tables: sheet.tables.slice(0, INSPECT_LIST_LIMIT).map((table4) => ({
+        name: table4.displayName,
+        range: formatRange(table4.range),
+        headerRow: table4.headerRow,
+        totalsRow: table4.totalsRow
+      })),
+      ...omitted2 > 0 ? { tablesOmitted: omitted2 } : {}
+    };
+  });
+}
+function definedNameList(workbook) {
+  const visible = workbook.definedNames.filter((name3) => !name3.hidden);
+  const definedNames = visible.slice(0, INSPECT_LIST_LIMIT).map((name3) => ({
+    name: name3.name,
+    refersTo: name3.formula,
+    ...name3.localSheet === void 0 ? {} : { sheetIndex: name3.localSheet }
+  }));
+  const omitted2 = visible.length - INSPECT_LIST_LIMIT;
+  return omitted2 > 0 ? { definedNames, definedNamesOmitted: omitted2 } : { definedNames };
+}
+function isoOf(serial, date1904, shows2) {
+  if (!(serial >= 0) || serial > MAX_DATE_SERIAL + 1) return void 0;
+  if (!date1904 && serial >= 60 && serial < 61) return void 0;
+  const date2 = serialToDate(serial, date1904);
+  if (date2.getUTCFullYear() > 9999) return void 0;
+  const iso = date2.toISOString();
+  const time = iso.slice(11, iso.endsWith(".000Z") ? 19 : 23);
+  if (serial < 1 && (!date1904 || !shows2.date)) return time;
+  return Number.isInteger(serial) && !shows2.time ? iso.slice(0, 10) : `${iso.slice(0, 10)}T${time}`;
+}
+function cellView2(workbook, cell) {
+  const value3 = cell?.value ?? null;
+  const text8 = displayText(workbook, cell);
+  const view = cell?.formula ? { value: value3, formula: cell.formula, text: text8 } : { value: value3, text: text8 };
+  const numFmt = styleAt(workbook, cell?.styleId).numFmt;
+  if (numFmt === "General") return view;
+  view.numberFormat = numFmt;
+  const parts = typeof value3 === "number" ? dateTimeParts(numFmt, value3) : void 0;
+  if (parts && typeof value3 === "number") {
+    const iso = isoOf(value3, workbook.date1904, parts);
+    if (iso) view.iso = iso;
+  }
+  return view;
+}
+var READ_LIMIT = 1e4;
+function rangeCells(workbook, sheet, range2) {
+  const count2 = (range2.end.row - range2.start.row + 1) * (range2.end.col - range2.start.col + 1);
+  if (count2 > READ_LIMIT) throw new Error(`Read at most ${READ_LIMIT} cells per request`);
+  const cells3 = [];
+  for (let row3 = range2.start.row; row3 <= range2.end.row; row3++)
+    for (let col = range2.start.col; col <= range2.end.col; col++)
+      cells3.push({
+        address: formatAddress({ row: row3, col }),
+        ...cellView2(workbook, getCell(sheet, row3, col))
+      });
+  return cells3;
+}
+
 // automation/xlsx.ts
 async function inspectXlsx(bytes) {
   const workbook = await loadXlsx(bytes);
   return {
-    sheets: workbook.sheets.map((sheet, index3) => ({ index: index3, name: sheet.name })),
+    sheets: sheetSummaries(workbook),
+    activeSheet: workbook.activeSheet,
+    ...definedNameList(workbook),
     properties: workbook.properties,
     warnings: workbook.warnings
   };
@@ -55847,19 +56025,7 @@ async function readXlsxRange(bytes, sheetIndex2, reference2) {
   const range2 = parseRange(reference2);
   if (!sheet || !range2 || range2.end.col > MAX_COL || range2.end.row > MAX_ROW)
     throw new Error("Invalid sheet or range");
-  const count2 = (range2.end.row - range2.start.row + 1) * (range2.end.col - range2.start.col + 1);
-  if (count2 > 1e4) throw new Error("Read at most 10000 cells per request");
-  const cells3 = [];
-  for (let row3 = range2.start.row; row3 <= range2.end.row; row3++)
-    for (let col = range2.start.col; col <= range2.end.col; col++) {
-      const cell = getCell(sheet, row3, col);
-      cells3.push({
-        address: formatAddress({ row: row3, col }),
-        value: cell?.value ?? null,
-        formula: cell?.formula
-      });
-    }
-  return { cells: cells3, warnings: workbook.warnings };
+  return { cells: rangeCells(workbook, sheet, range2), warnings: workbook.warnings };
 }
 async function setXlsxCells(bytes, sheetIndex2, cells3) {
   const workbook = await loadXlsx(bytes);
@@ -55902,6 +56068,65 @@ async function readXlsxFilledCells(bytes, { maxCells = 5e3 } = {}) {
     warnings: workbook.warnings
   };
 }
+async function findXlsxCells(bytes, text8, options2 = {}) {
+  if (!text8) throw new Error("The search text is empty");
+  const max = options2.maxResults ?? 100;
+  if (!Number.isSafeInteger(max) || max < 1 || max > 1e3)
+    throw new Error("Return between 1 and 1000 matches per request");
+  const workbook = await loadXlsx(bytes);
+  const query = { text: text8, lookIn: options2.lookIn ?? "formulas" };
+  const { sheetIndex: sheetIndex2 } = options2;
+  if (sheetIndex2 !== void 0) {
+    if (!Number.isSafeInteger(sheetIndex2) || !workbook.sheets[sheetIndex2])
+      throw new Error("Invalid sheet");
+    query.sheet = sheetIndex2;
+  }
+  if (options2.range !== void 0) {
+    const range2 = parseRange(options2.range);
+    if (sheetIndex2 === void 0) throw new Error("A range needs a sheetIndex");
+    if (!range2) throw new Error("Invalid range");
+    query.range = range2;
+  }
+  if (options2.matchCase) query.matchCase = true;
+  if (options2.wholeCell) query.wholeCell = true;
+  if (options2.wildcards === false) query.wildcards = false;
+  const found = findAll(workbook, query);
+  const matches2 = found.slice(0, max).map((match2) => {
+    const sheet = workbook.sheets[match2.sheet];
+    return {
+      sheetIndex: match2.sheet,
+      sheet: sheet?.name ?? "",
+      address: formatAddress(match2),
+      ...cellView2(workbook, sheet && getCell(sheet, match2.row, match2.col))
+    };
+  });
+  return {
+    matches: matches2,
+    total: found.length,
+    truncated: found.length > max,
+    warnings: workbook.warnings
+  };
+}
+async function readXlsxTable(bytes, name3) {
+  const workbook = await loadXlsx(bytes);
+  const wanted = name3.toLowerCase();
+  for (const [sheetIndex2, sheet] of workbook.sheets.entries()) {
+    const table4 = sheet.tables.find((t) => t.displayName.toLowerCase() === wanted);
+    if (!table4) continue;
+    return {
+      sheetIndex: sheetIndex2,
+      sheet: sheet.name,
+      name: table4.displayName,
+      range: formatRange(table4.range),
+      headerRow: table4.headerRow,
+      totalsRow: table4.totalsRow,
+      columns: table4.columns.map((column2) => column2.name),
+      cells: rangeCells(workbook, sheet, table4.range),
+      warnings: workbook.warnings
+    };
+  }
+  throw new Error(`No table named ${name3}`);
+}
 
 // visio/package-common.ts
 var VisioPackageError = class extends Error {
@@ -82490,4 +82715,4 @@ async function createXlsxFromSheets(sheets) {
   return saveXlsx(workbook);
 }
 
-export { createDocx, createDocxFromOutline, createXlsx, createXlsxFromSheets, editVsdx as editVisio, inspectDocx, inspectVisio, inspectXlsx, readXlsxFilledCells, readXlsxRange, setDocxRunText, setXlsxCells, suggestDocxRunText };
+export { createDocx, createDocxFromOutline, createXlsx, createXlsxFromSheets, editVsdx as editVisio, findXlsxCells, inspectDocx, inspectVisio, inspectXlsx, readXlsxFilledCells, readXlsxRange, readXlsxTable, setDocxRunText, setXlsxCells, suggestDocxRunText };

package/dist/automation/xlsx-read.d.ts

@@ -0,0 +1,56 @@
+import { type CellRange } from '../xlsx/address.js';
+import type { Cell, CellValue, Workbook, Worksheet } from '../xlsx/model.js';
+/** The most tables per sheet, and defined names, that an inspection lists. */
+export declare const INSPECT_LIST_LIMIT = 500;
+/** Each sheet's used range (the cells it stores: values, formulas or formatting), state and tables. */
+export declare function sheetSummaries(workbook: Workbook): {
+    index: number;
+    name: string;
+    state: import("../xlsx/index.js").SheetState;
+    usedRange: string | null;
+    rows: number;
+    columns: number;
+    tables: {
+        name: string;
+        range: string;
+        headerRow: boolean;
+        totalsRow: boolean;
+    }[];
+    tablesOmitted?: number;
+}[];
+/** The defined names Excel's Name Manager lists (hidden ones are left out), with their scope. */
+export declare function definedNameList(workbook: Workbook): {
+    definedNames: {
+        name: string;
+        refersTo: string;
+        sheetIndex?: number;
+    }[];
+    definedNamesOmitted: number;
+} | {
+    definedNamesOmitted?: never;
+    definedNames: {
+        name: string;
+        refersTo: string;
+        sheetIndex?: number;
+    }[];
+};
+export interface CellView {
+    value: CellValue;
+    formula?: string;
+    /** The text as the grid displays it, with the cell's number format applied. */
+    text: string;
+    /** The number format code, absent for General. */
+    numberFormat?: string;
+    /**
+     * The value of a cell shown as a date or time, in ISO 8601 without a time zone; absent for
+     * numbers and durations (`[h]:mm`).
+     */
+    iso?: string;
+}
+/** A cell's value and formula with its displayed text, number format and ISO date. */
+export declare function cellView(workbook: Workbook, cell: Cell | undefined): CellView;
+/** The cells of `range`, row by row, each with its address and {@link cellView}. */
+export declare function rangeCells(workbook: Workbook, sheet: Worksheet, range: CellRange): ({
+    address: string;
+} & CellView)[];
+//# sourceMappingURL=xlsx-read.d.ts.map

package/dist/automation/xlsx-read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xlsx-read.d.ts","sourceRoot":"","sources":["../../automation/xlsx-read.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,SAAS,EAA8B,MAAM,iBAAiB,CAAC;AAG7E,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAK1E,8EAA8E;AAC9E,eAAO,MAAM,kBAAkB,MAAM,CAAC;AAEtC,uGAAuG;AACvG,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ;;;;;;;;;;;;;;IAoBhD;AAED,iGAAiG;AACjG,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ;;;;;;;;;;;;;;EASjD;AAyBD,MAAM,WAAW,QAAQ;IACxB,KAAK,EAAE,SAAS,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+EAA+E;IAC/E,IAAI,EAAE,MAAM,CAAC;IACb,kDAAkD;IAClD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACb;AAED,sFAAsF;AACtF,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,GAAG,SAAS,GAAG,QAAQ,CAa7E;AAKD,oFAAoF;AACpF,wBAAgB,UAAU,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS;aAGvD,MAAM;gBAQ/B"}

package/dist/automation/xlsx.d.ts

@@ -1,18 +1,68 @@
+/**
+ * The sheets (index, name, state, used range with its row and column counts, tables), the
+ * active sheet, the defined names, the document properties and the loader warnings. Tables per
+ * sheet and names are capped at 500 each; `tablesOmitted` and `definedNamesOmitted` count the rest.
+ */
 export declare function inspectXlsx(bytes: Uint8Array): Promise<{
+    definedNames: {
+        name: string;
+        refersTo: string;
+        sheetIndex?: number;
+    }[];
+    definedNamesOmitted: number;
     sheets: {
         index: number;
         name: string;
+        state: import("../xlsx/index.js").SheetState;
+        usedRange: string | null;
+        rows: number;
+        columns: number;
+        tables: {
+            name: string;
+            range: string;
+            headerRow: boolean;
+            totalsRow: boolean;
+        }[];
+        tablesOmitted?: number;
     }[];
+    activeSheet: number;
+    properties: import("../xlsx/index.js").WorkbookProperties;
+    warnings: string[];
+} | {
+    definedNamesOmitted?: never;
+    definedNames: {
+        name: string;
+        refersTo: string;
+        sheetIndex?: number;
+    }[];
+    sheets: {
+        index: number;
+        name: string;
+        state: import("../xlsx/index.js").SheetState;
+        usedRange: string | null;
+        rows: number;
+        columns: number;
+        tables: {
+            name: string;
+            range: string;
+            headerRow: boolean;
+            totalsRow: boolean;
+        }[];
+        tablesOmitted?: number;
+    }[];
+    activeSheet: number;
     properties: import("../xlsx/index.js").WorkbookProperties;
     warnings: string[];
 }>;
 export declare function createXlsx(names: readonly string[]): Promise<Uint8Array>;
+/**
+ * The cells of an A1 range (at most 10,000), row by row: value, formula, the text as displayed,
+ * the number format (absent for General) and, for dates and times, the value in ISO 8601.
+ */
 export declare function readXlsxRange(bytes: Uint8Array, sheetIndex: number, reference: string): Promise<{
-    cells: {
+    cells: ({
         address: string;
-        value: string | number | boolean | import("../xlsx/index.js").CellError | null;
-        formula: string | undefined;
-    }[];
+    } & import("./xlsx-read.js").CellView)[];
     warnings: string[];
 }>;
 export declare function setXlsxCells(bytes: Uint8Array, sheetIndex: number, cells: readonly {
@@ -43,4 +93,55 @@ export declare function readXlsxFilledCells(bytes: Uint8Array, { maxCells }?: {
     truncated: boolean;
     warnings: string[];
 }>;
+export interface XlsxFindOptions {
+    /** The sheet to search; every sheet when absent. */
+    sheetIndex?: number;
+    /** An A1 range to search within (needs `sheetIndex`). */
+    range?: string;
+    /** `formulas` (Excel's default) searches what was typed; `values` the text as displayed. */
+    lookIn?: 'formulas' | 'values';
+    matchCase?: boolean;
+    /** The whole cell content must match. */
+    wholeCell?: boolean;
+    /** Excel wildcards: `*` any run, `?` one character, `~` escapes. On by default. */
+    wildcards?: boolean;
+    /** At most this many matches (1 to 1000, default 100); `total` counts them all. */
+    maxResults?: number;
+}
+/**
+ * The cells matching `text` the way Excel's Find does, sheet by sheet in row order, each with
+ * its sheet, address and the same view as a range read. Bounded by `maxResults`.
+ */
+export declare function findXlsxCells(bytes: Uint8Array, text: string, options?: XlsxFindOptions): Promise<{
+    matches: {
+        value: import("../xlsx/index.js").CellValue;
+        formula?: string;
+        text: string;
+        numberFormat?: string;
+        iso?: string;
+        sheetIndex: number;
+        sheet: string;
+        address: string;
+    }[];
+    total: number;
+    truncated: boolean;
+    warnings: string[];
+}>;
+/**
+ * A table found by name (ignoring case, as Excel does) on any sheet: its sheet, range, header and
+ * totals rows, column names and cells as a range read returns them (at most 10,000 cells).
+ */
+export declare function readXlsxTable(bytes: Uint8Array, name: string): Promise<{
+    sheetIndex: number;
+    sheet: string;
+    name: string;
+    range: string;
+    headerRow: boolean;
+    totalsRow: boolean;
+    columns: string[];
+    cells: ({
+        address: string;
+    } & import("./xlsx-read.js").CellView)[];
+    warnings: string[];
+}>;
 //# sourceMappingURL=xlsx.d.ts.map

package/dist/automation/xlsx.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"xlsx.d.ts","sourceRoot":"","sources":["../../automation/xlsx.ts"],"names":[],"mappings":"AAOA,wBAAsB,WAAW,CAAC,KAAK,EAAE,UAAU;;;;;;;GAOlD;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAW9E;AAED,wBAAsB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;;;;;;;GAoB3F;AAED,wBAAsB,YAAY,CACjC,KAAK,EAAE,UAAU,EACjB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,SAAS;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE;;;GAgBpD;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,QAAe,EAAE;;CAAK;;;;;qBAI3D,MAAM;mBAAS,OAAO;sBAAY,MAAM;;;;;;;GAoBjE"}
+{"version":3,"file":"xlsx.d.ts","sourceRoot":"","sources":["../../automation/xlsx.ts"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,KAAK,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GASlD;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAW9E;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;;;;;GAQ3F;AAED,wBAAsB,YAAY,CACjC,KAAK,EAAE,UAAU,EACjB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,SAAS;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE;;;GAgBpD;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,QAAe,EAAE;;CAAK;;;;;qBAI3D,MAAM;mBAAS,OAAO;sBAAY,MAAM;;;;;;;GAoBjE;AAED,MAAM,WAAW,eAAe;IAC/B,oDAAoD;IACpD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yDAAyD;IACzD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4FAA4F;IAC5F,MAAM,CAAC,EAAE,UAAU,GAAG,QAAQ,CAAC;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,yCAAyC;IACzC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,mFAAmF;IACnF,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,mFAAmF;IACnF,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAClC,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,eAAoB;;;;;;;;;;;;;;GAuC7B;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM;;;;;;;;;;;;GAmBlE"}

package/dist/{chunk-M6GDBVQ7.mjs → chunk-GQYQQ3GA.mjs}

@@ -1,4 +1,4 @@
-import { hasTextProperties, isImageLikeElement, blobUrlToDataUrl, getSubstituteFontFamily, stripXmlOrderSuffix } from './chunk-SLNQNVQM.mjs';
+import { hasTextProperties, isImageLikeElement, blobUrlToDataUrl, getSubstituteFontFamily, stripXmlOrderSuffix } from './chunk-LEV2SVMK.mjs';
 
 // pptx/converter/media-context.ts
 var MIME_TO_EXT = {

package/dist/{chunk-SLNQNVQM.mjs → chunk-LEV2SVMK.mjs}

@@ -21818,7 +21818,7 @@ function findTextBearingElementById(elements3, elementId) {
 }
 async function loadNestedDeck(pptxBytes) {
   try {
-    const { PptxHandler } = await import('./PptxHandler-2V4PQL6O.mjs');
+    const { PptxHandler } = await import('./PptxHandler-FYD7IYXT.mjs');
     const handler = new PptxHandler();
     const data = await handler.load(pptxBytes.buffer.slice(0));
     return { handler, slides: data.slides };

package/dist/{chunk-JUABSM7C.mjs → chunk-LVM3IZJ2.mjs}

@@ -1,4 +1,4 @@
-import { hasTextProperties } from './chunk-SLNQNVQM.mjs';
+import { hasTextProperties } from './chunk-LEV2SVMK.mjs';
 import { cloneSlide } from './chunk-54S5A5PZ.mjs';
 
 // pptx/core/builders/sdk/merge-operations.ts