@autorag/librarian 2.13.4 → 2.13.6

package/dist/parser/parse-worker.js

@@ -90,35 +90,340 @@ var init_language = __esm(() => {
   };
 });
 
-// src/parser/errors.ts
-function messageFrom(cause) {
-  if (cause instanceof Error)
-    return cause.message;
-  if (typeof cause === "string")
-    return cause;
-  return "unknown parser failure";
+// src/parser/spreadsheet-render.ts
+function estimateLineTokens(text) {
+  let halves = 0;
+  for (const char of text) {
+    const code = char.codePointAt(0) ?? 0;
+    halves += code < 128 ? 1 : code < 2048 ? 2 : 4;
+  }
+  return Math.ceil(halves / 2);
 }
-var ParseError, ParseIsolationError;
-var init_errors = __esm(() => {
-  ParseError = class ParseError extends Error {
-    parserName;
-    virtualPath;
-    constructor(parserName, virtualPath, cause) {
-      super(`Parser "${parserName}" failed for ${virtualPath}: ${messageFrom(cause)}`);
-      this.name = "ParseError";
-      this.parserName = parserName;
-      this.virtualPath = virtualPath;
-      this.cause = cause;
+function classifyText(text) {
+  const trimmed = text.trim();
+  if (NUMBER_TEXT.test(trimmed))
+    return "number";
+  if (DATE_TEXT.test(trimmed))
+    return "date";
+  return "text";
+}
+function renderWorkbook(sheets) {
+  return sheets.map(renderSheet).join(`
+
+`);
+}
+
+class SheetView {
+  rowCount;
+  colCount;
+  #grid;
+  #merges = new Map;
+  constructor(grid) {
+    this.#grid = grid;
+    this.rowCount = grid.rows.length;
+    const widest = grid.rows.reduce((max, row) => Math.max(max, row?.length ?? 0), 0);
+    const merges = (grid.merges ?? []).filter((merge) => merge.top < this.rowCount && merge.left < widest);
+    this.colCount = merges.reduce((max, merge) => Math.max(max, Math.min(merge.right, MAX_COLUMNS - 1) + 1), widest);
+    for (const merge of merges) {
+      const bottom = Math.min(merge.bottom, this.rowCount - 1);
+      const right = Math.min(merge.right, this.colCount - 1);
+      for (let row = merge.top;row <= bottom; row++) {
+        for (let col = merge.left;col <= right; col++)
+          this.#merges.set(row * COLUMN_STRIDE + col, merge);
+      }
     }
-  };
-  ParseIsolationError = class ParseIsolationError extends Error {
-    code;
-    constructor(code, message) {
-      super(message);
-      this.name = "ParseIsolationError";
-      this.code = code;
+  }
+  resolve(row, col) {
+    const merge = this.#merges.get(row * COLUMN_STRIDE + col);
+    const anchorRow = merge?.top ?? row;
+    const anchorCol = merge?.left ?? col;
+    const cell = this.#grid.rows[anchorRow]?.[anchorCol];
+    if (cell === undefined || clean(cell.text) === "")
+      return;
+    return { cell, row: anchorRow, col: anchorCol, merge };
+  }
+}
+function renderSheet(grid) {
+  const view = new SheetView(grid);
+  const heading = `## ${grid.name}${grid.hidden === true ? " (hidden)" : ""}`;
+  const blocks = [];
+  let pendingCaptions = [];
+  let previous;
+  const bands = findBands(view);
+  for (const [index, band] of bands.entries()) {
+    const rows = range(band.top, band.bottom);
+    if (rows.every((row) => singleValue(view, row, band) !== undefined)) {
+      const next = bands[index + 1];
+      const captionsNext = next !== undefined && rows.length <= MAX_CAPTION_BLOCK_ROWS && next.top - band.bottom - 1 <= MAX_CAPTION_GAP_ROWS && !range(next.top, next.bottom).every((row) => singleValue(view, row, next) !== undefined);
+      if (captionsNext) {
+        pendingCaptions = rows.map((row) => singleValue(view, row, band));
+        continue;
+      }
+      blocks.push(rows.map((row) => `[${grid.name}!${cellRange(band.left, band.right, row)}] ${singleValue(view, row, band)}`).join(`
+`));
+      continue;
+    }
+    let start = 0;
+    const ownCaptions = [];
+    while (start < rows.length && singleValue(view, rows[start], band) !== undefined) {
+      ownCaptions.push(singleValue(view, rows[start], band));
+      start++;
+    }
+    const body = rows.slice(start);
+    let captions = [...pendingCaptions, ...ownCaptions];
+    pendingCaptions = [];
+    const detected = detectHeader(view, band, body);
+    let header = detected?.header;
+    let dataRows = detected === undefined ? body : body.slice(detected.headerRows);
+    if (header === undefined && previous !== undefined && continuesTable(view, band, body, previous)) {
+      header = previous.header;
+      dataRows = body;
+      if (captions.length === 0)
+        captions = [...previous.captions];
+    }
+    if (header !== undefined)
+      previous = { band, header, captions };
+    const lines = dataRows.flatMap((row) => renderRow(grid.name, view, band, row, dataRows[0], header, captions));
+    if (lines.length > 0)
+      blocks.push(lines.join(`
+`));
+  }
+  return [heading, ...blocks].join(`
+
+`);
+}
+function findBands(view) {
+  const bands = [];
+  let current;
+  for (let row = 0;row < view.rowCount; row++) {
+    let left = Number.POSITIVE_INFINITY;
+    let right = Number.NEGATIVE_INFINITY;
+    for (let col = 0;col < view.colCount; col++) {
+      if (view.resolve(row, col) === undefined)
+        continue;
+      left = Math.min(left, col);
+      right = Math.max(right, col);
+    }
+    if (right < left) {
+      if (current !== undefined)
+        bands.push(current);
+      current = undefined;
+      continue;
+    }
+    if (current === undefined)
+      current = { top: row, bottom: row, left, right };
+    else {
+      current.bottom = row;
+      current.left = Math.min(current.left, left);
+      current.right = Math.max(current.right, right);
     }
+  }
+  if (current !== undefined)
+    bands.push(current);
+  return bands;
+}
+function rowValues(view, row, band) {
+  const values = [];
+  const seen = new Set;
+  for (let col = band.left;col <= band.right; col++) {
+    const resolved = view.resolve(row, col);
+    if (resolved === undefined)
+      continue;
+    const key = resolved.row * COLUMN_STRIDE + resolved.col;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    values.push(resolved);
+  }
+  return values;
+}
+function singleValue(view, row, band) {
+  const values = rowValues(view, row, band);
+  return values.length === 1 ? clean(values[0].cell.text) : undefined;
+}
+function detectHeader(view, band, body) {
+  const [first, second] = body;
+  if (first === undefined)
+    return;
+  const firstValues = rowValues(view, first, band);
+  if (firstValues.length < 2 || !firstValues.every((value) => headerLike(value.cell)))
+    return;
+  const grouped = firstValues.some((value) => value.row === first && value.merge !== undefined && value.merge.right > value.merge.left);
+  if (grouped && second !== undefined && body.length >= 3) {
+    const childValues = rowValues(view, second, band).filter((value) => value.row === second);
+    if (childValues.length >= 2 && childValues.every((value) => headerLike(value.cell))) {
+      const labels = new Map;
+      for (let col = band.left;col <= band.right; col++) {
+        const parent = labelAt(view, first, col);
+        const child = labelAt(view, second, col);
+        const label = child !== "" && child !== parent ? parent === "" ? child : `${parent} > ${child}` : parent;
+        if (label !== "")
+          labels.set(col, label);
+      }
+      const data = body.slice(2);
+      return { header: { labels, typedColumns: typedColumns(view, band, data, MIN_TYPED_SHARE, 1) }, headerRows: 2 };
+    }
+  }
+  const data = body.slice(1);
+  if (data.length < MIN_HEADER_DATA_ROWS)
+    return;
+  const typed = typedColumns(view, band, data, MIN_TYPED_SHARE, MIN_HEADER_DATA_ROWS);
+  if (typed.length === 0)
+    return;
+  const labels = new Map;
+  for (let col = band.left;col <= band.right; col++) {
+    const label = labelAt(view, first, col);
+    if (label !== "")
+      labels.set(col, label);
+  }
+  return { header: { labels, typedColumns: typed }, headerRows: 1 };
+}
+function headerLike(cell) {
+  const text = clean(cell.text);
+  if (cell.kind === "number")
+    return YEAR_TEXT.test(text);
+  return cell.kind === "text" && text.length <= MAX_HEADER_CELL_CHARS;
+}
+function labelAt(view, row, col) {
+  const resolved = view.resolve(row, col);
+  return resolved === undefined ? "" : clean(resolved.cell.text);
+}
+function typedColumns(view, band, rows, share, minimum) {
+  const columns = [];
+  for (let col = band.left;col <= band.right; col++) {
+    let filled = 0;
+    let typed = 0;
+    for (const row of rows) {
+      const resolved = view.resolve(row, col);
+      if (resolved === undefined || resolved.col !== col)
+        continue;
+      filled++;
+      if (resolved.cell.kind !== "text")
+        typed++;
+    }
+    if (filled >= minimum && typed / filled >= share)
+      columns.push(col);
+  }
+  return columns;
+}
+function continuesTable(view, band, body, previous) {
+  if (band.left < previous.band.left || band.right > previous.band.right)
+    return false;
+  const columns = previous.header.typedColumns.filter((col) => col >= band.left && col <= band.right);
+  if (columns.length === 0)
+    return false;
+  const typed = typedColumns(view, band, body, MIN_TYPED_SHARE, 1);
+  return columns.every((col) => typed.includes(col));
+}
+function renderRow(sheet, view, band, row, firstDataRow, header, captions) {
+  const items = [];
+  let spanning;
+  for (let col = band.left;col <= band.right; col++) {
+    const resolved = view.resolve(row, col);
+    if (resolved === undefined || resolved.col !== col)
+      continue;
+    if (resolved.row !== row && (resolved.row < firstDataRow || !fillsDown(resolved.merge)))
+      continue;
+    const comment = resolved.row === row && resolved.cell.comment !== undefined ? clean(resolved.cell.comment) : "";
+    const text = clean(resolved.cell.text);
+    const value = comment === "" ? text : `${text} (comment: ${comment})`;
+    if (resolved.merge !== undefined && resolved.merge.right > resolved.merge.left)
+      spanning = col;
+    items.push(header === undefined ? { col, value } : { col, label: header.labels.get(col) ?? columnName(col), value });
+  }
+  if (items.length === 0)
+    return [];
+  const [only] = items;
+  if (items.length === 1 && only !== undefined && only.col === spanning)
+    items[0] = { col: only.col, value: only.value };
+  const caption = captionText(captions);
+  const prefix = (left, right) => `[${sheet}!${cellRange(left, right, row)}${caption}] `;
+  const whole = prefix(band.left, band.right) + items.map(itemText).join(" | ");
+  if (estimateLineTokens(whole) <= MAX_LINE_TOKENS)
+    return [whole];
+  return splitRow(items, prefix);
+}
+function splitRow(items, prefix) {
+  const [key, ...rest] = items;
+  const keyText = itemText(key);
+  const lines = [];
+  let piece = [];
+  const flush = () => {
+    if (piece.length === 0)
+      return;
+    const head = lines.length === 0 ? "" : `${keyText} | `;
+    const first = lines.length === 0 ? key : piece[0];
+    lines.push(prefix(first.col, piece.at(-1).col) + head + piece.map(itemText).join(" | "));
+    piece = [];
   };
+  piece.push(key);
+  for (const item of rest) {
+    for (const part of fitItem(item, prefix, keyText)) {
+      const candidate = [...piece, part];
+      const head = lines.length === 0 ? "" : `${keyText} | `;
+      const start = lines.length === 0 ? key : candidate[0];
+      const text = prefix(start.col, part.col) + head + candidate.map(itemText).join(" | ");
+      if (piece.length > 0 && estimateLineTokens(text) > MAX_LINE_TOKENS)
+        flush();
+      piece.push(part);
+    }
+  }
+  flush();
+  return lines;
+}
+function fitItem(item, prefix, keyText) {
+  const overhead = estimateLineTokens(`${prefix(item.col, item.col)}${keyText} | ${item.label ?? ""}: `);
+  const budget = Math.max(16, MAX_LINE_TOKENS - overhead);
+  if (estimateLineTokens(item.value) <= budget)
+    return [item];
+  const parts = [];
+  let current = "";
+  for (const char of item.value) {
+    if (current !== "" && estimateLineTokens(current + char) > budget) {
+      parts.push({ ...item, value: current });
+      current = "";
+    }
+    current += char;
+  }
+  if (current !== "")
+    parts.push({ ...item, value: current });
+  return parts;
+}
+function fillsDown(merge) {
+  return merge !== undefined && merge.left === merge.right;
+}
+function itemText(item) {
+  return item.label === undefined ? item.value : `${item.label}: ${item.value}`;
+}
+function captionText(captions) {
+  if (captions.length === 0)
+    return "";
+  const joined = captions.join(" · ");
+  return ` · ${joined.length > MAX_CAPTION_CHARS ? `${joined.slice(0, MAX_CAPTION_CHARS - 1)}…` : joined}`;
+}
+function clean(text) {
+  return text.trim().replace(/\s*(?:\r\n|\r|\n)\s*/g, " / ").replace(/[\t\f\v]+/g, " ").replace(/\p{Cc}/gu, "");
+}
+function cellRange(left, right, row) {
+  const start = `${columnName(left)}${row + 1}`;
+  return left === right ? start : `${start}:${columnName(right)}${row + 1}`;
+}
+function columnName(col) {
+  let name = "";
+  for (let rest = col + 1;rest > 0; rest = Math.floor((rest - 1) / 26)) {
+    name = String.fromCharCode(65 + (rest - 1) % 26) + name;
+  }
+  return name;
+}
+function range(first, last) {
+  return Array.from({ length: last - first + 1 }, (_, index) => first + index);
+}
+var MAX_LINE_TOKENS = 768, MIN_HEADER_DATA_ROWS = 3, MIN_TYPED_SHARE = 0.8, MAX_COLUMNS = 16384, MAX_HEADER_CELL_CHARS = 60, MAX_CAPTION_CHARS = 120, MAX_CAPTION_BLOCK_ROWS = 3, MAX_CAPTION_GAP_ROWS = 2, COLUMN_STRIDE, NUMBER_TEXT, DATE_TEXT, YEAR_TEXT;
+var init_spreadsheet_render = __esm(() => {
+  COLUMN_STRIDE = 1 << 20;
+  NUMBER_TEXT = /^[-+]?[₩$€£¥]?\s?(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?\s?(?:%|원|천원|만원|백만원|억원)?$|^[-+]?\.\d+%?$/;
+  DATE_TEXT = /^\d{4}[-./]\d{1,2}(?:[-./]\d{1,2})?\.?$/;
+  YEAR_TEXT = /^(?:19|20)\d{2}$/;
 });
 
 // src/parser/text.ts
@@ -167,6 +472,194 @@ class Parser {
   version = "1";
 }
 
+// src/parser/csv.ts
+import { basename, extname } from "node:path";
+function toCell(text) {
+  return text.trim() === "" ? undefined : { text, kind: classifyText(text) };
+}
+function parseRows(text, delimiter, maxRows) {
+  const rows = [];
+  let total = 0;
+  let row = [];
+  let index = 0;
+  while (index < text.length) {
+    let field;
+    if (text[index] === '"') {
+      const quoted = readQuoted(text, index + 1);
+      const end = nextBoundary(text, quoted.end, delimiter);
+      field = quoted.value + text.slice(quoted.end, end);
+      index = end;
+    } else {
+      const end = nextBoundary(text, index, delimiter);
+      field = text.slice(index, end);
+      index = end;
+    }
+    row.push(field);
+    if (index >= text.length)
+      break;
+    if (text[index] === delimiter) {
+      index++;
+      if (index >= text.length)
+        row.push("");
+      continue;
+    }
+    index += text[index] === "\r" && text[index + 1] === `
+` ? 2 : 1;
+    if (total < maxRows)
+      rows.push(row);
+    total++;
+    row = [];
+  }
+  if (row.length > 0) {
+    if (total < maxRows)
+      rows.push(row);
+    total++;
+  }
+  return { rows, total };
+}
+function readQuoted(text, start) {
+  let value = "";
+  let cursor = start;
+  for (;; ) {
+    const quote = text.indexOf('"', cursor);
+    if (quote === -1)
+      return { value: value + text.slice(cursor), end: text.length };
+    value += text.slice(cursor, quote);
+    if (text[quote + 1] !== '"')
+      return { value, end: quote + 1 };
+    value += '"';
+    cursor = quote + 2;
+  }
+}
+function nextBoundary(text, from, delimiter) {
+  for (let index = from;index < text.length; index++) {
+    const char = text[index];
+    if (char === delimiter || char === `
+` || char === "\r")
+      return index;
+  }
+  return text.length;
+}
+function sniffDelimiter(text) {
+  const lines = leadingLines(text);
+  let best = CSV_DELIMITERS[0];
+  let bestScore = 0;
+  for (const candidate of CSV_DELIMITERS) {
+    const counts = lines.map((line) => countOutsideQuotes(line, candidate));
+    const first = counts[0] ?? 0;
+    if (first === 0)
+      continue;
+    const score = counts.filter((count) => count === first).length;
+    if (score > bestScore) {
+      best = candidate;
+      bestScore = score;
+    }
+  }
+  return best;
+}
+function leadingLines(text) {
+  const lines = [];
+  let start = 0;
+  let quoted = false;
+  for (let index = 0;index < text.length && lines.length < SNIFF_LINES; index++) {
+    const char = text[index];
+    if (char === '"')
+      quoted = !quoted;
+    else if (!quoted && (char === `
+` || char === "\r")) {
+      if (index > start)
+        lines.push(text.slice(start, index));
+      start = index + 1;
+    }
+  }
+  if (lines.length < SNIFF_LINES && start < text.length)
+    lines.push(text.slice(start));
+  return lines;
+}
+function countOutsideQuotes(line, delimiter) {
+  let count = 0;
+  let quoted = false;
+  for (const char of line) {
+    if (char === '"')
+      quoted = !quoted;
+    else if (!quoted && char === delimiter)
+      count++;
+  }
+  return count;
+}
+var DELIMITED_EXTENSIONS, DEFAULT_MAX_ROWS = 1e5, SNIFF_LINES = 50, CSV_DELIMITERS, SEPARATOR_DIRECTIVE, CsvParser;
+var init_csv = __esm(() => {
+  init_spreadsheet_render();
+  init_text();
+  DELIMITED_EXTENSIONS = [".csv", ".tsv"];
+  CSV_DELIMITERS = [",", ";", "\t", "|"];
+  SEPARATOR_DIRECTIVE = /^sep=(.)\r?\n/i;
+  CsvParser = class CsvParser extends Parser {
+    name = "csv";
+    extensions = DELIMITED_EXTENSIONS;
+    version = "2";
+    #maxRows;
+    constructor(options = {}) {
+      super();
+      this.#maxRows = options.maxRows ?? DEFAULT_MAX_ROWS;
+    }
+    async parse(input) {
+      const extension = extname(input.virtualPath);
+      const format = extension.slice(1).toLowerCase();
+      let text = decodeText(input.bytes).replace(/^\uFEFF/, "");
+      const directive = SEPARATOR_DIRECTIVE.exec(text);
+      if (directive !== null)
+        text = text.slice(directive[0].length);
+      const delimiter = directive?.[1] ?? (format === "tsv" ? "\t" : sniffDelimiter(text));
+      const { rows, total } = parseRows(text, delimiter, this.#maxRows);
+      const diagnostics = total > this.#maxRows ? [
+        {
+          code: "parser-warning",
+          severity: "warning",
+          message: `"${basename(input.virtualPath)}": indexed the first ${this.#maxRows} of ${total} rows`
+        }
+      ] : [];
+      const grid = { name: basename(input.virtualPath, extension), rows: rows.map((row) => row.map(toCell)) };
+      return {
+        markdown: normalizeMarkdown(renderWorkbook([grid])),
+        metadata: { parser: this.name, format },
+        ...diagnostics.length > 0 ? { diagnostics } : {}
+      };
+    }
+  };
+});
+
+// src/parser/errors.ts
+function messageFrom(cause) {
+  if (cause instanceof Error)
+    return cause.message;
+  if (typeof cause === "string")
+    return cause;
+  return "unknown parser failure";
+}
+var ParseError, ParseIsolationError;
+var init_errors = __esm(() => {
+  ParseError = class ParseError extends Error {
+    parserName;
+    virtualPath;
+    constructor(parserName, virtualPath, cause) {
+      super(`Parser "${parserName}" failed for ${virtualPath}: ${messageFrom(cause)}`);
+      this.name = "ParseError";
+      this.parserName = parserName;
+      this.virtualPath = virtualPath;
+      this.cause = cause;
+    }
+  };
+  ParseIsolationError = class ParseIsolationError extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.name = "ParseIsolationError";
+      this.code = code;
+    }
+  };
+});
+
 // src/parser/eml.ts
 import { simpleParser } from "mailparser";
 function addressText(address) {
@@ -250,7 +743,7 @@ var KORDOC_VERSION, KORDOC_EXTENSIONS, KORDOC_IMAGE_EXTENSIONS, defaultParse = a
 var init_kordoc = __esm(() => {
   init_errors();
   KORDOC_VERSION = installedKordocVersion();
-  KORDOC_EXTENSIONS = [".hwp", ".hwpx", ".hml", ".hwpml", ".pdf", ".docx", ".xlsx", ".xls"];
+  KORDOC_EXTENSIONS = [".hwp", ".hwpx", ".hml", ".hwpml", ".pdf", ".docx"];
   KORDOC_IMAGE_EXTENSIONS = [".png", ".jpg", ".jpeg", ".webp"];
   KordocParser = class KordocParser extends Parser {
     name = "kordoc";
@@ -665,7 +1158,7 @@ var init_plain_text = __esm(() => {
 });
 
 // src/parser/registry.ts
-import { extname } from "node:path";
+import { extname as extname2 } from "node:path";
 
 class ParserRegistry {
   parsersByExtension = new Map;
@@ -684,7 +1177,7 @@ class ParserRegistry {
     }
   }
   getForVirtualPath(virtualPath) {
-    return this.parsersByExtension.get(normalizeExtension(extname(virtualPath)));
+    return this.parsersByExtension.get(normalizeExtension(extname2(virtualPath)));
   }
   list() {
     return Array.from(new Set(this.parsersByExtension.values()));
@@ -696,6 +1189,149 @@ function normalizeExtension(extension) {
 }
 var init_registry = () => {};
 
+// src/parser/spreadsheet.ts
+import { extname as extname3 } from "node:path";
+import * as XLSX from "xlsx";
+function assertWorkbookSignature(format, bytes) {
+  if (startsWith(bytes, ZIP_SIGNATURE) || startsWith(bytes, OLE_SIGNATURE))
+    return;
+  const head = new TextDecoder().decode(bytes.subarray(0, 64)).replace(/^\uFEFF/, "").trimStart();
+  if (!head.startsWith("<")) {
+    throw new Error(`not a ${format} workbook: neither a ZIP or OLE2 file nor HTML/XML markup`);
+  }
+}
+function startsWith(bytes, prefix) {
+  return prefix.every((byte, index) => bytes[index] === byte);
+}
+function toGrid(name, sheet, hidden, date1904) {
+  const data = sheet?.["!data"] ?? [];
+  return {
+    name,
+    hidden: hidden !== undefined && hidden !== 0,
+    rows: data.map((row) => row?.map((cell) => cell === undefined ? undefined : toCell2(cell, date1904))),
+    merges: (sheet?.["!merges"] ?? []).map((merge) => ({
+      top: merge.s.r,
+      left: merge.s.c,
+      bottom: merge.e.r,
+      right: merge.e.c
+    }))
+  };
+}
+function toCell2(cell, date1904) {
+  const comment = (cell.c ?? []).map((note) => note.t?.trim() ?? "").filter((text) => text !== "").join(" / ");
+  const shown = displayed(cell, date1904);
+  if (shown === undefined)
+    return;
+  return comment === "" ? shown : { ...shown, comment };
+}
+function displayed(cell, date1904) {
+  if (cell.v === undefined || cell.v === null) {
+    return cell.f === undefined ? undefined : { text: `=${cell.f}`, kind: "formula" };
+  }
+  switch (cell.t) {
+    case "n":
+      return typeof cell.v === "number" ? formatNumber(cell.v, cell.z, date1904) : textCell(String(cell.v));
+    case "b":
+      return { text: cell.v === true ? "TRUE" : "FALSE", kind: "boolean" };
+    case "e":
+      return { text: cell.w ?? "#ERROR", kind: "error" };
+    case "d":
+      return { text: cell.w ?? String(cell.v), kind: "date" };
+    case "z":
+      return;
+    default:
+      return textCell(String(cell.v));
+  }
+}
+function textCell(text) {
+  return text.trim() === "" ? undefined : { text, kind: classifyText(text) };
+}
+function formatNumber(value, format, date1904) {
+  const plain = formatGeneral(value);
+  const code = typeof format === "string" ? format : format === undefined ? "General" : XLSX.SSF.get_table()[format];
+  if (code === undefined || code === "General" || /\[DBNum\d\]/i.test(code))
+    return { text: plain, kind: "number" };
+  const kind = XLSX.SSF.is_date(code) ? "date" : "number";
+  let shown;
+  try {
+    shown = XLSX.SSF.format(code, value, { date1904 }).trim();
+  } catch {
+    return { text: plain, kind };
+  }
+  if (shown === "")
+    return { text: plain, kind };
+  return { text: kind === "number" && hidesMagnitude(code) ? `${shown} (${plain})` : shown, kind };
+}
+function formatGeneral(value) {
+  if (Number.isInteger(value))
+    return String(value);
+  return String(Number(value.toPrecision(15)));
+}
+function hidesMagnitude(code) {
+  const bare = code.replace(/"[^"]*"/g, "").replace(/\\./g, "").replace(/\[[^\]]*\]/g, "");
+  return /[0#?],+(?![0#?,])/.test(bare);
+}
+var SPREADSHEET_EXTENSIONS, DEFAULT_MAX_ROWS_PER_SHEET = 1e5, ZIP_SIGNATURE, OLE_SIGNATURE, SpreadsheetParser;
+var init_spreadsheet = __esm(() => {
+  init_errors();
+  init_spreadsheet_render();
+  init_text();
+  SPREADSHEET_EXTENSIONS = [".xlsx", ".xlsm", ".xlsb", ".xls", ".ods"];
+  ZIP_SIGNATURE = [80, 75];
+  OLE_SIGNATURE = [208, 207, 17, 224, 161, 177, 26, 225];
+  SpreadsheetParser = class SpreadsheetParser extends Parser {
+    name = "spreadsheet";
+    extensions = SPREADSHEET_EXTENSIONS;
+    version = `2+sheetjs-${XLSX.version}`;
+    #maxRowsPerSheet;
+    constructor(options = {}) {
+      super();
+      this.#maxRowsPerSheet = options.maxRowsPerSheet ?? DEFAULT_MAX_ROWS_PER_SHEET;
+    }
+    async parse(input) {
+      const format = extname3(input.virtualPath).slice(1).toLowerCase();
+      let workbook;
+      try {
+        assertWorkbookSignature(format, input.bytes);
+        workbook = XLSX.read(input.bytes, {
+          type: "array",
+          dense: true,
+          cellFormula: true,
+          cellNF: true,
+          cellDates: false,
+          sheetRows: this.#maxRowsPerSheet,
+          raw: true
+        });
+      } catch (cause) {
+        throw new ParseError(this.name, input.virtualPath, cause);
+      }
+      const date1904 = workbook.Workbook?.WBProps?.date1904 === true;
+      const diagnostics = [];
+      const grids = workbook.SheetNames.map((name, index) => {
+        const sheet = workbook.Sheets[name];
+        const fullRef = sheet?.["!fullref"];
+        if (fullRef !== undefined) {
+          const full = XLSX.utils.decode_range(fullRef);
+          const total = full.e.r - full.s.r + 1;
+          if (total > this.#maxRowsPerSheet) {
+            diagnostics.push({
+              code: "parser-warning",
+              severity: "warning",
+              message: `sheet "${name}": indexed the first ${this.#maxRowsPerSheet} of ${total} rows`
+            });
+          }
+        }
+        return toGrid(name, sheet, workbook.Workbook?.Sheets?.[index]?.Hidden, date1904);
+      });
+      return {
+        markdown: normalizeMarkdown(renderWorkbook(grids)),
+        metadata: { parser: this.name, format },
+        ...diagnostics.length > 0 ? { diagnostics } : {}
+      };
+    }
+  };
+});
+
 // src/parser/defaults.ts
 import { join as join2 } from "node:path";
 function tesseractCachePathFor(workspacePath) {
@@ -726,18 +1362,22 @@ function createDefaultParserRegistry(options = {}) {
   return new ParserRegistry([
     new PlainTextParser,
     new KordocParser(kordocOptions),
+    new SpreadsheetParser,
+    new CsvParser,
     new PptxParser,
     new EmlParser
   ]);
 }
 var init_defaults = __esm(() => {
   init_language();
+  init_csv();
   init_eml();
   init_kordoc();
   init_ocr_engines();
   init_office();
   init_plain_text();
   init_registry();
+  init_spreadsheet();
 });
 
 // src/parser/parse-worker.ts