@origints/xlsx 0.1.0

package/dist/index.es.js

@@ -0,0 +1,2257 @@
+import $ from "exceljs";
+function l(s, t) {
+  return { ok: !0, value: s, path: t };
+}
+function h(s, t, e, r) {
+  return {
+    ok: !1,
+    failure: { kind: s, message: t, path: e, sourceLocation: r }
+  };
+}
+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 U(s) {
+  if (s.sheet)
+    return {
+      kind: "excel",
+      file: s.file ?? "",
+      sheet: s.sheet,
+      range: s.range ?? s.cell ?? ""
+    };
+}
+function b(s) {
+  return typeof s == "object" && s !== null && !(s instanceof Date) && "formula" in s;
+}
+function S(s) {
+  return typeof s == "object" && s !== null && !(s instanceof Date) && "error" in s;
+}
+async function M(s) {
+  const t = s.getReader(), e = [];
+  try {
+    for (; ; ) {
+      const { done: r, value: n } = await t.read();
+      if (r) break;
+      e.push(n);
+    }
+    return Buffer.concat(e);
+  } finally {
+    t.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 N(s) {
+  let t = "";
+  for (; s > 0; ) {
+    const e = (s - 1) % 26;
+    t = String.fromCharCode(65 + e) + t, s = Math.floor((s - 1) / 26);
+  }
+  return t;
+}
+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();
+  return {
+    row: parseInt(t[2], 10),
+    col: T(e),
+    colLetter: e
+  };
+}
+function R(s, t) {
+  return `${N(t)}${s}`;
+}
+function y(s) {
+  const t = s.split(":");
+  if (t.length === 1) {
+    const n = p(t[0]);
+    return {
+      start: { row: n.row, col: n.col },
+      end: { row: n.row, col: n.col }
+    };
+  }
+  if (t.length !== 2)
+    throw new Error(`Invalid range: ${s}`);
+  const e = p(t[0]), r = p(t[1]);
+  return {
+    start: { row: e.row, col: e.col },
+    end: { row: r.row, col: r.col }
+  };
+}
+function A(s, t, e, r) {
+  const n = R(s, t), o = R(e, r);
+  return n === o ? n : `${n}:${o}`;
+}
+function O(s, t, e) {
+  return s >= e.start.row && s <= e.end.row && t >= e.start.col && t <= e.end.col;
+}
+class w {
+  constructor(t, e, r) {
+    this.cell = t, this._path = e, this._sheetName = r;
+  }
+  /**
+   * Creates an XlsxCell from an ExcelJS cell.
+   * @internal
+   */
+  static fromExcelJS(t, e, r) {
+    const n = {
+      file: r,
+      sheet: e,
+      cell: t.address
+    };
+    return new w(t, n, e);
+  }
+  // ---------------------------------------------------------------------------
+  // IDENTITY & LOCATION
+  // ---------------------------------------------------------------------------
+  /**
+   * Returns the cell address (e.g., "A1").
+   */
+  get address() {
+    return this.cell.address;
+  }
+  /**
+   * Returns the 1-based row number.
+   */
+  get row() {
+    return typeof this.cell.row == "number" ? this.cell.row : parseInt(String(this.cell.row), 10);
+  }
+  /**
+   * Returns the 1-based column number.
+   */
+  get col() {
+    return typeof this.cell.col == "number" ? this.cell.col : parseInt(String(this.cell.col), 10);
+  }
+  /**
+   * Returns the column letter(s) (e.g., "A", "AA").
+   */
+  get colLetter() {
+    return this.address.replace(/\d+$/, "");
+  }
+  /**
+   * Returns the current path for lineage tracking.
+   */
+  get path() {
+    return this._path;
+  }
+  /**
+   * Returns the sheet name this cell belongs to.
+   */
+  get sheetName() {
+    return this._sheetName;
+  }
+  // ---------------------------------------------------------------------------
+  // VALUE EXTRACTION
+  // ---------------------------------------------------------------------------
+  /**
+   * 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);
+  }
+  /**
+   * Returns the extended cell value (including formula info).
+   */
+  extendedValue() {
+    return l(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);
+  }
+  /**
+   * 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);
+    }
+    return h("type", `Expected number, got ${E(t)}`, 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);
+  }
+  /**
+   * 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);
+    }
+    if (typeof t == "string") {
+      const e = new Date(t);
+      if (!isNaN(e.getTime()))
+        return l(e, this._path);
+    }
+    return h("type", `Expected date, got ${E(t)}`, 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);
+  }
+  // ---------------------------------------------------------------------------
+  // RICH TEXT & MARKDOWN
+  // ---------------------------------------------------------------------------
+  /**
+   * Get the cell content as rich text with formatting preserved.
+   * 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
+      }));
+      return l({ segments: u, hyperlink: e }, 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
+      };
+      return l(
+        {
+          segments: [c],
+          hyperlink: a.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
+    };
+    return l({ segments: [i], hyperlink: e }, this._path);
+  }
+  /**
+   * Get the cell content as Markdown.
+   *
+   * Converts cell content including:
+   * - Bold text -> **text**
+   * - Italic text -> *text*
+   * - Strikethrough -> ~~text~~
+   * - Hyperlinks -> [text](url)
+   * - 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;
+    }
+    return r && (n = `[${n}](${r})`), l(n, 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;
+  }
+  // ---------------------------------------------------------------------------
+  // TYPE CHECKING
+  // ---------------------------------------------------------------------------
+  /**
+   * Check if the cell is empty.
+   */
+  isEmpty() {
+    const t = this.cell.value;
+    return t == null || t === "";
+  }
+  /**
+   * Check if the cell contains a formula.
+   */
+  isFormula() {
+    return b(this.getRawValue());
+  }
+  /**
+   * Check if the cell is part of a merged range.
+   */
+  isMerged() {
+    return this.cell.isMerged;
+  }
+  /**
+   * Check if this is the master cell of a merged range.
+   */
+  isMergedMaster() {
+    return this.cell.isMerged ? this.cell.master.address === this.cell.address : !1;
+  }
+  /**
+   * Check if the cell contains a string.
+   */
+  isString() {
+    return typeof this.getResolvedValue() == "string";
+  }
+  /**
+   * Check if the cell contains a number.
+   */
+  isNumber() {
+    return typeof this.getResolvedValue() == "number";
+  }
+  /**
+   * Check if the cell contains a boolean.
+   */
+  isBoolean() {
+    return typeof this.getResolvedValue() == "boolean";
+  }
+  /**
+   * Check if the cell contains a date.
+   */
+  isDate() {
+    return this.getResolvedValue() instanceof Date;
+  }
+  /**
+   * Check if the cell contains an error.
+   */
+  isError() {
+    return S(this.getRawValue());
+  }
+  // ---------------------------------------------------------------------------
+  // METADATA
+  // ---------------------------------------------------------------------------
+  /**
+   * Get the cell's style information.
+   */
+  style() {
+    const t = this.cell.font, e = this.cell.fill, r = this.cell.border, n = 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)
+      } : void 0,
+      fill: e && e.type === "pattern" ? {
+        type: e.pattern,
+        color: e.fgColor?.argb
+      } : void 0,
+      border: r ? {
+        top: !!r.top,
+        bottom: !!r.bottom,
+        left: !!r.left,
+        right: !!r.right
+      } : void 0,
+      alignment: n ? {
+        horizontal: n.horizontal,
+        vertical: n.vertical,
+        wrapText: n.wrapText
+      } : void 0,
+      numFmt: this.cell.numFmt
+    };
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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(""),
+      this._path
+    ) : h("format", "Unable to extract comment text", this._path) : h("missing", "Cell does not contain a comment", this._path);
+  }
+  // ---------------------------------------------------------------------------
+  // NAVIGATION FROM CELL
+  // ---------------------------------------------------------------------------
+  /**
+   * 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(
+        "bounds",
+        `Cell offset (${t}, ${e}) from ${this.address} is out of bounds`,
+        this._path
+      );
+    const i = r(n, o);
+    return i ? l(i, i.path) : h(
+      "missing",
+      `Cell at ${R(n, o)} not found`,
+      this._path
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // INTERNAL HELPERS
+  // ---------------------------------------------------------------------------
+  /**
+   * Get the raw value, handling ExcelJS value types.
+   */
+  getRawValue() {
+    const t = this.cell.value;
+    if (t == null)
+      return null;
+    if (typeof t == "object") {
+      if ("error" in t)
+        return { error: String(t.error) };
+      if ("formula" in t) {
+        const e = t;
+        return {
+          formula: e.formula,
+          result: this.normalizeResult(e.result)
+        };
+      }
+      if ("sharedFormula" in t) {
+        const e = t;
+        return {
+          formula: e.sharedFormula,
+          result: this.normalizeResult(e.result)
+        };
+      }
+      if ("richText" in t)
+        return t.richText.map((r) => r.text).join("");
+      if (t instanceof Date)
+        return t;
+    }
+    return typeof t == "string" || typeof t == "number" || typeof t == "boolean" ? t : 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;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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);
+  }
+}
+function E(s) {
+  return s === null ? "null" : s === void 0 ? "undefined" : s instanceof Date ? "date" : Array.isArray(s) ? "array" : typeof s;
+}
+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;
+  }
+  /**
+   * 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
+    };
+    return new m(
+      t,
+      e,
+      r,
+      n,
+      o,
+      c,
+      i,
+      a
+    );
+  }
+  /**
+   * Creates an XlsxRange from an address string.
+   * @internal
+   */
+  static fromAddress(t, e, r, n) {
+    try {
+      const { start: o, end: i } = y(e);
+      return l(
+        m.fromCoords(
+          t,
+          o.row,
+          o.col,
+          i.row,
+          i.col,
+          r,
+          n
+        ),
+        { file: n, sheet: r, range: e }
+      );
+    } catch {
+      return h(
+        "range",
+        `Invalid range address: ${e}`,
+        { file: n, sheet: r }
+      );
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // IDENTITY
+  // ---------------------------------------------------------------------------
+  /**
+   * Returns the range address (e.g., "A1:C10").
+   */
+  get address() {
+    return A(
+      this._startRow,
+      this._startCol,
+      this._endRow,
+      this._endCol
+    );
+  }
+  /**
+   * Returns the start row (1-based).
+   */
+  get startRow() {
+    return this._startRow;
+  }
+  /**
+   * Returns the start column (1-based).
+   */
+  get startCol() {
+    return this._startCol;
+  }
+  /**
+   * Returns the end row (1-based).
+   */
+  get endRow() {
+    return this._endRow;
+  }
+  /**
+   * Returns the end column (1-based).
+   */
+  get endCol() {
+    return this._endCol;
+  }
+  /**
+   * Returns the current path for lineage tracking.
+   */
+  get path() {
+    return this._path;
+  }
+  /**
+   * Returns the number of rows in the range.
+   */
+  get rowCount() {
+    return this._endRow - this._startRow + 1;
+  }
+  /**
+   * Returns the number of columns in the range.
+   */
+  get colCount() {
+    return this._endCol - this._startCol + 1;
+  }
+  /**
+   * Returns the total number of cells in the range.
+   */
+  get cellCount() {
+    return this.rowCount * this.colCount;
+  }
+  // ---------------------------------------------------------------------------
+  // CELL ACCESS
+  // ---------------------------------------------------------------------------
+  /**
+   * 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(
+        "bounds",
+        `Offset (${t}, ${e}) is outside range ${this.address}`,
+        this._path
+      );
+    const o = this.worksheet.getCell(r, n);
+    return l(w.fromExcelJS(o, this._sheetName, this._file), {
+      ...this._path,
+      cell: o.address,
+      range: void 0
+    });
+  }
+  /**
+   * Get a cell by its address within this range.
+   */
+  cell(t) {
+    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(
+          "bounds",
+          `Cell ${t} is outside range ${this.address}`,
+          this._path
+        );
+      const r = this.worksheet.getCell(t);
+      return l(w.fromExcelJS(r, this._sheetName, this._file), {
+        ...this._path,
+        cell: t,
+        range: void 0
+      });
+    } catch {
+      return h("range", `Invalid cell address: ${t}`, this._path);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // ITERATION
+  // ---------------------------------------------------------------------------
+  /**
+   * 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);
+      }
+  }
+  /**
+   * 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));
+      }
+      yield e;
+    }
+  }
+  /**
+   * 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));
+      }
+      yield e;
+    }
+  }
+  /**
+   * 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);
+      }
+      t.push(r);
+    }
+    return t;
+  }
+  /**
+   * Get all cells as a flat array.
+   */
+  cellsArray() {
+    return [...this.cells()];
+  }
+  // ---------------------------------------------------------------------------
+  // SUBRANGE
+  // ---------------------------------------------------------------------------
+  /**
+   * Get a subrange within this range.
+   */
+  subRange(t) {
+    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(
+        "bounds",
+        `Subrange ${t} extends outside range ${this.address}`,
+        this._path
+      ) : l(
+        m.fromCoords(
+          this.worksheet,
+          e.row,
+          e.col,
+          r.row,
+          r.col,
+          this._sheetName,
+          this._file
+        ),
+        { ...this._path, range: t }
+      );
+    } catch {
+      return h("range", `Invalid range address: ${t}`, this._path);
+    }
+  }
+  /**
+   * Get the first row as a range.
+   */
+  firstRow() {
+    return m.fromCoords(
+      this.worksheet,
+      this._startRow,
+      this._startCol,
+      this._startRow,
+      this._endCol,
+      this._sheetName,
+      this._file
+    );
+  }
+  /**
+   * Get the last row as a range.
+   */
+  lastRow() {
+    return m.fromCoords(
+      this.worksheet,
+      this._endRow,
+      this._startCol,
+      this._endRow,
+      this._endCol,
+      this._sheetName,
+      this._file
+    );
+  }
+  /**
+   * Get the first column as a range.
+   */
+  firstCol() {
+    return m.fromCoords(
+      this.worksheet,
+      this._startRow,
+      this._startCol,
+      this._endRow,
+      this._startCol,
+      this._sheetName,
+      this._file
+    );
+  }
+  /**
+   * Get the last column as a range.
+   */
+  lastCol() {
+    return m.fromCoords(
+      this.worksheet,
+      this._startRow,
+      this._endCol,
+      this._endRow,
+      this._endCol,
+      this._sheetName,
+      this._file
+    );
+  }
+  /**
+   * 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(
+      "bounds",
+      `Row offset ${t} is outside range ${this.address}`,
+      this._path
+    ) : l(
+      m.fromCoords(
+        this.worksheet,
+        e,
+        this._startCol,
+        e,
+        this._endCol,
+        this._sheetName,
+        this._file
+      ),
+      this._path
+    );
+  }
+  /**
+   * 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(
+      "bounds",
+      `Column offset ${t} is outside range ${this.address}`,
+      this._path
+    ) : l(
+      m.fromCoords(
+        this.worksheet,
+        this._startRow,
+        e,
+        this._endRow,
+        e,
+        this._sheetName,
+        this._file
+      ),
+      this._path
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // QUERY
+  // ---------------------------------------------------------------------------
+  /**
+   * 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(
+      "missing",
+      `No cell matching predicate found in range ${this.address}`,
+      this._path
+    );
+  }
+  /**
+   * Find all cells matching the predicate.
+   */
+  findAll(t) {
+    const e = [];
+    for (const r of this.cells())
+      t(r) && e.push(r);
+    return e;
+  }
+  /**
+   * 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);
+    }
+    return h(
+      "missing",
+      `Value "${t}" 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))
+        return !0;
+    return !1;
+  }
+  /**
+   * Check if all cells match the predicate.
+   */
+  every(t) {
+    for (const e of this.cells())
+      if (!t(e))
+        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;
+  }
+  // ---------------------------------------------------------------------------
+  // CONVERSION
+  // ---------------------------------------------------------------------------
+  /**
+   * Convert range to a 2D array of values.
+   */
+  toArray() {
+    return this.values();
+  }
+  /**
+   * Convert range to array of objects using a header row.
+   * @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;
+        }
+      }
+      i.push(c);
+    }
+    return i;
+  }
+  /**
+   * Convert range to JSON-compatible structure.
+   */
+  toJson() {
+    return {
+      address: this.address,
+      rows: this.values()
+    };
+  }
+}
+class d {
+  constructor(t, e, r, n = "right") {
+    this.sheet = t, this._row = e, this._col = r, this._direction = n;
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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));
+  }
+  // ---------------------------------------------------------------------------
+  // POSITION
+  // ---------------------------------------------------------------------------
+  /**
+   * Get the current row (1-based).
+   */
+  get row() {
+    return this._row;
+  }
+  /**
+   * Get the current column (1-based).
+   */
+  get col() {
+    return this._col;
+  }
+  /**
+   * Get the current address.
+   */
+  get address() {
+    return R(this._row, this._col);
+  }
+  /**
+   * Get the current column letter.
+   */
+  get colLetter() {
+    return N(this._col);
+  }
+  /**
+   * Get the current direction.
+   */
+  get direction() {
+    return this._direction;
+  }
+  /**
+   * Get the path for lineage tracking.
+   */
+  get path() {
+    return {
+      ...this.sheet.path,
+      cell: this.address
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // MOVEMENT
+  // ---------------------------------------------------------------------------
+  /**
+   * Move by a delta (returns new cursor).
+   */
+  move(t, e) {
+    return new d(
+      this.sheet,
+      Math.max(1, this._row + t),
+      Math.max(1, this._col + e),
+      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);
+  }
+  /**
+   * Move to a specific row.
+   */
+  moveToRow(t) {
+    return new d(this.sheet, Math.max(1, t), 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);
+  }
+  /**
+   * Move left by count cells.
+   */
+  left(t = 1) {
+    return new d(
+      this.sheet,
+      this._row,
+      Math.max(1, this._col - t),
+      "left"
+    );
+  }
+  /**
+   * Move right by count cells.
+   */
+  right(t = 1) {
+    return new d(this.sheet, this._row, this._col + t, "right");
+  }
+  /**
+   * Move up by count cells.
+   */
+  up(t = 1) {
+    return new d(
+      this.sheet,
+      Math.max(1, this._row - t),
+      this._col,
+      "up"
+    );
+  }
+  /**
+   * Move down by count cells.
+   */
+  down(t = 1) {
+    return new d(this.sheet, this._row + t, this._col, "down");
+  }
+  /**
+   * Set the current direction.
+   */
+  setDirection(t) {
+    return new d(this.sheet, this._row, this._col, t);
+  }
+  /**
+   * Move forward in the current direction.
+   */
+  forward(t = 1) {
+    switch (this._direction) {
+      case "right":
+        return this.right(t);
+      case "left":
+        return this.left(t);
+      case "down":
+        return this.down(t);
+      case "up":
+        return this.up(t);
+    }
+  }
+  /**
+   * Move to the start of the current row.
+   */
+  startOfRow() {
+    return new d(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);
+  }
+  // ---------------------------------------------------------------------------
+  // SKIP OPERATIONS
+  // ---------------------------------------------------------------------------
+  /**
+   * Skip empty cells in the current direction.
+   */
+  skipEmpty() {
+    return this.skipWhile((t) => t.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();
+    }
+    return e;
+  }
+  /**
+   * Skip cells until the predicate is true.
+   */
+  skipUntil(t) {
+    return this.skipWhile((e) => !t(e));
+  }
+  /**
+   * Skip cells until a specific value is found.
+   */
+  skipToValue(t) {
+    return this.skipUntil((e) => {
+      const r = e.value();
+      return r.ok && r.value === t;
+    });
+  }
+  /**
+   * Skip a specific number of cells.
+   */
+  skip(t) {
+    return this.forward(t);
+  }
+  // ---------------------------------------------------------------------------
+  // GRAB OPERATIONS
+  // ---------------------------------------------------------------------------
+  /**
+   * Grab the current cell and move forward.
+   */
+  grab() {
+    const t = this.cell();
+    return t.ok ? l(
+      {
+        cell: t.value,
+        cursor: this.forward()
+      },
+      this.path
+    ) : t;
+  }
+  /**
+   * 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)
+        break;
+      e.push(o.value), r = r.forward();
+    }
+    return e.length === 0 ? h("bounds", "No cells to grab", this.path) : l({ cells: e, cursor: r }, 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();
+    }
+    return l({ cells: e, cursor: r }, this.path);
+  }
+  /**
+   * Grab cells until the predicate is true (not including the matching cell).
+   */
+  grabUntil(t) {
+    return this.grabWhile((e) => !t(e));
+  }
+  /**
+   * 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();
+    }
+    return l({ cells: t, cursor: r }, 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();
+    }
+    return l({ cells: t, cursor: r }, this.path);
+  }
+  /**
+   * Grab non-empty cells in the current direction.
+   */
+  grabNonEmpty() {
+    return this.grabWhile((t) => !t.isEmpty());
+  }
+  // ---------------------------------------------------------------------------
+  // PEEK OPERATIONS
+  // ---------------------------------------------------------------------------
+  /**
+   * Peek at the current cell without moving.
+   */
+  peek() {
+    return this.cell();
+  }
+  /**
+   * 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();
+    }
+    return l(e, this.path);
+  }
+  /**
+   * Peek at a cell at an offset without moving.
+   */
+  peekAt(t, e) {
+    return this.move(t, e).cell();
+  }
+  // ---------------------------------------------------------------------------
+  // CURRENT CELL
+  // ---------------------------------------------------------------------------
+  /**
+   * Get the cell at the current position.
+   */
+  cell() {
+    return this.sheet.cellAt(this._row, this._col);
+  }
+  /**
+   * Get the value of the current cell.
+   */
+  value() {
+    const t = this.cell();
+    return t.ok ? t.value.value() : t;
+  }
+  // ---------------------------------------------------------------------------
+  // UTILITIES
+  // ---------------------------------------------------------------------------
+  /**
+   * Check if the cursor is at a valid position with data.
+   */
+  isValid() {
+    return this.cell().ok;
+  }
+  /**
+   * Check if the current cell is empty.
+   */
+  isEmpty() {
+    const t = this.cell();
+    return t.ok && t.value.isEmpty();
+  }
+  /**
+   * Check if the current cell is non-empty.
+   */
+  isNotEmpty() {
+    const t = this.cell();
+    return t.ok && !t.value.isEmpty();
+  }
+  /**
+   * Create a new cursor at the same position.
+   */
+  clone() {
+    return new d(this.sheet, this._row, this._col, this._direction);
+  }
+}
+class k {
+  constructor(t, e, r) {
+    this.worksheet = t, this._path = e, this._file = r;
+  }
+  /**
+   * Creates an XlsxSheet from an ExcelJS worksheet.
+   * @internal
+   */
+  static fromExcelJS(t, e) {
+    const r = {
+      file: e,
+      sheet: t.name
+    };
+    return new k(t, r, e);
+  }
+  // ---------------------------------------------------------------------------
+  // IDENTITY
+  // ---------------------------------------------------------------------------
+  /**
+   * Returns the sheet name.
+   */
+  get name() {
+    return this.worksheet.name;
+  }
+  /**
+   * Returns the sheet index (1-based).
+   */
+  get index() {
+    return this.worksheet.id;
+  }
+  /**
+   * Returns the current path for lineage tracking.
+   */
+  get path() {
+    return this._path;
+  }
+  // ---------------------------------------------------------------------------
+  // CELL ACCESS
+  // ---------------------------------------------------------------------------
+  /**
+   * Get a cell by its address (e.g., "A1", "B2").
+   */
+  cell(t) {
+    try {
+      p(t);
+      const e = this.worksheet.getCell(t);
+      return l(w.fromExcelJS(e, this.name, this._file), {
+        ...this._path,
+        cell: t
+      });
+    } catch {
+      return h("range", `Invalid cell address: ${t}`, this._path);
+    }
+  }
+  /**
+   * Get a cell by row and column numbers (1-based).
+   */
+  cellAt(t, e) {
+    if (t < 1 || e < 1)
+      return h(
+        "bounds",
+        `Invalid cell coordinates: row=${t}, col=${e}`,
+        this._path
+      );
+    const r = this.worksheet.getCell(t, e);
+    return l(w.fromExcelJS(r, this.name, this._file), {
+      ...this._path,
+      cell: r.address
+    });
+  }
+  /**
+   * Get the value of a cell directly.
+   */
+  getValue(t) {
+    const e = this.cell(t);
+    return e.ok ? e.value.value() : e;
+  }
+  // ---------------------------------------------------------------------------
+  // RANGE OPERATIONS
+  // ---------------------------------------------------------------------------
+  /**
+   * Get a range by its address (e.g., "A1:C10").
+   */
+  range(t) {
+    return m.fromAddress(this.worksheet, t, this.name, this._file);
+  }
+  /**
+   * Get a range from start to end addresses.
+   */
+  rangeFrom(t, e) {
+    return this.range(`${t}:${e}`);
+  }
+  /**
+   * 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(
+        this.worksheet,
+        t,
+        e,
+        r,
+        n,
+        this.name,
+        this._file
+      ),
+      this._path
+    );
+  }
+  /**
+   * 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(
+        this.worksheet,
+        t.startRow,
+        t.startCol,
+        t.endRow,
+        t.endCol,
+        this.name,
+        this._file
+      ),
+      this._path
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // ROW / COLUMN ACCESS
+  // ---------------------------------------------------------------------------
+  /**
+   * 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(
+        this.worksheet,
+        t,
+        1,
+        t,
+        r,
+        this.name,
+        this._file
+      ),
+      this._path
+    );
+  }
+  /**
+   * 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(
+        this.worksheet,
+        1,
+        e,
+        n,
+        e,
+        this.name,
+        this._file
+      ),
+      this._path
+    );
+  }
+  /**
+   * Iterate over all rows with data.
+   */
+  *rows() {
+    const t = this.dimensions();
+    for (let e = t.startRow; e <= t.endRow; e++)
+      yield m.fromCoords(
+        this.worksheet,
+        e,
+        t.startCol,
+        e,
+        t.endCol,
+        this.name,
+        this._file
+      );
+  }
+  /**
+   * Iterate over all columns with data.
+   */
+  *cols() {
+    const t = this.dimensions();
+    for (let e = t.startCol; e <= t.endCol; e++)
+      yield m.fromCoords(
+        this.worksheet,
+        t.startRow,
+        e,
+        t.endRow,
+        e,
+        this.name,
+        this._file
+      );
+  }
+  // ---------------------------------------------------------------------------
+  // CURSOR CREATION
+  // ---------------------------------------------------------------------------
+  /**
+   * Create a cursor starting at the specified address.
+   */
+  cursor(t) {
+    const e = t ?? "A1";
+    return d.create(this, e);
+  }
+  /**
+   * Create a cursor starting at the specified coordinates (1-based).
+   */
+  cursorAt(t, e) {
+    return d.createAt(this, t, e);
+  }
+  // ---------------------------------------------------------------------------
+  // QUERY METHODS
+  // ---------------------------------------------------------------------------
+  /**
+   * Find the first cell matching the predicate.
+   */
+  find(t) {
+    const e = this.usedRange();
+    return e.ok ? e.value.find(t) : e;
+  }
+  /**
+   * Find all cells matching the predicate.
+   */
+  findAll(t) {
+    const e = this.usedRange();
+    return e.ok ? e.value.findAll(t) : [];
+  }
+  /**
+   * Find the first cell with the specified value.
+   */
+  findValue(t) {
+    const e = this.usedRange();
+    return e.ok ? e.value.findValue(t) : e;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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) : [];
+  }
+  // ---------------------------------------------------------------------------
+  // DIMENSIONS
+  // ---------------------------------------------------------------------------
+  /**
+   * 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;
+    if (this.worksheet.dimensions) {
+      const a = this.worksheet.dimensions;
+      if (typeof a == "string")
+        try {
+          const u = y(a);
+          r = u.start.row, o = u.start.col, n = u.end.row, i = u.end.col;
+        } catch {
+        }
+    }
+    return {
+      startRow: r,
+      endRow: n,
+      startCol: o,
+      endCol: i,
+      rowCount: n - r + 1,
+      colCount: i - o + 1
+    };
+  }
+  /**
+   * Get the number of rows with data.
+   */
+  rowCount() {
+    return this.dimensions().rowCount;
+  }
+  /**
+   * Get the number of columns with data.
+   */
+  colCount() {
+    return this.dimensions().colCount;
+  }
+  // ---------------------------------------------------------------------------
+  // MERGED CELLS
+  // ---------------------------------------------------------------------------
+  /**
+   * Get all merged cell ranges.
+   */
+  mergedRanges() {
+    const t = this.worksheet._merges;
+    return t ? Object.keys(t) : [];
+  }
+  /**
+   * Check if a cell is part of a merged range.
+   */
+  isMerged(t) {
+    const e = this.cell(t);
+    return e.ok ? e.value.isMerged() : !1;
+  }
+  // ---------------------------------------------------------------------------
+  // INTERNAL HELPERS
+  // ---------------------------------------------------------------------------
+  /**
+   * Get the underlying ExcelJS worksheet.
+   * @internal
+   */
+  getWorksheet() {
+    return this.worksheet;
+  }
+  /**
+   * 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);
+  }
+}
+class v {
+  constructor(t, e) {
+    this.workbook = t, this._path = e, this.sheetsCache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Creates an XlsxWorkbook from an ExcelJS workbook.
+   * @internal
+   */
+  static fromExcelJS(t, e) {
+    const r = { file: e };
+    return new v(t, r);
+  }
+  // ---------------------------------------------------------------------------
+  // IDENTITY
+  // ---------------------------------------------------------------------------
+  /**
+   * Returns the path for lineage tracking.
+   */
+  get path() {
+    return this._path;
+  }
+  /**
+   * Returns the file name if known.
+   */
+  get file() {
+    return this._path.file;
+  }
+  // ---------------------------------------------------------------------------
+  // SHEET ACCESS
+  // ---------------------------------------------------------------------------
+  /**
+   * 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);
+  }
+  /**
+   * Get a sheet by index (1-based, as per Excel convention).
+   */
+  sheetAt(t) {
+    if (t < 1)
+      return h(
+        "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`,
+        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);
+  }
+  /**
+   * Get all sheets.
+   */
+  sheets() {
+    const t = [];
+    return this.workbook.eachSheet((e) => {
+      const r = this.sheetsCache.get(e.name);
+      if (r)
+        t.push(r);
+      else {
+        const n = k.fromExcelJS(e, this._path.file);
+        this.sheetsCache.set(e.name, n), t.push(n);
+      }
+    }), t;
+  }
+  /**
+   * Get all sheet names.
+   */
+  sheetNames() {
+    const t = [];
+    return this.workbook.eachSheet((e) => {
+      t.push(e.name);
+    }), t;
+  }
+  /**
+   * Get the number of sheets.
+   */
+  sheetCount() {
+    return this.workbook.worksheets.length;
+  }
+  /**
+   * Get the first sheet.
+   */
+  firstSheet() {
+    return this.sheetAt(1);
+  }
+  /**
+   * Get the last sheet.
+   */
+  lastSheet() {
+    const t = this.sheetCount();
+    return t === 0 ? h("missing", "Workbook has no sheets", this._path) : this.sheetAt(t);
+  }
+  // ---------------------------------------------------------------------------
+  // PREDICATES
+  // ---------------------------------------------------------------------------
+  /**
+   * Check if a sheet with the given name exists.
+   */
+  hasSheet(t) {
+    return this.workbook.getWorksheet(t) !== 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
+    );
+  }
+  /**
+   * Find all sheets matching the predicate.
+   */
+  filterSheets(t) {
+    return this.sheets().filter(t);
+  }
+  /**
+   * Find a sheet by name pattern (regex).
+   */
+  findSheetByPattern(t) {
+    return this.findSheet((e) => t.test(e.name));
+  }
+  /**
+   * Find all sheets by name pattern (regex).
+   */
+  filterSheetsByPattern(t) {
+    return this.filterSheets((e) => t.test(e.name));
+  }
+  // ---------------------------------------------------------------------------
+  // WORKBOOK PROPERTIES
+  // ---------------------------------------------------------------------------
+  /**
+   * Get workbook properties.
+   */
+  properties() {
+    return {
+      title: this.workbook.title,
+      subject: this.workbook.subject,
+      creator: this.workbook.creator,
+      lastModifiedBy: this.workbook.lastModifiedBy,
+      created: this.workbook.created,
+      modified: this.workbook.modified
+    };
+  }
+  /**
+   * Get the workbook creator.
+   */
+  creator() {
+    return this.workbook.creator;
+  }
+  /**
+   * Get the workbook creation date.
+   */
+  created() {
+    return this.workbook.created;
+  }
+  /**
+   * Get the workbook modification date.
+   */
+  modified() {
+    return this.workbook.modified;
+  }
+  // ---------------------------------------------------------------------------
+  // DEFINED NAMES
+  // ---------------------------------------------------------------------------
+  /**
+   * Get all defined names in the workbook.
+   */
+  definedNames() {
+    return [];
+  }
+  // ---------------------------------------------------------------------------
+  // ITERATION
+  // ---------------------------------------------------------------------------
+  /**
+   * Iterate over all sheets.
+   */
+  *[Symbol.iterator]() {
+    for (const t of this.sheets())
+      yield t;
+  }
+  /**
+   * Execute a function for each sheet.
+   */
+  forEach(t) {
+    this.sheets().forEach(t);
+  }
+  /**
+   * Map over all sheets.
+   */
+  map(t) {
+    return this.sheets().map(t);
+  }
+  // ---------------------------------------------------------------------------
+  // INTERNAL
+  // ---------------------------------------------------------------------------
+  /**
+   * Get the underlying ExcelJS workbook.
+   * @internal
+   */
+  getWorkbook() {
+    return this.workbook;
+  }
+}
+const q = {
+  // ---------------------------------------------------------------------------
+  // 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;
+  },
+  /**
+   * 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;
+  },
+  /**
+   * Match cells whose value matches the regex pattern.
+   */
+  matches: (s) => (t) => {
+    const e = t.string();
+    return e.ok ? s.test(e.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;
+  },
+  /**
+   * 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;
+  },
+  // ---------------------------------------------------------------------------
+  // TYPE PREDICATES
+  // ---------------------------------------------------------------------------
+  /**
+   * Match cells containing a string value.
+   */
+  isString: () => (s) => s.isString(),
+  /**
+   * Match cells containing a numeric value.
+   */
+  isNumber: () => (s) => s.isNumber(),
+  /**
+   * Match cells containing a boolean value.
+   */
+  isBoolean: () => (s) => s.isBoolean(),
+  /**
+   * Match cells containing a date value.
+   */
+  isDate: () => (s) => s.isDate(),
+  /**
+   * Match empty cells.
+   */
+  isEmpty: () => (s) => s.isEmpty(),
+  /**
+   * Match non-empty cells.
+   */
+  isNotEmpty: () => (s) => !s.isEmpty(),
+  /**
+   * Match cells containing a formula.
+   */
+  isFormula: () => (s) => s.isFormula(),
+  /**
+   * Match cells containing an error.
+   */
+  isError: () => (s) => s.isError(),
+  /**
+   * Match merged cells.
+   */
+  isMerged: () => (s) => s.isMerged(),
+  // ---------------------------------------------------------------------------
+  // NUMERIC PREDICATES
+  // ---------------------------------------------------------------------------
+  /**
+   * Match cells with numeric value greater than n.
+   */
+  greaterThan: (s) => (t) => {
+    const e = t.number();
+    return e.ok && e.value > s;
+  },
+  /**
+   * Match cells with numeric value greater than or equal to n.
+   */
+  greaterThanOrEqual: (s) => (t) => {
+    const e = t.number();
+    return e.ok && e.value >= s;
+  },
+  /**
+   * Match cells with numeric value less than n.
+   */
+  lessThan: (s) => (t) => {
+    const e = t.number();
+    return e.ok && e.value < s;
+  },
+  /**
+   * Match cells with numeric value less than or equal to n.
+   */
+  lessThanOrEqual: (s) => (t) => {
+    const e = t.number();
+    return e.ok && e.value <= s;
+  },
+  /**
+   * 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;
+  },
+  // ---------------------------------------------------------------------------
+  // DATE PREDICATES
+  // ---------------------------------------------------------------------------
+  /**
+   * Match cells with date before the specified date.
+   */
+  dateBefore: (s) => (t) => {
+    const e = t.date();
+    return e.ok && e.value.getTime() < s.getTime();
+  },
+  /**
+   * Match cells with date after the specified date.
+   */
+  dateAfter: (s) => (t) => {
+    const e = t.date();
+    return e.ok && e.value.getTime() > s.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();
+  },
+  // ---------------------------------------------------------------------------
+  // LOCATION PREDICATES
+  // ---------------------------------------------------------------------------
+  /**
+   * Match cells in the specified row.
+   */
+  inRow: (s) => (t) => t.row === s,
+  /**
+   * Match cells in the specified column.
+   */
+  inCol: (s) => (t) => t.col === s,
+  /**
+   * Match cells in the specified column (by letter).
+   */
+  inColLetter: (s) => (t) => t.colLetter.toUpperCase() === s.toUpperCase(),
+  // ---------------------------------------------------------------------------
+  // COMPOSITION
+  // ---------------------------------------------------------------------------
+  /**
+   * Match cells that satisfy all predicates.
+   */
+  and: (...s) => (t) => s.every((e) => e(t)),
+  /**
+   * Match cells that satisfy at least one predicate.
+   */
+  or: (...s) => (t) => s.some((e) => e(t)),
+  /**
+   * Match cells that do not satisfy the predicate.
+   */
+  not: (s) => (t) => !s(t),
+  // ---------------------------------------------------------------------------
+  // STYLE PREDICATES
+  // ---------------------------------------------------------------------------
+  /**
+   * Match cells with bold font.
+   */
+  isBold: () => (s) => s.style().font?.bold === !0,
+  /**
+   * Match cells with italic font.
+   */
+  isItalic: () => (s) => s.style().font?.italic === !0,
+  /**
+   * Match cells with a hyperlink.
+   */
+  hasHyperlink: () => (s) => s.hyperlink().ok,
+  /**
+   * Match cells with a comment.
+   */
+  hasComment: () => (s) => s.comment().ok,
+  // ---------------------------------------------------------------------------
+  // UTILITY
+  // ---------------------------------------------------------------------------
+  /**
+   * Always match.
+   */
+  always: () => () => !0,
+  /**
+   * Never match.
+   */
+  never: () => () => !1,
+  /**
+   * Create a custom predicate from a function.
+   */
+  custom: (s) => s
+};
+function H(s) {
+  return {
+    kind: "transform",
+    namespace: "@origints/xlsx",
+    name: "parseXlsx",
+    args: s
+  };
+}
+const P = {
+  namespace: "@origints/xlsx",
+  name: "parseXlsx",
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  execute(s, t) {
+    throw new Error(
+      "parseXlsx requires async execution. Use parseXlsxAsyncImpl instead."
+    );
+  }
+};
+function C(s) {
+  return new Uint8Array(s).buffer;
+}
+const I = {
+  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);
+    else
+      throw new Error(
+        `parseXlsx expects stream or buffer input, got ${typeof s}`
+      );
+    const n = new $.Workbook();
+    return await n.xlsx.load(r), v.fromExcelJS(n, e.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 G(s, t) {
+  const e = new $.Workbook();
+  return await e.xlsx.readFile(s), v.fromExcelJS(e, t?.fileName ?? s);
+}
+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 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 j(s, t) {
+  return t?.firstRowAsHeaders ? B(s, t) : W(s, t);
+}
+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);
+    }
+    (n.length > 0 || t?.includeEmpty) && e.push(n);
+  }
+  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] = _;
+      } else
+        u[g] = 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);
+    }
+    o.push(a.join(e));
+  }
+  return o.join(r);
+}
+function Q(s, t) {
+  const e = s.usedRange();
+  return e.ok ? L(e.value, t) : "";
+}
+function Y(s) {
+  s.register(I);
+}
+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
+};
+//# sourceMappingURL=index.es.js.map