@statewalker/content-extractors 0.2.2 → 0.3.0

package/dist/zip-size.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-size.js","names":[],"sources":["../src/zip-size.ts"],"sourcesContent":["const EOCD_SIG = 0x06054b50;\nconst ZIP64_LOCATOR_SIG = 0x07064b50;\nconst ZIP64_EOCD_SIG = 0x06064b50;\nconst CD_ENTRY_SIG = 0x02014b50;\nconst EOCD_SIZE = 22;\nconst MAX_COMMENT = 0xffff;\n\nfunction fail(message: string): never {\n  throw new Error(`Invalid ZIP archive: ${message}`);\n}\n\n/**\n * Sums the uncompressed sizes of all entries declared in a ZIP archive's central directory,\n * without inflating anything. Supports ZIP64. Throws when the bytes are not a readable ZIP.\n *\n * The sizes are what the archive claims; a parser that inflates the data still has to check\n * them, which JSZip (used by mammoth and exceljs) does.\n */\nexport function zipUncompressedSize(bytes: Uint8Array): number {\n  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n  const len = bytes.byteLength;\n\n  // The end-of-central-directory record sits at the end, followed by a comment of up to 64 KiB.\n  let eocd = -1;\n  const stop = Math.max(0, len - EOCD_SIZE - MAX_COMMENT);\n  for (let i = len - EOCD_SIZE; i >= stop; i--) {\n    if (view.getUint32(i, true) === EOCD_SIG) {\n      eocd = i;\n      break;\n    }\n  }\n  if (eocd < 0) fail(\"not a ZIP file (no end of central directory record)\");\n\n  // Where the central directory must end: right before the (ZIP64) end record.\n  let cdEnd = eocd;\n  let entries = view.getUint16(eocd + 10, true);\n  let cdSize = view.getUint32(eocd + 12, true);\n  let cdOffset = view.getUint32(eocd + 16, true);\n\n  if (entries === 0xffff || cdSize === 0xffffffff || cdOffset === 0xffffffff) {\n    const locator = eocd - 20;\n    if (locator >= 0 && view.getUint32(locator, true) === ZIP64_LOCATOR_SIG) {\n      const z64 = Number(view.getBigUint64(locator + 8, true));\n      if (z64 + 56 > len || view.getUint32(z64, true) !== ZIP64_EOCD_SIG) {\n        fail(\"bad ZIP64 end of central directory record\");\n      }\n      cdEnd = z64;\n      entries = Number(view.getBigUint64(z64 + 32, true));\n      cdSize = Number(view.getBigUint64(z64 + 40, true));\n      cdOffset = Number(view.getBigUint64(z64 + 48, true));\n    }\n  }\n\n  // An archive with bytes prepended (a self-extracting stub, for example) keeps offsets relative\n  // to the original start; JSZip accepts it, so find the directory from its end instead.\n  if (cdOffset + 4 > len || (entries > 0 && view.getUint32(cdOffset, true) !== CD_ENTRY_SIG)) {\n    const shifted = cdEnd - cdSize;\n    if (shifted >= 0 && shifted + 4 <= len && view.getUint32(shifted, true) === CD_ENTRY_SIG) {\n      cdOffset = shifted;\n    }\n  }\n  if (cdOffset + cdSize > len) fail(\"central directory lies outside the file\");\n\n  let total = 0;\n  let pos = cdOffset;\n  for (let n = 0; n < entries; n++) {\n    if (pos + 46 > len || view.getUint32(pos, true) !== CD_ENTRY_SIG) {\n      fail(\"truncated or corrupt central directory\");\n    }\n    const size32 = view.getUint32(pos + 24, true);\n    const nameLen = view.getUint16(pos + 28, true);\n    const extraLen = view.getUint16(pos + 30, true);\n    const commentLen = view.getUint16(pos + 32, true);\n    let size = size32;\n    if (size32 === 0xffffffff) {\n      size = readZip64Size(view, pos + 46 + nameLen, extraLen);\n    }\n    total += size;\n    pos += 46 + nameLen + extraLen + commentLen;\n  }\n  return total;\n}\n\n/** Reads the 64-bit uncompressed size from an entry's ZIP64 extended information extra field. */\nfunction readZip64Size(view: DataView, start: number, length: number): number {\n  const end = start + length;\n  if (end > view.byteLength) fail(\"truncated or corrupt central directory\");\n  let p = start;\n  while (p + 4 <= end) {\n    const id = view.getUint16(p, true);\n    const size = view.getUint16(p + 2, true);\n    if (id === 0x0001) {\n      // The uncompressed size is the first field when the 32-bit value is 0xFFFFFFFF.\n      if (size < 8 || p + 12 > end) fail(\"bad ZIP64 extra field\");\n      return Number(view.getBigUint64(p + 4, true));\n    }\n    p += 4 + size;\n  }\n  fail(\"missing ZIP64 extra field\");\n}\n\n/**\n * Throws when the uncompressed size declared by a ZIP archive exceeds `maxBytes`, so a small\n * \"zip bomb\" is refused before a parser inflates it.\n */\nexport function assertZipUncompressedSize(bytes: Uint8Array, maxBytes: number): void {\n  const size = zipUncompressedSize(bytes);\n  if (size > maxBytes) {\n    throw new Error(\n      `Archive uncompressed size ${size} bytes exceeds the limit of ${maxBytes} bytes`,\n    );\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@statewalker/content-extractors",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "private": false,
   "type": "module",
   "description": "Content extractors: turn PDF, DOCX, XLSX, Markdown, and HTML into markdown text.",
-  "homepage": "https://github.com/statewalker/statewalker-content",
+  "bugs": {
+    "url": "https://github.com/statewalker/statewalker-search/issues"
+  },
+  "homepage": "https://github.com/statewalker/statewalker-search/tree/main/packages/content-extractors#readme",
   "author": {
     "name": "Mikhail Kotelnikov",
     "email": "mikhail.kotelnikov@gmail.com"
@@ -12,7 +15,8 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@github.com/statewalker/statewalker-content.git"
+    "url": "git+https://github.com/statewalker/statewalker-search.git",
+    "directory": "packages/content-extractors"
   },
   "exports": {
     ".": {
@@ -40,7 +44,6 @@
   ],
   "dependencies": {
     "@joplin/turndown-plugin-gfm": "^1.0.68",
-    "@types/turndown": "^5.0.6",
     "exceljs": "^4.4.0",
     "mammoth": "^1.13.0",
     "markdown-it": "^15.0.2",
@@ -49,6 +52,7 @@
   },
   "devDependencies": {
     "@types/node": "^26.6.4",
+    "@types/turndown": "^5.0.6",
     "rimraf": "^6.1.3",
     "tsdown": "^0.23.0",
     "typescript": "^7.0.2",

package/src/collect-bytes.ts

@@ -1,3 +1,12 @@
+/** Options for {@link collectBytes} and {@link collectText}. */
+export interface CollectOptions {
+  /**
+   * Largest input accepted, in bytes. Reading stops and an error is thrown as soon as the total
+   * exceeds it, so an oversized or endless stream is never held in memory. No limit when omitted.
+   */
+  maxBytes?: number;
+}
+
 /**
  * Bridges the streaming world (chunked iterables from fetch, file reads,
  * etc.) with libraries that require a single contiguous buffer (pdfjs-dist,
@@ -6,12 +15,17 @@
  */
 export async function collectBytes(
   content: AsyncIterable<Uint8Array> | Iterable<Uint8Array>,
+  options: CollectOptions = {},
 ): Promise<Uint8Array> {
+  const { maxBytes = Number.POSITIVE_INFINITY } = options;
   const chunks: Uint8Array[] = [];
   let totalLength = 0;
   for await (const chunk of content) {
-    chunks.push(chunk);
     totalLength += chunk.length;
+    if (totalLength > maxBytes) {
+      throw new Error(`Input exceeds the limit of ${maxBytes} bytes`);
+    }
+    chunks.push(chunk);
   }
   const first = chunks[0];
   if (chunks.length === 1 && first) {
@@ -33,7 +47,8 @@ export async function collectBytes(
  */
 export async function collectText(
   content: AsyncIterable<Uint8Array> | Iterable<Uint8Array>,
+  options: CollectOptions = {},
 ): Promise<string> {
-  const bytes = await collectBytes(content);
+  const bytes = await collectBytes(content, options);
   return new TextDecoder().decode(bytes);
 }

package/src/extractor-registry.ts

@@ -13,10 +13,11 @@ export class ExtractorRegistry {
 
   /**
    * Associates a suffix pattern with an extractor so the registry can
-   * route files to the right handler based on their filename.
+   * route files to the right handler based on their filename. Patterns are
+   * case-insensitive, like the file names they are matched against.
    */
   registerByPattern(pattern: string, extractor: ContentExtractor): void {
-    this.patternMap.set(pattern, extractor);
+    this.patternMap.set(pattern.toLowerCase(), extractor);
   }
 
   /**

package/src/extractors/docx-extractor.ts

@@ -1,21 +1,36 @@
 import mammoth from "mammoth";
 import { collectBytes } from "../collect-bytes.js";
 import { htmlToMarkdown } from "../html-to-markdown.js";
+import {
+  DEFAULT_MAX_BYTES,
+  DEFAULT_MAX_UNCOMPRESSED_BYTES,
+  type ZipExtractorLimits,
+} from "../limits.js";
 import type { ContentExtractor } from "../types.js";
+import { assertZipUncompressedSize } from "../zip-size.js";
 
 /**
  * Unlocks Word document content for text-based pipelines via a two-stage
  * conversion (DOCX -> HTML -> markdown). Supplies both `buffer` and
  * `arrayBuffer` to mammoth so the same code runs in Node.js and browsers
- * without environment detection.
+ * without environment detection. The input size and the archive's declared
+ * uncompressed size are checked before mammoth inflates it.
  */
-export const docxExtractor: ContentExtractor = async (content) => {
-  const bytes = await collectBytes(content);
-  const arrayBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-  // mammoth uses "buffer" in Node.js and "arrayBuffer" in browsers
-  const result = await mammoth.convertToHtml({
-    buffer: arrayBuffer,
-    arrayBuffer,
-  } as Parameters<typeof mammoth.convertToHtml>[0]);
-  return htmlToMarkdown(result.value);
-};
+export function createDocxExtractor(limits: ZipExtractorLimits = {}): ContentExtractor {
+  const { maxBytes = DEFAULT_MAX_BYTES, maxUncompressedBytes = DEFAULT_MAX_UNCOMPRESSED_BYTES } =
+    limits;
+  return async (content) => {
+    const bytes = await collectBytes(content, { maxBytes });
+    assertZipUncompressedSize(bytes, maxUncompressedBytes);
+    const arrayBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    // mammoth uses "buffer" in Node.js and "arrayBuffer" in browsers
+    const result = await mammoth.convertToHtml({
+      buffer: arrayBuffer,
+      arrayBuffer,
+    } as Parameters<typeof mammoth.convertToHtml>[0]);
+    return htmlToMarkdown(result.value);
+  };
+}
+
+/** DOCX/DOCM extractor with the default limits. */
+export const docxExtractor: ContentExtractor = createDocxExtractor();

package/src/extractors/html-extractor.ts

@@ -1,5 +1,6 @@
 import { collectText } from "../collect-bytes.js";
 import { htmlToMarkdown } from "../html-to-markdown.js";
+import { DEFAULT_MAX_BYTES, type ExtractorLimits } from "../limits.js";
 import type { ContentExtractor } from "../types.js";
 
 /**
@@ -7,7 +8,10 @@ import type { ContentExtractor } from "../types.js";
  * text format. Delegates to `htmlToMarkdown` for the actual conversion,
  * keeping this extractor focused on the bytes-to-string bridging step.
  */
-export const htmlExtractor: ContentExtractor = async (content) => {
-  const html = await collectText(content);
-  return htmlToMarkdown(html);
-};
+export function createHtmlExtractor(limits: ExtractorLimits = {}): ContentExtractor {
+  const { maxBytes = DEFAULT_MAX_BYTES } = limits;
+  return async (content) => htmlToMarkdown(await collectText(content, { maxBytes }));
+}
+
+/** HTML extractor with the default limits. */
+export const htmlExtractor: ContentExtractor = createHtmlExtractor();

package/src/extractors/index.ts

@@ -1,34 +1,40 @@
-export { docxExtractor } from "./docx-extractor.js";
-export { htmlExtractor } from "./html-extractor.js";
-export { markdownExtractor } from "./markdown-extractor.js";
-export { pdfExtractor } from "./pdf-extractor.js";
-export { textExtractor } from "./text-extractor.js";
-export { xlsxExtractor } from "./xlsx-extractor.js";
+export { createDocxExtractor, docxExtractor } from "./docx-extractor.js";
+export { createHtmlExtractor, htmlExtractor } from "./html-extractor.js";
+export { createMarkdownExtractor, markdownExtractor } from "./markdown-extractor.js";
+export { createPdfExtractor, pdfExtractor } from "./pdf-extractor.js";
+export { createTextExtractor, textExtractor } from "./text-extractor.js";
+export { createXlsxExtractor, xlsxExtractor } from "./xlsx-extractor.js";
 
 import { ExtractorRegistry } from "../extractor-registry.js";
-import { docxExtractor } from "./docx-extractor.js";
-import { htmlExtractor } from "./html-extractor.js";
-import { markdownExtractor } from "./markdown-extractor.js";
-import { pdfExtractor } from "./pdf-extractor.js";
-import { textExtractor } from "./text-extractor.js";
-import { xlsxExtractor } from "./xlsx-extractor.js";
+import type { ZipExtractorLimits } from "../limits.js";
+import { createDocxExtractor } from "./docx-extractor.js";
+import { createHtmlExtractor } from "./html-extractor.js";
+import { createMarkdownExtractor } from "./markdown-extractor.js";
+import { createPdfExtractor } from "./pdf-extractor.js";
+import { createTextExtractor } from "./text-extractor.js";
+import { createXlsxExtractor } from "./xlsx-extractor.js";
 
 /**
  * Provides a batteries-included registry so most consumers can start
  * extracting immediately without manual format registration. Custom
  * registries are still supported for apps that need to override or
- * limit the built-in set.
+ * limit the built-in set. `limits` applies to every registered extractor
+ * (`maxUncompressedBytes` only to DOCX, DOCM and XLSX); omitted limits
+ * take the defaults.
  */
-export function createDefaultRegistry(): ExtractorRegistry {
+export function createDefaultRegistry(limits: ZipExtractorLimits = {}): ExtractorRegistry {
+  const markdown = createMarkdownExtractor(limits);
+  const html = createHtmlExtractor(limits);
+  const docx = createDocxExtractor(limits);
   const registry = new ExtractorRegistry();
-  registry.registerByPattern("*.md", markdownExtractor);
-  registry.registerByPattern("*.markdown", markdownExtractor);
-  registry.registerByPattern("*.txt", textExtractor);
-  registry.registerByPattern("*.html", htmlExtractor);
-  registry.registerByPattern("*.htm", htmlExtractor);
-  registry.registerByPattern("*.pdf", pdfExtractor);
-  registry.registerByPattern("*.docx", docxExtractor);
-  registry.registerByPattern("*.docm", docxExtractor);
-  registry.registerByPattern("*.xlsx", xlsxExtractor);
+  registry.registerByPattern("*.md", markdown);
+  registry.registerByPattern("*.markdown", markdown);
+  registry.registerByPattern("*.txt", createTextExtractor(limits));
+  registry.registerByPattern("*.html", html);
+  registry.registerByPattern("*.htm", html);
+  registry.registerByPattern("*.pdf", createPdfExtractor(limits));
+  registry.registerByPattern("*.docx", docx);
+  registry.registerByPattern("*.docm", docx);
+  registry.registerByPattern("*.xlsx", createXlsxExtractor(limits));
   return registry;
 }

package/src/extractors/markdown-extractor.ts

@@ -1,4 +1,5 @@
 import { collectText } from "../collect-bytes.js";
+import { DEFAULT_MAX_BYTES, type ExtractorLimits } from "../limits.js";
 import type { ContentExtractor } from "../types.js";
 
 /**
@@ -7,6 +8,10 @@ import type { ContentExtractor } from "../types.js";
  * the registry can distinguish `.md` from `.txt` -- allowing future
  * markdown-specific processing without breaking existing registrations.
  */
-export const markdownExtractor: ContentExtractor = async (content) => {
-  return collectText(content);
-};
+export function createMarkdownExtractor(limits: ExtractorLimits = {}): ContentExtractor {
+  const { maxBytes = DEFAULT_MAX_BYTES } = limits;
+  return (content) => collectText(content, { maxBytes });
+}
+
+/** Markdown extractor with the default limits. */
+export const markdownExtractor: ContentExtractor = createMarkdownExtractor();

package/src/extractors/pdf-extractor.ts

@@ -1,5 +1,6 @@
 import { extractText } from "unpdf";
 import { collectBytes } from "../collect-bytes.js";
+import { DEFAULT_MAX_BYTES, type ExtractorLimits } from "../limits.js";
 import type { ContentExtractor } from "../types.js";
 
 /**
@@ -7,17 +8,25 @@ import type { ContentExtractor } from "../types.js";
  * section with a `## Page N` header. This preserves page boundaries in
  * the indexed content, making search results more precise.
  */
-export const pdfExtractor: ContentExtractor = async (content) => {
-  const bytes = await collectBytes(content);
-  const { text: pages } = await extractText(bytes);
+export function createPdfExtractor(limits: ExtractorLimits = {}): ContentExtractor {
+  const { maxBytes = DEFAULT_MAX_BYTES } = limits;
+  return async (content) => {
+    const bytes = await collectBytes(content, { maxBytes });
+    // A copy, always a plain Uint8Array: pdfjs rejects a Node Buffer, and it takes over (detaches)
+    // the buffer it is given, which would empty the caller's array.
+    const { text: pages } = await extractText(new Uint8Array(bytes));
 
-  const sections: string[] = [];
-  for (let i = 0; i < pages.length; i++) {
-    const pageText = pages[i]?.trim();
-    if (pageText) {
-      sections.push(`## Page ${i + 1}\n\n${pageText}`);
+    const sections: string[] = [];
+    for (let i = 0; i < pages.length; i++) {
+      const pageText = pages[i]?.trim();
+      if (pageText) {
+        sections.push(`## Page ${i + 1}\n\n${pageText}`);
+      }
     }
-  }
 
-  return sections.join("\n\n");
-};
+    return sections.join("\n\n");
+  };
+}
+
+/** PDF extractor with the default limits. */
+export const pdfExtractor: ContentExtractor = createPdfExtractor();

package/src/extractors/text-extractor.ts

@@ -1,4 +1,5 @@
 import { collectText } from "../collect-bytes.js";
+import { DEFAULT_MAX_BYTES, type ExtractorLimits } from "../limits.js";
 import type { ContentExtractor } from "../types.js";
 
 /**
@@ -6,6 +7,10 @@ import type { ContentExtractor } from "../types.js";
  * decode bytes to a string. Exists as a distinct entry so `.txt` files
  * route through the same pipeline as every other format.
  */
-export const textExtractor: ContentExtractor = async (content) => {
-  return collectText(content);
-};
+export function createTextExtractor(limits: ExtractorLimits = {}): ContentExtractor {
+  const { maxBytes = DEFAULT_MAX_BYTES } = limits;
+  return (content) => collectText(content, { maxBytes });
+}
+
+/** Plain-text extractor with the default limits. */
+export const textExtractor: ContentExtractor = createTextExtractor();

package/src/extractors/xlsx-extractor.ts

@@ -1,57 +1,88 @@
 import ExcelJS from "exceljs";
 import { collectBytes } from "../collect-bytes.js";
+import {
+  DEFAULT_MAX_BYTES,
+  DEFAULT_MAX_UNCOMPRESSED_BYTES,
+  type ZipExtractorLimits,
+} from "../limits.js";
 import type { ContentExtractor } from "../types.js";
+import { assertZipUncompressedSize } from "../zip-size.js";
+
+/**
+ * Makes a cell value safe inside a Markdown table row: `|` becomes `\|` so it does not start a
+ * new column, and every line break (CR, LF, CRLF) becomes one space so it does not end the row.
+ */
+export function escapeCell(value: string): string {
+  return value.replace(/\|/g, "\\|").replace(/\r\n|\r|\n/g, " ");
+}
+
+/** Width of the widest row. A loop, not `Math.max(...)`, so large sheets do not overflow the stack. */
+export function maxColumnCount(rows: readonly (readonly unknown[])[]): number {
+  let max = 0;
+  for (const row of rows) {
+    if (row.length > max) max = row.length;
+  }
+  return max;
+}
 
 /**
  * Converts Excel spreadsheets into markdown tables so the content
  * is searchable and consumable by text-based pipelines. Each worksheet
  * becomes a separate section with a level-2 heading. Empty sheets are
- * skipped to avoid noise.
+ * skipped to avoid noise. The input size and the archive's declared
+ * uncompressed size are checked before exceljs inflates it.
  */
-export const xlsxExtractor: ContentExtractor = async (content) => {
-  const bytes = await collectBytes(content);
-  const workbook = new ExcelJS.Workbook();
-  const arrayBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-  await workbook.xlsx.load(arrayBuffer as ArrayBuffer);
-
-  const sections: string[] = [];
-
-  workbook.eachSheet((sheet) => {
-    const rows: string[][] = [];
-
-    sheet.eachRow((row) => {
-      const cells: string[] = [];
-      row.eachCell({ includeEmpty: true }, (cell) => {
-        try {
-          const v = cell.value;
-          cells.push(v == null ? "" : String(v));
-        } catch {
-          cells.push("");
-        }
+export function createXlsxExtractor(limits: ZipExtractorLimits = {}): ContentExtractor {
+  const { maxBytes = DEFAULT_MAX_BYTES, maxUncompressedBytes = DEFAULT_MAX_UNCOMPRESSED_BYTES } =
+    limits;
+  return async (content) => {
+    const bytes = await collectBytes(content, { maxBytes });
+    assertZipUncompressedSize(bytes, maxUncompressedBytes);
+    const workbook = new ExcelJS.Workbook();
+    const arrayBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    await workbook.xlsx.load(arrayBuffer as ArrayBuffer);
+
+    const sections: string[] = [];
+
+    workbook.eachSheet((sheet) => {
+      const rows: string[][] = [];
+
+      sheet.eachRow((row) => {
+        const cells: string[] = [];
+        row.eachCell({ includeEmpty: true }, (cell) => {
+          try {
+            const v = cell.value;
+            cells.push(v == null ? "" : escapeCell(String(v)));
+          } catch {
+            cells.push("");
+          }
+        });
+        rows.push(cells);
       });
-      rows.push(cells);
-    });
 
-    if (rows.length === 0) return;
+      if (rows.length === 0) return;
 
-    // Normalize column count to the widest row
-    const colCount = Math.max(...rows.map((r) => r.length));
-    const padded = rows.map((r) => {
-      while (r.length < colCount) r.push("");
-      return r;
-    });
+      // Normalize column count to the widest row
+      const colCount = maxColumnCount(rows);
+      for (const r of rows) {
+        while (r.length < colCount) r.push("");
+      }
 
-    // First row as headers, rest as data
-    const [headers, ...dataRows] = padded;
-    if (!headers) return;
+      // First row as headers, rest as data
+      const [headers, ...dataRows] = rows;
+      if (!headers) return;
 
-    const headerLine = `| ${headers.join(" | ")} |`;
-    const separator = `| ${headers.map(() => "---").join(" | ")} |`;
-    const bodyLines = dataRows.map((r) => `| ${r.join(" | ")} |`);
+      const headerLine = `| ${headers.join(" | ")} |`;
+      const separator = `| ${headers.map(() => "---").join(" | ")} |`;
+      const bodyLines = dataRows.map((r) => `| ${r.join(" | ")} |`);
+
+      const table = [headerLine, separator, ...bodyLines].join("\n");
+      sections.push(`## ${sheet.name}\n\n${table}`);
+    });
 
-    const table = [headerLine, separator, ...bodyLines].join("\n");
-    sections.push(`## ${sheet.name}\n\n${table}`);
-  });
+    return sections.join("\n\n");
+  };
+}
 
-  return sections.join("\n\n");
-};
+/** XLSX extractor with the default limits. */
+export const xlsxExtractor: ContentExtractor = createXlsxExtractor();

package/src/html-to-markdown.ts

@@ -6,7 +6,9 @@ import TurndownService from "turndown";
  * Normalizes HTML into markdown so downstream consumers get a uniform
  * text format regardless of whether the source was HTML, DOCX (via
  * mammoth's HTML output), or any other HTML-producing extractor.
- * Uses Turndown with GFM tables and strikethrough support.
+ * Uses Turndown with GFM tables and strikethrough support. The content of
+ * `<script>`, `<style>`, `<noscript>` and `<template>` is dropped: it is
+ * code or markup, not document text.
  */
 export function htmlToMarkdown(html: string): string {
   const turndownService = new TurndownService({
@@ -18,5 +20,6 @@ export function htmlToMarkdown(html: string): string {
     strongDelimiter: "**",
   });
   turndownService.use(gfm);
+  turndownService.remove(["script", "style", "noscript", "template"]);
   return turndownService.turndown(html);
 }

package/src/index.ts

@@ -2,6 +2,8 @@ export * from "./collect-bytes.js";
 export * from "./extractor-registry.js";
 export * from "./extractors/index.js";
 export * from "./html-to-markdown.js";
+export * from "./limits.js";
 export * from "./markdown-to-html.js";
 export * from "./mime-utils.js";
 export * from "./types.js";
+export * from "./zip-size.js";

package/src/limits.ts

@@ -0,0 +1,20 @@
+/** Default largest input an extractor reads: 100 MiB. */
+export const DEFAULT_MAX_BYTES = 100 * 1024 * 1024;
+
+/** Default largest total uncompressed size of a DOCX/XLSX archive: 500 MiB. */
+export const DEFAULT_MAX_UNCOMPRESSED_BYTES = 500 * 1024 * 1024;
+
+/** Limits every built-in extractor accepts. Pass `Infinity` to turn a limit off. */
+export interface ExtractorLimits {
+  /** Largest input read, in bytes. Default {@link DEFAULT_MAX_BYTES}. */
+  maxBytes?: number;
+}
+
+/** Limits of the ZIP-based extractors (DOCX, DOCM, XLSX). */
+export interface ZipExtractorLimits extends ExtractorLimits {
+  /**
+   * Largest sum of the uncompressed entry sizes declared in the archive's central directory,
+   * checked before the archive is inflated. Default {@link DEFAULT_MAX_UNCOMPRESSED_BYTES}.
+   */
+  maxUncompressedBytes?: number;
+}

package/src/markdown-to-html.ts

@@ -1,21 +1,27 @@
 import MarkdownIt from "markdown-it";
 
-const md = new MarkdownIt({
-  html: true,
-  linkify: true,
-  typographer: true,
-  breaks: false,
-});
+const options = { linkify: true, typographer: true, breaks: false } as const;
+const escaping = new MarkdownIt({ ...options, html: false });
+const passThrough = new MarkdownIt({ ...options, html: true });
+
+export interface MarkdownToHtmlOptions {
+  /**
+   * Pass raw HTML in the Markdown through to the output. Off by default: raw HTML is escaped,
+   * so `<script>` or `<img onerror>` in an uploaded file cannot run when the output is shown.
+   * Turn it on only for trusted input, or sanitise the output before rendering it.
+   */
+  html?: boolean;
+}
 
 /**
  * Provides the reverse of `htmlToMarkdown` for cases where extracted
  * markdown needs to be rendered back to HTML (e.g. previews, email
- * output). Configured with pass-through raw HTML and auto-linking
- * so embedded markup and bare URLs survive the round-trip.
+ * output). Bare URLs are auto-linked. Raw HTML is escaped unless
+ * `options.html` is set.
  */
-export function markdownToHtml(markdown: string): string {
+export function markdownToHtml(markdown: string, options: MarkdownToHtmlOptions = {}): string {
   if (!markdown || markdown.trim() === "") {
     return "";
   }
-  return md.render(markdown);
+  return (options.html ? passThrough : escaping).render(markdown);
 }

package/src/mime-utils.ts

@@ -18,8 +18,9 @@ const MIME_MAP: Record<string, string> = {
  * Content-Type header and need a MIME type for the registry fallback path.
  */
 export function getMimeType(path: string): string | undefined {
-  const dotIndex = path.lastIndexOf(".");
+  const name = path.slice(path.lastIndexOf("/") + 1);
+  const dotIndex = name.lastIndexOf(".");
   if (dotIndex === -1) return undefined;
-  const ext = path.slice(dotIndex).toLowerCase();
+  const ext = name.slice(dotIndex).toLowerCase();
   return MIME_MAP[ext];
 }