@statewalker/content-extractors 0.2.2 → 0.3.0

package/README.md

@@ -1,26 +1,121 @@
 # @statewalker/content-extractors
 
-Content extractors: turn PDF, DOCX, XLSX, Markdown, and HTML into markdown **text** via a mime-aware registry.
+## What it is
 
-## Installation
+Turns files into Markdown text for indexing. Each extractor takes the file bytes as an iterable of `Uint8Array` chunks and returns text: PDF (page by page), DOCX (via HTML), XLSX (one Markdown table per sheet), HTML, Markdown and plain text. An `ExtractorRegistry` picks the extractor from the file name, with an optional MIME-type fallback.
+
+## Why it exists
+
+An indexer needs text, while documents arrive as PDF, Office files or HTML. Each format needs a different parser; this package wraps them behind one function type, `ContentExtractor`, so an ingestion pipeline can route any file by name without knowing the parsers. Producing Markdown keeps headings and tables, which `@statewalker/indexer-chunker` then uses as cut points.
+
+## How to use
 
 ```sh
 pnpm add @statewalker/content-extractors
 ```
 
-## Usage
+| Import | Gives |
+| --- | --- |
+| `@statewalker/content-extractors` | Everything below. |
+| `@statewalker/content-extractors/extractors` | The extractors and `createDefaultRegistry` only. |
+| `@statewalker/content-extractors/types` | `ContentExtractor`, `ContentNormalizer` (types only). |
+
+- `createDefaultRegistry(limits?)` — registry for `*.md`, `*.markdown`, `*.txt`, `*.html`, `*.htm`, `*.pdf`, `*.docx`, `*.docm`, `*.xlsx`; `limits` (`{ maxBytes?, maxUncompressedBytes? }`) applies to every extractor in it.
+- `ExtractorRegistry` — `registerByPattern(pattern, extractor)`, `registerByMime(mime, extractor)`, `getByPath(path)`, `getByMime(mime)`, `get(path, mime?)`.
+- Extractors with the default limits: `pdfExtractor`, `docxExtractor`, `xlsxExtractor`, `htmlExtractor`, `markdownExtractor`, `textExtractor`.
+- Extractor factories with your own limits: `createPdfExtractor({ maxBytes? })`, `createDocxExtractor({ maxBytes?, maxUncompressedBytes? })`, `createXlsxExtractor({ maxBytes?, maxUncompressedBytes? })`, `createHtmlExtractor({ maxBytes? })`, `createMarkdownExtractor({ maxBytes? })`, `createTextExtractor({ maxBytes? })`.
+- Limits: `DEFAULT_MAX_BYTES` (100 MiB), `DEFAULT_MAX_UNCOMPRESSED_BYTES` (500 MiB), types `ExtractorLimits`, `ZipExtractorLimits`.
+- Helpers: `htmlToMarkdown(html)`, `markdownToHtml(markdown, { html? })`, `getMimeType(path)`, `collectBytes(chunks, { maxBytes? })`, `collectText(chunks, { maxBytes? })`, `zipUncompressedSize(bytes)`, `assertZipUncompressedSize(bytes, maxBytes)`.
+
+## Examples
+
+Extract a file by name:
 
 ```ts
+import { readFile } from "node:fs/promises";
 import { createDefaultRegistry } from "@statewalker/content-extractors";
 
 const registry = createDefaultRegistry();
-const extractor = registry.get("report.pdf");
-const markdown = await extractor?.(pdfBytes); // string
+const extract = registry.get("report.pdf");
+if (!extract) throw new Error("unsupported file type");
+const markdown = (await extract([await readFile("report.pdf")])) as string;
+```
+
+Streamed input works the same way (`AsyncIterable<Uint8Array>`, for example a `fetch` body):
+
+```ts
+const response = await fetch(url);
+const extract = registry.get(url, response.headers.get("content-type") ?? undefined);
+const text = await extract?.(response.body as AsyncIterable<Uint8Array>);
 ```
 
