@origints/xlsx 0.1.1 → 0.2.0

package/dist/index.es.js

@@ -1,112 +1,116 @@
-import $ from "exceljs";
-function l(s, t) {
-  return { ok: !0, value: s, path: t };
+import { TYPE_LABEL as N, registerSpecExecutor as we, globalRegistry as me } from "@origints/core";
+import re from "exceljs";
+function f(r, e) {
+  return { ok: !0, value: r, path: e };
 }
-function h(s, t, e, r) {
+function w(r, e, t, n) {
   return {
     ok: !1,
-    failure: { kind: s, message: t, path: e, sourceLocation: r }
+    failure: { kind: r, message: e, path: t, sourceLocation: n }
   };
 }
-function F(s) {
-  const t = [];
-  return s.file && t.push(s.file), s.sheet && t.push(`[${s.sheet}]`), s.range ? t.push(`!${s.range}`) : s.cell && t.push(`!${s.cell}`), t.join("") || "workbook";
+function Je(r) {
+  const e = [];
+  return r.file && e.push(r.file), r.sheet && e.push(`[${r.sheet}]`), r.range ? e.push(`!${r.range}`) : r.cell && e.push(`!${r.cell}`), e.join("") || "workbook";
 }
-function U(s) {
-  if (s.sheet)
+function je(r) {
+  if (r.sheet)
     return {
       kind: "excel",
-      file: s.file ?? "",
-      sheet: s.sheet,
-      range: s.range ?? s.cell ?? ""
+      file: r.file ?? "",
+      sheet: r.sheet,
+      range: r.range ?? r.cell ?? ""
     };
 }
-function b(s) {
-  return typeof s == "object" && s !== null && !(s instanceof Date) && "formula" in s;
+function P(r) {
+  return typeof r == "object" && r !== null && !(r instanceof Date) && "formula" in r;
 }
-function S(s) {
-  return typeof s == "object" && s !== null && !(s instanceof Date) && "error" in s;
+function Q(r) {
+  return typeof r == "object" && r !== null && !(r instanceof Date) && "error" in r;
 }
-async function M(s) {
-  const t = s.getReader(), e = [];
+async function ge(r) {
+  const e = r.getReader(), t = [];
   try {
     for (; ; ) {
-      const { done: r, value: n } = await t.read();
-      if (r) break;
-      e.push(n);
+      const { done: n, value: s } = await e.read();
+      if (n) break;
+      t.push(s);
     }
-    return Buffer.concat(e);
+    return Buffer.concat(t);
   } finally {
-    t.releaseLock();
+    e.releaseLock();
   }
 }
-function T(s) {
-  let t = 0;
-  for (let e = 0; e < s.length; e++)
-    t = t * 26 + (s.charCodeAt(e) - 64);
-  return t;
+function ne(r) {
+  let e = 0;
+  for (let t = 0; t < r.length; t++)
+    e = e * 26 + (r.charCodeAt(t) - 64);
+  return e;
 }
-function N(s) {
-  let t = "";
-  for (; s > 0; ) {
-    const e = (s - 1) % 26;
-    t = String.fromCharCode(65 + e) + t, s = Math.floor((s - 1) / 26);
+function fe(r) {
+  let e = "";
+  for (; r > 0; ) {
+    const t = (r - 1) % 26;
+    e = String.fromCharCode(65 + t) + e, r = Math.floor((r - 1) / 26);
   }
-  return t;
+  return e;
 }
-function p(s) {
-  const t = s.match(/^([A-Z]+)(\d+)$/i);
-  if (!t)
-    throw new Error(`Invalid cell address: ${s}`);
-  const e = t[1].toUpperCase();
+function V(r) {
+  const e = r.match(/^([A-Z]+)(\d+)$/i);
+  if (!e)
+    throw new Error(`Invalid cell address: ${r}`);
+  const t = e[1].toUpperCase();
   return {
-    row: parseInt(t[2], 10),
-    col: T(e),
-    colLetter: e
+    row: parseInt(e[2], 10),
+    col: ne(t),
+    colLetter: t
   };
 }
-function R(s, t) {
-  return `${N(t)}${s}`;
+function Y(r, e) {
+  return `${fe(e)}${r}`;
 }
-function y(s) {
-  const t = s.split(":");
-  if (t.length === 1) {
-    const n = p(t[0]);
+function H(r) {
+  const e = r.split(":");
+  if (e.length === 1) {
+    const s = V(e[0]);
     return {
-      start: { row: n.row, col: n.col },
-      end: { row: n.row, col: n.col }
+      start: { row: s.row, col: s.col },
+      end: { row: s.row, col: s.col }
     };
   }
-  if (t.length !== 2)
-    throw new Error(`Invalid range: ${s}`);
-  const e = p(t[0]), r = p(t[1]);
+  if (e.length !== 2)
+    throw new Error(`Invalid range: ${r}`);
+  const t = V(e[0]), n = V(e[1]);
   return {
-    start: { row: e.row, col: e.col },
-    end: { row: r.row, col: r.col }
+    start: { row: t.row, col: t.col },
+    end: { row: n.row, col: n.col }
   };
 }
-function A(s, t, e, r) {
-  const n = R(s, t), o = R(e, r);
-  return n === o ? n : `${n}:${o}`;
+function le(r, e, t, n) {
+  const s = Y(r, e), l = Y(t, n);
+  return s === l ? s : `${s}:${l}`;
 }
-function O(s, t, e) {
-  return s >= e.start.row && s <= e.end.row && t >= e.start.col && t <= e.end.col;
+function Le(r, e, t) {
+  return r >= t.start.row && r <= t.end.row && e >= t.start.col && e <= t.end.col;
 }
-class w {
-  constructor(t, e, r) {
-    this.cell = t, this._path = e, this._sheetName = r;
+class W {
+  constructor(e, t, n) {
+    this.cell = e, this._path = t, this._sheetName = n;
+  }
+  get [N]() {
+    return `XlsxCell(${this.address})`;
   }
   /**
    * Creates an XlsxCell from an ExcelJS cell.
    * @internal
    */
-  static fromExcelJS(t, e, r) {
-    const n = {
-      file: r,
-      sheet: e,
-      cell: t.address
+  static fromExcelJS(e, t, n) {
+    const s = {
+      file: n,
+      sheet: t,
+      cell: e.address
     };
-    return new w(t, n, e);
+    return new W(e, s, t);
   }
   // ---------------------------------------------------------------------------
   // IDENTITY & LOCATION
@@ -154,67 +158,67 @@ class w {
    * Returns the raw cell value.
    */
   value() {
-    const t = this.getRawValue();
-    return b(t) ? l(t.result ?? null, this._path) : S(t) ? h("formula", `Cell contains error: ${t.error}`, this._path) : l(t, this._path);
+    const e = this.getRawValue();
+    return P(e) ? f(e.result ?? null, this._path) : Q(e) ? w("formula", `Cell contains error: ${e.error}`, this._path) : f(e, this._path);
   }
   /**
    * Returns the extended cell value (including formula info).
    */
   extendedValue() {
-    return l(this.getRawValue(), this._path);
+    return f(this.getRawValue(), this._path);
   }
   /**
    * Extract value as a string.
    */
   string() {
-    const t = this.getResolvedValue();
-    return t == null ? h("type", "Expected string, got null", this._path) : typeof t == "string" ? l(t, this._path) : typeof t == "number" || typeof t == "boolean" ? l(String(t), this._path) : t instanceof Date ? l(t.toISOString(), this._path) : h("type", `Expected string, got ${typeof t}`, this._path);
+    const e = this.getResolvedValue();
+    return e == null ? w("type", "Expected string, got null", this._path) : typeof e == "string" ? f(e, this._path) : typeof e == "number" || typeof e == "boolean" ? f(String(e), this._path) : e instanceof Date ? f(e.toISOString(), this._path) : w("type", `Expected string, got ${typeof e}`, this._path);
   }
   /**
    * Extract value as a number.
    */
   number() {
-    const t = this.getResolvedValue();
-    if (typeof t == "number")
-      return l(t, this._path);
-    if (typeof t == "string") {
-      const e = parseFloat(t);
-      if (!isNaN(e))
-        return l(e, this._path);
+    const e = this.getResolvedValue();
+    if (typeof e == "number")
+      return f(e, this._path);
+    if (typeof e == "string") {
+      const t = parseFloat(e);
+      if (!isNaN(t))
+        return f(t, this._path);
     }
-    return h("type", `Expected number, got ${E(t)}`, this._path);
+    return w("type", `Expected number, got ${ee(e)}`, this._path);
   }
   /**
    * Extract value as a boolean.
    */
   boolean() {
-    const t = this.getResolvedValue();
-    return typeof t == "boolean" ? l(t, this._path) : h("type", `Expected boolean, got ${E(t)}`, this._path);
+    const e = this.getResolvedValue();
+    return typeof e == "boolean" ? f(e, this._path) : w("type", `Expected boolean, got ${ee(e)}`, this._path);
   }
   /**
    * Extract value as a Date.
    */
   date() {
-    const t = this.getResolvedValue();
-    if (t instanceof Date)
-      return l(t, this._path);
-    if (typeof t == "number") {
-      const e = this.excelDateToJS(t);
-      return l(e, this._path);
+    const e = this.getResolvedValue();
+    if (e instanceof Date)
+      return f(e, this._path);
+    if (typeof e == "number") {
+      const t = this.excelDateToJS(e);
+      return f(t, this._path);
     }
-    if (typeof t == "string") {
-      const e = new Date(t);
-      if (!isNaN(e.getTime()))
-        return l(e, this._path);
+    if (typeof e == "string") {
+      const t = new Date(e);
+      if (!isNaN(t.getTime()))
+        return f(t, this._path);
     }
-    return h("type", `Expected date, got ${E(t)}`, this._path);
+    return w("type", `Expected date, got ${ee(e)}`, this._path);
   }
   /**
    * Get the formula if this cell contains one.
    */
   formula() {
-    const t = this.getRawValue();
-    return b(t) ? l(t.formula, this._path) : h("type", "Cell does not contain a formula", this._path);
+    const e = this.getRawValue();
+    return P(e) ? f(e.formula, this._path) : w("type", "Cell does not contain a formula", this._path);
   }
   // ---------------------------------------------------------------------------
   // RICH TEXT & MARKDOWN
@@ -224,50 +228,50 @@ class w {
    * Returns segments with their individual formatting properties.
    */
   richText() {
-    const t = this.cell.value, e = this.cell.hyperlink;
-    if (t && typeof t == "object" && "richText" in t) {
-      const u = t.richText.map((c) => ({
-        text: c.text,
-        bold: c.font?.bold,
-        italic: c.font?.italic,
-        underline: c.font?.underline === !0 || c.font?.underline === "single",
-        strikethrough: c.font?.strike,
-        color: c.font?.color?.argb,
-        size: c.font?.size,
-        font: c.font?.name
+    const e = this.cell.value, t = this.cell.hyperlink;
+    if (e && typeof e == "object" && "richText" in e) {
+      const a = e.richText.map((i) => ({
+        text: i.text,
+        bold: i.font?.bold,
+        italic: i.font?.italic,
+        underline: i.font?.underline === !0 || i.font?.underline === "single",
+        strikethrough: i.font?.strike,
+        color: i.font?.color?.argb,
+        size: i.font?.size,
+        font: i.font?.name
       }));
-      return l({ segments: u, hyperlink: e }, this._path);
+      return f({ segments: a, hyperlink: t }, this._path);
     }
-    if (t && typeof t == "object" && "text" in t && "hyperlink" in t) {
-      const a = t, u = this.style(), c = {
-        text: a.text,
-        bold: u.font?.bold,
-        italic: u.font?.italic,
-        underline: u.font?.underline,
-        strikethrough: u.font?.strikethrough,
-        color: u.font?.color,
-        size: u.font?.size,
-        font: u.font?.name
+    if (e && typeof e == "object" && "text" in e && "hyperlink" in e) {
+      const o = e, a = this.style(), i = {
+        text: o.text,
+        bold: a.font?.bold,
+        italic: a.font?.italic,
+        underline: a.font?.underline,
+        strikethrough: a.font?.strikethrough,
+        color: a.font?.color,
+        size: a.font?.size,
+        font: a.font?.name
       };
-      return l(
+      return f(
         {
-          segments: [c],
-          hyperlink: a.hyperlink
+          segments: [i],
+          hyperlink: o.hyperlink
         },
         this._path
       );
     }
-    const r = this.getResolvedValue(), n = r !== null ? String(r) : "", o = this.style(), i = {
-      text: n,
-      bold: o.font?.bold,
-      italic: o.font?.italic,
-      underline: o.font?.underline,
-      strikethrough: o.font?.strikethrough,
-      color: o.font?.color,
-      size: o.font?.size,
-      font: o.font?.name
+    const n = this.getResolvedValue(), s = n !== null ? String(n) : "", l = this.style(), u = {
+      text: s,
+      bold: l.font?.bold,
+      italic: l.font?.italic,
+      underline: l.font?.underline,
+      strikethrough: l.font?.strikethrough,
+      color: l.font?.color,
+      size: l.font?.size,
+      font: l.font?.name
     };
-    return l({ segments: [i], hyperlink: e }, this._path);
+    return f({ segments: [u], hyperlink: t }, this._path);
   }
   /**
    * Get the cell content as Markdown.
@@ -280,23 +284,23 @@ class w {
    * - Rich text segments with mixed formatting
    */
   markdown() {
-    const t = this.richText();
-    if (!t.ok)
-      return t;
-    const { segments: e, hyperlink: r } = t.value;
-    let n = "";
-    for (const o of e) {
-      let i = o.text;
-      o.strikethrough && (i = `~~${i}~~`), o.bold && (i = `**${i}**`), o.italic && (i = `*${i}*`), n += i;
+    const e = this.richText();
+    if (!e.ok)
+      return e;
+    const { segments: t, hyperlink: n } = e.value;
+    let s = "";
+    for (const l of t) {
+      let u = l.text;
+      l.strikethrough && (u = `~~${u}~~`), l.bold && (u = `**${u}**`), l.italic && (u = `*${u}*`), s += u;
     }
-    return r && (n = `[${n}](${r})`), l(n, this._path);
+    return n && (s = `[${s}](${n})`), f(s, this._path);
   }
   /**
    * Check if the cell contains rich text (multiple formatted segments).
    */
   isRichText() {
-    const t = this.cell.value;
-    return t !== null && typeof t == "object" && "richText" in t;
+    const e = this.cell.value;
+    return e !== null && typeof e == "object" && "richText" in e;
   }
   // ---------------------------------------------------------------------------
   // TYPE CHECKING
@@ -305,14 +309,14 @@ class w {
    * Check if the cell is empty.
    */
   isEmpty() {
-    const t = this.cell.value;
-    return t == null || t === "";
+    const e = this.cell.value;
+    return e == null || e === "";
   }
   /**
    * Check if the cell contains a formula.
    */
   isFormula() {
-    return b(this.getRawValue());
+    return P(this.getRawValue());
   }
   /**
    * Check if the cell is part of a merged range.
@@ -354,7 +358,7 @@ class w {
    * Check if the cell contains an error.
    */
   isError() {
-    return S(this.getRawValue());
+    return Q(this.getRawValue());
   }
   // ---------------------------------------------------------------------------
   // METADATA
@@ -363,31 +367,31 @@ class w {
    * Get the cell's style information.
    */
   style() {
-    const t = this.cell.font, e = this.cell.fill, r = this.cell.border, n = this.cell.alignment;
+    const e = this.cell.font, t = this.cell.fill, n = this.cell.border, s = this.cell.alignment;
     return {
-      font: t ? {
-        name: t.name,
-        size: t.size,
-        bold: t.bold,
-        italic: t.italic,
-        underline: t.underline === !0 || t.underline === "single",
-        strikethrough: t.strike,
-        color: t.color?.argb ?? (t.color?.theme !== void 0 ? `theme:${t.color.theme}` : void 0)
+      font: e ? {
+        name: e.name,
+        size: e.size,
+        bold: e.bold,
+        italic: e.italic,
+        underline: e.underline === !0 || e.underline === "single",
+        strikethrough: e.strike,
+        color: e.color?.argb ?? (e.color?.theme !== void 0 ? `theme:${e.color.theme}` : void 0)
       } : void 0,
-      fill: e && e.type === "pattern" ? {
-        type: e.pattern,
-        color: e.fgColor?.argb
+      fill: t && t.type === "pattern" ? {
+        type: t.pattern,
+        color: t.fgColor?.argb
       } : void 0,
-      border: r ? {
-        top: !!r.top,
-        bottom: !!r.bottom,
-        left: !!r.left,
-        right: !!r.right
+      border: n ? {
+        top: !!n.top,
+        bottom: !!n.bottom,
+        left: !!n.left,
+        right: !!n.right
       } : void 0,
-      alignment: n ? {
-        horizontal: n.horizontal,
-        vertical: n.vertical,
-        wrapText: n.wrapText
+      alignment: s ? {
+        horizontal: s.horizontal,
+        vertical: s.vertical,
+        wrapText: s.wrapText
       } : void 0,
       numFmt: this.cell.numFmt
     };
@@ -396,18 +400,18 @@ class w {
    * Get the hyperlink URL if the cell contains one.
    */
   hyperlink() {
-    const t = this.cell.hyperlink;
-    return t ? l(t, this._path) : h("missing", "Cell does not contain a hyperlink", this._path);
+    const e = this.cell.hyperlink;
+    return e ? f(e, this._path) : w("missing", "Cell does not contain a hyperlink", this._path);
   }
   /**
    * Get the comment/note if the cell has one.
    */
   comment() {
-    const t = this.cell.note;
-    return t ? typeof t == "string" ? l(t, this._path) : t.texts ? l(
-      t.texts.map((e) => e.text).join(""),
+    const e = this.cell.note;
+    return e ? typeof e == "string" ? f(e, this._path) : e.texts ? f(
+      e.texts.map((t) => t.text).join(""),
       this._path
-    ) : h("format", "Unable to extract comment text", this._path) : h("missing", "Cell does not contain a comment", this._path);
+    ) : w("format", "Unable to extract comment text", this._path) : w("missing", "Cell does not contain a comment", this._path);
   }
   // ---------------------------------------------------------------------------
   // NAVIGATION FROM CELL
@@ -416,18 +420,18 @@ class w {
    * Get a cell offset from this one.
    * @internal Used by navigation methods
    */
-  getOffsetCell(t, e, r) {
-    const n = this.row + t, o = this.col + e;
-    if (n < 1 || o < 1)
-      return h(
+  getOffsetCell(e, t, n) {
+    const s = this.row + e, l = this.col + t;
+    if (s < 1 || l < 1)
+      return w(
         "bounds",
-        `Cell offset (${t}, ${e}) from ${this.address} is out of bounds`,
+        `Cell offset (${e}, ${t}) from ${this.address} is out of bounds`,
         this._path
       );
-    const i = r(n, o);
-    return i ? l(i, i.path) : h(
+    const u = n(s, l);
+    return u ? f(u, u.path) : w(
       "missing",
-      `Cell at ${R(n, o)} not found`,
+      `Cell at ${Y(s, l)} not found`,
       this._path
     );
   }
@@ -438,108 +442,110 @@ class w {
    * Get the raw value, handling ExcelJS value types.
    */
   getRawValue() {
-    const t = this.cell.value;
-    if (t == null)
+    const e = this.cell.value;
+    if (e == null)
       return null;
-    if (typeof t == "object") {
-      if ("error" in t)
-        return { error: String(t.error) };
-      if ("formula" in t) {
-        const e = t;
+    if (typeof e == "object") {
+      if ("error" in e)
+        return { error: String(e.error) };
+      if ("formula" in e) {
+        const t = e;
         return {
-          formula: e.formula,
-          result: this.normalizeResult(e.result)
+          formula: t.formula,
+          result: this.normalizeResult(t.result)
         };
       }
-      if ("sharedFormula" in t) {
-        const e = t;
+      if ("sharedFormula" in e) {
+        const t = e;
         return {
-          formula: e.sharedFormula,
-          result: this.normalizeResult(e.result)
+          formula: t.sharedFormula,
+          result: this.normalizeResult(t.result)
         };
       }
-      if ("richText" in t)
-        return t.richText.map((r) => r.text).join("");
-      if (t instanceof Date)
-        return t;
+      if ("richText" in e)
+        return e.richText.map((n) => n.text).join("");
+      if (e instanceof Date)
+        return e;
     }
-    return typeof t == "string" || typeof t == "number" || typeof t == "boolean" ? t : null;
+    return typeof e == "string" || typeof e == "number" || typeof e == "boolean" ? e : null;
   }
   /**
    * Get the resolved value (formula result or plain value).
    */
   getResolvedValue() {
-    const t = this.getRawValue();
-    return b(t) ? t.result ?? null : S(t) ? null : t;
+    const e = this.getRawValue();
+    return P(e) ? e.result ?? null : Q(e) ? null : e;
   }
   /**
    * Normalize a formula result value.
    */
-  normalizeResult(t) {
-    return t == null ? null : typeof t == "string" || typeof t == "number" || typeof t == "boolean" || t instanceof Date ? t : null;
+  normalizeResult(e) {
+    return e == null ? null : typeof e == "string" || typeof e == "number" || typeof e == "boolean" || e instanceof Date ? e : null;
   }
   /**
    * Convert Excel date number to JavaScript Date.
    * Excel dates are days since 1900-01-01 (with a leap year bug).
    */
-  excelDateToJS(t) {
-    const e = t > 60 ? -1 : 0, r = t + e - 1, n = new Date(1900, 0, 1);
-    return new Date(n.getTime() + r * 24 * 60 * 60 * 1e3);
+  excelDateToJS(e) {
+    const t = e > 60 ? -1 : 0, n = e + t - 1, s = new Date(1900, 0, 1);
+    return new Date(s.getTime() + n * 24 * 60 * 60 * 1e3);
   }
 }
-function E(s) {
-  return s === null ? "null" : s === void 0 ? "undefined" : s instanceof Date ? "date" : Array.isArray(s) ? "array" : typeof s;
+function ee(r) {
+  return r === null ? "null" : r === void 0 ? "undefined" : r instanceof Date ? "date" : Array.isArray(r) ? "array" : typeof r;
 }
-class m {
-  constructor(t, e, r, n, o, i, a, u) {
-    this.worksheet = t, this._startRow = e, this._startCol = r, this._endRow = n, this._endCol = o, this._path = i, this._sheetName = a, this._file = u;
+class y {
+  constructor(e, t, n, s, l, u, o, a) {
+    this.worksheet = e, this._startRow = t, this._startCol = n, this._endRow = s, this._endCol = l, this._path = u, this._sheetName = o, this._file = a;
+  }
+  get [N]() {
+    return `XlsxRange(${this.address})`;
   }
   /**
    * Creates an XlsxRange from coordinates.
    * @internal
    */
-  static fromCoords(t, e, r, n, o, i, a) {
-    const u = A(e, r, n, o), c = {
-      file: a,
-      sheet: i,
-      range: u
+  static fromCoords(e, t, n, s, l, u, o) {
+    const a = le(t, n, s, l), i = {
+      file: o,
+      sheet: u,
+      range: a
     };
-    return new m(
-      t,
+    return new y(
       e,
-      r,
+      t,
       n,
-      o,
-      c,
+      s,
+      l,
       i,
-      a
+      u,
+      o
     );
   }
   /**
    * Creates an XlsxRange from an address string.
    * @internal
    */
-  static fromAddress(t, e, r, n) {
+  static fromAddress(e, t, n, s) {
     try {
-      const { start: o, end: i } = y(e);
-      return l(
-        m.fromCoords(
-          t,
-          o.row,
-          o.col,
-          i.row,
-          i.col,
-          r,
-          n
+      const { start: l, end: u } = H(t);
+      return f(
+        y.fromCoords(
+          e,
+          l.row,
+          l.col,
+          u.row,
+          u.col,
+          n,
+          s
         ),
-        { file: n, sheet: r, range: e }
+        { file: s, sheet: n, range: t }
       );
     } catch {
-      return h(
-        "range",
-        `Invalid range address: ${e}`,
-        { file: n, sheet: r }
-      );
+      return w("range", `Invalid range address: ${t}`, {
+        file: s,
+        sheet: n
+      });
     }
   }
   // ---------------------------------------------------------------------------
@@ -549,7 +555,7 @@ class m {
    * Returns the range address (e.g., "A1:C10").
    */
   get address() {
-    return A(
+    return le(
       this._startRow,
       this._startCol,
       this._endRow,
@@ -611,41 +617,41 @@ class m {
    * Get a cell at specific row and column within this range.
    * Coordinates are relative to the range start (0-indexed).
    */
-  cellAt(t, e) {
-    const r = this._startRow + t, n = this._startCol + e;
-    if (r < this._startRow || r > this._endRow || n < this._startCol || n > this._endCol)
-      return h(
+  cellAt(e, t) {
+    const n = this._startRow + e, s = this._startCol + t;
+    if (n < this._startRow || n > this._endRow || s < this._startCol || s > this._endCol)
+      return w(
         "bounds",
-        `Offset (${t}, ${e}) is outside range ${this.address}`,
+        `Offset (${e}, ${t}) is outside range ${this.address}`,
         this._path
       );
-    const o = this.worksheet.getCell(r, n);
-    return l(w.fromExcelJS(o, this._sheetName, this._file), {
+    const l = this.worksheet.getCell(n, s);
+    return f(W.fromExcelJS(l, this._sheetName, this._file), {
       ...this._path,
-      cell: o.address,
+      cell: l.address,
       range: void 0
     });
   }
   /**
    * Get a cell by its address within this range.
    */
-  cell(t) {
+  cell(e) {
     try {
-      const { start: e } = y(t);
-      if (e.row < this._startRow || e.row > this._endRow || e.col < this._startCol || e.col > this._endCol)
-        return h(
+      const { start: t } = H(e);
+      if (t.row < this._startRow || t.row > this._endRow || t.col < this._startCol || t.col > this._endCol)
+        return w(
           "bounds",
-          `Cell ${t} is outside range ${this.address}`,
+          `Cell ${e} is outside range ${this.address}`,
           this._path
         );
-      const r = this.worksheet.getCell(t);
-      return l(w.fromExcelJS(r, this._sheetName, this._file), {
+      const n = this.worksheet.getCell(e);
+      return f(W.fromExcelJS(n, this._sheetName, this._file), {
         ...this._path,
-        cell: t,
+        cell: e,
         range: void 0
       });
     } catch {
-      return h("range", `Invalid cell address: ${t}`, this._path);
+      return w("range", `Invalid cell address: ${e}`, this._path);
     }
   }
   // ---------------------------------------------------------------------------
@@ -655,52 +661,52 @@ class m {
    * Iterate over all cells in the range (row by row).
    */
   *cells() {
-    for (let t = this._startRow; t <= this._endRow; t++)
-      for (let e = this._startCol; e <= this._endCol; e++) {
-        const r = this.worksheet.getCell(t, e);
-        yield w.fromExcelJS(r, this._sheetName, this._file);
+    for (let e = this._startRow; e <= this._endRow; e++)
+      for (let t = this._startCol; t <= this._endCol; t++) {
+        const n = this.worksheet.getCell(e, t);
+        yield W.fromExcelJS(n, this._sheetName, this._file);
       }
   }
   /**
    * Iterate over rows, returning arrays of cells.
    */
   *rows() {
-    for (let t = this._startRow; t <= this._endRow; t++) {
-      const e = [];
-      for (let r = this._startCol; r <= this._endCol; r++) {
-        const n = this.worksheet.getCell(t, r);
-        e.push(w.fromExcelJS(n, this._sheetName, this._file));
+    for (let e = this._startRow; e <= this._endRow; e++) {
+      const t = [];
+      for (let n = this._startCol; n <= this._endCol; n++) {
+        const s = this.worksheet.getCell(e, n);
+        t.push(W.fromExcelJS(s, this._sheetName, this._file));
       }
-      yield e;
+      yield t;
     }
   }
   /**
    * Iterate over columns, returning arrays of cells.
    */
   *cols() {
-    for (let t = this._startCol; t <= this._endCol; t++) {
-      const e = [];
-      for (let r = this._startRow; r <= this._endRow; r++) {
-        const n = this.worksheet.getCell(r, t);
-        e.push(w.fromExcelJS(n, this._sheetName, this._file));
+    for (let e = this._startCol; e <= this._endCol; e++) {
+      const t = [];
+      for (let n = this._startRow; n <= this._endRow; n++) {
+        const s = this.worksheet.getCell(n, e);
+        t.push(W.fromExcelJS(s, this._sheetName, this._file));
       }
-      yield e;
+      yield t;
     }
   }
   /**
    * Get all values in the range as a 2D array.
    */
   values() {
-    const t = [];
-    for (const e of this.rows()) {
-      const r = [];
-      for (const n of e) {
-        const o = n.value();
-        r.push(o.ok ? o.value : null);
+    const e = [];
+    for (const t of this.rows()) {
+      const n = [];
+      for (const s of t) {
+        const l = s.value();
+        n.push(l.ok ? l.value : null);
       }
-      t.push(r);
+      e.push(n);
     }
-    return t;
+    return e;
   }
   /**
    * Get all cells as a flat array.
@@ -714,34 +720,34 @@ class m {
   /**
    * Get a subrange within this range.
    */
-  subRange(t) {
+  subRange(e) {
     try {
-      const { start: e, end: r } = y(t);
-      return e.row < this._startRow || r.row > this._endRow || e.col < this._startCol || r.col > this._endCol ? h(
+      const { start: t, end: n } = H(e);
+      return t.row < this._startRow || n.row > this._endRow || t.col < this._startCol || n.col > this._endCol ? w(
         "bounds",
-        `Subrange ${t} extends outside range ${this.address}`,
+        `Subrange ${e} extends outside range ${this.address}`,
         this._path
-      ) : l(
-        m.fromCoords(
+      ) : f(
+        y.fromCoords(
           this.worksheet,
-          e.row,
-          e.col,
-          r.row,
-          r.col,
+          t.row,
+          t.col,
+          n.row,
+          n.col,
           this._sheetName,
           this._file
         ),
-        { ...this._path, range: t }
+        { ...this._path, range: e }
       );
     } catch {
-      return h("range", `Invalid range address: ${t}`, this._path);
+      return w("range", `Invalid range address: ${e}`, this._path);
     }
   }
   /**
    * Get the first row as a range.
    */
   firstRow() {
-    return m.fromCoords(
+    return y.fromCoords(
       this.worksheet,
       this._startRow,
       this._startCol,
@@ -755,7 +761,7 @@ class m {
    * Get the last row as a range.
    */
   lastRow() {
-    return m.fromCoords(
+    return y.fromCoords(
       this.worksheet,
       this._endRow,
       this._startCol,
@@ -769,7 +775,7 @@ class m {
    * Get the first column as a range.
    */
   firstCol() {
-    return m.fromCoords(
+    return y.fromCoords(
       this.worksheet,
       this._startRow,
       this._startCol,
@@ -783,7 +789,7 @@ class m {
    * Get the last column as a range.
    */
   lastCol() {
-    return m.fromCoords(
+    return y.fromCoords(
       this.worksheet,
       this._startRow,
       this._endCol,
@@ -796,18 +802,18 @@ class m {
   /**
    * Get a specific row as a range (0-indexed offset from start).
    */
-  rowAt(t) {
-    const e = this._startRow + t;
-    return e < this._startRow || e > this._endRow ? h(
+  rowAt(e) {
+    const t = this._startRow + e;
+    return t < this._startRow || t > this._endRow ? w(
       "bounds",
-      `Row offset ${t} is outside range ${this.address}`,
+      `Row offset ${e} is outside range ${this.address}`,
       this._path
-    ) : l(
-      m.fromCoords(
+    ) : f(
+      y.fromCoords(
         this.worksheet,
-        e,
+        t,
         this._startCol,
-        e,
+        t,
         this._endCol,
         this._sheetName,
         this._file
@@ -818,19 +824,19 @@ class m {
   /**
    * Get a specific column as a range (0-indexed offset from start).
    */
-  colAt(t) {
-    const e = this._startCol + t;
-    return e < this._startCol || e > this._endCol ? h(
+  colAt(e) {
+    const t = this._startCol + e;
+    return t < this._startCol || t > this._endCol ? w(
       "bounds",
-      `Column offset ${t} is outside range ${this.address}`,
+      `Column offset ${e} is outside range ${this.address}`,
       this._path
-    ) : l(
-      m.fromCoords(
+    ) : f(
+      y.fromCoords(
         this.worksheet,
         this._startRow,
-        e,
+        t,
         this._endRow,
-        e,
+        t,
         this._sheetName,
         this._file
       ),
@@ -843,11 +849,11 @@ class m {
   /**
    * Find the first cell matching the predicate.
    */
-  find(t) {
-    for (const e of this.cells())
-      if (t(e))
-        return l(e, e.path);
-    return h(
+  find(e) {
+    for (const t of this.cells())
+      if (e(t))
+        return f(t, t.path);
+    return w(
       "missing",
       `No cell matching predicate found in range ${this.address}`,
       this._path
@@ -856,53 +862,53 @@ class m {
   /**
    * Find all cells matching the predicate.
    */
-  findAll(t) {
-    const e = [];
-    for (const r of this.cells())
-      t(r) && e.push(r);
-    return e;
+  findAll(e) {
+    const t = [];
+    for (const n of this.cells())
+      e(n) && t.push(n);
+    return t;
   }
   /**
    * Find the first cell with the specified value.
    */
-  findValue(t) {
-    for (const e of this.cells()) {
-      const r = e.value();
-      if (r.ok && r.value === t)
-        return l(e, e.path);
+  findValue(e) {
+    for (const t of this.cells()) {
+      const n = t.value();
+      if (n.ok && n.value === e)
+        return f(t, t.path);
     }
-    return h(
+    return w(
       "missing",
-      `Value "${t}" not found in range ${this.address}`,
+      `Value "${e}" not found in range ${this.address}`,
       this._path
     );
   }
   /**
    * Check if any cell matches the predicate.
    */
-  some(t) {
-    for (const e of this.cells())
-      if (t(e))
+  some(e) {
+    for (const t of this.cells())
+      if (e(t))
         return !0;
     return !1;
   }
   /**
    * Check if all cells match the predicate.
    */
-  every(t) {
-    for (const e of this.cells())
-      if (!t(e))
+  every(e) {
+    for (const t of this.cells())
+      if (!e(t))
         return !1;
     return !0;
   }
   /**
    * Count cells matching the predicate.
    */
-  count(t) {
-    let e = 0;
-    for (const r of this.cells())
-      t(r) && e++;
-    return e;
+  count(e) {
+    let t = 0;
+    for (const n of this.cells())
+      e(n) && t++;
+    return t;
   }
   // ---------------------------------------------------------------------------
   // CONVERSION
@@ -918,27 +924,27 @@ class m {
    * @param headerRowOffset - Row offset for headers (default: 0, first row)
    * @param dataStartOffset - Row offset where data starts (default: 1, second row)
    */
-  toObjects(t = 0, e = 1) {
-    const r = [...this.rows()];
-    if (r.length === 0) return [];
-    const n = r[t];
-    if (!n) return [];
-    const o = n.map((a) => {
-      const u = a.value();
-      return u.ok && u.value !== null ? String(u.value) : "";
-    }), i = [];
-    for (let a = e; a < r.length; a++) {
-      const u = r[a], c = {};
-      for (let f = 0; f < o.length; f++) {
-        const g = o[f];
-        if (g) {
-          const _ = u[f]?.value();
-          c[g] = _?.ok ? _.value : null;
+  toObjects(e = 0, t = 1) {
+    const n = [...this.rows()];
+    if (n.length === 0) return [];
+    const s = n[e];
+    if (!s) return [];
+    const l = s.map((o) => {
+      const a = o.value();
+      return a.ok && a.value !== null ? String(a.value) : "";
+    }), u = [];
+    for (let o = t; o < n.length; o++) {
+      const a = n[o], i = {};
+      for (let c = 0; c < l.length; c++) {
+        const h = l[c];
+        if (h) {
+          const k = a[c]?.value();
+          i[h] = k?.ok ? k.value : null;
         }
       }
-      i.push(c);
+      u.push(i);
     }
-    return i;
+    return u;
   }
   /**
    * Convert range to JSON-compatible structure.
@@ -950,24 +956,27 @@ class m {
     };
   }
 }
-class d {
-  constructor(t, e, r, n = "right") {
-    this.sheet = t, this._row = e, this._col = r, this._direction = n;
+class $ {
+  constructor(e, t, n, s = "right") {
+    this.sheet = e, this._row = t, this._col = n, this._direction = s;
+  }
+  get [N]() {
+    return `XlsxCursor(${this.address} ${this._direction})`;
   }
   /**
    * Create a cursor from an address string.
    * @internal
    */
-  static create(t, e) {
-    const { row: r, col: n } = p(e);
-    return new d(t, r, n);
+  static create(e, t) {
+    const { row: n, col: s } = V(t);
+    return new $(e, n, s);
   }
   /**
    * Create a cursor from row and column coordinates.
    * @internal
    */
-  static createAt(t, e, r) {
-    return new d(t, Math.max(1, e), Math.max(1, r));
+  static createAt(e, t, n) {
+    return new $(e, Math.max(1, t), Math.max(1, n));
   }
   // ---------------------------------------------------------------------------
   // POSITION
@@ -988,13 +997,13 @@ class d {
    * Get the current address.
    */
   get address() {
-    return R(this._row, this._col);
+    return Y(this._row, this._col);
   }
   /**
    * Get the current column letter.
    */
   get colLetter() {
-    return N(this._col);
+    return fe(this._col);
   }
   /**
    * Get the current direction.
@@ -1017,58 +1026,68 @@ class d {
   /**
    * Move by a delta (returns new cursor).
    */
-  move(t, e) {
-    return new d(
+  move(e, t) {
+    return new $(
       this.sheet,
-      Math.max(1, this._row + t),
-      Math.max(1, this._col + e),
+      Math.max(1, this._row + e),
+      Math.max(1, this._col + t),
       this._direction
     );
   }
   /**
    * Move to a specific address.
    */
-  moveTo(t) {
-    const { row: e, col: r } = p(t);
-    return new d(this.sheet, e, r, this._direction);
+  moveTo(e) {
+    const { row: t, col: n } = V(e);
+    return new $(this.sheet, t, n, this._direction);
   }
   /**
    * Move to a specific row.
    */
-  moveToRow(t) {
-    return new d(this.sheet, Math.max(1, t), this._col, this._direction);
+  moveToRow(e) {
+    return new $(
+      this.sheet,
+      Math.max(1, e),
+      this._col,
+      this._direction
+    );
   }
   /**
    * Move to a specific column.
    */
-  moveToCol(t) {
-    const e = typeof t == "string" ? T(t.toUpperCase()) : t;
-    return new d(this.sheet, this._row, Math.max(1, e), this._direction);
+  moveToCol(e) {
+    const t = typeof e == "string" ? ne(e.toUpperCase()) : e;
+    return new $(
+      this.sheet,
+      this._row,
+      Math.max(1, t),
+      this._direction
+    );
   }
   /**
    * Move left by count cells.
    */
-  left(t = 1) {
-    return new d(
+  left(e = 1) {
+    return new $(
       this.sheet,
       this._row,
-      Math.max(1, this._col - t),
+      Math.max(1, this._col - e),
       "left"
     );
   }
   /**
    * Move right by count cells.
    */
-  right(t = 1) {
-    return new d(this.sheet, this._row, this._col + t, "right");
+  right(e = 1) {
+    return new $(this.sheet, this._row, this._col + e, "right");
   }
   /**
    * Move up by count cells.
    */
-  up(t = 1) {
-    return new d(
+  up(e = 1) {
+    return new $(
       this.sheet,
-      Math.max(1, this._row - t),
+      Math.max(1, this._row - e),
       this._col,
       "up"
     );
@@ -1076,41 +1095,41 @@ class d {
   /**
    * Move down by count cells.
    */
-  down(t = 1) {
-    return new d(this.sheet, this._row + t, this._col, "down");
+  down(e = 1) {
+    return new $(this.sheet, this._row + e, this._col, "down");
   }
   /**
    * Set the current direction.
    */
-  setDirection(t) {
-    return new d(this.sheet, this._row, this._col, t);
+  setDirection(e) {
+    return new $(this.sheet, this._row, this._col, e);
   }
   /**
    * Move forward in the current direction.
    */
-  forward(t = 1) {
+  forward(e = 1) {
     switch (this._direction) {
       case "right":
-        return this.right(t);
+        return this.right(e);
       case "left":
-        return this.left(t);
+        return this.left(e);
       case "down":
-        return this.down(t);
+        return this.down(e);
       case "up":
-        return this.up(t);
+        return this.up(e);
     }
   }
   /**
    * Move to the start of the current row.
    */
   startOfRow() {
-    return new d(this.sheet, this._row, 1, this._direction);
+    return new $(this.sheet, this._row, 1, this._direction);
   }
   /**
    * Move to the start of the current column.
    */
   startOfCol() {
-    return new d(this.sheet, 1, this._col, this._direction);
+    return new $(this.sheet, 1, this._col, this._direction);
   }
   // ---------------------------------------------------------------------------
   // SKIP OPERATIONS
@@ -1119,41 +1138,41 @@ class d {
    * Skip empty cells in the current direction.
    */
   skipEmpty() {
-    return this.skipWhile((t) => t.isEmpty());
+    return this.skipWhile((e) => e.isEmpty());
   }
   /**
    * Skip cells while the predicate is true.
    */
-  skipWhile(t) {
-    let e = this;
-    const r = this.sheet.dimensions(), n = Math.max(r.rowCount, r.colCount) * 2;
-    for (let o = 0; o < n; o++) {
-      const i = e.cell();
-      if (!i.ok || !t(i.value)) break;
-      e = e.forward();
+  skipWhile(e) {
+    let t = this;
+    const n = this.sheet.dimensions(), s = Math.max(n.rowCount, n.colCount) * 2;
+    for (let l = 0; l < s; l++) {
+      const u = t.cell();
+      if (!u.ok || !e(u.value)) break;
+      t = t.forward();
     }
-    return e;
+    return t;
   }
   /**
    * Skip cells until the predicate is true.
    */
-  skipUntil(t) {
-    return this.skipWhile((e) => !t(e));
+  skipUntil(e) {
+    return this.skipWhile((t) => !e(t));
   }
   /**
    * Skip cells until a specific value is found.
    */
-  skipToValue(t) {
-    return this.skipUntil((e) => {
-      const r = e.value();
-      return r.ok && r.value === t;
+  skipToValue(e) {
+    return this.skipUntil((t) => {
+      const n = t.value();
+      return n.ok && n.value === e;
     });
   }
   /**
    * Skip a specific number of cells.
    */
-  skip(t) {
-    return this.forward(t);
+  skip(e) {
+    return this.forward(e);
   }
   // ---------------------------------------------------------------------------
   // GRAB OPERATIONS
@@ -1162,80 +1181,80 @@ class d {
    * Grab the current cell and move forward.
    */
   grab() {
-    const t = this.cell();
-    return t.ok ? l(
+    const e = this.cell();
+    return e.ok ? f(
       {
-        cell: t.value,
+        cell: e.value,
         cursor: this.forward()
       },
       this.path
-    ) : t;
+    ) : e;
   }
   /**
    * Grab n cells in the current direction.
    */
-  grabN(t) {
-    const e = [];
-    let r = this;
-    for (let n = 0; n < t; n++) {
-      const o = r.cell();
-      if (!o.ok)
+  grabN(e) {
+    const t = [];
+    let n = this;
+    for (let s = 0; s < e; s++) {
+      const l = n.cell();
+      if (!l.ok)
         break;
-      e.push(o.value), r = r.forward();
+      t.push(l.value), n = n.forward();
     }
-    return e.length === 0 ? h("bounds", "No cells to grab", this.path) : l({ cells: e, cursor: r }, this.path);
+    return t.length === 0 ? w("bounds", "No cells to grab", this.path) : f({ cells: t, cursor: n }, this.path);
   }
   /**
    * Grab cells while the predicate is true.
    */
-  grabWhile(t) {
-    const e = [];
-    let r = this;
-    const n = this.sheet.dimensions(), o = Math.max(n.rowCount, n.colCount) * 2;
-    for (let i = 0; i < o; i++) {
-      const a = r.cell();
-      if (!a.ok || !t(a.value)) break;
-      e.push(a.value), r = r.forward();
+  grabWhile(e) {
+    const t = [];
+    let n = this;
+    const s = this.sheet.dimensions(), l = Math.max(s.rowCount, s.colCount) * 2;
+    for (let u = 0; u < l; u++) {
+      const o = n.cell();
+      if (!o.ok || !e(o.value)) break;
+      t.push(o.value), n = n.forward();
     }
-    return l({ cells: e, cursor: r }, this.path);
+    return f({ cells: t, cursor: n }, this.path);
   }
   /**
    * Grab cells until the predicate is true (not including the matching cell).
    */
-  grabUntil(t) {
-    return this.grabWhile((e) => !t(e));
+  grabUntil(e) {
+    return this.grabWhile((t) => !e(t));
   }
   /**
    * Grab the rest of the current row.
    */
   grabRow() {
-    const t = [], e = this.sheet.dimensions();
-    let r = this.setDirection("right");
-    for (let n = this._col; n <= e.endCol; n++) {
-      const o = r.cell();
-      if (!o.ok) break;
-      t.push(o.value), r = r.forward();
+    const e = [], t = this.sheet.dimensions();
+    let n = this.setDirection("right");
+    for (let s = this._col; s <= t.endCol; s++) {
+      const l = n.cell();
+      if (!l.ok) break;
+      e.push(l.value), n = n.forward();
     }
-    return l({ cells: t, cursor: r }, this.path);
+    return f({ cells: e, cursor: n }, this.path);
   }
   /**
    * Grab the rest of the current column.
    */
   grabCol() {
-    const t = [], e = this.sheet.dimensions();
-    let r = this.setDirection("down");
-    for (let n = this._row; n <= e.endRow; n++) {
-      const o = r.cell();
-      if (!o.ok) break;
-      t.push(o.value), r = r.forward();
+    const e = [], t = this.sheet.dimensions();
+    let n = this.setDirection("down");
+    for (let s = this._row; s <= t.endRow; s++) {
+      const l = n.cell();
+      if (!l.ok) break;
+      e.push(l.value), n = n.forward();
     }
-    return l({ cells: t, cursor: r }, this.path);
+    return f({ cells: e, cursor: n }, this.path);
   }
   /**
    * Grab non-empty cells in the current direction.
    */
   grabNonEmpty() {
-    return this.grabWhile((t) => !t.isEmpty());
+    return this.grabWhile((e) => !e.isEmpty());
   }
   // ---------------------------------------------------------------------------
   // PEEK OPERATIONS
@@ -1249,21 +1268,21 @@ class d {
   /**
    * Peek at cells ahead without moving.
    */
-  peekAhead(t) {
-    const e = [];
-    let r = this;
-    for (let n = 0; n < t; n++) {
-      const o = r.cell();
-      if (!o.ok) break;
-      e.push(o.value), r = r.forward();
+  peekAhead(e) {
+    const t = [];
+    let n = this;
+    for (let s = 0; s < e; s++) {
+      const l = n.cell();
+      if (!l.ok) break;
+      t.push(l.value), n = n.forward();
     }
-    return l(e, this.path);
+    return f(t, this.path);
   }
   /**
    * Peek at a cell at an offset without moving.
    */
-  peekAt(t, e) {
-    return this.move(t, e).cell();
+  peekAt(e, t) {
+    return this.move(e, t).cell();
   }
   // ---------------------------------------------------------------------------
   // CURRENT CELL
@@ -1278,8 +1297,8 @@ class d {
    * Get the value of the current cell.
    */
   value() {
-    const t = this.cell();
-    return t.ok ? t.value.value() : t;
+    const e = this.cell();
+    return e.ok ? e.value.value() : e;
   }
   // ---------------------------------------------------------------------------
   // UTILITIES
@@ -1294,37 +1313,40 @@ class d {
    * Check if the current cell is empty.
    */
   isEmpty() {
-    const t = this.cell();
-    return t.ok && t.value.isEmpty();
+    const e = this.cell();
+    return e.ok && e.value.isEmpty();
   }
   /**
    * Check if the current cell is non-empty.
    */
   isNotEmpty() {
-    const t = this.cell();
-    return t.ok && !t.value.isEmpty();
+    const e = this.cell();
+    return e.ok && !e.value.isEmpty();
   }
   /**
    * Create a new cursor at the same position.
    */
   clone() {
-    return new d(this.sheet, this._row, this._col, this._direction);
+    return new $(this.sheet, this._row, this._col, this._direction);
   }
 }
-class k {
-  constructor(t, e, r) {
-    this.worksheet = t, this._path = e, this._file = r;
+class O {
+  constructor(e, t, n) {
+    this.worksheet = e, this._path = t, this._file = n;
+  }
+  get [N]() {
+    return `XlsxSheet(${this.name})`;
   }
   /**
    * Creates an XlsxSheet from an ExcelJS worksheet.
    * @internal
    */
-  static fromExcelJS(t, e) {
-    const r = {
-      file: e,
-      sheet: t.name
+  static fromExcelJS(e, t) {
+    const n = {
+      file: t,
+      sheet: e.name
     };
-    return new k(t, r, e);
+    return new O(e, n, t);
   }
   // ---------------------------------------------------------------------------
   // IDENTITY
@@ -1353,40 +1375,40 @@ class k {
   /**
    * Get a cell by its address (e.g., "A1", "B2").
    */
-  cell(t) {
+  cell(e) {
     try {
-      p(t);
-      const e = this.worksheet.getCell(t);
-      return l(w.fromExcelJS(e, this.name, this._file), {
+      V(e);
+      const t = this.worksheet.getCell(e);
+      return f(W.fromExcelJS(t, this.name, this._file), {
         ...this._path,
-        cell: t
+        cell: e
       });
     } catch {
-      return h("range", `Invalid cell address: ${t}`, this._path);
+      return w("range", `Invalid cell address: ${e}`, this._path);
     }
   }
   /**
    * Get a cell by row and column numbers (1-based).
    */
-  cellAt(t, e) {
-    if (t < 1 || e < 1)
-      return h(
+  cellAt(e, t) {
+    if (e < 1 || t < 1)
+      return w(
         "bounds",
-        `Invalid cell coordinates: row=${t}, col=${e}`,
+        `Invalid cell coordinates: row=${e}, col=${t}`,
         this._path
       );
-    const r = this.worksheet.getCell(t, e);
-    return l(w.fromExcelJS(r, this.name, this._file), {
+    const n = this.worksheet.getCell(e, t);
+    return f(W.fromExcelJS(n, this.name, this._file), {
       ...this._path,
-      cell: r.address
+      cell: n.address
     });
   }
   /**
    * Get the value of a cell directly.
    */
-  getValue(t) {
-    const e = this.cell(t);
-    return e.ok ? e.value.value() : e;
+  getValue(e) {
+    const t = this.cell(e);
+    return t.ok ? t.value.value() : t;
   }
   // ---------------------------------------------------------------------------
   // RANGE OPERATIONS
@@ -1394,26 +1416,26 @@ class k {
   /**
    * Get a range by its address (e.g., "A1:C10").
    */
-  range(t) {
-    return m.fromAddress(this.worksheet, t, this.name, this._file);
+  range(e) {
+    return y.fromAddress(this.worksheet, e, this.name, this._file);
   }
   /**
    * Get a range from start to end addresses.
    */
-  rangeFrom(t, e) {
-    return this.range(`${t}:${e}`);
+  rangeFrom(e, t) {
+    return this.range(`${e}:${t}`);
   }
   /**
    * Get a range by coordinates (1-based).
    */
-  rangeAt(t, e, r, n) {
-    return t < 1 || e < 1 || r < 1 || n < 1 ? h("bounds", "Invalid range coordinates", this._path) : l(
-      m.fromCoords(
+  rangeAt(e, t, n, s) {
+    return e < 1 || t < 1 || n < 1 || s < 1 ? w("bounds", "Invalid range coordinates", this._path) : f(
+      y.fromCoords(
         this.worksheet,
-        t,
         e,
-        r,
+        t,
         n,
+        s,
         this.name,
         this._file
       ),
@@ -1424,14 +1446,14 @@ class k {
    * Get the used range of the sheet (cells with data).
    */
   usedRange() {
-    const t = this.dimensions();
-    return t.rowCount === 0 || t.colCount === 0 ? h("missing", "Sheet has no used cells", this._path) : l(
-      m.fromCoords(
+    const e = this.dimensions();
+    return e.rowCount === 0 || e.colCount === 0 ? w("missing", "Sheet has no used cells", this._path) : f(
+      y.fromCoords(
         this.worksheet,
-        t.startRow,
-        t.startCol,
-        t.endRow,
-        t.endCol,
+        e.startRow,
+        e.startCol,
+        e.endRow,
+        e.endCol,
         this.name,
         this._file
       ),
@@ -1444,18 +1466,18 @@ class k {
   /**
    * Get a row as a range.
    */
-  row(t) {
-    const e = this.dimensions();
-    if (t < 1)
-      return h("bounds", `Invalid row number: ${t}`, this._path);
-    const r = Math.max(e.endCol, 1);
-    return l(
-      m.fromCoords(
+  row(e) {
+    const t = this.dimensions();
+    if (e < 1)
+      return w("bounds", `Invalid row number: ${e}`, this._path);
+    const n = Math.max(t.endCol, 1);
+    return f(
+      y.fromCoords(
         this.worksheet,
-        t,
+        e,
         1,
-        t,
-        r,
+        e,
+        n,
         this.name,
         this._file
       ),
@@ -1465,18 +1487,18 @@ class k {
   /**
    * Get a column as a range.
    */
-  col(t) {
-    const e = typeof t == "string" ? T(t.toUpperCase()) : t;
-    if (e < 1)
-      return h("bounds", `Invalid column: ${t}`, this._path);
-    const r = this.dimensions(), n = Math.max(r.endRow, 1);
-    return l(
-      m.fromCoords(
+  col(e) {
+    const t = typeof e == "string" ? ne(e.toUpperCase()) : e;
+    if (t < 1)
+      return w("bounds", `Invalid column: ${e}`, this._path);
+    const n = this.dimensions(), s = Math.max(n.endRow, 1);
+    return f(
+      y.fromCoords(
         this.worksheet,
         1,
-        e,
-        n,
-        e,
+        t,
+        s,
+        t,
         this.name,
         this._file
       ),
@@ -1487,14 +1509,14 @@ class k {
    * Iterate over all rows with data.
    */
   *rows() {
-    const t = this.dimensions();
-    for (let e = t.startRow; e <= t.endRow; e++)
-      yield m.fromCoords(
+    const e = this.dimensions();
+    for (let t = e.startRow; t <= e.endRow; t++)
+      yield y.fromCoords(
         this.worksheet,
-        e,
-        t.startCol,
-        e,
-        t.endCol,
+        t,
+        e.startCol,
+        t,
+        e.endCol,
         this.name,
         this._file
       );
@@ -1503,14 +1525,14 @@ class k {
    * Iterate over all columns with data.
    */
   *cols() {
-    const t = this.dimensions();
-    for (let e = t.startCol; e <= t.endCol; e++)
-      yield m.fromCoords(
+    const e = this.dimensions();
+    for (let t = e.startCol; t <= e.endCol; t++)
+      yield y.fromCoords(
         this.worksheet,
-        t.startRow,
-        e,
-        t.endRow,
-        e,
+        e.startRow,
+        t,
+        e.endRow,
+        t,
         this.name,
         this._file
       );
@@ -1521,15 +1543,15 @@ class k {
   /**
    * Create a cursor starting at the specified address.
    */
-  cursor(t) {
-    const e = t ?? "A1";
-    return d.create(this, e);
+  cursor(e) {
+    const t = e ?? "A1";
+    return $.create(this, t);
   }
   /**
    * Create a cursor starting at the specified coordinates (1-based).
    */
-  cursorAt(t, e) {
-    return d.createAt(this, t, e);
+  cursorAt(e, t) {
+    return $.createAt(this, e, t);
   }
   // ---------------------------------------------------------------------------
   // QUERY METHODS
@@ -1537,37 +1559,37 @@ class k {
   /**
    * Find the first cell matching the predicate.
    */
-  find(t) {
-    const e = this.usedRange();
-    return e.ok ? e.value.find(t) : e;
+  find(e) {
+    const t = this.usedRange();
+    return t.ok ? t.value.find(e) : t;
   }
   /**
    * Find all cells matching the predicate.
    */
-  findAll(t) {
-    const e = this.usedRange();
-    return e.ok ? e.value.findAll(t) : [];
+  findAll(e) {
+    const t = this.usedRange();
+    return t.ok ? t.value.findAll(e) : [];
   }
   /**
    * Find the first cell with the specified value.
    */
-  findValue(t) {
-    const e = this.usedRange();
-    return e.ok ? e.value.findValue(t) : e;
+  findValue(e) {
+    const t = this.usedRange();
+    return t.ok ? t.value.findValue(e) : t;
   }
   /**
    * Find cells within a specific range matching the predicate.
    */
-  findInRange(t, e) {
-    const r = this.range(t);
-    return r.ok ? r.value.find(e) : r;
+  findInRange(e, t) {
+    const n = this.range(e);
+    return n.ok ? n.value.find(t) : n;
   }
   /**
    * Find all cells within a specific range matching the predicate.
    */
-  findAllInRange(t, e) {
-    const r = this.range(t);
-    return r.ok ? r.value.findAll(e) : [];
+  findAllInRange(e, t) {
+    const n = this.range(e);
+    return n.ok ? n.value.findAll(t) : [];
   }
   // ---------------------------------------------------------------------------
   // DIMENSIONS
@@ -1576,24 +1598,24 @@ class k {
    * Get the dimensions of the used area.
    */
   dimensions() {
-    const t = this.worksheet.rowCount, e = this.worksheet.columnCount;
-    let r = 1, n = t, o = 1, i = e;
+    const e = this.worksheet.rowCount, t = this.worksheet.columnCount;
+    let n = 1, s = e, l = 1, u = t;
     if (this.worksheet.dimensions) {
-      const a = this.worksheet.dimensions;
-      if (typeof a == "string")
+      const o = this.worksheet.dimensions;
+      if (typeof o == "string")
         try {
-          const u = y(a);
-          r = u.start.row, o = u.start.col, n = u.end.row, i = u.end.col;
+          const a = H(o);
+          n = a.start.row, l = a.start.col, s = a.end.row, u = a.end.col;
         } catch {
         }
     }
     return {
-      startRow: r,
-      endRow: n,
-      startCol: o,
-      endCol: i,
-      rowCount: n - r + 1,
-      colCount: i - o + 1
+      startRow: n,
+      endRow: s,
+      startCol: l,
+      endCol: u,
+      rowCount: s - n + 1,
+      colCount: u - l + 1
     };
   }
   /**
@@ -1615,15 +1637,15 @@ class k {
    * Get all merged cell ranges.
    */
   mergedRanges() {
-    const t = this.worksheet._merges;
-    return t ? Object.keys(t) : [];
+    const e = this.worksheet._merges;
+    return e ? Object.keys(e) : [];
   }
   /**
    * Check if a cell is part of a merged range.
    */
-  isMerged(t) {
-    const e = this.cell(t);
-    return e.ok ? e.value.isMerged() : !1;
+  isMerged(e) {
+    const t = this.cell(e);
+    return t.ok ? t.value.isMerged() : !1;
   }
   // ---------------------------------------------------------------------------
   // INTERNAL HELPERS
@@ -1639,23 +1661,26 @@ class k {
    * Get a cell by coordinates for internal use.
    * @internal
    */
-  getCellInternal(t, e) {
-    if (t < 1 || e < 1) return;
-    const r = this.worksheet.getCell(t, e);
-    return w.fromExcelJS(r, this.name, this._file);
+  getCellInternal(e, t) {
+    if (e < 1 || t < 1) return;
+    const n = this.worksheet.getCell(e, t);
+    return W.fromExcelJS(n, this.name, this._file);
   }
 }
-class v {
-  constructor(t, e) {
-    this.workbook = t, this._path = e, this.sheetsCache = /* @__PURE__ */ new Map();
+class z {
+  constructor(e, t) {
+    this.workbook = e, this._path = t, this.sheetsCache = /* @__PURE__ */ new Map();
+  }
+  get [N]() {
+    return `XlsxWorkbook(${this.sheetCount()} sheets)`;
   }
   /**
    * Creates an XlsxWorkbook from an ExcelJS workbook.
    * @internal
    */
-  static fromExcelJS(t, e) {
-    const r = { file: e };
-    return new v(t, r);
+  static fromExcelJS(e, t) {
+    const n = { file: t };
+    return new z(e, n);
   }
   // ---------------------------------------------------------------------------
   // IDENTITY
@@ -1678,66 +1703,58 @@ class v {
   /**
    * Get a sheet by name.
    */
-  sheet(t) {
-    const e = this.sheetsCache.get(t);
-    if (e)
-      return l(e, { ...this._path, sheet: t });
-    const r = this.workbook.getWorksheet(t);
-    if (!r)
-      return h(
-        "missing",
-        `Sheet "${t}" not found`,
-        this._path
-      );
-    const n = k.fromExcelJS(r, this._path.file);
-    return this.sheetsCache.set(t, n), l(n, n.path);
+  sheet(e) {
+    const t = this.sheetsCache.get(e);
+    if (t)
+      return f(t, { ...this._path, sheet: e });
+    const n = this.workbook.getWorksheet(e);
+    if (!n)
+      return w("missing", `Sheet "${e}" not found`, this._path);
+    const s = O.fromExcelJS(n, this._path.file);
+    return this.sheetsCache.set(e, s), f(s, s.path);
   }
   /**
    * Get a sheet by index (1-based, as per Excel convention).
    */
-  sheetAt(t) {
-    if (t < 1)
-      return h(
+  sheetAt(e) {
+    if (e < 1)
+      return w(
         "bounds",
-        `Sheet index must be >= 1, got ${t}`,
-        this._path
-      );
-    const e = this.workbook.getWorksheet(t);
-    if (!e)
-      return h(
-        "missing",
-        `Sheet at index ${t} not found`,
+        `Sheet index must be >= 1, got ${e}`,
         this._path
       );
-    const r = this.sheetsCache.get(e.name);
-    if (r)
-      return l(r, r.path);
-    const n = k.fromExcelJS(e, this._path.file);
-    return this.sheetsCache.set(e.name, n), l(n, n.path);
+    const t = this.workbook.getWorksheet(e);
+    if (!t)
+      return w("missing", `Sheet at index ${e} not found`, this._path);
+    const n = this.sheetsCache.get(t.name);
+    if (n)
+      return f(n, n.path);
+    const s = O.fromExcelJS(t, this._path.file);
+    return this.sheetsCache.set(t.name, s), f(s, s.path);
   }
   /**
    * Get all sheets.
    */
   sheets() {
-    const t = [];
-    return this.workbook.eachSheet((e) => {
-      const r = this.sheetsCache.get(e.name);
-      if (r)
-        t.push(r);
+    const e = [];
+    return this.workbook.eachSheet((t) => {
+      const n = this.sheetsCache.get(t.name);
+      if (n)
+        e.push(n);
       else {
-        const n = k.fromExcelJS(e, this._path.file);
-        this.sheetsCache.set(e.name, n), t.push(n);
+        const s = O.fromExcelJS(t, this._path.file);
+        this.sheetsCache.set(t.name, s), e.push(s);
       }
-    }), t;
+    }), e;
   }
   /**
    * Get all sheet names.
    */
   sheetNames() {
-    const t = [];
-    return this.workbook.eachSheet((e) => {
-      t.push(e.name);
-    }), t;
+    const e = [];
+    return this.workbook.eachSheet((t) => {
+      e.push(t.name);
+    }), e;
   }
   /**
    * Get the number of sheets.
@@ -1755,8 +1772,8 @@ class v {
    * Get the last sheet.
    */
   lastSheet() {
-    const t = this.sheetCount();
-    return t === 0 ? h("missing", "Workbook has no sheets", this._path) : this.sheetAt(t);
+    const e = this.sheetCount();
+    return e === 0 ? w("missing", "Workbook has no sheets", this._path) : this.sheetAt(e);
   }
   // ---------------------------------------------------------------------------
   // PREDICATES
@@ -1764,39 +1781,35 @@ class v {
   /**
    * Check if a sheet with the given name exists.
    */
-  hasSheet(t) {
-    return this.workbook.getWorksheet(t) !== void 0;
+  hasSheet(e) {
+    return this.workbook.getWorksheet(e) !== void 0;
   }
   /**
    * Find the first sheet matching the predicate.
    */
-  findSheet(t) {
-    for (const e of this.sheets())
-      if (t(e))
-        return l(e, e.path);
-    return h(
-      "missing",
-      "No sheet matching predicate found",
-      this._path
-    );
+  findSheet(e) {
+    for (const t of this.sheets())
+      if (e(t))
+        return f(t, t.path);
+    return w("missing", "No sheet matching predicate found", this._path);
   }
   /**
    * Find all sheets matching the predicate.
    */
-  filterSheets(t) {
-    return this.sheets().filter(t);
+  filterSheets(e) {
+    return this.sheets().filter(e);
   }
   /**
    * Find a sheet by name pattern (regex).
    */
-  findSheetByPattern(t) {
-    return this.findSheet((e) => t.test(e.name));
+  findSheetByPattern(e) {
+    return this.findSheet((t) => e.test(t.name));
   }
   /**
    * Find all sheets by name pattern (regex).
    */
-  filterSheetsByPattern(t) {
-    return this.filterSheets((e) => t.test(e.name));
+  filterSheetsByPattern(e) {
+    return this.filterSheets((t) => e.test(t.name));
   }
   // ---------------------------------------------------------------------------
   // WORKBOOK PROPERTIES
@@ -1848,20 +1861,20 @@ class v {
    * Iterate over all sheets.
    */
   *[Symbol.iterator]() {
-    for (const t of this.sheets())
-      yield t;
+    for (const e of this.sheets())
+      yield e;
   }
   /**
    * Execute a function for each sheet.
    */
-  forEach(t) {
-    this.sheets().forEach(t);
+  forEach(e) {
+    this.sheets().forEach(e);
   }
   /**
    * Map over all sheets.
    */
-  map(t) {
-    return this.sheets().map(t);
+  map(e) {
+    return this.sheets().map(e);
   }
   // ---------------------------------------------------------------------------
   // INTERNAL
@@ -1874,44 +1887,44 @@ class v {
     return this.workbook;
   }
 }
-const q = {
+const Oe = {
   // ---------------------------------------------------------------------------
   // VALUE PREDICATES
   // ---------------------------------------------------------------------------
   /**
    * Match cells with the exact value.
    */
-  equals: (s) => (t) => {
-    const e = t.value();
-    return e.ok ? s === null ? e.value === null : e.value === null ? !1 : s instanceof Date && e.value instanceof Date ? s.getTime() === e.value.getTime() : e.value === s : !1;
+  equals: (r) => (e) => {
+    const t = e.value();
+    return t.ok ? r === null ? t.value === null : t.value === null ? !1 : r instanceof Date && t.value instanceof Date ? r.getTime() === t.value.getTime() : t.value === r : !1;
   },
   /**
    * Match cells containing the specified text (case-insensitive by default).
    */
-  contains: (s, t = !1) => (e) => {
-    const r = e.string();
-    return r.ok ? t ? r.value.includes(s) : r.value.toLowerCase().includes(s.toLowerCase()) : !1;
+  contains: (r, e = !1) => (t) => {
+    const n = t.string();
+    return n.ok ? e ? n.value.includes(r) : n.value.toLowerCase().includes(r.toLowerCase()) : !1;
   },
   /**
    * Match cells whose value matches the regex pattern.
    */
-  matches: (s) => (t) => {
-    const e = t.string();
-    return e.ok ? s.test(e.value) : !1;
+  matches: (r) => (e) => {
+    const t = e.string();
+    return t.ok ? r.test(t.value) : !1;
   },
   /**
    * Match cells whose string value starts with the prefix.
    */
-  startsWith: (s, t = !1) => (e) => {
-    const r = e.string();
-    return r.ok ? t ? r.value.startsWith(s) : r.value.toLowerCase().startsWith(s.toLowerCase()) : !1;
+  startsWith: (r, e = !1) => (t) => {
+    const n = t.string();
+    return n.ok ? e ? n.value.startsWith(r) : n.value.toLowerCase().startsWith(r.toLowerCase()) : !1;
   },
   /**
    * Match cells whose string value ends with the suffix.
    */
-  endsWith: (s, t = !1) => (e) => {
-    const r = e.string();
-    return r.ok ? t ? r.value.endsWith(s) : r.value.toLowerCase().endsWith(s.toLowerCase()) : !1;
+  endsWith: (r, e = !1) => (t) => {
+    const n = t.string();
+    return n.ok ? e ? n.value.endsWith(r) : n.value.toLowerCase().endsWith(r.toLowerCase()) : !1;
   },
   // ---------------------------------------------------------------------------
   // TYPE PREDICATES
@@ -1919,76 +1932,76 @@ const q = {
   /**
    * Match cells containing a string value.
    */
-  isString: () => (s) => s.isString(),
+  isString: () => (r) => r.isString(),
   /**
    * Match cells containing a numeric value.
    */
-  isNumber: () => (s) => s.isNumber(),
+  isNumber: () => (r) => r.isNumber(),
   /**
    * Match cells containing a boolean value.
    */
-  isBoolean: () => (s) => s.isBoolean(),
+  isBoolean: () => (r) => r.isBoolean(),
   /**
    * Match cells containing a date value.
    */
-  isDate: () => (s) => s.isDate(),
+  isDate: () => (r) => r.isDate(),
   /**
    * Match empty cells.
    */
-  isEmpty: () => (s) => s.isEmpty(),
+  isEmpty: () => (r) => r.isEmpty(),
   /**
    * Match non-empty cells.
    */
-  isNotEmpty: () => (s) => !s.isEmpty(),
+  isNotEmpty: () => (r) => !r.isEmpty(),
   /**
    * Match cells containing a formula.
    */
-  isFormula: () => (s) => s.isFormula(),
+  isFormula: () => (r) => r.isFormula(),
   /**
    * Match cells containing an error.
    */
-  isError: () => (s) => s.isError(),
+  isError: () => (r) => r.isError(),
   /**
    * Match merged cells.
    */
-  isMerged: () => (s) => s.isMerged(),
+  isMerged: () => (r) => r.isMerged(),
   // ---------------------------------------------------------------------------
   // NUMERIC PREDICATES
   // ---------------------------------------------------------------------------
   /**
    * Match cells with numeric value greater than n.
    */
-  greaterThan: (s) => (t) => {
-    const e = t.number();
-    return e.ok && e.value > s;
+  greaterThan: (r) => (e) => {
+    const t = e.number();
+    return t.ok && t.value > r;
   },
   /**
    * Match cells with numeric value greater than or equal to n.
    */
-  greaterThanOrEqual: (s) => (t) => {
-    const e = t.number();
-    return e.ok && e.value >= s;
+  greaterThanOrEqual: (r) => (e) => {
+    const t = e.number();
+    return t.ok && t.value >= r;
   },
   /**
    * Match cells with numeric value less than n.
    */
-  lessThan: (s) => (t) => {
-    const e = t.number();
-    return e.ok && e.value < s;
+  lessThan: (r) => (e) => {
+    const t = e.number();
+    return t.ok && t.value < r;
   },
   /**
    * Match cells with numeric value less than or equal to n.
    */
-  lessThanOrEqual: (s) => (t) => {
-    const e = t.number();
-    return e.ok && e.value <= s;
+  lessThanOrEqual: (r) => (e) => {
+    const t = e.number();
+    return t.ok && t.value <= r;
   },
   /**
    * Match cells with numeric value between min and max (inclusive).
    */
-  between: (s, t) => (e) => {
-    const r = e.number();
-    return r.ok && r.value >= s && r.value <= t;
+  between: (r, e) => (t) => {
+    const n = t.number();
+    return n.ok && n.value >= r && n.value <= e;
   },
   // ---------------------------------------------------------------------------
   // DATE PREDICATES
@@ -1996,25 +2009,25 @@ const q = {
   /**
    * Match cells with date before the specified date.
    */
-  dateBefore: (s) => (t) => {
-    const e = t.date();
-    return e.ok && e.value.getTime() < s.getTime();
+  dateBefore: (r) => (e) => {
+    const t = e.date();
+    return t.ok && t.value.getTime() < r.getTime();
   },
   /**
    * Match cells with date after the specified date.
    */
-  dateAfter: (s) => (t) => {
-    const e = t.date();
-    return e.ok && e.value.getTime() > s.getTime();
+  dateAfter: (r) => (e) => {
+    const t = e.date();
+    return t.ok && t.value.getTime() > r.getTime();
   },
   /**
    * Match cells with date between start and end (inclusive).
    */
-  dateBetween: (s, t) => (e) => {
-    const r = e.date();
-    if (!r.ok) return !1;
-    const n = r.value.getTime();
-    return n >= s.getTime() && n <= t.getTime();
+  dateBetween: (r, e) => (t) => {
+    const n = t.date();
+    if (!n.ok) return !1;
+    const s = n.value.getTime();
+    return s >= r.getTime() && s <= e.getTime();
   },
   // ---------------------------------------------------------------------------
   // LOCATION PREDICATES
@@ -2022,49 +2035,49 @@ const q = {
   /**
    * Match cells in the specified row.
    */
-  inRow: (s) => (t) => t.row === s,
+  inRow: (r) => (e) => e.row === r,
   /**
    * Match cells in the specified column.
    */
-  inCol: (s) => (t) => t.col === s,
+  inCol: (r) => (e) => e.col === r,
   /**
    * Match cells in the specified column (by letter).
    */
-  inColLetter: (s) => (t) => t.colLetter.toUpperCase() === s.toUpperCase(),
+  inColLetter: (r) => (e) => e.colLetter.toUpperCase() === r.toUpperCase(),
   // ---------------------------------------------------------------------------
   // COMPOSITION
   // ---------------------------------------------------------------------------
   /**
    * Match cells that satisfy all predicates.
    */
-  and: (...s) => (t) => s.every((e) => e(t)),
+  and: (...r) => (e) => r.every((t) => t(e)),
   /**
    * Match cells that satisfy at least one predicate.
    */
-  or: (...s) => (t) => s.some((e) => e(t)),
+  or: (...r) => (e) => r.some((t) => t(e)),
   /**
    * Match cells that do not satisfy the predicate.
    */
-  not: (s) => (t) => !s(t),
+  not: (r) => (e) => !r(e),
   // ---------------------------------------------------------------------------
   // STYLE PREDICATES
   // ---------------------------------------------------------------------------
   /**
    * Match cells with bold font.
    */
-  isBold: () => (s) => s.style().font?.bold === !0,
+  isBold: () => (r) => r.style().font?.bold === !0,
   /**
    * Match cells with italic font.
    */
-  isItalic: () => (s) => s.style().font?.italic === !0,
+  isItalic: () => (r) => r.style().font?.italic === !0,
   /**
    * Match cells with a hyperlink.
    */
-  hasHyperlink: () => (s) => s.hyperlink().ok,
+  hasHyperlink: () => (r) => r.hyperlink().ok,
   /**
    * Match cells with a comment.
    */
-  hasComment: () => (s) => s.comment().ok,
+  hasComment: () => (r) => r.comment().ok,
   // ---------------------------------------------------------------------------
   // UTILITY
   // ---------------------------------------------------------------------------
@@ -2079,179 +2092,1659 @@ const q = {
   /**
    * Create a custom predicate from a function.
    */
-  custom: (s) => s
+  custom: (r) => r
 };
-function H(s) {
+function x(r, e) {
+  return { kind: "extract", format: "xlsx", steps: r, extract: e };
+}
+class g {
+  /** @internal */
+  constructor(e) {
+    this.steps = e;
+  }
+  /** @internal Expose steps for colWhere/rowWhere headerRef */
+  get _steps() {
+    return this.steps;
+  }
+  // ---------------------------------------------------------------------------
+  // Terminal extraction
+  // ---------------------------------------------------------------------------
+  /** Extract cell value as string */
+  string() {
+    return x(this.steps, "string");
+  }
+  /** Extract cell value as number */
+  number() {
+    return x(this.steps, "number");
+  }
+  /** Extract cell value as boolean */
+  boolean() {
+    return x(this.steps, "boolean");
+  }
+  /** Extract cell value as Date */
+  date() {
+    return x(this.steps, "date");
+  }
+  /** Extract raw cell value */
+  value() {
+    return x(this.steps, "value");
+  }
+  /** Extract cell formula */
+  formula() {
+    return x(this.steps, "formula");
+  }
+  // ---------------------------------------------------------------------------
+  // Relative movement (cell → cell)
+  // ---------------------------------------------------------------------------
+  /** Move right by count cells (default 1) */
+  right(e = 1) {
+    return new g([...this.steps, { kind: "right", count: e }]);
+  }
+  /** Move left by count cells (default 1) */
+  left(e = 1) {
+    return new g([...this.steps, { kind: "left", count: e }]);
+  }
+  /** Move up by count cells (default 1) */
+  up(e = 1) {
+    return new g([...this.steps, { kind: "up", count: e }]);
+  }
+  /** Move down by count cells (default 1) */
+  down(e = 1) {
+    return new g([...this.steps, { kind: "down", count: e }]);
+  }
+  /** Move by row and column deltas */
+  offset(e, t) {
+    return new g([
+      ...this.steps,
+      { kind: "offset", rowDelta: e, colDelta: t }
+    ]);
+  }
+  /** Scan in direction until predicate matches */
+  scanTo(e, t) {
+    return new g([
+      ...this.steps,
+      { kind: "scanTo", direction: e, predicate: t._spec }
+    ]);
+  }
+  /** Skip cells in direction while predicate matches, land on first non-matching */
+  skipWhile(e, t) {
+    return new g([
+      ...this.steps,
+      { kind: "skipWhile", direction: e, predicate: t._spec }
+    ]);
+  }
+  // ---------------------------------------------------------------------------
+  // Collection (cell → array via collect)
+  // ---------------------------------------------------------------------------
+  /**
+   * Iterate over cells from this position in a direction while the predicate matches.
+   * Returns an ArraySpec whose items are produced by the itemMapper.
+   */
+  eachCell(e, t, n) {
+    const s = n(new g([])), l = {
+      kind: "eachCell",
+      direction: e,
+      while: t._spec
+    };
+    return {
+      kind: "array",
+      source: x(this.steps, l),
+      items: s
+    };
+  }
+  /**
+   * Iterate over slices (rows or columns) from this cell position.
+   * Each slice is passed as an XlsxSliceSB to the mapper, providing
+   * header-relative column/row access via colWhere/rowWhere.
+   */
+  eachSlice(e, t, n) {
+    const s = n(new pe([])), l = {
+      kind: "eachSlice",
+      direction: e,
+      while: t._spec
+    };
+    return {
+      kind: "array",
+      source: x(this.steps, l),
+      items: s
+    };
+  }
+}
+class pe {
+  /** @internal */
+  constructor(e) {
+    this.steps = e;
+  }
+  /** Access a column by matching its header cell against a predicate (header-relative) */
+  colWhere(e, t) {
+    const n = x(e._steps, "value");
+    return new g([
+      ...this.steps,
+      { kind: "colWhere", headerRef: n, predicate: t._spec }
+    ]);
+  }
+  /** Access a row by matching its header cell against a predicate (header-relative, for rotated tables) */
+  rowWhere(e, t) {
+    const n = x(e._steps, "value");
+    return new g([
+      ...this.steps,
+      { kind: "rowWhere", headerRef: n, predicate: t._spec }
+    ]);
+  }
+  /** Access a column by 0-based offset from the anchor */
+  col(e) {
+    return new g([
+      ...this.steps,
+      { kind: "offset", rowDelta: 0, colDelta: e }
+    ]);
+  }
+  /** Access a row by 0-based offset from the anchor (for rotated tables) */
+  row(e) {
+    return new g([
+      ...this.steps,
+      { kind: "offset", rowDelta: e, colDelta: 0 }
+    ]);
+  }
+}
+class ve {
+  /** @internal */
+  constructor(e) {
+    this.steps = e;
+  }
+  /** Access a column by 1-based index within the row */
+  col(e) {
+    return new g([...this.steps, { kind: "col", index: e }]);
+  }
+  /** Navigate to a cell by address within the row */
+  cell(e) {
+    return new g([...this.steps, { kind: "cell", ref: e }]);
+  }
+}
+class te {
+  /** @internal */
+  constructor(e) {
+    this.steps = e;
+  }
+  /** Navigate to a cell by address within the range */
+  cell(e) {
+    return new g([...this.steps, { kind: "cell", ref: e }]);
+  }
+  /** Navigate to a cell by coordinates within the range */
+  cellAt(e, t) {
+    return new g([...this.steps, { kind: "cellAt", row: e, col: t }]);
+  }
+  /**
+   * Iterate over rows in the range.
+   * Each row is provided as an XlsxRowItemSB to the mapper.
+   * Returns an ArraySpec.
+   */
+  rows(e) {
+    const t = e(new ve([]));
+    return {
+      kind: "array",
+      source: x(this.steps, "rows"),
+      items: t
+    };
+  }
+  /**
+   * Iterate over all cells in the range as a flat list.
+   * Each cell is provided as an XlsxCellSB to the mapper.
+   * Returns an ArraySpec.
+   */
+  cells(e) {
+    const t = e(new g([]));
+    return {
+      kind: "array",
+      source: x(this.steps, "cells"),
+      items: t
+    };
+  }
+}
+class be {
+  /** @internal */
+  constructor(e) {
+    this.steps = e;
+  }
+  /** Navigate to a cell by address within this row */
+  cell(e) {
+    return new g([...this.steps, { kind: "cell", ref: e }]);
+  }
+  /** Navigate to a cell by column within this row */
+  cellAt(e, t) {
+    return new g([...this.steps, { kind: "cellAt", row: e, col: t }]);
+  }
+}
+class _e {
+  /** @internal */
+  constructor(e) {
+    this.steps = e;
+  }
+  /** Navigate to a cell by address within this column */
+  cell(e) {
+    return new g([...this.steps, { kind: "cell", ref: e }]);
+  }
+  /** Navigate to a cell by coordinates within this column */
+  cellAt(e, t) {
+    return new g([...this.steps, { kind: "cellAt", row: e, col: t }]);
+  }
+}
+class U {
+  /** @internal */
+  constructor(e) {
+    this.steps = e;
+  }
+  // ---------------------------------------------------------------------------
+  // Direct cell navigation
+  // ---------------------------------------------------------------------------
+  /** Navigate to a cell by address (e.g., "A1", "B2") */
+  cell(e) {
+    return new g([...this.steps, { kind: "cell", ref: e }]);
+  }
+  /** Navigate to a cell by 1-based row and column coordinates */
+  cellAt(e, t) {
+    return new g([...this.steps, { kind: "cellAt", row: e, col: t }]);
+  }
+  // ---------------------------------------------------------------------------
+  // Cell search (sheet → cell)
+  // ---------------------------------------------------------------------------
+  /** Find the first cell matching the predicate */
+  find(e) {
+    return new g([
+      ...this.steps,
+      { kind: "find", predicate: e._spec }
+    ]);
+  }
+  /** Find the first cell matching the predicate in the specified row */
+  findInRow(e, t) {
+    return new g([
+      ...this.steps,
+      { kind: "findInRow", rowIndex: e, predicate: t._spec }
+    ]);
+  }
+  /** Find the first cell matching the predicate in the specified column */
+  findInCol(e, t) {
+    return new g([
+      ...this.steps,
+      { kind: "findInCol", colIndex: e, predicate: t._spec }
+    ]);
+  }
+  /** Find the first cell matching the predicate in the specified range */
+  findInRange(e, t) {
+    return new g([
+      ...this.steps,
+      { kind: "findInRange", rangeRef: e, predicate: t._spec }
+    ]);
+  }
+  range(e, t) {
+    if (t === void 0)
+      return new te([
+        ...this.steps,
+        { kind: "range", ref: e }
+      ]);
+    if (typeof e == "string" && typeof t == "string")
+      return new te([
+        ...this.steps,
+        { kind: "range", ref: `${e}:${t}` }
+      ]);
+    const n = x(e._steps, "value"), s = x(t._steps, "value");
+    return new te([
+      ...this.steps,
+      { kind: "rangeFromCells", from: n, to: s }
+    ]);
+  }
+  /** Navigate to a row by 1-based index */
+  row(e) {
+    return new be([...this.steps, { kind: "row", index: e }]);
+  }
+  /** Navigate to a column by 1-based index */
+  col(e) {
+    return new _e([...this.steps, { kind: "col", index: e }]);
+  }
+}
+class se {
+  constructor(e) {
+    this.steps = e;
+  }
+  /** Create a root spec builder */
+  static root() {
+    return new se([]);
+  }
+  /** Navigate to a sheet by name */
+  sheet(e) {
+    return new U([...this.steps, { kind: "sheet", name: e }]);
+  }
+  /** Navigate to a sheet by 1-based index */
+  sheetAt(e) {
+    return new U([...this.steps, { kind: "sheetAt", index: e }]);
+  }
+  /** Navigate to the first sheet */
+  firstSheet() {
+    return new U([...this.steps, { kind: "firstSheet" }]);
+  }
+  /** Find a sheet matching the predicate */
+  findSheet(e) {
+    return new U([
+      ...this.steps,
+      { kind: "findSheet", predicate: e._spec }
+    ]);
+  }
+}
+function ze(r) {
   return {
     kind: "transform",
     namespace: "@origints/xlsx",
     name: "parseXlsx",
-    args: s
+    args: r,
+    specBuilderFactory: () => se.root()
   };
 }
-const P = {
+const Pe = {
   namespace: "@origints/xlsx",
   name: "parseXlsx",
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  execute(s, t) {
+  execute(r, e) {
     throw new Error(
       "parseXlsx requires async execution. Use parseXlsxAsyncImpl instead."
     );
   }
 };
-function C(s) {
-  return new Uint8Array(s).buffer;
+function X(r) {
+  return new Uint8Array(r).buffer;
 }
-const I = {
+const Ce = {
   namespace: "@origints/xlsx",
   name: "parseXlsx",
-  async execute(s, t) {
-    const e = t ?? {};
-    let r;
-    if (s instanceof ReadableStream) {
-      const o = await M(s);
-      r = C(o);
-    } else if (Buffer.isBuffer(s))
-      r = C(s);
-    else if (s instanceof ArrayBuffer)
-      r = s;
-    else if (s instanceof Uint8Array)
-      r = C(s);
+  async execute(r, e) {
+    const t = e ?? {};
+    let n;
+    if (r instanceof ReadableStream) {
+      const l = await ge(r);
+      n = X(l);
+    } else if (Buffer.isBuffer(r))
+      n = X(r);
+    else if (r instanceof ArrayBuffer)
+      n = r;
+    else if (r instanceof Uint8Array)
+      n = X(r);
     else
       throw new Error(
-        `parseXlsx expects stream or buffer input, got ${typeof s}`
+        `parseXlsx expects stream or buffer input, got ${typeof r}`
       );
-    const n = new $.Workbook();
-    return await n.xlsx.load(r), v.fromExcelJS(n, e.fileName);
+    const s = new re.Workbook();
+    return await s.xlsx.load(n), z.fromExcelJS(s, t.fileName);
   }
 };
-async function Z(s, t) {
-  const e = new $.Workbook();
-  let r;
-  return s instanceof ArrayBuffer ? r = s : r = C(s), await e.xlsx.load(r), v.fromExcelJS(e, t?.fileName);
+async function Ue(r, e) {
+  const t = new re.Workbook();
+  let n;
+  return r instanceof ArrayBuffer ? n = r : n = X(r), await t.xlsx.load(n), z.fromExcelJS(t, e?.fileName);
 }
-async function G(s, t) {
-  const e = new $.Workbook();
-  return await e.xlsx.readFile(s), v.fromExcelJS(e, t?.fileName ?? s);
+async function He(r, e) {
+  const t = new re.Workbook();
+  return await t.xlsx.readFile(r), z.fromExcelJS(t, e?.fileName ?? r);
 }
-function D(s, t) {
-  return s == null ? null : s instanceof Date ? t?.dateAsIsoString !== !1 ? s.toISOString() : s.getTime() : typeof s == "string" || typeof s == "number" || typeof s == "boolean" ? s : null;
+function E(r) {
+  switch (r.kind) {
+    // Value predicates
+    case "equals":
+      return (e) => {
+        const t = e.value();
+        return t.ok ? r.value === null ? t.value === null : t.value === null ? !1 : r.value instanceof Date && t.value instanceof Date ? r.value.getTime() === t.value.getTime() : t.value === r.value : !1;
+      };
+    case "contains":
+      return (e) => {
+        const t = e.string();
+        return t.ok ? r.caseSensitive ? t.value.includes(r.text) : t.value.toLowerCase().includes(r.text.toLowerCase()) : !1;
+      };
+    case "matches":
+      return (e) => {
+        const t = e.string();
+        return t.ok ? new RegExp(r.pattern, r.flags).test(t.value) : !1;
+      };
+    case "startsWith":
+      return (e) => {
+        const t = e.string();
+        return t.ok ? r.caseSensitive ? t.value.startsWith(r.prefix) : t.value.toLowerCase().startsWith(r.prefix.toLowerCase()) : !1;
+      };
+    case "endsWith":
+      return (e) => {
+        const t = e.string();
+        return t.ok ? r.caseSensitive ? t.value.endsWith(r.suffix) : t.value.toLowerCase().endsWith(r.suffix.toLowerCase()) : !1;
+      };
+    // Type predicates
+    case "isString":
+      return (e) => e.isString();
+    case "isNumber":
+      return (e) => e.isNumber();
+    case "isBoolean":
+      return (e) => e.isBoolean();
+    case "isDate":
+      return (e) => e.isDate();
+    case "isEmpty":
+      return (e) => e.isEmpty();
+    case "isNotEmpty":
+      return (e) => !e.isEmpty();
+    case "isFormula":
+      return (e) => e.isFormula();
+    case "isError":
+      return (e) => e.isError();
+    case "isMerged":
+      return (e) => e.isMerged();
+    // Numeric predicates
+    case "gt":
+      return (e) => {
+        const t = e.number();
+        return t.ok && t.value > r.value;
+      };
+    case "gte":
+      return (e) => {
+        const t = e.number();
+        return t.ok && t.value >= r.value;
+      };
+    case "lt":
+      return (e) => {
+        const t = e.number();
+        return t.ok && t.value < r.value;
+      };
+    case "lte":
+      return (e) => {
+        const t = e.number();
+        return t.ok && t.value <= r.value;
+      };
+    case "between":
+      return (e) => {
+        const t = e.number();
+        return t.ok && t.value >= r.min && t.value <= r.max;
+      };
+    // Style predicates
+    case "isBold":
+      return (e) => e.style().font?.bold === !0;
+    case "isItalic":
+      return (e) => e.style().font?.italic === !0;
+    case "hasHyperlink":
+      return (e) => e.hyperlink().ok;
+    case "hasComment":
+      return (e) => e.comment().ok;
+    // Composition
+    case "and": {
+      const e = E(r.left), t = E(r.right);
+      return (n) => e(n) && t(n);
+    }
+    case "or": {
+      const e = E(r.left), t = E(r.right);
+      return (n) => e(n) || t(n);
+    }
+    case "not": {
+      const e = E(r.operand);
+      return (t) => !e(t);
+    }
+  }
 }
-function J(s, t) {
-  const e = s.value(), r = e.ok ? D(e.value, t) : null;
-  return t?.includeCellAddresses ? {
-    address: s.address,
-    value: r
-  } : r;
+function M(r) {
+  switch (r.kind) {
+    case "nameEquals":
+      return (e) => e.name === r.name;
+    case "nameContains":
+      return (e) => e.name.includes(r.text);
+    case "nameStartsWith":
+      return (e) => e.name.startsWith(r.prefix);
+    case "nameEndsWith":
+      return (e) => e.name.endsWith(r.suffix);
+    case "nameMatches": {
+      const e = new RegExp(r.pattern, r.flags);
+      return (t) => e.test(t.name);
+    }
+    case "and": {
+      const e = M(r.left), t = M(r.right);
+      return (n) => e(n) && t(n);
+    }
+    case "or": {
+      const e = M(r.left), t = M(r.right);
+      return (n) => e(n) || t(n);
+    }
+    case "not": {
+      const e = M(r.operand);
+      return (t) => !e(t);
+    }
+  }
+}
+function F(r) {
+  switch (r.kind) {
+    case "rowCol": {
+      const e = E(r.predicate);
+      return (t, n, s) => {
+        const l = s + r.offset;
+        if (l < 1) return !1;
+        const u = t.cellAt(n, l);
+        return u.ok ? e(u.value) : !1;
+      };
+    }
+    case "and": {
+      const e = F(r.left), t = F(r.right);
+      return (n, s, l) => e(n, s, l) && t(n, s, l);
+    }
+    case "or": {
+      const e = F(r.left), t = F(r.right);
+      return (n, s, l) => e(n, s, l) || t(n, s, l);
+    }
+    case "not": {
+      const e = F(r.operand);
+      return (t, n, s) => !e(t, n, s);
+    }
+  }
 }
-function j(s, t) {
-  return t?.firstRowAsHeaders ? B(s, t) : W(s, t);
+function v(r) {
+  return {
+    _spec: r,
+    and(e) {
+      return v({ kind: "and", left: r, right: e._spec });
+    },
+    or(e) {
+      return v({ kind: "or", left: r, right: e._spec });
+    },
+    not() {
+      return v({ kind: "not", operand: r });
+    },
+    describe() {
+      return C(r);
+    }
+  };
 }
-function W(s, t) {
-  const e = [];
-  for (const r of s.rows()) {
-    const n = [];
-    for (const o of r) {
-      const i = J(o, t);
-      i !== null || t?.includeEmpty ? n.push(i) : (n.length > 0 || t?.includeEmpty) && n.push(null);
+function T(r) {
+  return {
+    _spec: r,
+    and(e) {
+      return T({ kind: "and", left: r, right: e._spec });
+    },
+    or(e) {
+      return T({ kind: "or", left: r, right: e._spec });
+    },
+    not() {
+      return T({ kind: "not", operand: r });
+    },
+    describe() {
+      return I(r);
     }
-    (n.length > 0 || t?.includeEmpty) && e.push(n);
+  };
+}
+function ye(r) {
+  return r === null ? "null" : r instanceof Date ? `Date(${r.toISOString()})` : typeof r == "string" ? `'${r}'` : String(r);
+}
+const Xe = Object.freeze({
+  // Value predicates
+  equals: (r) => v({ kind: "equals", value: r }),
+  contains: (r, e = !1) => v({ kind: "contains", text: r, caseSensitive: e }),
+  matches: (r) => v({
+    kind: "matches",
+    pattern: r.source,
+    flags: r.flags
+  }),
+  startsWith: (r, e = !1) => v({ kind: "startsWith", prefix: r, caseSensitive: e }),
+  endsWith: (r, e = !1) => v({ kind: "endsWith", suffix: r, caseSensitive: e }),
+  // Type predicates
+  isString: () => v({ kind: "isString" }),
+  isNumber: () => v({ kind: "isNumber" }),
+  isBoolean: () => v({ kind: "isBoolean" }),
+  isDate: () => v({ kind: "isDate" }),
+  isEmpty: () => v({ kind: "isEmpty" }),
+  isNotEmpty: () => v({ kind: "isNotEmpty" }),
+  isFormula: () => v({ kind: "isFormula" }),
+  isError: () => v({ kind: "isError" }),
+  isMerged: () => v({ kind: "isMerged" }),
+  // Numeric predicates
+  gt: (r) => v({ kind: "gt", value: r }),
+  gte: (r) => v({ kind: "gte", value: r }),
+  lt: (r) => v({ kind: "lt", value: r }),
+  lte: (r) => v({ kind: "lte", value: r }),
+  between: (r, e) => v({ kind: "between", min: r, max: e }),
+  // Style predicates
+  isBold: () => v({ kind: "isBold" }),
+  isItalic: () => v({ kind: "isItalic" }),
+  hasHyperlink: () => v({ kind: "hasHyperlink" }),
+  hasComment: () => v({ kind: "hasComment" })
+}), Ke = Object.freeze({
+  nameEquals: (r) => T({ kind: "nameEquals", name: r }),
+  nameContains: (r) => T({ kind: "nameContains", text: r }),
+  nameStartsWith: (r) => T({ kind: "nameStartsWith", prefix: r }),
+  nameEndsWith: (r) => T({ kind: "nameEndsWith", suffix: r }),
+  nameMatches: (r) => T({
+    kind: "nameMatches",
+    pattern: r.source,
+    flags: r.flags
+  })
+});
+function C(r) {
+  switch (r.kind) {
+    case "equals":
+      return `equals(${ye(r.value)})`;
+    case "contains":
+      return `contains('${r.text}')`;
+    case "matches":
+      return `matches(/${r.pattern}/${r.flags})`;
+    case "startsWith":
+      return `startsWith('${r.prefix}')`;
+    case "endsWith":
+      return `endsWith('${r.suffix}')`;
+    case "isString":
+      return "isString()";
+    case "isNumber":
+      return "isNumber()";
+    case "isBoolean":
+      return "isBoolean()";
+    case "isDate":
+      return "isDate()";
+    case "isEmpty":
+      return "isEmpty()";
+    case "isNotEmpty":
+      return "isNotEmpty()";
+    case "isFormula":
+      return "isFormula()";
+    case "isError":
+      return "isError()";
+    case "isMerged":
+      return "isMerged()";
+    case "gt":
+      return `gt(${r.value})`;
+    case "gte":
+      return `gte(${r.value})`;
+    case "lt":
+      return `lt(${r.value})`;
+    case "lte":
+      return `lte(${r.value})`;
+    case "between":
+      return `between(${r.min}, ${r.max})`;
+    case "isBold":
+      return "isBold()";
+    case "isItalic":
+      return "isItalic()";
+    case "hasHyperlink":
+      return "hasHyperlink()";
+    case "hasComment":
+      return "hasComment()";
+    case "and":
+      return `${C(r.left)} AND ${C(r.right)}`;
+    case "or":
+      return `${C(r.left)} OR ${C(r.right)}`;
+    case "not":
+      return `NOT(${C(r.operand)})`;
+  }
+}
+function K(r) {
+  return {
+    _spec: r,
+    and(e) {
+      return K({ kind: "and", left: r, right: e._spec });
+    },
+    or(e) {
+      return K({ kind: "or", left: r, right: e._spec });
+    },
+    not() {
+      return K({ kind: "not", operand: r });
+    },
+    describe() {
+      return q(r);
+    }
+  };
+}
+function Ye(r, e) {
+  return K({ kind: "rowCol", offset: r, predicate: e._spec });
+}
+function q(r) {
+  switch (r.kind) {
+    case "rowCol":
+      return `rowCol(${r.offset}, ${C(r.predicate)})`;
+    case "and":
+      return `${q(r.left)} AND ${q(r.right)}`;
+    case "or":
+      return `${q(r.left)} OR ${q(r.right)}`;
+    case "not":
+      return `NOT(${q(r.operand)})`;
+  }
+}
+function I(r) {
+  switch (r.kind) {
+    case "nameEquals":
+      return `nameEquals('${r.name}')`;
+    case "nameContains":
+      return `nameContains('${r.text}')`;
+    case "nameStartsWith":
+      return `nameStartsWith('${r.prefix}')`;
+    case "nameEndsWith":
+      return `nameEndsWith('${r.suffix}')`;
+    case "nameMatches":
+      return `nameMatches(/${r.pattern}/${r.flags})`;
+    case "and":
+      return `${I(r.left)} AND ${I(r.right)}`;
+    case "or":
+      return `${I(r.left)} OR ${I(r.right)}`;
+    case "not":
+      return `NOT(${I(r.operand)})`;
+  }
+}
+const ie = /* @__PURE__ */ new WeakMap(), ae = /* @__PURE__ */ new WeakMap();
+function D(r) {
+  return { ok: !0, value: r, path: [] };
+}
+function S(r) {
+  return { ok: !1, kind: "format", message: r, path: [] };
+}
+function j(r, e) {
+  return { ok: !1, kind: "format", message: r, path: [...e] };
+}
+function _(r, e) {
+  return r.ok ? r.value : S(
+    `XLSX navigation failed at ${e}: ${r.failure.message}`
+  );
+}
+function ce(r) {
+  switch (r.kind) {
+    case "sheet":
+      return `sheet("${r.name}")`;
+    case "sheetAt":
+      return `sheetAt(${r.index})`;
+    case "firstSheet":
+      return "firstSheet()";
+    case "findSheet":
+      return `findSheet(${I(r.predicate)})`;
+    case "cell":
+      return `cell("${r.ref}")`;
+    case "cellAt":
+      return `cellAt(${r.row}, ${r.col})`;
+    case "find":
+      return `find(${C(r.predicate)})`;
+    case "findInRow":
+      return `findInRow(${r.rowIndex}, ${C(r.predicate)})`;
+    case "findInCol":
+      return `findInCol(${r.colIndex}, ${C(r.predicate)})`;
+    case "findInRange":
+      return `findInRange("${r.rangeRef}", ${C(r.predicate)})`;
+    case "right":
+      return `right(${r.count})`;
+    case "left":
+      return `left(${r.count})`;
+    case "up":
+      return `up(${r.count})`;
+    case "down":
+      return `down(${r.count})`;
+    case "offset":
+      return `offset(${r.rowDelta}, ${r.colDelta})`;
+    case "scanTo":
+      return `scanTo(${r.direction}, ${C(r.predicate)})`;
+    case "skipWhile":
+      return `skipWhile(${r.direction}, ${C(r.predicate)})`;
+    case "colWhere":
+      return `colWhere(${C(r.predicate)})`;
+    case "rowWhere":
+      return `rowWhere(${C(r.predicate)})`;
+    case "range":
+      return `range("${r.ref}")`;
+    case "rangeFromCells":
+      return "rangeFromCells()";
+    case "row":
+      return `row(${r.index})`;
+    case "col":
+      return `col(${r.index})`;
+  }
+}
+function m(r) {
+  return typeof r == "object" && r !== null && "ok" in r && !r.ok;
+}
+class $e {
+  constructor(e, t, n) {
+    this.workbook = e, this.sheet = t, this.anchorCell = n;
+  }
+  get [N]() {
+    return "XlsxSliceContext";
   }
-  return e;
 }
-function B(s, t) {
-  const e = [...s.rows()];
-  if (e.length === 0) return [];
-  const n = e[0].map((i) => {
-    const a = i.value();
-    return a.ok && a.value !== null ? String(a.value) : `col_${i.col}`;
-  }), o = [];
-  for (let i = 1; i < e.length; i++) {
-    const a = e[i], u = {};
-    let c = !1;
-    for (let f = 0; f < n.length; f++) {
-      const g = n[f], x = a[f];
-      if (x) {
-        const _ = J(x, t);
-        _ !== null && (c = !0), u[g] = _;
+function Re(r) {
+  if (r == null || typeof r != "object") return null;
+  const e = r[N];
+  if (typeof e == "string") {
+    if (e === "XlsxSliceContext") return "sliceContext";
+    if (e.startsWith("XlsxWorkbook")) return "workbook";
+    if (e.startsWith("XlsxRange")) return "range";
+    if (e.startsWith("XlsxCell")) return "cell";
+  }
+  return r instanceof y ? "range" : r instanceof W ? "cell" : "workbook";
+}
+function oe(r) {
+  switch (r) {
+    case "right":
+      return { rowDelta: 0, colDelta: 1 };
+    case "left":
+      return { rowDelta: 0, colDelta: -1 };
+    case "down":
+      return { rowDelta: 1, colDelta: 0 };
+    case "up":
+      return { rowDelta: -1, colDelta: 0 };
+  }
+}
+function ue(r, e, t, n, s, l) {
+  const u = E(s), { rowDelta: o, colDelta: a } = oe(n), i = r.dimensions(), c = Math.max(i.rowCount, i.colCount) * 2;
+  let h = e + o, d = t + a;
+  for (let b = 0; b < c && !(h < 1 || d < 1 || h > i.endRow + 1 || d > i.endCol + 1); b++) {
+    const p = r.cellAt(h, d);
+    if (!p.ok) break;
+    const R = p.value;
+    if (l === "scanTo") {
+      if (u(R)) return R;
+    } else if (!u(R)) return R;
+    h += o, d += a;
+  }
+  const k = C(s);
+  return S(l === "scanTo" ? `scanTo(${n}): no cell matching ${k} found` : `skipWhile(${n}): predicate ${k} never stopped matching`);
+}
+function xe(r, e, t, n, s) {
+  const l = E(s), { rowDelta: u, colDelta: o } = oe(n), a = r.dimensions(), i = Math.max(a.rowCount, a.colCount) * 2, c = [];
+  let h = e, d = t;
+  for (let k = 0; k < i && !(h < 1 || d < 1 || h > a.endRow + 1 || d > a.endCol + 1); k++) {
+    const b = r.cellAt(h, d);
+    if (!b.ok) break;
+    const p = b.value;
+    if (!l(p)) break;
+    c.push(p), h += u, d += o;
+  }
+  return c;
+}
+function Se(r, e, t, n, s, l) {
+  const u = F(l), { rowDelta: o, colDelta: a } = oe(s), i = e.dimensions(), c = Math.max(i.rowCount, i.colCount) * 2, h = [];
+  let d = t, k = n;
+  for (let b = 0; b < c && !(d < 1 || k < 1 || d > i.endRow + 1 || k > i.endCol + 1 || !u(e, d, k)); b++) {
+    const p = e.cellAt(d, k);
+    if (!p.ok) break;
+    h.push(new $e(r, e, p.value)), d += o, k += a;
+  }
+  return h;
+}
+function L(r, e) {
+  let t = r;
+  const n = [];
+  function s(o, a) {
+    a.level === "cell" ? n.push(`${o}@${a.cell.address}`) : n.push(o);
+  }
+  function l(o, a) {
+    const i = [...n];
+    return a && i.push(ce(a)), j(o, i);
+  }
+  function u(o) {
+    return o.message;
+  }
+  for (const o of e) {
+    const a = ce(o);
+    switch (o.kind) {
+      // ----- Workbook → Sheet -----
+      case "sheet": {
+        const i = _(t.workbook.sheet(o.name), a);
+        if (m(i)) return l(u(i), o);
+        t = {
+          level: "sheet",
+          workbook: t.workbook,
+          sheet: i
+        }, s(a, t);
+        break;
+      }
+      case "sheetAt": {
+        const i = _(t.workbook.sheetAt(o.index), a);
+        if (m(i)) return l(u(i), o);
+        t = {
+          level: "sheet",
+          workbook: t.workbook,
+          sheet: i
+        }, s(a, t);
+        break;
+      }
+      case "firstSheet": {
+        const i = _(t.workbook.firstSheet(), a);
+        if (m(i)) return l(u(i), o);
+        t = {
+          level: "sheet",
+          workbook: t.workbook,
+          sheet: i
+        }, s(a, t);
+        break;
+      }
+      case "findSheet": {
+        const i = M(o.predicate), c = _(t.workbook.findSheet(i), a);
+        if (m(c)) return l(u(c), o);
+        t = {
+          level: "sheet",
+          workbook: t.workbook,
+          sheet: c
+        }, s(a, t);
+        break;
+      }
+      // ----- Sheet → Cell (direct) -----
+      case "cell": {
+        if (t.level === "workbook")
+          return l("cell() called without a sheet navigation step", o);
+        if (t.level === "range") {
+          const h = _(t.range.cell(o.ref), a);
+          if (m(h)) return l(u(h), o);
+          t = {
+            level: "cell",
+            workbook: t.workbook,
+            sheet: t.sheet,
+            cell: h
+          }, s(a, t);
+          break;
+        }
+        const i = t.sheet, c = _(i.cell(o.ref), a);
+        if (m(c)) return l(u(c), o);
+        t = {
+          level: "cell",
+          workbook: t.workbook,
+          sheet: i,
+          cell: c
+        }, s(a, t);
+        break;
+      }
+      case "cellAt": {
+        if (t.level === "workbook")
+          return l(
+            "cellAt() called without a sheet navigation step",
+            o
+          );
+        if (t.level === "range") {
+          const h = _(t.range.cellAt(o.row, o.col), a);
+          if (m(h)) return l(u(h), o);
+          t = {
+            level: "cell",
+            workbook: t.workbook,
+            sheet: t.sheet,
+            cell: h
+          }, s(a, t);
+          break;
+        }
+        const i = t.sheet, c = _(i.cellAt(o.row, o.col), a);
+        if (m(c)) return l(u(c), o);
+        t = {
+          level: "cell",
+          workbook: t.workbook,
+          sheet: i,
+          cell: c
+        }, s(a, t);
+        break;
+      }
+      // ----- Sheet → Cell (search) -----
+      case "find": {
+        if (t.level !== "sheet")
+          return l("find() requires sheet-level navigation state", o);
+        const i = t.sheet, c = E(o.predicate), h = _(i.find(c), a);
+        if (m(h))
+          return l(u(h), o);
+        t = { level: "cell", workbook: t.workbook, sheet: i, cell: h }, s(a, t);
+        break;
+      }
+      case "findInRow": {
+        if (t.level !== "sheet")
+          return l(
+            "findInRow() requires sheet-level navigation state",
+            o
+          );
+        const i = t.sheet, c = E(o.predicate), h = i.dimensions(), d = Math.max(h.endCol, 1);
+        let k = null;
+        for (let b = 1; b <= d; b++) {
+          const p = i.cellAt(o.rowIndex, b);
+          if (p.ok && c(p.value)) {
+            k = p.value;
+            break;
+          }
+        }
+        if (!k)
+          return l(
+            `findInRow(${o.rowIndex}): no cell matching ${C(o.predicate)} found`,
+            o
+          );
+        t = {
+          level: "cell",
+          workbook: t.workbook,
+          sheet: i,
+          cell: k
+        }, s(a, t);
+        break;
+      }
+      case "findInCol": {
+        if (t.level !== "sheet")
+          return l(
+            "findInCol() requires sheet-level navigation state",
+            o
+          );
+        const i = t.sheet, c = E(o.predicate), h = i.dimensions(), d = Math.max(h.endRow, 1);
+        let k = null;
+        for (let b = 1; b <= d; b++) {
+          const p = i.cellAt(b, o.colIndex);
+          if (p.ok && c(p.value)) {
+            k = p.value;
+            break;
+          }
+        }
+        if (!k)
+          return l(
+            `findInCol(${o.colIndex}): no cell matching ${C(o.predicate)} found`,
+            o
+          );
+        t = {
+          level: "cell",
+          workbook: t.workbook,
+          sheet: i,
+          cell: k
+        }, s(a, t);
+        break;
+      }
+      case "findInRange": {
+        if (t.level !== "sheet")
+          return l(
+            "findInRange() requires sheet-level navigation state",
+            o
+          );
+        const i = t.sheet, c = E(o.predicate), h = _(
+          i.findInRange(o.rangeRef, c),
+          a
+        );
+        if (m(h))
+          return l(u(h), o);
+        t = { level: "cell", workbook: t.workbook, sheet: i, cell: h }, s(a, t);
+        break;
+      }
+      // ----- Cell → Cell (relative movement) -----
+      case "right": {
+        if (t.level !== "cell")
+          return l("right() requires cell-level navigation state", o);
+        const i = t.sheet, c = _(
+          i.cellAt(t.cell.row, t.cell.col + o.count),
+          a
+        );
+        if (m(c))
+          return l(u(c), o);
+        t = { level: "cell", workbook: t.workbook, sheet: i, cell: c }, s(a, t);
+        break;
+      }
+      case "left": {
+        if (t.level !== "cell")
+          return l("left() requires cell-level navigation state", o);
+        const i = t.sheet, c = t.cell.col - o.count;
+        if (c < 1)
+          return l(
+            `left(${o.count}) from column ${t.cell.col} goes out of bounds`,
+            o
+          );
+        const h = _(
+          i.cellAt(t.cell.row, c),
+          a
+        );
+        if (m(h))
+          return l(u(h), o);
+        t = { level: "cell", workbook: t.workbook, sheet: i, cell: h }, s(a, t);
+        break;
+      }
+      case "up": {
+        if (t.level !== "cell")
+          return l("up() requires cell-level navigation state", o);
+        const i = t.sheet, c = t.cell.row - o.count;
+        if (c < 1)
+          return l(
+            `up(${o.count}) from row ${t.cell.row} goes out of bounds`,
+            o
+          );
+        const h = _(
+          i.cellAt(c, t.cell.col),
+          a
+        );
+        if (m(h))
+          return l(u(h), o);
+        t = { level: "cell", workbook: t.workbook, sheet: i, cell: h }, s(a, t);
+        break;
+      }
+      case "down": {
+        if (t.level !== "cell")
+          return l("down() requires cell-level navigation state", o);
+        const i = t.sheet, c = _(
+          i.cellAt(t.cell.row + o.count, t.cell.col),
+          a
+        );
+        if (m(c))
+          return l(u(c), o);
+        t = { level: "cell", workbook: t.workbook, sheet: i, cell: c }, s(a, t);
+        break;
+      }
+      case "offset": {
+        if (t.level !== "cell")
+          return l("offset() requires cell-level navigation state", o);
+        const i = t.sheet, c = t.cell.row + o.rowDelta, h = t.cell.col + o.colDelta;
+        if (c < 1 || h < 1)
+          return l(
+            `offset(${o.rowDelta}, ${o.colDelta}) from ${t.cell.address} goes out of bounds`,
+            o
+          );
+        const d = _(
+          i.cellAt(c, h),
+          a
+        );
+        if (m(d))
+          return l(u(d), o);
+        t = { level: "cell", workbook: t.workbook, sheet: i, cell: d }, s(a, t);
+        break;
+      }
+      // ----- Cell → Cell (scan) -----
+      case "scanTo": {
+        if (t.level !== "cell")
+          return l("scanTo() requires cell-level navigation state", o);
+        const i = t.sheet, c = ue(
+          i,
+          t.cell.row,
+          t.cell.col,
+          o.direction,
+          o.predicate,
+          "scanTo"
+        );
+        if (m(c))
+          return l(
+            u(c),
+            o
+          );
+        t = {
+          level: "cell",
+          workbook: t.workbook,
+          sheet: i,
+          cell: c
+        }, s(a, t);
+        break;
+      }
+      case "skipWhile": {
+        if (t.level !== "cell")
+          return l(
+            "skipWhile() requires cell-level navigation state",
+            o
+          );
+        const i = t.sheet, c = ue(
+          i,
+          t.cell.row,
+          t.cell.col,
+          o.direction,
+          o.predicate,
+          "skipWhile"
+        );
+        if (m(c))
+          return l(
+            u(c),
+            o
+          );
+        t = {
+          level: "cell",
+          workbook: t.workbook,
+          sheet: i,
+          cell: c
+        }, s(a, t);
+        break;
+      }
+      // ----- Sheet → Range -----
+      case "range": {
+        if (t.level !== "sheet")
+          return l("range() requires sheet-level navigation state", o);
+        const i = t.sheet, c = _(i.range(o.ref), a);
+        if (m(c)) return l(u(c), o);
+        t = {
+          level: "range",
+          workbook: t.workbook,
+          sheet: i,
+          range: c
+        }, s(a, t);
+        break;
+      }
+      case "rangeFromCells": {
+        if (t.level !== "sheet")
+          return l(
+            "rangeFromCells requires sheet-level navigation state",
+            o
+          );
+        const i = t.sheet, c = L(
+          { level: "workbook", workbook: t.workbook },
+          o.from.steps
+        );
+        if (m(c))
+          return l(u(c), o);
+        const h = c;
+        if (h.state.level !== "cell")
+          return l(
+            'rangeFromCells: "from" did not resolve to a cell',
+            o
+          );
+        const d = h.state.cell, k = L(
+          { level: "workbook", workbook: t.workbook },
+          o.to.steps
+        );
+        if (m(k))
+          return l(u(k), o);
+        const b = k;
+        if (b.state.level !== "cell")
+          return l('rangeFromCells: "to" did not resolve to a cell', o);
+        const p = b.state.cell, R = _(
+          i.rangeAt(d.row, d.col, p.row, p.col),
+          a
+        );
+        if (m(R)) return l(u(R), o);
+        t = {
+          level: "range",
+          workbook: t.workbook,
+          sheet: i,
+          range: R
+        }, s(a, t);
+        break;
+      }
+      case "row": {
+        if (t.level !== "sheet")
+          return l("row() requires sheet-level navigation state", o);
+        const i = t.sheet, c = _(i.row(o.index), a);
+        if (m(c)) return l(u(c), o);
+        t = {
+          level: "range",
+          workbook: t.workbook,
+          sheet: i,
+          range: c
+        }, s(a, t);
+        break;
+      }
+      case "col": {
+        if (t.level === "range") {
+          const h = _(t.range.cellAt(0, o.index - 1), a);
+          if (m(h)) return l(u(h), o);
+          t = {
+            level: "cell",
+            workbook: t.workbook,
+            sheet: t.sheet,
+            cell: h
+          }, s(a, t);
+          break;
+        }
+        if (t.level !== "sheet")
+          return l(
+            "col() requires sheet-level or range-level navigation state",
+            o
+          );
+        const i = t.sheet, c = _(i.col(o.index), a);
+        if (m(c)) return l(u(c), o);
+        t = {
+          level: "range",
+          workbook: t.workbook,
+          sheet: i,
+          range: c
+        }, s(a, t);
+        break;
+      }
+      // ----- Header-relative navigation -----
+      case "colWhere": {
+        if (t.level !== "cell")
+          return l(
+            "colWhere() requires cell-level navigation state",
+            o
+          );
+        const i = t.sheet, c = JSON.stringify(o);
+        let h = ie.get(i), d = h?.get(c) ?? null;
+        if (d === null) {
+          const b = o.headerRef, p = L(
+            { level: "workbook", workbook: t.workbook },
+            b.steps
+          );
+          if (m(p))
+            return l(u(p), o);
+          const R = p;
+          if (R.state.level !== "cell")
+            return l(
+              "colWhere: headerRef did not resolve to a cell",
+              o
+            );
+          const B = R.state.cell.row, Z = i.dimensions(), G = E(o.predicate);
+          for (let A = 1; A <= Z.endCol; A++) {
+            const J = i.cellAt(B, A);
+            if (J.ok && G(J.value)) {
+              d = A;
+              break;
+            }
+          }
+          if (d === null) {
+            const A = C(o.predicate);
+            return l(
+              `colWhere: no column matching ${A} found in header row ${B}`,
+              o
+            );
+          }
+          h || (h = /* @__PURE__ */ new Map(), ie.set(i, h)), h.set(c, d);
+        }
+        const k = _(i.cellAt(t.cell.row, d), a);
+        if (m(k)) return l(u(k), o);
+        t = {
+          level: "cell",
+          workbook: t.workbook,
+          sheet: i,
+          cell: k
+        }, s(a, t);
+        break;
+      }
+      case "rowWhere": {
+        if (t.level !== "cell")
+          return l(
+            "rowWhere() requires cell-level navigation state",
+            o
+          );
+        const i = t.sheet, c = JSON.stringify(o);
+        let h = ae.get(i), d = h?.get(c) ?? null;
+        if (d === null) {
+          const b = o.headerRef, p = L(
+            { level: "workbook", workbook: t.workbook },
+            b.steps
+          );
+          if (m(p))
+            return l(u(p), o);
+          const R = p;
+          if (R.state.level !== "cell")
+            return l(
+              "rowWhere: headerRef did not resolve to a cell",
+              o
+            );
+          const B = R.state.cell.col, Z = i.dimensions(), G = E(o.predicate);
+          for (let A = 1; A <= Z.endRow; A++) {
+            const J = i.cellAt(A, B);
+            if (J.ok && G(J.value)) {
+              d = A;
+              break;
+            }
+          }
+          if (d === null) {
+            const A = C(o.predicate);
+            return l(
+              `rowWhere: no row matching ${A} found in header column ${B}`,
+              o
+            );
+          }
+          h || (h = /* @__PURE__ */ new Map(), ae.set(i, h)), h.set(c, d);
+        }
+        const k = _(i.cellAt(d, t.cell.col), a);
+        if (m(k)) return l(u(k), o);
+        t = {
+          level: "cell",
+          workbook: t.workbook,
+          sheet: i,
+          cell: k
+        }, s(a, t);
+        break;
+      }
+    }
+  }
+  return { state: t, breadcrumbs: n };
+}
+function Ee(r, e) {
+  if (typeof e != "string")
+    return S(
+      `Unexpected extract type on cell: ${JSON.stringify(e)}`
+    );
+  switch (e) {
+    case "string": {
+      const t = r.string();
+      return t.ok ? D(t.value) : S(`Failed to extract string: ${t.failure.message}`);
+    }
+    case "number": {
+      const t = r.number();
+      return t.ok ? D(t.value) : S(`Failed to extract number: ${t.failure.message}`);
+    }
+    case "boolean": {
+      const t = r.boolean();
+      return t.ok ? D(t.value) : S(`Failed to extract boolean: ${t.failure.message}`);
+    }
+    case "date": {
+      const t = r.date();
+      return t.ok ? D(t.value) : S(`Failed to extract date: ${t.failure.message}`);
+    }
+    case "value": {
+      const t = r.value();
+      return t.ok ? D(t.value) : S(`Failed to extract value: ${t.failure.message}`);
+    }
+    case "formula": {
+      const t = r.formula();
+      return t.ok ? D(t.value) : S(`Failed to extract formula: ${t.failure.message}`);
+    }
+    default:
+      return S(`Unknown cell extract type: ${e}`);
+  }
+}
+function Ae(r, e) {
+  if (e === "rows") {
+    const t = [];
+    for (let n = 0; n < r.rowCount; n++) {
+      const s = r.rowAt(n);
+      if (!s.ok)
+        return S(
+          `Failed to get row at offset ${n}: ${s.failure.message}`
+        );
+      t.push(s.value);
+    }
+    return D(t);
+  }
+  return e === "cells" ? D(r.cellsArray()) : S(
+    `Extract type "${typeof e == "string" ? e : JSON.stringify(e)}" is not valid at range level`
+  );
+}
+function We(r, e, t) {
+  const n = xe(
+    r,
+    e.row,
+    e.col,
+    t.direction,
+    t.while
+  );
+  return D(n);
+}
+function De(r, e) {
+  if (r.kind !== "extract" || r.format !== "xlsx")
+    return S(
+      `Expected extract spec with format "xlsx", got kind="${r.kind}" format="${r.format}"`
+    );
+  const t = Re(e);
+  let n;
+  switch (t) {
+    case "range": {
+      n = {
+        level: "range",
+        workbook: null,
+        sheet: null,
+        range: e
+      };
+      break;
+    }
+    case "cell": {
+      n = {
+        level: "cell",
+        workbook: null,
+        sheet: null,
+        cell: e
+      };
+      break;
+    }
+    case "sliceContext": {
+      const i = e;
+      n = {
+        level: "cell",
+        workbook: i.workbook,
+        sheet: i.sheet,
+        cell: i.anchorCell
+      };
+      break;
+    }
+    default: {
+      n = { level: "workbook", workbook: e };
+      break;
+    }
+  }
+  const s = L(n, r.steps);
+  if (m(s))
+    return s;
+  const { state: l, breadcrumbs: u } = s, o = r.extract;
+  function a(i) {
+    return i.ok ? { ...i, path: [...u] } : { ...i, path: [...u, ...i.path] };
+  }
+  return typeof o == "object" && o.kind === "eachCell" ? l.level !== "cell" ? j(
+    "eachCell extract requires cell-level navigation state",
+    u
+  ) : a(We(l.sheet, l.cell, o)) : typeof o == "object" && o.kind === "eachSlice" ? l.level !== "cell" ? j(
+    "eachSlice extract requires cell-level navigation state",
+    u
+  ) : { ok: !0, value: Se(
+    l.workbook,
+    l.sheet,
+    l.cell.row,
+    l.cell.col,
+    o.direction,
+    o.while
+  ), path: [...u] } : o === "rows" || o === "cells" ? l.level !== "range" ? j(
+    `"${o}" extract requires range-level navigation state`,
+    u
+  ) : a(Ae(l.range, o)) : l.level !== "cell" ? j(
+    "XLSX spec navigation did not reach a cell",
+    u
+  ) : a(Ee(l.cell, o));
+}
+function Te(r, e) {
+  return r == null ? null : r instanceof Date ? e?.dateAsIsoString !== !1 ? r.toISOString() : r.getTime() : typeof r == "string" || typeof r == "number" || typeof r == "boolean" ? r : null;
+}
+function de(r, e) {
+  const t = r.value(), n = t.ok ? Te(t.value, e) : null;
+  return e?.includeCellAddresses ? {
+    address: r.address,
+    value: n
+  } : n;
+}
+function Ie(r, e) {
+  return e?.firstRowAsHeaders ? Me(r, e) : Ne(r, e);
+}
+function Ne(r, e) {
+  const t = [];
+  for (const n of r.rows()) {
+    const s = [];
+    for (const l of n) {
+      const u = de(l, e);
+      u !== null || e?.includeEmpty ? s.push(u) : (s.length > 0 || e?.includeEmpty) && s.push(null);
+    }
+    (s.length > 0 || e?.includeEmpty) && t.push(s);
+  }
+  return t;
+}
+function Me(r, e) {
+  const t = [...r.rows()];
+  if (t.length === 0) return [];
+  const s = t[0].map((u) => {
+    const o = u.value();
+    return o.ok && o.value !== null ? String(o.value) : `col_${u.col}`;
+  }), l = [];
+  for (let u = 1; u < t.length; u++) {
+    const o = t[u], a = {};
+    let i = !1;
+    for (let c = 0; c < s.length; c++) {
+      const h = s[c], d = o[c];
+      if (d) {
+        const k = de(d, e);
+        k !== null && (i = !0), a[h] = k;
       } else
-        u[g] = null;
+        a[h] = null;
     }
-    (c || t?.includeEmpty) && o.push(u);
-  }
-  return o;
-}
-function V(s, t) {
-  const e = s.usedRange();
-  return e.ok ? j(e.value, t) : t?.firstRowAsHeaders ? [] : [[]];
-}
-function K(s, t) {
-  const e = s.sheets();
-  if (t?.includeSheetNames !== !1) {
-    const r = {};
-    for (const n of e)
-      r[n.name] = V(n, t);
-    return r;
-  }
-  return e.map((r) => V(r, t));
-}
-function L(s, t) {
-  const e = t?.delimiter ?? ",", r = t?.lineEnding ?? `
-`, n = t?.quoteStrings ?? !0, o = [];
-  for (const i of s.rows()) {
-    const a = [];
-    for (const u of i) {
-      const c = u.value();
-      let f;
-      !c.ok || c.value === null ? f = "" : c.value instanceof Date ? f = c.value.toISOString() : f = String(c.value), n && (f.includes(e) || f.includes(`
-`) || f.includes("\r") || f.includes('"')) && (f = '"' + f.replace(/"/g, '""') + '"'), a.push(f);
+    (i || e?.includeEmpty) && l.push(a);
+  }
+  return l;
+}
+function he(r, e) {
+  const t = r.usedRange();
+  return t.ok ? Ie(t.value, e) : e?.firstRowAsHeaders ? [] : [[]];
+}
+function Ze(r, e) {
+  const t = r.sheets();
+  if (e?.includeSheetNames !== !1) {
+    const n = {};
+    for (const s of t)
+      n[s.name] = he(s, e);
+    return n;
+  }
+  return t.map((n) => he(n, e));
+}
+function Fe(r, e) {
+  const t = e?.delimiter ?? ",", n = e?.lineEnding ?? `
+`, s = e?.quoteStrings ?? !0, l = [];
+  for (const u of r.rows()) {
+    const o = [];
+    for (const a of u) {
+      const i = a.value();
+      let c;
+      !i.ok || i.value === null ? c = "" : i.value instanceof Date ? c = i.value.toISOString() : c = String(i.value), s && (c.includes(t) || c.includes(`
+`) || c.includes("\r") || c.includes('"')) && (c = '"' + c.replace(/"/g, '""') + '"'), o.push(c);
     }
-    o.push(a.join(e));
+    l.push(o.join(t));
   }
-  return o.join(r);
+  return l.join(n);
 }
-function Q(s, t) {
-  const e = s.usedRange();
-  return e.ok ? L(e.value, t) : "";
+function Ge(r, e) {
+  const t = r.usedRange();
+  return t.ok ? Fe(t.value, e) : "";
 }
-function Y(s) {
-  s.register(I);
+function qe(r) {
+  r.register(Ce);
 }
+qe(me);
+we(
+  "xlsx",
+  (r, e) => De(r, e)
+);
 export {
-  w as XlsxCell,
-  d as XlsxCursor,
-  m as XlsxRange,
-  k as XlsxSheet,
-  v as XlsxWorkbook,
-  J as cellToJson,
-  D as cellValueToJson,
-  T as columnLetterToNumber,
-  N as columnNumberToLetter,
-  h as fail,
-  R as formatAddress,
-  A as formatRange,
-  F as formatXlsxPath,
-  S as isError,
-  b as isFormula,
-  O as isInRange,
-  l as ok,
-  p as parseAddress,
-  y as parseRange,
-  H as parseXlsx,
-  I as parseXlsxAsyncImpl,
-  Z as parseXlsxBuffer,
-  G as parseXlsxFile,
-  P as parseXlsxImpl,
-  q as predicates,
-  W as rangeToArray,
-  L as rangeToCsv,
-  j as rangeToJson,
-  B as rangeToObjects,
-  Y as registerXlsxTransforms,
-  Q as sheetToCsv,
-  V as sheetToJson,
-  M as streamToBuffer,
-  U as toExcelLocation,
-  K as workbookToJson
+  W as XlsxCell,
+  g as XlsxCellSB,
+  _e as XlsxColSB,
+  $ as XlsxCursor,
+  y as XlsxRange,
+  te as XlsxRangeSB,
+  ve as XlsxRowItemSB,
+  be as XlsxRowSB,
+  O as XlsxSheet,
+  U as XlsxSheetSB,
+  $e as XlsxSliceContext,
+  pe as XlsxSliceSB,
+  se as XlsxSpecBuilder,
+  z as XlsxWorkbook,
+  Xe as cell,
+  de as cellToJson,
+  Te as cellValueToJson,
+  ne as columnLetterToNumber,
+  fe as columnNumberToLetter,
+  E as compileCellPredicate,
+  F as compileRowPredicate,
+  M as compileSheetPredicate,
+  C as describeCellPredicate,
+  q as describeRowPredicate,
+  I as describeSheetPredicate,
+  De as executeXlsxSpec,
+  w as fail,
+  Y as formatAddress,
+  le as formatRange,
+  Je as formatXlsxPath,
+  Q as isError,
+  P as isFormula,
+  Le as isInRange,
+  f as ok,
+  V as parseAddress,
+  H as parseRange,
+  ze as parseXlsx,
+  Ce as parseXlsxAsyncImpl,
+  Ue as parseXlsxBuffer,
+  He as parseXlsxFile,
+  Pe as parseXlsxImpl,
+  Oe as predicates,
+  Ne as rangeToArray,
+  Fe as rangeToCsv,
+  Ie as rangeToJson,
+  Me as rangeToObjects,
+  qe as registerXlsxTransforms,
+  Ye as rowCol,
+  Ke as sheet,
+  Ge as sheetToCsv,
+  he as sheetToJson,
+  ge as streamToBuffer,
+  je as toExcelLocation,
+  Ze as workbookToJson
 };
 //# sourceMappingURL=index.es.js.map