@openjsxl/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1262 @@
+// src/errors.ts
+var XlsxError = class extends Error {
+  /** Machine-readable discriminant; branch on this rather than the message. */
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "XlsxError";
+    this.code = code;
+  }
+};
+
+// src/ooxml/a1.ts
+var CODE_UPPER_A = 65;
+var CODE_UPPER_Z = 90;
+var CODE_LOWER_A = 97;
+var CODE_LOWER_Z = 122;
+function columnToIndex(letters) {
+  if (letters.length === 0) throw new Error("empty column reference");
+  let index = 0;
+  for (let i = 0; i < letters.length; i++) {
+    const code = letters.charCodeAt(i);
+    let value = 0;
+    if (code >= CODE_UPPER_A && code <= CODE_UPPER_Z) value = code - CODE_UPPER_A + 1;
+    else if (code >= CODE_LOWER_A && code <= CODE_LOWER_Z) value = code - CODE_LOWER_A + 1;
+    else throw new Error(`invalid column reference: ${letters}`);
+    index = index * 26 + value;
+    if (index > Number.MAX_SAFE_INTEGER)
+      throw new Error(`column reference too large: ${letters}`);
+  }
+  return index;
+}
+function indexToColumn(index) {
+  if (!Number.isInteger(index) || index < 1) throw new Error(`invalid column index: ${index}`);
+  let remaining = index;
+  let letters = "";
+  while (remaining > 0) {
+    const digit = (remaining - 1) % 26;
+    letters = String.fromCharCode(CODE_UPPER_A + digit) + letters;
+    remaining = Math.floor((remaining - 1) / 26);
+  }
+  return letters;
+}
+var A1_PATTERN = /^([A-Za-z]+)([1-9][0-9]*)$/;
+function parseRef(ref) {
+  const match = A1_PATTERN.exec(ref);
+  if (match === null) throw new Error(`invalid A1 reference: ${ref}`);
+  return {
+    col: columnToIndex(match[1]),
+    row: Number.parseInt(match[2], 10)
+  };
+}
+function formatRef(ref) {
+  if (!Number.isInteger(ref.row) || ref.row < 1) throw new Error(`invalid row index: ${ref.row}`);
+  return `${indexToColumn(ref.col)}${ref.row}`;
+}
+
+// src/ooxml/dates.ts
+var MS_PER_DAY = 864e5;
+var EPOCH_1900_UTC = Date.UTC(1899, 11, 30);
+var EPOCH_1904_UTC = Date.UTC(1904, 0, 1);
+function serialToDate(serial, date1904 = false) {
+  const epoch = date1904 ? EPOCH_1904_UTC : EPOCH_1900_UTC;
+  return new Date(epoch + Math.round(serial * MS_PER_DAY));
+}
+
+// src/ooxml/cell.ts
+function decodeCell(raw, ctx) {
+  const { ref, value } = raw;
+  switch (raw.type) {
+    case "s": {
+      const index = Number.parseInt(value ?? "", 10);
+      const resolved = Number.isInteger(index) ? ctx.sharedStrings[index] : void 0;
+      return resolved === void 0 ? { ref, type: "empty", value: null } : { ref, type: "string", value: resolved };
+    }
+    case "inlineStr":
+    case "str":
+      return value === void 0 ? { ref, type: "empty", value: null } : { ref, type: "string", value };
+    case "b":
+      return value === void 0 ? { ref, type: "empty", value: null } : { ref, type: "boolean", value: value === "1" };
+    case "e":
+      return value === void 0 ? { ref, type: "empty", value: null } : { ref, type: "error", value };
+    default: {
+      if (value === void 0 || value === "") return { ref, type: "empty", value: null };
+      const num = Number(value);
+      if (!Number.isFinite(num)) return { ref, type: "empty", value: null };
+      if (ctx.styles?.isDateStyle(raw.style)) {
+        return { ref, type: "date", value: serialToDate(num, ctx.date1904 ?? false) };
+      }
+      return { ref, type: "number", value: num };
+    }
+  }
+}
+
+// src/utils/chars.ts
+function isWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r";
+}
+
+// src/utils/xml-names.ts
+function localName(name) {
+  const colon = name.indexOf(":");
+  return colon === -1 ? name : name.slice(colon + 1);
+}
+function relationshipId(attrs) {
+  if (attrs["r:id"] !== void 0) return attrs["r:id"];
+  for (const key of Object.keys(attrs)) {
+    if (localName(key) === "id") return attrs[key];
+  }
+  return void 0;
+}
+
+// src/xml/entities.ts
+var ENTITY_PATTERN = /&(#x[0-9a-fA-F]+|#[0-9]+|amp|lt|gt|quot|apos);/g;
+function decodeXmlEntities(input) {
+  if (!input.includes("&")) return input;
+  return input.replace(ENTITY_PATTERN, (match, body) => {
+    switch (body) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return '"';
+      case "apos":
+        return "'";
+      default: {
+        const code = body[1] === "x" ? Number.parseInt(body.slice(2), 16) : Number.parseInt(body.slice(1), 10);
+        const isScalar = code >= 0 && code <= 1114111 && !(code >= 55296 && code <= 57343);
+        return isScalar ? String.fromCodePoint(code) : match;
+      }
+    }
+  });
+}
+
+// src/xml/tokenizer.ts
+function* tokenize(xml) {
+  const len = xml.length;
+  let i = xml.charCodeAt(0) === 65279 ? 1 : 0;
+  while (i < len) {
+    const lt = xml.indexOf("<", i);
+    if (lt === -1) {
+      const text = xml.slice(i);
+      if (text.length > 0) yield { kind: "text", value: decodeXmlEntities(text) };
+      break;
+    }
+    if (lt > i) {
+      yield { kind: "text", value: decodeXmlEntities(xml.slice(i, lt)) };
+    }
+    const next = xml[lt + 1];
+    if (next === "?") {
+      const end = xml.indexOf("?>", lt + 2);
+      i = end === -1 ? len : end + 2;
+      continue;
+    }
+    if (next === "!") {
+      if (xml.startsWith("<!--", lt)) {
+        const end2 = xml.indexOf("-->", lt + 4);
+        i = end2 === -1 ? len : end2 + 3;
+        continue;
+      }
+      if (xml.startsWith("<![CDATA[", lt)) {
+        const end2 = xml.indexOf("]]>", lt + 9);
+        const content = xml.slice(lt + 9, end2 === -1 ? len : end2);
+        if (content.length > 0) yield { kind: "text", value: content };
+        i = end2 === -1 ? len : end2 + 3;
+        continue;
+      }
+      const end = xml.indexOf(">", lt + 2);
+      i = end === -1 ? len : end + 1;
+      continue;
+    }
+    if (next === "/") {
+      const end = xml.indexOf(">", lt + 2);
+      const name2 = xml.slice(lt + 2, end === -1 ? len : end).trim();
+      yield { kind: "close", name: name2 };
+      i = end === -1 ? len : end + 1;
+      continue;
+    }
+    if (next === void 0 || next === ">" || next === "=" || isWhitespace(next)) {
+      yield { kind: "text", value: "<" };
+      i = lt + 1;
+      continue;
+    }
+    let j = lt + 1;
+    const nameStart = j;
+    while (j < len) {
+      const ch = xml[j];
+      if (isWhitespace(ch) || ch === ">" || ch === "/") break;
+      j++;
+    }
+    const name = xml.slice(nameStart, j);
+    const attrs = {};
+    let selfClosing = false;
+    while (j < len) {
+      while (j < len && isWhitespace(xml[j])) j++;
+      if (j >= len) break;
+      const ch = xml[j];
+      if (ch === ">") {
+        j++;
+        break;
+      }
+      if (ch === "/") {
+        selfClosing = true;
+        j++;
+        continue;
+      }
+      const attrNameStart = j;
+      while (j < len) {
+        const c = xml[j];
+        if (c === "=" || c === ">" || c === "/" || isWhitespace(c)) break;
+        j++;
+      }
+      const attrName = xml.slice(attrNameStart, j);
+      while (j < len && isWhitespace(xml[j])) j++;
+      if (xml[j] === "=") {
+        j++;
+        while (j < len && isWhitespace(xml[j])) j++;
+        const quote = xml[j];
+        if (quote === '"' || quote === "'") {
+          j++;
+          const close = xml.indexOf(quote, j);
+          const end = close === -1 ? len : close;
+          if (attrName.length > 0) attrs[attrName] = decodeXmlEntities(xml.slice(j, end));
+          j = close === -1 ? len : close + 1;
+        } else {
+          const valStart = j;
+          while (j < len && !isWhitespace(xml[j]) && xml[j] !== ">" && xml[j] !== "/") j++;
+          if (attrName.length > 0)
+            attrs[attrName] = decodeXmlEntities(xml.slice(valStart, j));
+        }
+      } else if (attrName.length > 0) {
+        attrs[attrName] = "";
+      }
+    }
+    yield { kind: "open", name, attrs, selfClosing };
+    i = j;
+  }
+}
+
+// src/xml/stream.ts
+var CDATA_OPEN = "<![CDATA[";
+var COMMENT_OPEN = "<!--";
+var MAX_ENTITY_TAIL = 16;
+function isPartialMarkerOf(buf, at, marker) {
+  const tail = buf.length - at;
+  return tail < marker.length && marker.startsWith(buf.slice(at));
+}
+function safeBoundary(buf) {
+  const len = buf.length;
+  let i = 0;
+  let safe = 0;
+  while (i < len) {
+    const lt = buf.indexOf("<", i);
+    if (lt === -1) {
+      const amp = buf.lastIndexOf("&");
+      const splitEntity = amp >= i && buf.indexOf(";", amp) === -1 && len - amp <= MAX_ENTITY_TAIL;
+      return splitEntity ? amp : len;
+    }
+    if (isPartialMarkerOf(buf, lt, COMMENT_OPEN) || isPartialMarkerOf(buf, lt, CDATA_OPEN)) {
+      return lt;
+    }
+    let end;
+    if (buf.startsWith(COMMENT_OPEN, lt)) {
+      end = buf.indexOf("-->", lt + COMMENT_OPEN.length);
+      if (end === -1) return lt;
+      i = end + 3;
+    } else if (buf.startsWith(CDATA_OPEN, lt)) {
+      end = buf.indexOf("]]>", lt + CDATA_OPEN.length);
+      if (end === -1) return lt;
+      i = end + 3;
+    } else if (buf[lt + 1] === "?") {
+      end = buf.indexOf("?>", lt + 2);
+      if (end === -1) return lt;
+      i = end + 2;
+    } else {
+      let k = lt + 1;
+      let quote = "";
+      let close = -1;
+      while (k < len) {
+        const ch = buf[k];
+        if (quote !== "") {
+          if (ch === quote) quote = "";
+        } else if (ch === '"' || ch === "'") {
+          quote = ch;
+        } else if (ch === ">") {
+          close = k;
+          break;
+        }
+        k++;
+      }
+      if (close === -1) return lt;
+      i = close + 1;
+    }
+    safe = i;
+  }
+  return safe;
+}
+function createXmlStream() {
+  let buffer = "";
+  return {
+    push(text) {
+      buffer += text;
+      const cut = safeBoundary(buffer);
+      if (cut === 0) return [];
+      const tokens = [...tokenize(buffer.slice(0, cut))];
+      buffer = buffer.slice(cut);
+      return tokens;
+    },
+    flush() {
+      if (buffer === "") return [];
+      const tokens = [...tokenize(buffer)];
+      buffer = "";
+      return tokens;
+    }
+  };
+}
+
+// src/ooxml/rels.ts
+function parseRels(xml) {
+  const rels = /* @__PURE__ */ new Map();
+  for (const token of tokenize(xml)) {
+    if (token.kind !== "open" || localName(token.name) !== "Relationship") continue;
+    const id = token.attrs.Id;
+    const target = token.attrs.Target;
+    if (id === void 0 || target === void 0) continue;
+    rels.set(id, {
+      id,
+      type: token.attrs.Type ?? "",
+      target,
+      targetMode: token.attrs.TargetMode === "External" ? "External" : "Internal"
+    });
+  }
+  return rels;
+}
+function resolveTarget(baseDir, target) {
+  const segments = target.startsWith("/") || baseDir === "" ? [] : baseDir.split("/");
+  for (const part of target.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") segments.pop();
+    else segments.push(part);
+  }
+  return segments.join("/");
+}
+
+// src/ooxml/shared-strings.ts
+function parseSharedStrings(xml) {
+  const strings = [];
+  let inItem = false;
+  let current = "";
+  let textDepth = 0;
+  let phoneticDepth = 0;
+  for (const token of tokenize(xml)) {
+    if (token.kind === "open") {
+      const name = localName(token.name);
+      if (name === "si") {
+        if (inItem) {
+          strings.push(current);
+          inItem = false;
+        }
+        if (token.selfClosing) {
+          strings.push("");
+        } else {
+          inItem = true;
+          current = "";
+          textDepth = 0;
+          phoneticDepth = 0;
+        }
+      } else if (inItem && !token.selfClosing) {
+        if (name === "t") textDepth++;
+        else if (name === "rPh" || name === "phoneticPr") phoneticDepth++;
+      }
+    } else if (token.kind === "text") {
+      if (inItem && textDepth > 0 && phoneticDepth === 0) current += token.value;
+    } else {
+      const name = localName(token.name);
+      if (!inItem) continue;
+      if (name === "t") {
+        if (textDepth > 0) textDepth--;
+      } else if (name === "rPh" || name === "phoneticPr") {
+        if (phoneticDepth > 0) phoneticDepth--;
+      } else if (name === "si") {
+        strings.push(current);
+        inItem = false;
+      }
+    }
+  }
+  return strings;
+}
+
+// src/ooxml/styles.ts
+var BUILTIN_FORMATS = {
+  0: "General",
+  1: "0",
+  2: "0.00",
+  3: "#,##0",
+  4: "#,##0.00",
+  5: '"$"#,##0_);("$"#,##0)',
+  6: '"$"#,##0_);[Red]("$"#,##0)',
+  7: '"$"#,##0.00_);("$"#,##0.00)',
+  8: '"$"#,##0.00_);[Red]("$"#,##0.00)',
+  9: "0%",
+  10: "0.00%",
+  11: "0.00E+00",
+  12: "# ?/?",
+  13: "# ??/??",
+  14: "mm-dd-yy",
+  15: "d-mmm-yy",
+  16: "d-mmm",
+  17: "mmm-yy",
+  18: "h:mm AM/PM",
+  19: "h:mm:ss AM/PM",
+  20: "h:mm",
+  21: "h:mm:ss",
+  22: "m/d/yy h:mm",
+  37: "#,##0_);(#,##0)",
+  38: "#,##0_);[Red](#,##0)",
+  39: "#,##0.00_);(#,##0.00)",
+  40: "#,##0.00_);[Red](#,##0.00)",
+  45: "mm:ss",
+  46: "[h]:mm:ss",
+  47: "mmss.0",
+  48: "##0.0E+0",
+  49: "@"
+};
+function isBuiltinDateId(id) {
+  return id >= 14 && id <= 22 || id >= 27 && id <= 36 || id >= 45 && id <= 47 || id >= 50 && id <= 58;
+}
+var ELAPSED_TIME = /\[(?:h+|m+|s+)\]/i;
+var NON_TOKEN = /\[[^\]]*\]|"[^"]*"|\\./g;
+var DATE_TOKEN = /[dmyhs]/i;
+function isDateFormatCode(formatCode) {
+  if (ELAPSED_TIME.test(formatCode)) return true;
+  return DATE_TOKEN.test(formatCode.replace(NON_TOKEN, ""));
+}
+function parseStyles(xml) {
+  const customFormats = /* @__PURE__ */ new Map();
+  const cellFormatIds = [];
+  let inNumFmts = false;
+  let inCellXfs = false;
+  for (const token of tokenize(xml)) {
+    if (token.kind === "text") continue;
+    const name = localName(token.name);
+    if (token.kind === "open") {
+      if (name === "numFmts") {
+        if (!token.selfClosing) inNumFmts = true;
+      } else if (name === "cellXfs") {
+        if (!token.selfClosing) inCellXfs = true;
+      } else if (name === "numFmt" && inNumFmts) {
+        const id = Number(token.attrs.numFmtId);
+        const code = token.attrs.formatCode;
+        if (Number.isInteger(id) && code !== void 0) customFormats.set(id, code);
+      } else if (name === "xf" && inCellXfs) {
+        const id = Number(token.attrs.numFmtId ?? "0");
+        cellFormatIds.push(Number.isInteger(id) ? id : 0);
+      }
+    } else if (token.kind === "close") {
+      if (name === "numFmts") inNumFmts = false;
+      else if (name === "cellXfs") inCellXfs = false;
+    }
+  }
+  function isDateStyle(styleIndex) {
+    const numFmtId = cellFormatIds[styleIndex ?? 0];
+    if (numFmtId === void 0) return false;
+    const custom = customFormats.get(numFmtId);
+    return custom !== void 0 ? isDateFormatCode(custom) : isBuiltinDateId(numFmtId);
+  }
+  function formatCode(styleIndex) {
+    const numFmtId = cellFormatIds[styleIndex ?? 0];
+    if (numFmtId === void 0) return void 0;
+    return customFormats.get(numFmtId) ?? BUILTIN_FORMATS[numFmtId];
+  }
+  return { isDateStyle, formatCode };
+}
+
+// src/ooxml/workbook.ts
+function parseWorkbook(xml) {
+  const sheets = [];
+  let date1904 = false;
+  for (const token of tokenize(xml)) {
+    if (token.kind !== "open") continue;
+    const tag = localName(token.name);
+    if (tag === "workbookPr") {
+      const flag = token.attrs.date1904;
+      if (flag === "1" || flag === "true") date1904 = true;
+    } else if (tag === "sheet") {
+      const name = token.attrs.name;
+      const rid = relationshipId(token.attrs);
+      if (name === void 0 || rid === void 0) continue;
+      const state = token.attrs.state;
+      sheets.push({ name, rid, visible: state !== "hidden" && state !== "veryHidden" });
+    }
+  }
+  return { sheets, date1904 };
+}
+
+// src/zip/inflate.ts
+async function inflateRaw(data, maxBytes = Number.POSITIVE_INFINITY) {
+  const blob = new Blob([data]);
+  const reader = blob.stream().pipeThrough(new DecompressionStream("deflate-raw")).getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > maxBytes) {
+      await reader.cancel();
+      throw new Error(`inflated output exceeds the expected ${maxBytes} bytes`);
+    }
+    chunks.push(value);
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
+async function* inflateRawStream(data, maxBytes = Number.POSITIVE_INFINITY) {
+  const blob = new Blob([data]);
+  const reader = blob.stream().pipeThrough(new DecompressionStream("deflate-raw")).getReader();
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        throw new Error(`inflated output exceeds the expected ${maxBytes} bytes`);
+      }
+      yield value;
+    }
+  } finally {
+    await reader.cancel().catch(() => {
+    });
+  }
+}
+
+// src/zip/central-directory.ts
+var SIG_EOCD = 101010256;
+var SIG_CENTRAL = 33639248;
+var SIG_LOCAL = 67324752;
+var EOCD_MIN_SIZE = 22;
+var MAX_COMMENT = 65535;
+var ZIP64_SENTINEL = 4294967295;
+function findEocd(view, len) {
+  const earliest = Math.max(0, len - EOCD_MIN_SIZE - MAX_COMMENT);
+  for (let pos = len - EOCD_MIN_SIZE; pos >= earliest; pos--) {
+    if (view.getUint32(pos, true) !== SIG_EOCD) continue;
+    const commentLen = view.getUint16(pos + 20, true);
+    if (pos + EOCD_MIN_SIZE + commentLen === len) return pos;
+  }
+  return -1;
+}
+function openZip(bytes, options) {
+  const len = bytes.byteLength;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, len);
+  const maxPartBytes = options?.maxPartBytes;
+  const eocd = findEocd(view, len);
+  if (eocd === -1) {
+    throw new XlsxError(
+      "not-a-zip",
+      "not a zip archive: end-of-central-directory record not found"
+    );
+  }
+  const entryCount = view.getUint16(eocd + 10, true);
+  const cdOffset = view.getUint32(eocd + 16, true);
+  if (cdOffset === ZIP64_SENTINEL)
+    throw new XlsxError("unsupported", "ZIP64 archives are not supported");
+  if (cdOffset > len) {
+    throw new XlsxError("corrupt-zip", "corrupt zip: central directory offset past end of file");
+  }
+  const decoder2 = new TextDecoder();
+  const entries = /* @__PURE__ */ new Map();
+  let pos = cdOffset;
+  for (let i = 0; i < entryCount; i++) {
+    if (pos + 46 > len || view.getUint32(pos, true) !== SIG_CENTRAL) {
+      throw new XlsxError(
+        "corrupt-zip",
+        `corrupt zip: bad central directory header at offset ${pos}`
+      );
+    }
+    const method = view.getUint16(pos + 10, true);
+    const compressedSize = view.getUint32(pos + 20, true);
+    const uncompressedSize = view.getUint32(pos + 24, true);
+    const nameLen = view.getUint16(pos + 28, true);
+    const extraLen = view.getUint16(pos + 30, true);
+    const commentLen = view.getUint16(pos + 32, true);
+    const localHeaderOffset = view.getUint32(pos + 42, true);
+    if (compressedSize === ZIP64_SENTINEL || uncompressedSize === ZIP64_SENTINEL || localHeaderOffset === ZIP64_SENTINEL) {
+      throw new XlsxError("unsupported", "ZIP64 archives are not supported");
+    }
+    const name = decoder2.decode(bytes.subarray(pos + 46, pos + 46 + nameLen));
+    pos += 46 + nameLen + extraLen + commentLen;
+    if (name.endsWith("/")) continue;
+    if (entries.has(name)) {
+      throw new XlsxError("corrupt-zip", `corrupt zip: duplicate entry name ${name}`);
+    }
+    entries.set(name, { name, method, compressedSize, uncompressedSize, localHeaderOffset });
+  }
+  function locate(name) {
+    const entry = entries.get(name);
+    if (entry === void 0) throw new XlsxError("missing-part", `zip entry not found: ${name}`);
+    if (maxPartBytes !== void 0 && entry.uncompressedSize > maxPartBytes) {
+      throw new XlsxError(
+        "part-too-large",
+        `zip part ${name} declares ${entry.uncompressedSize} bytes, over the ${maxPartBytes}-byte limit`
+      );
+    }
+    const header = entry.localHeaderOffset;
+    if (header + 30 > len || view.getUint32(header, true) !== SIG_LOCAL) {
+      throw new XlsxError("corrupt-zip", `corrupt zip: bad local header for ${name}`);
+    }
+    const nameLen = view.getUint16(header + 26, true);
+    const extraLen = view.getUint16(header + 28, true);
+    const dataStart = header + 30 + nameLen + extraLen;
+    if (dataStart + entry.compressedSize > len) {
+      throw new XlsxError(
+        "corrupt-zip",
+        `corrupt zip: entry data for ${name} runs past end of file`
+      );
+    }
+    return { entry, payload: bytes.subarray(dataStart, dataStart + entry.compressedSize) };
+  }
+  async function read(name) {
+    const { entry, payload } = locate(name);
+    if (entry.method === 0) return payload;
+    if (entry.method === 8) {
+      if (entry.compressedSize === 0) return new Uint8Array(0);
+      try {
+        return await inflateRaw(payload, entry.uncompressedSize);
+      } catch (cause) {
+        throw new XlsxError("corrupt-zip", `corrupt zip: failed to inflate ${name}`, {
+          cause
+        });
+      }
+    }
+    throw new XlsxError(
+      "unsupported",
+      `unsupported zip compression method ${entry.method} for ${name}`
+    );
+  }
+  async function* readStream(name) {
+    const { entry, payload } = locate(name);
+    if (entry.method === 0) {
+      if (payload.byteLength > 0) yield payload;
+      return;
+    }
+    if (entry.method === 8) {
+      if (entry.compressedSize === 0) return;
+      try {
+        yield* inflateRawStream(payload, entry.uncompressedSize);
+      } catch (cause) {
+        throw new XlsxError("corrupt-zip", `corrupt zip: failed to inflate ${name}`, {
+          cause
+        });
+      }
+      return;
+    }
+    throw new XlsxError(
+      "unsupported",
+      `unsupported zip compression method ${entry.method} for ${name}`
+    );
+  }
+  return {
+    entries,
+    has: (name) => entries.has(name),
+    read,
+    readStream
+  };
+}
+
+// src/reader/worksheet.ts
+function safeColumn(ref) {
+  try {
+    return parseRef(ref).col;
+  } catch {
+    return void 0;
+  }
+}
+function columnStyleFromToken(attrs) {
+  if (attrs.style === void 0) return void 0;
+  const style = Number(attrs.style);
+  const min = Number(attrs.min);
+  const max = Number(attrs.max);
+  if (!Number.isInteger(style) || !Number.isInteger(min) || !Number.isInteger(max))
+    return void 0;
+  return { min, max, style };
+}
+function rowDefaultStyleFromToken(attrs) {
+  if (attrs.customFormat !== "1" && attrs.customFormat !== "true") return void 0;
+  if (attrs.s === void 0) return void 0;
+  const s = Number(attrs.s);
+  return Number.isInteger(s) ? s : void 0;
+}
+function effectiveStyle(ownS, rowDefault, col, columns) {
+  if (ownS !== void 0) {
+    const s = Number(ownS);
+    return Number.isInteger(s) ? s : void 0;
+  }
+  if (rowDefault !== void 0) return rowDefault;
+  if (col !== void 0) {
+    const range = columns.find((c) => col >= c.min && col <= c.max);
+    if (range !== void 0) return range.style;
+  }
+  return void 0;
+}
+function createRowAssembler(ctx) {
+  let inSheetData = false;
+  let inRow = false;
+  let lastRow = 0;
+  let rowIndex = 0;
+  let cells = [];
+  let lastCol = 0;
+  const columns = [];
+  let rowDefault;
+  let inCell = false;
+  let cellRef = "";
+  let cellType;
+  let cellStyle;
+  let cellIsInline = false;
+  let cellValue = "";
+  let hasValue = false;
+  let inValue = false;
+  let inInline = false;
+  let textDepth = 0;
+  let phoneticDepth = 0;
+  const flushCell = () => {
+    if (!inCell) return;
+    cells.push(
+      decodeCell(
+        {
+          ref: cellRef,
+          type: cellType,
+          value: hasValue ? cellValue : void 0,
+          style: cellStyle
+        },
+        ctx
+      )
+    );
+    inCell = false;
+  };
+  function push(token) {
+    const out = [];
+    if (token.kind === "open") {
+      const name2 = localName(token.name);
+      if (name2 === "sheetData") {
+        if (!token.selfClosing) inSheetData = true;
+        return out;
+      }
+      if (name2 === "col") {
+        const cs = columnStyleFromToken(token.attrs);
+        if (cs !== void 0) columns.push(cs);
+        return out;
+      }
+      if (!inSheetData) return out;
+      if (name2 === "row") {
+        flushCell();
+        if (inRow) out.push({ index: rowIndex, cells });
+        const r = token.attrs.r;
+        const parsed = r !== void 0 ? Number.parseInt(r, 10) : Number.NaN;
+        rowIndex = Number.isInteger(parsed) && parsed > 0 ? parsed : lastRow + 1;
+        lastRow = rowIndex;
+        rowDefault = rowDefaultStyleFromToken(token.attrs);
+        cells = [];
+        lastCol = 0;
+        if (token.selfClosing) {
+          out.push({ index: rowIndex, cells });
+          inRow = false;
+        } else {
+          inRow = true;
+        }
+        return out;
+      }
+      if (!inRow) return out;
+      if (name2 === "c") {
+        flushCell();
+        const r = token.attrs.r;
+        let col;
+        if (r !== void 0) {
+          cellRef = r;
+          col = safeColumn(r);
+          if (col !== void 0) lastCol = col;
+        } else {
+          lastCol += 1;
+          col = lastCol;
+          cellRef = formatRef({ col: lastCol, row: rowIndex });
+        }
+        cellType = token.attrs.t;
+        cellStyle = effectiveStyle(token.attrs.s, rowDefault, col, columns);
+        cellIsInline = cellType === "inlineStr";
+        cellValue = "";
+        hasValue = false;
+        inValue = false;
+        inInline = false;
+        textDepth = 0;
+        phoneticDepth = 0;
+        if (token.selfClosing) {
+          cells.push(
+            decodeCell(
+              { ref: cellRef, type: cellType, value: void 0, style: cellStyle },
+              ctx
+            )
+          );
+        } else {
+          inCell = true;
+        }
+        return out;
+      }
+      if (!inCell) return out;
+      if (cellIsInline) {
+        if (name2 === "is") {
+          hasValue = true;
+          if (!token.selfClosing) inInline = true;
+        } else if (name2 === "t") {
+          if (inInline && !token.selfClosing) textDepth++;
+        } else if (name2 === "rPh" || name2 === "phoneticPr") {
+          if (inInline && !token.selfClosing) phoneticDepth++;
+        }
+      } else if (name2 === "v") {
+        hasValue = true;
+        if (!token.selfClosing) inValue = true;
+      }
+      return out;
+    }
+    if (token.kind === "text") {
+      const collect = cellIsInline ? inInline && textDepth > 0 && phoneticDepth === 0 : inValue;
+      if (inCell && collect) {
+        cellValue += token.value;
+        hasValue = true;
+      }
+      return out;
+    }
+    const name = localName(token.name);
+    if (name === "sheetData") {
+      flushCell();
+      if (inRow) {
+        out.push({ index: rowIndex, cells });
+        inRow = false;
+      }
+      inSheetData = false;
+      return out;
+    }
+    if (name === "row") {
+      if (inRow) {
+        flushCell();
+        out.push({ index: rowIndex, cells });
+        inRow = false;
+      }
+      return out;
+    }
+    if (!inCell) return out;
+    if (name === "c") flushCell();
+    else if (name === "v") inValue = false;
+    else if (name === "is") inInline = false;
+    else if (name === "t") {
+      if (textDepth > 0) textDepth--;
+    } else if (name === "rPh" || name === "phoneticPr") {
+      if (phoneticDepth > 0) phoneticDepth--;
+    }
+    return out;
+  }
+  function flush() {
+    flushCell();
+    if (inRow) {
+      inRow = false;
+      return [{ index: rowIndex, cells }];
+    }
+    return [];
+  }
+  return { push, flush };
+}
+function parseComments(xml) {
+  const authors = [];
+  const comments = [];
+  let inAuthors = false;
+  let authorText;
+  let current;
+  let inText = false;
+  let tDepth = 0;
+  let text = "";
+  for (const token of tokenize(xml)) {
+    if (token.kind === "open") {
+      const name = localName(token.name);
+      if (name === "authors") {
+        if (!token.selfClosing) inAuthors = true;
+      } else if (name === "author" && inAuthors) {
+        if (token.selfClosing) authors.push("");
+        else authorText = "";
+      } else if (name === "comment") {
+        const ref = token.attrs.ref;
+        const rawId = token.attrs.authorId;
+        const authorId = rawId !== void 0 && rawId !== "" && Number.isInteger(Number(rawId)) ? Number(rawId) : -1;
+        current = ref !== void 0 && ref !== "" ? { ref, authorId } : void 0;
+        text = "";
+        inText = false;
+        tDepth = 0;
+      } else if (name === "text" && current !== void 0) {
+        if (!token.selfClosing) inText = true;
+      } else if (name === "t" && inText) {
+        if (!token.selfClosing) tDepth++;
+      }
+    } else if (token.kind === "text") {
+      if (authorText !== void 0) authorText += token.value;
+      else if (inText && tDepth > 0) text += token.value;
+    } else {
+      const name = localName(token.name);
+      if (name === "authors") inAuthors = false;
+      else if (name === "author" && authorText !== void 0) {
+        authors.push(authorText);
+        authorText = void 0;
+      } else if (name === "t") {
+        if (tDepth > 0) tDepth--;
+      } else if (name === "text") inText = false;
+      else if (name === "comment" && current !== void 0) {
+        const author = authors[current.authorId];
+        comments.push({
+          ref: current.ref,
+          ...author !== void 0 && author !== "" ? { author } : {},
+          text
+        });
+        current = void 0;
+      }
+    }
+  }
+  return comments;
+}
+function parseDimension(xml) {
+  for (const token of tokenize(xml)) {
+    if (token.kind === "open" && localName(token.name) === "dimension") {
+      const ref = token.attrs.ref;
+      if (ref !== void 0 && ref !== "") return ref;
+    }
+  }
+  return void 0;
+}
+function parseCellStyles(xml) {
+  const styles = /* @__PURE__ */ new Map();
+  const columns = [];
+  let rowDefault;
+  let lastRow = 0;
+  let rowIndex = 0;
+  let lastCol = 0;
+  for (const token of tokenize(xml)) {
+    if (token.kind !== "open") continue;
+    const name = localName(token.name);
+    if (name === "col") {
+      const cs = columnStyleFromToken(token.attrs);
+      if (cs !== void 0) columns.push(cs);
+      continue;
+    }
+    if (name === "row") {
+      const r2 = token.attrs.r;
+      const parsed = r2 !== void 0 ? Number.parseInt(r2, 10) : Number.NaN;
+      rowIndex = Number.isInteger(parsed) && parsed > 0 ? parsed : lastRow + 1;
+      lastRow = rowIndex;
+      rowDefault = rowDefaultStyleFromToken(token.attrs);
+      lastCol = 0;
+      continue;
+    }
+    if (name !== "c") continue;
+    const r = token.attrs.r;
+    let ref;
+    let col;
+    if (r !== void 0) {
+      ref = r;
+      col = safeColumn(r);
+      if (col !== void 0) lastCol = col;
+    } else {
+      lastCol += 1;
+      col = lastCol;
+      ref = formatRef({ col: lastCol, row: rowIndex });
+    }
+    const index = effectiveStyle(token.attrs.s, rowDefault, col, columns);
+    if (index !== void 0) styles.set(ref, index);
+  }
+  return styles;
+}
+function* readRows(xml, ctx) {
+  const assembler = createRowAssembler(ctx);
+  for (const token of tokenize(xml)) yield* assembler.push(token);
+  yield* assembler.flush();
+}
+function parseMergedCells(xml) {
+  const ranges = [];
+  for (const token of tokenize(xml)) {
+    if (token.kind === "open" && localName(token.name) === "mergeCell") {
+      const ref = token.attrs.ref;
+      if (ref !== void 0 && ref !== "") ranges.push(ref);
+    }
+  }
+  return ranges;
+}
+function parseHyperlinks(xml, rels) {
+  const links = [];
+  for (const token of tokenize(xml)) {
+    if (token.kind !== "open" || localName(token.name) !== "hyperlink") continue;
+    const ref = token.attrs.ref;
+    if (ref === void 0 || ref === "") continue;
+    const rid = relationshipId(token.attrs);
+    const target = rid !== void 0 ? rels?.get(rid)?.target : void 0;
+    const location = token.attrs.location;
+    const tooltip = token.attrs.tooltip;
+    const display = token.attrs.display;
+    links.push({
+      ref,
+      ...target !== void 0 ? { target } : {},
+      ...location !== void 0 && location !== "" ? { location } : {},
+      ...tooltip !== void 0 ? { tooltip } : {},
+      ...display !== void 0 ? { display } : {}
+    });
+  }
+  return links;
+}
+async function* streamRows(chunks, ctx) {
+  const assembler = createRowAssembler(ctx);
+  const xml = createXmlStream();
+  const decoder2 = new TextDecoder();
+  for await (const bytes of chunks) {
+    const text = decoder2.decode(bytes, { stream: true });
+    if (text === "") continue;
+    for (const token of xml.push(text)) yield* assembler.push(token);
+  }
+  const tail = decoder2.decode();
+  if (tail !== "") for (const token of xml.push(tail)) yield* assembler.push(token);
+  for (const token of xml.flush()) yield* assembler.push(token);
+  yield* assembler.flush();
+}
+
+// src/reader/workbook.ts
+var decoder = new TextDecoder();
+var REL_OFFICE_DOCUMENT = "/officeDocument";
+var REL_SHARED_STRINGS = "/sharedStrings";
+var REL_STYLES = "/styles";
+var REL_COMMENTS = "/comments";
+function directoryOf(path) {
+  const slash = path.lastIndexOf("/");
+  return slash === -1 ? "" : path.slice(0, slash);
+}
+function relsPathFor(path) {
+  const slash = path.lastIndexOf("/");
+  const dir = slash === -1 ? "" : path.slice(0, slash);
+  const file = slash === -1 ? path : path.slice(slash + 1);
+  return dir === "" ? `_rels/${file}.rels` : `${dir}/_rels/${file}.rels`;
+}
+async function readText(zip, path) {
+  if (!zip.has(path))
+    throw new XlsxError("missing-part", `xlsx is missing a required part: ${path}`);
+  return decoder.decode(await zip.read(path));
+}
+var Worksheet = class {
+  /** Sheet name as shown on Excel's tab. */
+  name;
+  #info;
+  #xml;
+  #context;
+  #rels;
+  #commentsXml;
+  #cells;
+  #merged;
+  #hyperlinks;
+  #cellStyles;
+  #dimension;
+  #dimensionRead = false;
+  #comments;
+  constructor(info, xml, context, rels, commentsXml) {
+    this.name = info.name;
+    this.#info = info;
+    this.#xml = xml;
+    this.#context = context;
+    this.#rels = rels;
+    this.#commentsXml = commentsXml;
+  }
+  /** Workbook-relative part path, e.g. `xl/worksheets/sheet1.xml`. */
+  get path() {
+    return this.#info.path;
+  }
+  /** false for hidden or very-hidden sheets. */
+  get visible() {
+    return this.#info.visible;
+  }
+  /**
+   * Merged-cell ranges in A1 notation (e.g. `['A1:B1', 'A2:A4']`), in document order. Only the
+   * top-left cell of a merge holds a value; the rest read as `empty`. Empty when none.
+   */
+  get mergedCells() {
+    if (this.#merged === void 0) this.#merged = parseMergedCells(this.#xml);
+    return this.#merged;
+  }
+  /**
+   * Hyperlinks declared on this sheet, in document order. Each carries the covered `ref` and,
+   * where present, a resolved external `target`, an in-workbook `location`, a `tooltip`, and a
+   * `display` override. Empty when none.
+   */
+  get hyperlinks() {
+    if (this.#hyperlinks === void 0) {
+      this.#hyperlinks = parseHyperlinks(this.#xml, this.#rels);
+    }
+    return this.#hyperlinks;
+  }
+  /**
+   * The number-format code applied to the cell at `ref` — a custom code like `"yyyy-mm-dd"`
+   * or `"0.00%"`, or a built-in one. `undefined` when the workbook has no style table or the
+   * id has no portable code. An unstyled or absent cell resolves to the default format (style
+   * 0, usually `"General"`), mirroring how date detection defaults.
+   */
+  numberFormat(ref) {
+    return this.#context.styles?.formatCode(this.#cellStyleMap().get(ref));
+  }
+  /**
+   * The sheet's declared used range in A1 notation (e.g. `"A1:E10"`, or a single cell), from
+   * the worksheet's `<dimension>`. `undefined` when the producer omits it — it is an optional
+   * hint, not authoritative, so treat a present value as advisory.
+   */
+  get dimension() {
+    if (!this.#dimensionRead) {
+      this.#dimension = parseDimension(this.#xml);
+      this.#dimensionRead = true;
+    }
+    return this.#dimension;
+  }
+  /**
+   * The comments anchored to cells on this sheet, in document order — each with its `ref`,
+   * resolved `author`, and plain `text`. Empty when the sheet has no comments part.
+   */
+  get comments() {
+    if (this.#comments === void 0) {
+      this.#comments = this.#commentsXml === void 0 ? [] : parseComments(this.#commentsXml);
+    }
+    return this.#comments;
+  }
+  #cellStyleMap() {
+    if (this.#cellStyles === void 0) this.#cellStyles = parseCellStyles(this.#xml);
+    return this.#cellStyles;
+  }
+  /** The cell at an A1 reference. Absent cells read as `empty` (Excel treats them blank). */
+  cell(ref) {
+    return this.#index().get(ref) ?? { ref, type: "empty", value: null };
+  }
+  /** Stream the populated rows in document order. Sparse: empty rows/cells are absent. */
+  async *rows() {
+    for (const row of readRows(this.#xml, this.#context)) {
+      yield row;
+    }
+  }
+  #index() {
+    if (this.#cells === void 0) {
+      const cells = /* @__PURE__ */ new Map();
+      for (const row of readRows(this.#xml, this.#context)) {
+        for (const cell of row.cells) cells.set(cell.ref, cell);
+      }
+      this.#cells = cells;
+    }
+    return this.#cells;
+  }
+};
+var Workbook = class {
+  /** Sheets in tab order. */
+  sheets;
+  #byName;
+  constructor(sheets, byName) {
+    this.sheets = sheets;
+    this.#byName = byName;
+  }
+  /** The worksheet with this tab name. Throws if there is none. */
+  sheet(name) {
+    const worksheet = this.#byName.get(name);
+    if (worksheet === void 0) {
+      const available = this.sheets.map((s) => s.name).join(", ");
+      throw new XlsxError(
+        "no-such-sheet",
+        `no sheet named ${JSON.stringify(name)}; available: ${available}`
+      );
+    }
+    return worksheet;
+  }
+};
+async function loadWorkbook(source, options) {
+  const bytes = source instanceof Uint8Array ? source : new Uint8Array(source);
+  const zip = openZip(bytes, options);
+  const packageRels = parseRels(await readText(zip, "_rels/.rels"));
+  const office = [...packageRels.values()].find((r) => r.type.endsWith(REL_OFFICE_DOCUMENT));
+  if (office === void 0) {
+    throw new XlsxError("not-xlsx", "not an xlsx: no officeDocument relationship");
+  }
+  const workbookPath = resolveTarget("", office.target);
+  const workbookDir = directoryOf(workbookPath);
+  const { sheets: workbookSheets, date1904 } = parseWorkbook(await readText(zip, workbookPath));
+  const workbookRels = parseRels(await readText(zip, relsPathFor(workbookPath)));
+  let sharedStrings = [];
+  const sst = [...workbookRels.values()].find((r) => r.type.endsWith(REL_SHARED_STRINGS));
+  if (sst !== void 0 && sst.targetMode !== "External") {
+    const sstPath = resolveTarget(workbookDir, sst.target);
+    if (zip.has(sstPath)) {
+      sharedStrings = parseSharedStrings(decoder.decode(await zip.read(sstPath)));
+    }
+  }
+  let styles;
+  const stylesRel = [...workbookRels.values()].find((r) => r.type.endsWith(REL_STYLES));
+  if (stylesRel !== void 0 && stylesRel.targetMode !== "External") {
+    const stylesPath = resolveTarget(workbookDir, stylesRel.target);
+    if (zip.has(stylesPath)) {
+      styles = parseStyles(decoder.decode(await zip.read(stylesPath)));
+    }
+  }
+  const context = styles !== void 0 ? { sharedStrings, date1904, styles } : { sharedStrings, date1904 };
+  const sheets = [];
+  for (const entry of workbookSheets) {
+    const rel = workbookRels.get(entry.rid);
+    if (rel === void 0 || rel.targetMode === "External") continue;
+    const path = resolveTarget(workbookDir, rel.target);
+    if (!zip.has(path)) continue;
+    sheets.push({ info: { name: entry.name, path, visible: entry.visible }, path });
+  }
+  return { zip, context, sheets };
+}
+async function openXlsx(source, options) {
+  const { zip, context, sheets } = await loadWorkbook(source, options);
+  const infos = [];
+  const byName = /* @__PURE__ */ new Map();
+  for (const { info, path } of sheets) {
+    const xml = decoder.decode(await zip.read(path));
+    const relsPath = relsPathFor(path);
+    const rels = zip.has(relsPath) ? parseRels(decoder.decode(await zip.read(relsPath))) : void 0;
+    let commentsXml;
+    const commentsRel = rels && [...rels.values()].find((r) => r.type.endsWith(REL_COMMENTS));
+    if (commentsRel !== void 0 && commentsRel.targetMode !== "External") {
+      const commentsPath = resolveTarget(directoryOf(path), commentsRel.target);
+      if (zip.has(commentsPath)) commentsXml = decoder.decode(await zip.read(commentsPath));
+    }
+    infos.push(info);
+    if (!byName.has(info.name)) {
+      byName.set(info.name, new Worksheet(info, xml, context, rels, commentsXml));
+    }
+  }
+  return new Workbook(infos, byName);
+}
+async function* streamSheetRows(source, sheetName, options) {
+  const { zip, context, sheets } = await loadWorkbook(source, options);
+  const first = sheets[0];
+  if (first === void 0) throw new XlsxError("not-xlsx", "xlsx has no readable worksheets");
+  let path = first.path;
+  if (sheetName !== void 0) {
+    const match = sheets.find((s) => s.info.name === sheetName);
+    if (match === void 0) {
+      const available = sheets.map((s) => s.info.name).join(", ");
+      throw new XlsxError(
+        "no-such-sheet",
+        `no sheet named ${JSON.stringify(sheetName)}; available: ${available}`
+      );
+    }
+    path = match.path;
+  }
+  yield* streamRows(zip.readStream(path), context);
+}
+
+export { Workbook, Worksheet, XlsxError, columnToIndex, formatRef, indexToColumn, openXlsx, parseRef, serialToDate, streamSheetRows };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map