-## API
+Route files without an extension by MIME type:
+
+```ts
+import { createDefaultRegistry, htmlExtractor, pdfExtractor } from "@statewalker/content-extractors";
+
+const registry = createDefaultRegistry();
+registry.registerByMime("application/pdf", pdfExtractor);
+registry.registerByMime("text/html", htmlExtractor);
+registry.get("upload-1234", "application/pdf"); // pdfExtractor
+```
+
+Change the size limits (see [Input size limits](#input-size-limits)):
+
+```ts
+import { createDefaultRegistry, createXlsxExtractor } from "@statewalker/content-extractors";
+
+const registry = createDefaultRegistry({ maxBytes: 20 * 1024 * 1024 }); // 20 MiB per file
+registry.registerByPattern("*.xlsx", createXlsxExtractor({ maxUncompressedBytes: 2 * 1024 ** 3 }));
+```
+
+Helpers:
+
+```ts
+import { getMimeType, htmlToMarkdown, markdownToHtml } from "@statewalker/content-extractors";
+
+getMimeType("a.PDF"); // "application/pdf"
+htmlToMarkdown("<h1>T</h1>"); // "# T"
+htmlToMarkdown("<p>hi</p><script>alert(1)</script>"); // "hi": script, style, noscript, template are dropped
+markdownToHtml("**b**"); // "<p><strong>b</strong></p>\n"
+markdownToHtml("<b>x</b>"); // "<p>&lt;b&gt;x&lt;/b&gt;</p>\n": raw HTML is escaped unless { html: true }
+```
+
+## Internals
+
+### What each format produces
+
+| Format | Parser | Output |
+| --- | --- | --- |
+| PDF | `unpdf` | `## Page N` section per non-empty page |
+| DOCX, DOCM | `mammoth` to HTML, then `htmlToMarkdown` | Markdown with headings, lists, tables |
+| XLSX | `exceljs` | `## <sheet name>` and a Markdown table per sheet; first row is the header; pipes in cells escaped, line breaks as spaces |
+| HTML | `turndown` + GFM plugin | ATX headings, fenced code, GFM tables; `<script>`, `<style>`, `<noscript>`, `<template>` dropped |
+| Markdown, text | none | UTF-8 decoded text as-is |
+
+### Input size limits
+
+Every built-in extractor reads at most `maxBytes` of input (default `DEFAULT_MAX_BYTES`, 100 MiB) and throws `Input exceeds the limit of N bytes` beyond it; reading stops as soon as the limit is passed, so an endless stream is not buffered. The DOCX, DOCM and XLSX extractors also read the ZIP central directory before handing the archive to mammoth or exceljs, add up the declared uncompressed sizes, and throw `Archive uncompressed size … exceeds the limit …` when the sum is over `maxUncompressedBytes` (default `DEFAULT_MAX_UNCOMPRESSED_BYTES`, 500 MiB). This refuses a small "zip bomb" before it is inflated. Bytes that are not a readable ZIP throw `Invalid ZIP archive: …`.
+
+Pass limits to `createDefaultRegistry(limits)` or to a `create*Extractor(limits)` factory; `Infinity` turns a limit off. `collectBytes` and `collectText` have no limit unless `maxBytes` is given.
+
+The uncompressed check trusts the sizes the archive declares. An archive that lies about them is still caught by JSZip (inside mammoth and exceljs), which compares the inflated size with the declared one, but only after inflating that entry.
+
+### Things that surprise
+
+- **The default registry has no MIME routes.** `createDefaultRegistry().get("upload-1234", "application/pdf")` returns `undefined`; register MIME types yourself as shown above.
+- **Path matching is by suffix, longest first.** `*.test.html` beats `*.html`. Matching is case-insensitive on both the file name and the pattern (`*.PDF` matches `report.pdf`), and only the part after the last `/` is used. `getMimeType` also looks only after the last `/`: `notes.md/LICENSE` has no extension.
+- **XLSX cells are flattened to one line.** A `|` becomes `\|` and each line break (CR, LF, CRLF) becomes one space, so a cell never adds a column or splits a row.
+- **XLSX formula and rich-text cells come out as `[object Object]`**, and dates as `Date.toString()` in the local time zone. Plain numbers and strings are fine.
+- **`ContentExtractor` returns `Promise<string | unknown>`.** All built-in extractors return a string; cast or check before use.
+- **`markdownToHtml` escapes raw HTML by default.** Extracted files often come from untrusted uploads, so `<script>` or `<img onerror>` in them is shown as text. `{ html: true }` passes raw HTML through; use it only for trusted input, or sanitise the output before rendering it.
+- **Everything is read into memory.** PDF, DOCX and XLSX parsers need one contiguous buffer, so `collectBytes` joins the chunks first, up to the `maxBytes` limit.
+- `ContentNormalizer` is only an interface: a slot for a post-processing step (for example an LLM clean-up) that this package does not implement.
+
+### Dependencies
+
+`unpdf` (PDF text), `mammoth` (DOCX to HTML), `exceljs` (XLSX), `turndown`, `@joplin/turndown-plugin-gfm` and `@types/turndown` (HTML to Markdown), `markdown-it` (Markdown to HTML).
+
+## License
 
-- `ContentExtractor` — the core contract: `bytes → Promise<string>`.
-- `ExtractorRegistry` / `createDefaultRegistry` — resolve an extractor by path or MIME type.
-- Format handlers under `./extractors` (PDF, DOCX, XLSX, Markdown, HTML).
-- `html-to-markdown`, `markdown-to-html`, `mime-utils`, `collect-bytes` helpers.
+MIT

package/dist/collect-bytes.d.ts

@@ -1,16 +1,24 @@
 //#region src/collect-bytes.d.ts
+/** 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,
  * mammoth). Returns the original chunk when only one arrives, avoiding
  * an extra copy in the common single-read case.
  */
-export declare function collectBytes(content: AsyncIterable<Uint8Array> | Iterable<Uint8Array>): Promise<Uint8Array>;
+export declare function collectBytes(content: AsyncIterable<Uint8Array> | Iterable<Uint8Array>, options?: CollectOptions): Promise<Uint8Array>;
 /**
  * Shorthand for text-based extractors (plain text, markdown, HTML) that
  * need the full content as a string. Avoids duplicating the
  * collect-then-decode pattern across every text extractor.
  */
-export declare function collectText(content: AsyncIterable<Uint8Array> | Iterable<Uint8Array>): Promise<string>;
+export declare function collectText(content: AsyncIterable<Uint8Array> | Iterable<Uint8Array>, options?: CollectOptions): Promise<string>;
 //#endregion
 //# sourceMappingURL=collect-bytes.d.ts.map

package/dist/collect-bytes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collect-bytes.d.ts","names":[],"sources":["../src/collect-bytes.ts"],"mappings":";;;;;;;wBAMsB,aACpB,SAAS,cAAc,cAAc,SAAS,cAC7C,QAAQ;;;;;;wBAyBW,YACpB,SAAS,cAAc,cAAc,SAAS,cAC7C"}
+{"version":3,"file":"collect-bytes.d.ts","names":[],"sources":["../src/collect-bytes.ts"],"mappings":";;iBACiB;;;;;EAKf;;;;;;;;wBASoB,aACpB,SAAS,cAAc,cAAc,SAAS,aAC9C,UAAS,iBACR,QAAQ;;;;;;wBA6BW,YACpB,SAAS,cAAc,cAAc,SAAS,aAC9C,UAAS,iBACR"}

package/dist/collect-bytes.js

@@ -5,12 +5,14 @@
 * mammoth). Returns the original chunk when only one arrives, avoiding
 * an extra copy in the common single-read case.
 */
-async function collectBytes(content) {
+async function collectBytes(content, options = {}) {
+	const { maxBytes = Number.POSITIVE_INFINITY } = options;
 	const chunks = [];
 	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) return first;
@@ -27,8 +29,8 @@ async function collectBytes(content) {
 * need the full content as a string. Avoids duplicating the
 * collect-then-decode pattern across every text extractor.
 */
-async function collectText(content) {
-	const bytes = await collectBytes(content);
+async function collectText(content, options = {}) {
+	const bytes = await collectBytes(content, options);
 	return new TextDecoder().decode(bytes);
 }
 //#endregion

package/dist/collect-bytes.js.map

@@ -1 +1 @@
-{"version":3,"file":"collect-bytes.js","names":[],"sources":["../src/collect-bytes.ts"],"sourcesContent":["/**\n * Bridges the streaming world (chunked iterables from fetch, file reads,\n * etc.) with libraries that require a single contiguous buffer (pdfjs-dist,\n * mammoth). Returns the original chunk when only one arrives, avoiding\n * an extra copy in the common single-read case.\n */\nexport async function collectBytes(\n  content: AsyncIterable<Uint8Array> | Iterable<Uint8Array>,\n): Promise<Uint8Array> {\n  const chunks: Uint8Array[] = [];\n  let totalLength = 0;\n  for await (const chunk of content) {\n    chunks.push(chunk);\n    totalLength += chunk.length;\n  }\n  const first = chunks[0];\n  if (chunks.length === 1 && first) {\n    return first;\n  }\n  const result = new Uint8Array(totalLength);\n  let offset = 0;\n  for (const chunk of chunks) {\n    result.set(chunk, offset);\n    offset += chunk.length;\n  }\n  return result;\n}\n\n/**\n * Shorthand for text-based extractors (plain text, markdown, HTML) that\n * need the full content as a string. Avoids duplicating the\n * collect-then-decode pattern across every text extractor.\n */\nexport async function collectText(\n  content: AsyncIterable<Uint8Array> | Iterable<Uint8Array>,\n): Promise<string> {\n  const bytes = await collectBytes(content);\n  return new TextDecoder().decode(bytes);\n}\n"],"mappings":";;;;;;;AAMA,eAAsB,aACpB,SACqB;CACrB,MAAM,SAAuB,CAAC;CAC9B,IAAI,cAAc;CAClB,WAAW,MAAM,SAAS,SAAS;EACjC,OAAO,KAAK,KAAK;EACjB,eAAe,MAAM;CACvB;CACA,MAAM,QAAQ,OAAO;CACrB,IAAI,OAAO,WAAW,KAAK,OACzB,OAAO;CAET,MAAM,SAAS,IAAI,WAAW,WAAW;CACzC,IAAI,SAAS;CACb,KAAK,MAAM,SAAS,QAAQ;EAC1B,OAAO,IAAI,OAAO,MAAM;EACxB,UAAU,MAAM;CAClB;CACA,OAAO;AACT;;;;;;AAOA,eAAsB,YACpB,SACiB;CACjB,MAAM,QAAQ,MAAM,aAAa,OAAO;CACxC,OAAO,IAAI,YAAY,CAAC,CAAC,OAAO,KAAK;AACvC"}
+{"version":3,"file":"collect-bytes.js","names":[],"sources":["../src/collect-bytes.ts"],"sourcesContent":["/** Options for {@link collectBytes} and {@link collectText}. */\nexport interface CollectOptions {\n  /**\n   * Largest input accepted, in bytes. Reading stops and an error is thrown as soon as the total\n   * exceeds it, so an oversized or endless stream is never held in memory. No limit when omitted.\n   */\n  maxBytes?: number;\n}\n\n/**\n * Bridges the streaming world (chunked iterables from fetch, file reads,\n * etc.) with libraries that require a single contiguous buffer (pdfjs-dist,\n * mammoth). Returns the original chunk when only one arrives, avoiding\n * an extra copy in the common single-read case.\n */\nexport async function collectBytes(\n  content: AsyncIterable<Uint8Array> | Iterable<Uint8Array>,\n  options: CollectOptions = {},\n): Promise<Uint8Array> {\n  const { maxBytes = Number.POSITIVE_INFINITY } = options;\n  const chunks: Uint8Array[] = [];\n  let totalLength = 0;\n  for await (const chunk of content) {\n    totalLength += chunk.length;\n    if (totalLength > maxBytes) {\n      throw new Error(`Input exceeds the limit of ${maxBytes} bytes`);\n    }\n    chunks.push(chunk);\n  }\n  const first = chunks[0];\n  if (chunks.length === 1 && first) {\n    return first;\n  }\n  const result = new Uint8Array(totalLength);\n  let offset = 0;\n  for (const chunk of chunks) {\n    result.set(chunk, offset);\n    offset += chunk.length;\n  }\n  return result;\n}\n\n/**\n * Shorthand for text-based extractors (plain text, markdown, HTML) that\n * need the full content as a string. Avoids duplicating the\n * collect-then-decode pattern across every text extractor.\n */\nexport async function collectText(\n  content: AsyncIterable<Uint8Array> | Iterable<Uint8Array>,\n  options: CollectOptions = {},\n): Promise<string> {\n  const bytes = await collectBytes(content, options);\n  return new TextDecoder().decode(bytes);\n}\n"],"mappings":";;;;;;;AAeA,eAAsB,aACpB,SACA,UAA0B,CAAC,GACN;CACrB,MAAM,EAAE,WAAW,OAAO,sBAAsB;CAChD,MAAM,SAAuB,CAAC;CAC9B,IAAI,cAAc;CAClB,WAAW,MAAM,SAAS,SAAS;EACjC,eAAe,MAAM;EACrB,IAAI,cAAc,UAChB,MAAM,IAAI,MAAM,8BAA8B,SAAS,OAAO;EAEhE,OAAO,KAAK,KAAK;CACnB;CACA,MAAM,QAAQ,OAAO;CACrB,IAAI,OAAO,WAAW,KAAK,OACzB,OAAO;CAET,MAAM,SAAS,IAAI,WAAW,WAAW;CACzC,IAAI,SAAS;CACb,KAAK,MAAM,SAAS,QAAQ;EAC1B,OAAO,IAAI,OAAO,MAAM;EACxB,UAAU,MAAM;CAClB;CACA,OAAO;AACT;;;;;;AAOA,eAAsB,YACpB,SACA,UAA0B,CAAC,GACV;CACjB,MAAM,QAAQ,MAAM,aAAa,SAAS,OAAO;CACjD,OAAO,IAAI,YAAY,CAAC,CAAC,OAAO,KAAK;AACvC"}

package/dist/extractor-registry.d.ts

@@ -12,7 +12,8 @@ export declare class ExtractorRegistry {
   private mimeMap;
   /**
    * 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;
   /**

package/dist/extractor-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractor-registry.d.ts","names":[],"sources":["../src/extractor-registry.ts"],"mappings":";;;;;;;;;qBASa;UACH;UACA;;;;;EAMR,kBAAkB,iBAAiB,WAAW;;;;;EAQ9C,eAAe,kBAAkB,WAAW;;;;;EAQ5C,UAAU,eAAe;;EAoBzB,UAAU,mBAAmB;;;;;;EAS7B,IAAI,cAAc,oBAAoB"}
+{"version":3,"file":"extractor-registry.d.ts","names":[],"sources":["../src/extractor-registry.ts"],"mappings":";;;;;;;;;qBASa;UACH;UACA;;;;;;EAOR,kBAAkB,iBAAiB,WAAW;;;;;EAQ9C,eAAe,kBAAkB,WAAW;;;;;EAQ5C,UAAU,eAAe;;EAoBzB,UAAU,mBAAmB;;;;;;EAS7B,IAAI,cAAc,oBAAoB"}

package/dist/extractor-registry.js

@@ -11,10 +11,11 @@ var ExtractorRegistry = class {
 	mimeMap = /* @__PURE__ */ new Map();
 	/**
 	* 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, extractor) {
-		this.patternMap.set(pattern, extractor);
+		this.patternMap.set(pattern.toLowerCase(), extractor);
 	}
 	/**
 	* Provides a fallback route for files that lack a recognizable extension

package/dist/extractor-registry.js.map

@@ -1 +1 @@
-{"version":3,"file":"extractor-registry.js","names":[],"sources":["../src/extractor-registry.ts"],"sourcesContent":["import type { ContentExtractor } from \"./types.js\";\n\n/**\n * Central routing table that decouples file-format knowledge from the\n * extraction pipeline. New formats can be added without touching pipeline\n * code. Longest-suffix matching ensures compound extensions (e.g.\n * `*.tar.gz`) win over shorter ones, and MIME-type fallback handles\n * files that arrive without a recognizable extension.\n */\nexport class ExtractorRegistry {\n  private patternMap = new Map<string, ContentExtractor>();\n  private mimeMap = new Map<string, ContentExtractor>();\n\n  /**\n   * Associates a suffix pattern with an extractor so the registry can\n   * route files to the right handler based on their filename.\n   */\n  registerByPattern(pattern: string, extractor: ContentExtractor): void {\n    this.patternMap.set(pattern, extractor);\n  }\n\n  /**\n   * Provides a fallback route for files that lack a recognizable extension\n   * (e.g. temp files or HTTP responses identified only by Content-Type).\n   */\n  registerByMime(mimeType: string, extractor: ContentExtractor): void {\n    this.mimeMap.set(mimeType, extractor);\n  }\n\n  /**\n   * Resolves by filename suffix, preferring the most specific match so\n   * compound extensions like `*.test.html` beat `*.html` when both exist.\n   */\n  getByPath(path: string): ContentExtractor | undefined {\n    const filename = path.includes(\"/\") ? path.slice(path.lastIndexOf(\"/\") + 1) : path;\n    const lowerFilename = filename.toLowerCase();\n\n    let bestMatch: ContentExtractor | undefined;\n    let bestLength = 0;\n\n    for (const [pattern, extractor] of this.patternMap) {\n      // Pattern format: *.ext or *.compound.ext\n      const suffix = pattern.startsWith(\"*\") ? pattern.slice(1) : pattern;\n      if (lowerFilename.endsWith(suffix) && suffix.length > bestLength) {\n        bestMatch = extractor;\n        bestLength = suffix.length;\n      }\n    }\n\n    return bestMatch;\n  }\n\n  /** Direct MIME lookup -- used internally by `get` as the fallback path. */\n  getByMime(mimeType: string): ContentExtractor | undefined {\n    return this.mimeMap.get(mimeType);\n  }\n\n  /**\n   * Single entry point for the pipeline -- tries the most reliable signal\n   * (file extension) first, then falls back to MIME type so callers never\n   * need to worry about the resolution strategy.\n   */\n  get(path: string, mimeType?: string): ContentExtractor | undefined {\n    const byPath = this.getByPath(path);\n    if (byPath) return byPath;\n    if (mimeType) return this.getByMime(mimeType);\n    return undefined;\n  }\n}\n"],"mappings":";;;;;;;;AASA,IAAa,oBAAb,MAA+B;CAC7B,6BAAqB,IAAI,IAA8B;CACvD,0BAAkB,IAAI,IAA8B;;;;;CAMpD,kBAAkB,SAAiB,WAAmC;EACpE,KAAK,WAAW,IAAI,SAAS,SAAS;CACxC;;;;;CAMA,eAAe,UAAkB,WAAmC;EAClE,KAAK,QAAQ,IAAI,UAAU,SAAS;CACtC;;;;;CAMA,UAAU,MAA4C;EAEpD,MAAM,iBADW,KAAK,SAAS,GAAG,IAAI,KAAK,MAAM,KAAK,YAAY,GAAG,IAAI,CAAC,IAAI,KAAA,CAC/C,YAAY;EAE3C,IAAI;EACJ,IAAI,aAAa;EAEjB,KAAK,MAAM,CAAC,SAAS,cAAc,KAAK,YAAY;GAElD,MAAM,SAAS,QAAQ,WAAW,GAAG,IAAI,QAAQ,MAAM,CAAC,IAAI;GAC5D,IAAI,cAAc,SAAS,MAAM,KAAK,OAAO,SAAS,YAAY;IAChE,YAAY;IACZ,aAAa,OAAO;GACtB;EACF;EAEA,OAAO;CACT;;CAGA,UAAU,UAAgD;EACxD,OAAO,KAAK,QAAQ,IAAI,QAAQ;CAClC;;;;;;CAOA,IAAI,MAAc,UAAiD;EACjE,MAAM,SAAS,KAAK,UAAU,IAAI;EAClC,IAAI,QAAQ,OAAO;EACnB,IAAI,UAAU,OAAO,KAAK,UAAU,QAAQ;CAE9C;AACF"}
+{"version":3,"file":"extractor-registry.js","names":[],"sources":["../src/extractor-registry.ts"],"sourcesContent":["import type { ContentExtractor } from \"./types.js\";\n\n/**\n * Central routing table that decouples file-format knowledge from the\n * extraction pipeline. New formats can be added without touching pipeline\n * code. Longest-suffix matching ensures compound extensions (e.g.\n * `*.tar.gz`) win over shorter ones, and MIME-type fallback handles\n * files that arrive without a recognizable extension.\n */\nexport class ExtractorRegistry {\n  private patternMap = new Map<string, ContentExtractor>();\n  private mimeMap = new Map<string, ContentExtractor>();\n\n  /**\n   * Associates a suffix pattern with an extractor so the registry can\n   * route files to the right handler based on their filename. Patterns are\n   * case-insensitive, like the file names they are matched against.\n   */\n  registerByPattern(pattern: string, extractor: ContentExtractor): void {\n    this.patternMap.set(pattern.toLowerCase(), extractor);\n  }\n\n  /**\n   * Provides a fallback route for files that lack a recognizable extension\n   * (e.g. temp files or HTTP responses identified only by Content-Type).\n   */\n  registerByMime(mimeType: string, extractor: ContentExtractor): void {\n    this.mimeMap.set(mimeType, extractor);\n  }\n\n  /**\n   * Resolves by filename suffix, preferring the most specific match so\n   * compound extensions like `*.test.html` beat `*.html` when both exist.\n   */\n  getByPath(path: string): ContentExtractor | undefined {\n    const filename = path.includes(\"/\") ? path.slice(path.lastIndexOf(\"/\") + 1) : path;\n    const lowerFilename = filename.toLowerCase();\n\n    let bestMatch: ContentExtractor | undefined;\n    let bestLength = 0;\n\n    for (const [pattern, extractor] of this.patternMap) {\n      // Pattern format: *.ext or *.compound.ext\n      const suffix = pattern.startsWith(\"*\") ? pattern.slice(1) : pattern;\n      if (lowerFilename.endsWith(suffix) && suffix.length > bestLength) {\n        bestMatch = extractor;\n        bestLength = suffix.length;\n      }\n    }\n\n    return bestMatch;\n  }\n\n  /** Direct MIME lookup -- used internally by `get` as the fallback path. */\n  getByMime(mimeType: string): ContentExtractor | undefined {\n    return this.mimeMap.get(mimeType);\n  }\n\n  /**\n   * Single entry point for the pipeline -- tries the most reliable signal\n   * (file extension) first, then falls back to MIME type so callers never\n   * need to worry about the resolution strategy.\n   */\n  get(path: string, mimeType?: string): ContentExtractor | undefined {\n    const byPath = this.getByPath(path);\n    if (byPath) return byPath;\n    if (mimeType) return this.getByMime(mimeType);\n    return undefined;\n  }\n}\n"],"mappings":";;;;;;;;AASA,IAAa,oBAAb,MAA+B;CAC7B,6BAAqB,IAAI,IAA8B;CACvD,0BAAkB,IAAI,IAA8B;;;;;;CAOpD,kBAAkB,SAAiB,WAAmC;EACpE,KAAK,WAAW,IAAI,QAAQ,YAAY,GAAG,SAAS;CACtD;;;;;CAMA,eAAe,UAAkB,WAAmC;EAClE,KAAK,QAAQ,IAAI,UAAU,SAAS;CACtC;;;;;CAMA,UAAU,MAA4C;EAEpD,MAAM,iBADW,KAAK,SAAS,GAAG,IAAI,KAAK,MAAM,KAAK,YAAY,GAAG,IAAI,CAAC,IAAI,KAAA,CAC/C,YAAY;EAE3C,IAAI;EACJ,IAAI,aAAa;EAEjB,KAAK,MAAM,CAAC,SAAS,cAAc,KAAK,YAAY;GAElD,MAAM,SAAS,QAAQ,WAAW,GAAG,IAAI,QAAQ,MAAM,CAAC,IAAI;GAC5D,IAAI,cAAc,SAAS,MAAM,KAAK,OAAO,SAAS,YAAY;IAChE,YAAY;IACZ,aAAa,OAAO;GACtB;EACF;EAEA,OAAO;CACT;;CAGA,UAAU,UAAgD;EACxD,OAAO,KAAK,QAAQ,IAAI,QAAQ;CAClC;;;;;;CAOA,IAAI,MAAc,UAAiD;EACjE,MAAM,SAAS,KAAK,UAAU,IAAI;EAClC,IAAI,QAAQ,OAAO;EACnB,IAAI,UAAU,OAAO,KAAK,UAAU,QAAQ;CAE9C;AACF"}

package/dist/extractors/docx-extractor.d.ts

@@ -1,11 +1,15 @@
+import { ZipExtractorLimits } from "../limits.js";
 import { ContentExtractor } from "../types.js";
 //#region src/extractors/docx-extractor.d.ts
 /**
  * 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 declare function createDocxExtractor(limits?: ZipExtractorLimits): ContentExtractor;
+/** DOCX/DOCM extractor with the default limits. */
 export declare const docxExtractor: ContentExtractor;
 //#endregion
 //# sourceMappingURL=docx-extractor.d.ts.map

package/dist/extractors/docx-extractor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"docx-extractor.d.ts","names":[],"sources":["../../src/extractors/docx-extractor.ts"],"mappings":";;;;;;;;qBAWa,eAAe"}
+{"version":3,"file":"docx-extractor.d.ts","names":[],"sources":["../../src/extractors/docx-extractor.ts"],"mappings":";;;;;;;;;;wBAkBgB,oBAAoB,SAAQ,qBAA0B;;qBAiBzD,eAAe"}

package/dist/extractors/docx-extractor.js

@@ -1,23 +1,32 @@
 import { collectBytes } from "../collect-bytes.js";
 import { htmlToMarkdown } from "../html-to-markdown.js";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_UNCOMPRESSED_BYTES } from "../limits.js";
+import { assertZipUncompressedSize } from "../zip-size.js";
 import mammoth from "mammoth";
 //#region src/extractors/docx-extractor.ts
 /**
 * 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.
 */
-const docxExtractor = async (content) => {
-	const bytes = await collectBytes(content);
-	const arrayBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-	const result = await mammoth.convertToHtml({
-		buffer: arrayBuffer,
-		arrayBuffer
-	});
-	return htmlToMarkdown(result.value);
-};
+function createDocxExtractor(limits = {}) {
+	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);
+		const result = await mammoth.convertToHtml({
+			buffer: arrayBuffer,
+			arrayBuffer
+		});
+		return htmlToMarkdown(result.value);
+	};
+}
+/** DOCX/DOCM extractor with the default limits. */
+const docxExtractor = createDocxExtractor();
 //#endregion
-export { docxExtractor };
+export { createDocxExtractor, docxExtractor };
 
 //# sourceMappingURL=docx-extractor.js.map

package/dist/extractors/docx-extractor.js.map

@@ -1 +1 @@
-{"version":3,"file":"docx-extractor.js","names":[],"sources":["../../src/extractors/docx-extractor.ts"],"sourcesContent":["import mammoth from \"mammoth\";\nimport { collectBytes } from \"../collect-bytes.js\";\nimport { htmlToMarkdown } from \"../html-to-markdown.js\";\nimport type { ContentExtractor } from \"../types.js\";\n\n/**\n * Unlocks Word document content for text-based pipelines via a two-stage\n * conversion (DOCX -> HTML -> markdown). Supplies both `buffer` and\n * `arrayBuffer` to mammoth so the same code runs in Node.js and browsers\n * without environment detection.\n */\nexport const docxExtractor: ContentExtractor = async (content) => {\n  const bytes = await collectBytes(content);\n  const arrayBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);\n  // mammoth uses \"buffer\" in Node.js and \"arrayBuffer\" in browsers\n  const result = await mammoth.convertToHtml({\n    buffer: arrayBuffer,\n    arrayBuffer,\n  } as Parameters<typeof mammoth.convertToHtml>[0]);\n  return htmlToMarkdown(result.value);\n};\n"],"mappings":";;;;;;;;;;AAWA,MAAa,gBAAkC,OAAO,YAAY;CAChE,MAAM,QAAQ,MAAM,aAAa,OAAO;CACxC,MAAM,cAAc,MAAM,OAAO,MAAM,MAAM,YAAY,MAAM,aAAa,MAAM,UAAU;CAE5F,MAAM,SAAS,MAAM,QAAQ,cAAc;EACzC,QAAQ;EACR;CACF,CAAgD;CAChD,OAAO,eAAe,OAAO,KAAK;AACpC"}
+{"version":3,"file":"docx-extractor.js","names":[],"sources":["../../src/extractors/docx-extractor.ts"],"sourcesContent":["import mammoth from \"mammoth\";\nimport { collectBytes } from \"../collect-bytes.js\";\nimport { htmlToMarkdown } from \"../html-to-markdown.js\";\nimport {\n  DEFAULT_MAX_BYTES,\n  DEFAULT_MAX_UNCOMPRESSED_BYTES,\n  type ZipExtractorLimits,\n} from \"../limits.js\";\nimport type { ContentExtractor } from \"../types.js\";\nimport { assertZipUncompressedSize } from \"../zip-size.js\";\n\n/**\n * Unlocks Word document content for text-based pipelines via a two-stage\n * conversion (DOCX -> HTML -> markdown). Supplies both `buffer` and\n * `arrayBuffer` to mammoth so the same code runs in Node.js and browsers\n * without environment detection. The input size and the archive's declared\n * uncompressed size are checked before mammoth inflates it.\n */\nexport function createDocxExtractor(limits: ZipExtractorLimits = {}): ContentExtractor {\n  const { maxBytes = DEFAULT_MAX_BYTES, maxUncompressedBytes = DEFAULT_MAX_UNCOMPRESSED_BYTES } =\n    limits;\n  return async (content) => {\n    const bytes = await collectBytes(content, { maxBytes });\n    assertZipUncompressedSize(bytes, maxUncompressedBytes);\n    const arrayBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);\n    // mammoth uses \"buffer\" in Node.js and \"arrayBuffer\" in browsers\n    const result = await mammoth.convertToHtml({\n      buffer: arrayBuffer,\n      arrayBuffer,\n    } as Parameters<typeof mammoth.convertToHtml>[0]);\n    return htmlToMarkdown(result.value);\n  };\n}\n\n/** DOCX/DOCM extractor with the default limits. */\nexport const docxExtractor: ContentExtractor = createDocxExtractor();\n"],"mappings":";;;;;;;;;;;;;AAkBA,SAAgB,oBAAoB,SAA6B,CAAC,GAAqB;CACrF,MAAM,EAAE,WAAW,mBAAmB,uBAAuB,mCAC3D;CACF,OAAO,OAAO,YAAY;EACxB,MAAM,QAAQ,MAAM,aAAa,SAAS,EAAE,SAAS,CAAC;EACtD,0BAA0B,OAAO,oBAAoB;EACrD,MAAM,cAAc,MAAM,OAAO,MAAM,MAAM,YAAY,MAAM,aAAa,MAAM,UAAU;EAE5F,MAAM,SAAS,MAAM,QAAQ,cAAc;GACzC,QAAQ;GACR;EACF,CAAgD;EAChD,OAAO,eAAe,OAAO,KAAK;CACpC;AACF;;AAGA,MAAa,gBAAkC,oBAAoB"}

package/dist/extractors/html-extractor.d.ts

@@ -1,3 +1,4 @@
+import { ExtractorLimits } from "../limits.js";
 import { ContentExtractor } from "../types.js";
 //#region src/extractors/html-extractor.d.ts
 /**
@@ -5,6 +6,8 @@ import { 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 declare function createHtmlExtractor(limits?: ExtractorLimits): ContentExtractor;
+/** HTML extractor with the default limits. */
 export declare const htmlExtractor: ContentExtractor;
 //#endregion
 //# sourceMappingURL=html-extractor.d.ts.map

package/dist/extractors/html-extractor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"html-extractor.d.ts","names":[],"sources":["../../src/extractors/html-extractor.ts"],"mappings":";;;;;;;qBASa,eAAe"}
+{"version":3,"file":"html-extractor.d.ts","names":[],"sources":["../../src/extractors/html-extractor.ts"],"mappings":";;;;;;;;wBAUgB,oBAAoB,SAAQ,kBAAuB;;qBAMtD,eAAe"}

package/dist/extractors/html-extractor.js

@@ -1,16 +1,19 @@
 import { collectText } from "../collect-bytes.js";
 import { htmlToMarkdown } from "../html-to-markdown.js";
+import { DEFAULT_MAX_BYTES } from "../limits.js";
 //#region src/extractors/html-extractor.ts
 /**
 * Converts HTML files to markdown so the pipeline outputs a uniform
 * text format. Delegates to `htmlToMarkdown` for the actual conversion,
 * keeping this extractor focused on the bytes-to-string bridging step.
 */
-const htmlExtractor = async (content) => {
-	const html = await collectText(content);
-	return htmlToMarkdown(html);
-};
+function createHtmlExtractor(limits = {}) {
+	const { maxBytes = DEFAULT_MAX_BYTES } = limits;
+	return async (content) => htmlToMarkdown(await collectText(content, { maxBytes }));
+}
+/** HTML extractor with the default limits. */
+const htmlExtractor = createHtmlExtractor();
 //#endregion
-export { htmlExtractor };
+export { createHtmlExtractor, htmlExtractor };
 
 //# sourceMappingURL=html-extractor.js.map

package/dist/extractors/html-extractor.js.map

@@ -1 +1 @@
-{"version":3,"file":"html-extractor.js","names":[],"sources":["../../src/extractors/html-extractor.ts"],"sourcesContent":["import { collectText } from \"../collect-bytes.js\";\nimport { htmlToMarkdown } from \"../html-to-markdown.js\";\nimport type { ContentExtractor } from \"../types.js\";\n\n/**\n * Converts HTML files to markdown so the pipeline outputs a uniform\n * text format. Delegates to `htmlToMarkdown` for the actual conversion,\n * keeping this extractor focused on the bytes-to-string bridging step.\n */\nexport const htmlExtractor: ContentExtractor = async (content) => {\n  const html = await collectText(content);\n  return htmlToMarkdown(html);\n};\n"],"mappings":";;;;;;;;AASA,MAAa,gBAAkC,OAAO,YAAY;CAChE,MAAM,OAAO,MAAM,YAAY,OAAO;CACtC,OAAO,eAAe,IAAI;AAC5B"}
+{"version":3,"file":"html-extractor.js","names":[],"sources":["../../src/extractors/html-extractor.ts"],"sourcesContent":["import { collectText } from \"../collect-bytes.js\";\nimport { htmlToMarkdown } from \"../html-to-markdown.js\";\nimport { DEFAULT_MAX_BYTES, type ExtractorLimits } from \"../limits.js\";\nimport type { ContentExtractor } from \"../types.js\";\n\n/**\n * Converts HTML files to markdown so the pipeline outputs a uniform\n * text format. Delegates to `htmlToMarkdown` for the actual conversion,\n * keeping this extractor focused on the bytes-to-string bridging step.\n */\nexport function createHtmlExtractor(limits: ExtractorLimits = {}): ContentExtractor {\n  const { maxBytes = DEFAULT_MAX_BYTES } = limits;\n  return async (content) => htmlToMarkdown(await collectText(content, { maxBytes }));\n}\n\n/** HTML extractor with the default limits. */\nexport const htmlExtractor: ContentExtractor = createHtmlExtractor();\n"],"mappings":";;;;;;;;;AAUA,SAAgB,oBAAoB,SAA0B,CAAC,GAAqB;CAClF,MAAM,EAAE,WAAW,sBAAsB;CACzC,OAAO,OAAO,YAAY,eAAe,MAAM,YAAY,SAAS,EAAE,SAAS,CAAC,CAAC;AACnF;;AAGA,MAAa,gBAAkC,oBAAoB"}

package/dist/extractors/index.d.ts

@@ -1,18 +1,21 @@
-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 { ZipExtractorLimits } from "../limits.js";
+import { createDocxExtractor, docxExtractor } from "./docx-extractor.js";
+import { createHtmlExtractor, htmlExtractor } from "./html-extractor.js";
+import { createMarkdownExtractor, markdownExtractor } from "./markdown-extractor.js";
+import { createPdfExtractor, pdfExtractor } from "./pdf-extractor.js";
+import { createTextExtractor, textExtractor } from "./text-extractor.js";
+import { createXlsxExtractor, xlsxExtractor } from "./xlsx-extractor.js";
 import { ExtractorRegistry } from "../extractor-registry.js";
 //#region src/extractors/index.d.ts
 /**
  * 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 declare function createDefaultRegistry(): ExtractorRegistry;
+export declare function createDefaultRegistry(limits?: ZipExtractorLimits): ExtractorRegistry;
 //#endregion
-export { docxExtractor, htmlExtractor, markdownExtractor, pdfExtractor, textExtractor, xlsxExtractor };
+export { createDocxExtractor, createHtmlExtractor, createMarkdownExtractor, createPdfExtractor, createTextExtractor, createXlsxExtractor, docxExtractor, htmlExtractor, markdownExtractor, pdfExtractor, textExtractor, xlsxExtractor };
 //# sourceMappingURL=index.d.ts.map

package/dist/extractors/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/extractors/index.ts"],"mappings":";;;;;;;;;;;;;;wBAqBgB,yBAAyB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/extractors/index.ts"],"mappings":";;;;;;;;;;;;;;;;;wBAwBgB,sBAAsB,SAAQ,qBAA0B"}

package/dist/extractors/index.js

@@ -1,31 +1,36 @@
-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 { createDocxExtractor, docxExtractor } from "./docx-extractor.js";
+import { createHtmlExtractor, htmlExtractor } from "./html-extractor.js";
+import { createMarkdownExtractor, markdownExtractor } from "./markdown-extractor.js";
+import { createPdfExtractor, pdfExtractor } from "./pdf-extractor.js";
+import { createTextExtractor, textExtractor } from "./text-extractor.js";
+import { createXlsxExtractor, xlsxExtractor } from "./xlsx-extractor.js";
 import { ExtractorRegistry } from "../extractor-registry.js";
 //#region src/extractors/index.ts
 /**
 * 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.
 */
-function createDefaultRegistry() {
+function createDefaultRegistry(limits = {}) {
+	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;
 }
 //#endregion
-export { createDefaultRegistry, docxExtractor, htmlExtractor, markdownExtractor, pdfExtractor, textExtractor, xlsxExtractor };
+export { createDefaultRegistry, createDocxExtractor, createHtmlExtractor, createMarkdownExtractor, createPdfExtractor, createTextExtractor, createXlsxExtractor, docxExtractor, htmlExtractor, markdownExtractor, pdfExtractor, textExtractor, xlsxExtractor };
 
 //# sourceMappingURL=index.js.map

package/dist/extractors/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/extractors/index.ts"],"sourcesContent":["export { docxExtractor } from \"./docx-extractor.js\";\nexport { htmlExtractor } from \"./html-extractor.js\";\nexport { markdownExtractor } from \"./markdown-extractor.js\";\nexport { pdfExtractor } from \"./pdf-extractor.js\";\nexport { textExtractor } from \"./text-extractor.js\";\nexport { xlsxExtractor } from \"./xlsx-extractor.js\";\n\nimport { ExtractorRegistry } from \"../extractor-registry.js\";\nimport { docxExtractor } from \"./docx-extractor.js\";\nimport { htmlExtractor } from \"./html-extractor.js\";\nimport { markdownExtractor } from \"./markdown-extractor.js\";\nimport { pdfExtractor } from \"./pdf-extractor.js\";\nimport { textExtractor } from \"./text-extractor.js\";\nimport { xlsxExtractor } from \"./xlsx-extractor.js\";\n\n/**\n * Provides a batteries-included registry so most consumers can start\n * extracting immediately without manual format registration. Custom\n * registries are still supported for apps that need to override or\n * limit the built-in set.\n */\nexport function createDefaultRegistry(): ExtractorRegistry {\n  const registry = new ExtractorRegistry();\n  registry.registerByPattern(\"*.md\", markdownExtractor);\n  registry.registerByPattern(\"*.markdown\", markdownExtractor);\n  registry.registerByPattern(\"*.txt\", textExtractor);\n  registry.registerByPattern(\"*.html\", htmlExtractor);\n  registry.registerByPattern(\"*.htm\", htmlExtractor);\n  registry.registerByPattern(\"*.pdf\", pdfExtractor);\n  registry.registerByPattern(\"*.docx\", docxExtractor);\n  registry.registerByPattern(\"*.docm\", docxExtractor);\n  registry.registerByPattern(\"*.xlsx\", xlsxExtractor);\n  return registry;\n}\n"],"mappings":";;;;;;;;;;;;;;AAqBA,SAAgB,wBAA2C;CACzD,MAAM,WAAW,IAAI,kBAAkB;CACvC,SAAS,kBAAkB,QAAQ,iBAAiB;CACpD,SAAS,kBAAkB,cAAc,iBAAiB;CAC1D,SAAS,kBAAkB,SAAS,aAAa;CACjD,SAAS,kBAAkB,UAAU,aAAa;CAClD,SAAS,kBAAkB,SAAS,aAAa;CACjD,SAAS,kBAAkB,SAAS,YAAY;CAChD,SAAS,kBAAkB,UAAU,aAAa;CAClD,SAAS,kBAAkB,UAAU,aAAa;CAClD,SAAS,kBAAkB,UAAU,aAAa;CAClD,OAAO;AACT"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/extractors/index.ts"],"sourcesContent":["export { createDocxExtractor, docxExtractor } from \"./docx-extractor.js\";\nexport { createHtmlExtractor, htmlExtractor } from \"./html-extractor.js\";\nexport { createMarkdownExtractor, markdownExtractor } from \"./markdown-extractor.js\";\nexport { createPdfExtractor, pdfExtractor } from \"./pdf-extractor.js\";\nexport { createTextExtractor, textExtractor } from \"./text-extractor.js\";\nexport { createXlsxExtractor, xlsxExtractor } from \"./xlsx-extractor.js\";\n\nimport { ExtractorRegistry } from \"../extractor-registry.js\";\nimport type { ZipExtractorLimits } from \"../limits.js\";\nimport { createDocxExtractor } from \"./docx-extractor.js\";\nimport { createHtmlExtractor } from \"./html-extractor.js\";\nimport { createMarkdownExtractor } from \"./markdown-extractor.js\";\nimport { createPdfExtractor } from \"./pdf-extractor.js\";\nimport { createTextExtractor } from \"./text-extractor.js\";\nimport { createXlsxExtractor } from \"./xlsx-extractor.js\";\n\n/**\n * Provides a batteries-included registry so most consumers can start\n * extracting immediately without manual format registration. Custom\n * registries are still supported for apps that need to override or\n * limit the built-in set. `limits` applies to every registered extractor\n * (`maxUncompressedBytes` only to DOCX, DOCM and XLSX); omitted limits\n * take the defaults.\n */\nexport function createDefaultRegistry(limits: ZipExtractorLimits = {}): ExtractorRegistry {\n  const markdown = createMarkdownExtractor(limits);\n  const html = createHtmlExtractor(limits);\n  const docx = createDocxExtractor(limits);\n  const registry = new ExtractorRegistry();\n  registry.registerByPattern(\"*.md\", markdown);\n  registry.registerByPattern(\"*.markdown\", markdown);\n  registry.registerByPattern(\"*.txt\", createTextExtractor(limits));\n  registry.registerByPattern(\"*.html\", html);\n  registry.registerByPattern(\"*.htm\", html);\n  registry.registerByPattern(\"*.pdf\", createPdfExtractor(limits));\n  registry.registerByPattern(\"*.docx\", docx);\n  registry.registerByPattern(\"*.docm\", docx);\n  registry.registerByPattern(\"*.xlsx\", createXlsxExtractor(limits));\n  return registry;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAwBA,SAAgB,sBAAsB,SAA6B,CAAC,GAAsB;CACxF,MAAM,WAAW,wBAAwB,MAAM;CAC/C,MAAM,OAAO,oBAAoB,MAAM;CACvC,MAAM,OAAO,oBAAoB,MAAM;CACvC,MAAM,WAAW,IAAI,kBAAkB;CACvC,SAAS,kBAAkB,QAAQ,QAAQ;CAC3C,SAAS,kBAAkB,cAAc,QAAQ;CACjD,SAAS,kBAAkB,SAAS,oBAAoB,MAAM,CAAC;CAC/D,SAAS,kBAAkB,UAAU,IAAI;CACzC,SAAS,kBAAkB,SAAS,IAAI;CACxC,SAAS,kBAAkB,SAAS,mBAAmB,MAAM,CAAC;CAC9D,SAAS,kBAAkB,UAAU,IAAI;CACzC,SAAS,kBAAkB,UAAU,IAAI;CACzC,SAAS,kBAAkB,UAAU,oBAAoB,MAAM,CAAC;CAChE,OAAO;AACT"}

package/dist/extractors/markdown-extractor.d.ts

@@ -1,3 +1,4 @@
+import { ExtractorLimits } from "../limits.js";
 import { ContentExtractor } from "../types.js";
 //#region src/extractors/markdown-extractor.d.ts
 /**
@@ -6,6 +7,8 @@ import { ContentExtractor } from "../types.js";
  * the registry can distinguish `.md` from `.txt` -- allowing future
  * markdown-specific processing without breaking existing registrations.
  */
+export declare function createMarkdownExtractor(limits?: ExtractorLimits): ContentExtractor;
+/** Markdown extractor with the default limits. */
 export declare const markdownExtractor: ContentExtractor;
 //#endregion
 //# sourceMappingURL=markdown-extractor.d.ts.map

package/dist/extractors/markdown-extractor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"markdown-extractor.d.ts","names":[],"sources":["../../src/extractors/markdown-extractor.ts"],"mappings":";;;;;;;;qBASa,mBAAmB"}
+{"version":3,"file":"markdown-extractor.d.ts","names":[],"sources":["../../src/extractors/markdown-extractor.ts"],"mappings":";;;;;;;;;wBAUgB,wBAAwB,SAAQ,kBAAuB;;qBAM1D,mBAAmB"}

package/dist/extractors/markdown-extractor.js

@@ -1,4 +1,5 @@
 import { collectText } from "../collect-bytes.js";
+import { DEFAULT_MAX_BYTES } from "../limits.js";
 //#region src/extractors/markdown-extractor.ts
 /**
 * Passthrough extractor for markdown files. Functionally identical to
@@ -6,10 +7,13 @@ import { collectText } from "../collect-bytes.js";
 * the registry can distinguish `.md` from `.txt` -- allowing future
 * markdown-specific processing without breaking existing registrations.
 */
-const markdownExtractor = async (content) => {
-	return collectText(content);
-};
+function createMarkdownExtractor(limits = {}) {
+	const { maxBytes = DEFAULT_MAX_BYTES } = limits;
+	return (content) => collectText(content, { maxBytes });
+}
+/** Markdown extractor with the default limits. */
+const markdownExtractor = createMarkdownExtractor();
 //#endregion
-export { markdownExtractor };
+export { createMarkdownExtractor, markdownExtractor };
 
 //# sourceMappingURL=markdown-extractor.js.map

package/dist/extractors/markdown-extractor.js.map

@@ -1 +1 @@
-{"version":3,"file":"markdown-extractor.js","names":[],"sources":["../../src/extractors/markdown-extractor.ts"],"sourcesContent":["import { collectText } from \"../collect-bytes.js\";\nimport type { ContentExtractor } from \"../types.js\";\n\n/**\n * Passthrough extractor for markdown files. Functionally identical to\n * `textExtractor` but registered under its own extension patterns so\n * the registry can distinguish `.md` from `.txt` -- allowing future\n * markdown-specific processing without breaking existing registrations.\n */\nexport const markdownExtractor: ContentExtractor = async (content) => {\n  return collectText(content);\n};\n"],"mappings":";;;;;;;;AASA,MAAa,oBAAsC,OAAO,YAAY;CACpE,OAAO,YAAY,OAAO;AAC5B"}
+{"version":3,"file":"markdown-extractor.js","names":[],"sources":["../../src/extractors/markdown-extractor.ts"],"sourcesContent":["import { collectText } from \"../collect-bytes.js\";\nimport { DEFAULT_MAX_BYTES, type ExtractorLimits } from \"../limits.js\";\nimport type { ContentExtractor } from \"../types.js\";\n\n/**\n * Passthrough extractor for markdown files. Functionally identical to\n * `textExtractor` but registered under its own extension patterns so\n * the registry can distinguish `.md` from `.txt` -- allowing future\n * markdown-specific processing without breaking existing registrations.\n */\nexport function createMarkdownExtractor(limits: ExtractorLimits = {}): ContentExtractor {\n  const { maxBytes = DEFAULT_MAX_BYTES } = limits;\n  return (content) => collectText(content, { maxBytes });\n}\n\n/** Markdown extractor with the default limits. */\nexport const markdownExtractor: ContentExtractor = createMarkdownExtractor();\n"],"mappings":";;;;;;;;;AAUA,SAAgB,wBAAwB,SAA0B,CAAC,GAAqB;CACtF,MAAM,EAAE,WAAW,sBAAsB;CACzC,QAAQ,YAAY,YAAY,SAAS,EAAE,SAAS,CAAC;AACvD;;AAGA,MAAa,oBAAsC,wBAAwB"}

package/dist/extractors/pdf-extractor.d.ts

@@ -1,3 +1,4 @@
+import { ExtractorLimits } from "../limits.js";
 import { ContentExtractor } from "../types.js";
 //#region src/extractors/pdf-extractor.d.ts
 /**
@@ -5,6 +6,8 @@ import { ContentExtractor } from "../types.js";
  * section with a `## Page N` header. This preserves page boundaries in
  * the indexed content, making search results more precise.
  */
+export declare function createPdfExtractor(limits?: ExtractorLimits): ContentExtractor;
+/** PDF extractor with the default limits. */
 export declare const pdfExtractor: ContentExtractor;
 //#endregion
 //# sourceMappingURL=pdf-extractor.d.ts.map

package/dist/extractors/pdf-extractor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pdf-extractor.d.ts","names":[],"sources":["../../src/extractors/pdf-extractor.ts"],"mappings":";;;;;;;qBASa,cAAc"}
+{"version":3,"file":"pdf-extractor.d.ts","names":[],"sources":["../../src/extractors/pdf-extractor.ts"],"mappings":";;;;;;;;wBAUgB,mBAAmB,SAAQ,kBAAuB;;qBAqBrD,cAAc"}