@yolk-sdk/extractors 0.1.0-canary.98

package/dist/node/index.d.mts

@@ -0,0 +1,6 @@
+import { FileExtractor, FileExtractorApi } from "../service.mjs";
+import { OfficeArchiveLimits, normalizeOfficeArchive } from "./office-archive.mjs";
+import { SheetJsLoader } from "./sheetjs.mjs";
+import { FileExtractorIsolation, WorkerIsolationOptions, defaultWorkerIsolation } from "./extraction-isolation.mjs";
+import { FileExtractorLayer, FileExtractorOptions, makeFileExtractorLayer } from "./live-layer.mjs";
+export { FileExtractor, type FileExtractorApi, type FileExtractorIsolation, FileExtractorLayer, type FileExtractorOptions, type OfficeArchiveLimits, type SheetJsLoader, type WorkerIsolationOptions, defaultWorkerIsolation, makeFileExtractorLayer, normalizeOfficeArchive };

package/dist/node/index.mjs

@@ -0,0 +1,5 @@
+import { FileExtractor } from "../service.mjs";
+import { normalizeOfficeArchive } from "./office-archive.mjs";
+import { defaultWorkerIsolation } from "./extraction-isolation.mjs";
+import { FileExtractorLayer, makeFileExtractorLayer } from "./live-layer.mjs";
+export { FileExtractor, FileExtractorLayer, defaultWorkerIsolation, makeFileExtractorLayer, normalizeOfficeArchive };

package/dist/node/live-layer.d.mts

@@ -0,0 +1,36 @@
+import { FileExtractorLimits } from "../limits.mjs";
+import { FileExtractor } from "../service.mjs";
+import { SheetJsLoader } from "./sheetjs.mjs";
+import { FileExtractorIsolation } from "./extraction-isolation.mjs";
+import { Layer } from "effect";
+
+//#region src/node/live-layer.d.ts
+type FileExtractorOptions = {
+  /** Override any default limit; see `defaultFileExtractorLimits`. */readonly limits?: Partial<FileExtractorLimits>;
+  /**
+   * Where parsers run (default `'worker'`): each PDF, DOCX, XLSX, and PPTX extraction runs in a
+   * fresh worker thread with V8 heap, stack, and time limits, admitted through a pool of 4 workers
+   * per JavaScript realm; pass an object to change them. `'none'` parses in the calling thread and is
+   * unsafe for untrusted input.
+   */
+  readonly isolation?: FileExtractorIsolation;
+  /**
+   * Load SheetJS in the calling thread. Only with `isolation: 'none'` (a worker cannot receive a
+   * function and always imports the installed `xlsx` itself); any other isolation is a defect
+   * when the layer is built. Defaults to a lazy `import('xlsx')`. Missing, non-SheetJS, or
+   * pre-0.20.3 modules fail with `SheetJsUnavailableError`.
+   */
+  readonly loadSheetJs?: SheetJsLoader;
+};
+/**
+ * Node `FileExtractor` layer with custom limits, isolation, or (in-process) SheetJS loader.
+ * Invalid limits or isolation settings are defects.
+ */
+declare const makeFileExtractorLayer: (options?: FileExtractorOptions) => Layer.Layer<FileExtractor, never, never>;
+/**
+ * Node `FileExtractor` layer with the default limits, worker isolation, and lazy SheetJS loading.
+ */
+declare const FileExtractorLayer: Layer.Layer<FileExtractor, never, never>;
+//#endregion
+export { FileExtractorLayer, FileExtractorOptions, makeFileExtractorLayer };
+//# sourceMappingURL=live-layer.d.mts.map

package/dist/node/live-layer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-layer.d.mts","names":[],"sources":["../../src/node/live-layer.ts"],"mappings":";;;;;;;KAmBY,oBAAA;+EAED,MAAA,GAAS,OAAA,CAAQ,mBAAA;EAFI;;;;;;EAAA,SASrB,SAAA,GAAY,sBAAA;EAOe;;;;;;EAAA,SAA3B,WAAA,GAAc,aAAA;AAAA;;AAAa;AAkFtC;;cAAa,sBAAA,GAA0B,OAAA,GAAS,oBAAA,KAAyB,KAAA,CAAA,KAAA,CAAA,aAAA;;;;cAkB5D,kBAAA,EAAkB,KAAA,CAAA,KAAA,CAAA,aAAA"}

package/dist/node/live-layer.mjs

@@ -0,0 +1,70 @@
+import { FileExtractionError, UnsupportedFileFormatError } from "../errors.mjs";
+import { fileFormatFor } from "../format.mjs";
+import { FileExtractorLimits, defaultFileExtractorLimits } from "../limits.mjs";
+import { FileExtractor } from "../service.mjs";
+import { defaultSheetJsLoader } from "./sheetjs.mjs";
+import { extractParsedFile, isParsedFileFormat, makeExtractedFile } from "./extract-file.mjs";
+import { WorkerIsolationSettings, defaultExtractionWorkerUrl, defaultWorkerIsolation, makeWorkerExtractor } from "./extraction-isolation.mjs";
+import { Effect, Layer } from "effect";
+import * as Schema from "effect/Schema";
+//#region src/node/live-layer.ts
+const decodeText = (bytes) => new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+/** Build the Node `FileExtractor` from validated limits and the parser runner. */
+const makeFileExtractor = (limits, extractParsed) => ({ extract: (input) => Effect.gen(function* () {
+	const format = fileFormatFor(input);
+	if (format === void 0) return yield* Effect.fail(new UnsupportedFileFormatError({
+		filename: input.filename,
+		mediaType: input.mediaType
+	}));
+	yield* Effect.annotateCurrentSpan({
+		"file_extractor.format": format,
+		"file_extractor.file_size": input.bytes.byteLength
+	});
+	if (input.bytes.byteLength > limits.maxInputBytes) return yield* Effect.fail(new FileExtractionError({
+		message: "File exceeds the extraction size limit",
+		format
+	}));
+	if (isParsedFileFormat(format)) return yield* extractParsed(input, format, limits);
+	return yield* makeExtractedFile(decodeText(input.bytes), {
+		format,
+		title: input.filename
+	});
+}).pipe(Effect.withSpan("FileExtractor.extract")) });
+const parsedFileExtractor = (options) => {
+	const isolation = options.isolation ?? "worker";
+	if (isolation === "none") {
+		const loader = options.loadSheetJs ?? defaultSheetJsLoader;
+		return Effect.succeed((input, format, limits) => extractParsedFile(input, format, limits, loader));
+	}
+	if (options.loadSheetJs !== void 0) return Effect.die(/* @__PURE__ */ new Error("FileExtractorOptions.loadSheetJs runs SheetJS in the calling thread and needs isolation: \"none\""));
+	const overrides = isolation === "worker" ? {} : isolation;
+	const timeoutMs = overrides.timeoutMs ?? defaultWorkerIsolation.timeoutMs;
+	return Schema.decodeUnknownEffect(WorkerIsolationSettings)({
+		maxOldGenerationSizeMb: overrides.maxOldGenerationSizeMb ?? defaultWorkerIsolation.maxOldGenerationSizeMb,
+		maxYoungGenerationSizeMb: overrides.maxYoungGenerationSizeMb ?? defaultWorkerIsolation.maxYoungGenerationSizeMb,
+		stackSizeMb: overrides.stackSizeMb ?? defaultWorkerIsolation.stackSizeMb,
+		timeoutMs,
+		maxConcurrentWorkers: overrides.maxConcurrentWorkers ?? defaultWorkerIsolation.maxConcurrentWorkers,
+		maxQueueWaitMs: overrides.maxQueueWaitMs ?? timeoutMs
+	}).pipe(Effect.flatMap((settings) => makeWorkerExtractor(settings, overrides.workerUrl ?? defaultExtractionWorkerUrl())));
+};
+/**
+* Node `FileExtractor` layer with custom limits, isolation, or (in-process) SheetJS loader.
+* Invalid limits or isolation settings are defects.
+*/
+const makeFileExtractorLayer = (options = {}) => Layer.effect(FileExtractor, Effect.gen(function* () {
+	const limits = yield* Schema.decodeUnknownEffect(FileExtractorLimits)({
+		...defaultFileExtractorLimits,
+		...options.limits
+	});
+	const extractParsed = yield* parsedFileExtractor(options);
+	return FileExtractor.of(makeFileExtractor(limits, extractParsed));
+}).pipe(Effect.orDie));
+/**
+* Node `FileExtractor` layer with the default limits, worker isolation, and lazy SheetJS loading.
+*/
+const FileExtractorLayer = makeFileExtractorLayer();
+//#endregion
+export { FileExtractorLayer, makeFileExtractorLayer };
+
+//# sourceMappingURL=live-layer.mjs.map

package/dist/node/live-layer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-layer.mjs","names":[],"sources":["../../src/node/live-layer.ts"],"sourcesContent":["import { Effect, Layer } from 'effect'\nimport * as Schema from 'effect/Schema'\nimport { FileExtractionError, UnsupportedFileFormatError } from '../errors.ts'\nimport { fileFormatFor } from '../format.ts'\nimport { defaultFileExtractorLimits, FileExtractorLimits } from '../limits.ts'\nimport { FileExtractor } from '../service.ts'\nimport type { FileExtractorApi } from '../service.ts'\nimport { extractParsedFile, isParsedFileFormat, makeExtractedFile } from './extract-file.ts'\nimport type { ParsedFileFormat } from './extract-file.ts'\nimport {\n  defaultExtractionWorkerUrl,\n  defaultWorkerIsolation,\n  makeWorkerExtractor,\n  WorkerIsolationSettings\n} from './extraction-isolation.ts'\nimport type { FileExtractorIsolation, WorkerExtractor } from './extraction-isolation.ts'\nimport { defaultSheetJsLoader } from './sheetjs.ts'\nimport type { SheetJsLoader } from './sheetjs.ts'\n\nexport type FileExtractorOptions = {\n  /** Override any default limit; see `defaultFileExtractorLimits`. */\n  readonly limits?: Partial<FileExtractorLimits>\n  /**\n   * Where parsers run (default `'worker'`): each PDF, DOCX, XLSX, and PPTX extraction runs in a\n   * fresh worker thread with V8 heap, stack, and time limits, admitted through a pool of 4 workers\n   * per JavaScript realm; pass an object to change them. `'none'` parses in the calling thread and is\n   * unsafe for untrusted input.\n   */\n  readonly isolation?: FileExtractorIsolation\n  /**\n   * Load SheetJS in the calling thread. Only with `isolation: 'none'` (a worker cannot receive a\n   * function and always imports the installed `xlsx` itself); any other isolation is a defect\n   * when the layer is built. Defaults to a lazy `import('xlsx')`. Missing, non-SheetJS, or\n   * pre-0.20.3 modules fail with `SheetJsUnavailableError`.\n   */\n  readonly loadSheetJs?: SheetJsLoader\n}\n\nconst decodeText = (bytes: Uint8Array) => new TextDecoder('utf-8', { fatal: false }).decode(bytes)\n\ntype ParsedFileExtractor = WorkerExtractor\n\n/** Build the Node `FileExtractor` from validated limits and the parser runner. */\nconst makeFileExtractor = (\n  limits: FileExtractorLimits,\n  extractParsed: ParsedFileExtractor\n): FileExtractorApi => ({\n  extract: input =>\n    Effect.gen(function* () {\n      const format = fileFormatFor(input)\n\n      if (format === undefined)\n        return yield* Effect.fail(\n          new UnsupportedFileFormatError({ filename: input.filename, mediaType: input.mediaType })\n        )\n\n      yield* Effect.annotateCurrentSpan({\n        'file_extractor.format': format,\n        'file_extractor.file_size': input.bytes.byteLength\n      })\n\n      if (input.bytes.byteLength > limits.maxInputBytes)\n        return yield* Effect.fail(\n          new FileExtractionError({ message: 'File exceeds the extraction size limit', format })\n        )\n\n      if (isParsedFileFormat(format)) return yield* extractParsed(input, format, limits)\n\n      // Text formats are only decoded and sanitized; no parser reads them.\n      return yield* makeExtractedFile(decodeText(input.bytes), { format, title: input.filename })\n    }).pipe(Effect.withSpan('FileExtractor.extract'))\n})\n\nconst parsedFileExtractor = (\n  options: FileExtractorOptions\n): Effect.Effect<ParsedFileExtractor, Schema.SchemaError> => {\n  const isolation = options.isolation ?? 'worker'\n\n  if (isolation === 'none') {\n    const loader = options.loadSheetJs ?? defaultSheetJsLoader\n\n    return Effect.succeed((input, format: ParsedFileFormat, limits) =>\n      extractParsedFile(input, format, limits, loader)\n    )\n  }\n\n  if (options.loadSheetJs !== undefined)\n    return Effect.die(\n      new Error(\n        'FileExtractorOptions.loadSheetJs runs SheetJS in the calling thread and needs isolation: \"none\"'\n      )\n    )\n\n  const overrides = isolation === 'worker' ? {} : isolation\n  const timeoutMs = overrides.timeoutMs ?? defaultWorkerIsolation.timeoutMs\n\n  return Schema.decodeUnknownEffect(WorkerIsolationSettings)({\n    maxOldGenerationSizeMb:\n      overrides.maxOldGenerationSizeMb ?? defaultWorkerIsolation.maxOldGenerationSizeMb,\n    maxYoungGenerationSizeMb:\n      overrides.maxYoungGenerationSizeMb ?? defaultWorkerIsolation.maxYoungGenerationSizeMb,\n    stackSizeMb: overrides.stackSizeMb ?? defaultWorkerIsolation.stackSizeMb,\n    timeoutMs,\n    maxConcurrentWorkers:\n      overrides.maxConcurrentWorkers ?? defaultWorkerIsolation.maxConcurrentWorkers,\n    maxQueueWaitMs: overrides.maxQueueWaitMs ?? timeoutMs\n  }).pipe(\n    Effect.flatMap(settings =>\n      makeWorkerExtractor(settings, overrides.workerUrl ?? defaultExtractionWorkerUrl())\n    )\n  )\n}\n\n/**\n * Node `FileExtractor` layer with custom limits, isolation, or (in-process) SheetJS loader.\n * Invalid limits or isolation settings are defects.\n */\nexport const makeFileExtractorLayer = (options: FileExtractorOptions = {}) =>\n  Layer.effect(\n    FileExtractor,\n    Effect.gen(function* () {\n      const limits = yield* Schema.decodeUnknownEffect(FileExtractorLimits)({\n        ...defaultFileExtractorLimits,\n        ...options.limits\n      })\n\n      const extractParsed = yield* parsedFileExtractor(options)\n\n      return FileExtractor.of(makeFileExtractor(limits, extractParsed))\n    }).pipe(Effect.orDie)\n  )\n\n/**\n * Node `FileExtractor` layer with the default limits, worker isolation, and lazy SheetJS loading.\n */\nexport const FileExtractorLayer = makeFileExtractorLayer()\n"],"mappings":";;;;;;;;;;AAsCA,MAAM,cAAc,UAAsB,IAAI,YAAY,SAAS,EAAE,OAAO,MAAM,CAAC,EAAE,OAAO,KAAK;;AAKjG,MAAM,qBACJ,QACA,mBACsB,EACtB,UAAS,UACP,OAAO,IAAI,aAAa;CACtB,MAAM,SAAS,cAAc,KAAK;CAElC,IAAI,WAAW,KAAA,GACb,OAAO,OAAO,OAAO,KACnB,IAAI,2BAA2B;EAAE,UAAU,MAAM;EAAU,WAAW,MAAM;CAAU,CAAC,CACzF;CAEF,OAAO,OAAO,oBAAoB;EAChC,yBAAyB;EACzB,4BAA4B,MAAM,MAAM;CAC1C,CAAC;CAED,IAAI,MAAM,MAAM,aAAa,OAAO,eAClC,OAAO,OAAO,OAAO,KACnB,IAAI,oBAAoB;EAAE,SAAS;EAA0C;CAAO,CAAC,CACvF;CAEF,IAAI,mBAAmB,MAAM,GAAG,OAAO,OAAO,cAAc,OAAO,QAAQ,MAAM;CAGjF,OAAO,OAAO,kBAAkB,WAAW,MAAM,KAAK,GAAG;EAAE;EAAQ,OAAO,MAAM;CAAS,CAAC;AAC5F,CAAC,EAAE,KAAK,OAAO,SAAS,uBAAuB,CAAC,EACpD;AAEA,MAAM,uBACJ,YAC2D;CAC3D,MAAM,YAAY,QAAQ,aAAa;CAEvC,IAAI,cAAc,QAAQ;EACxB,MAAM,SAAS,QAAQ,eAAe;EAEtC,OAAO,OAAO,SAAS,OAAO,QAA0B,WACtD,kBAAkB,OAAO,QAAQ,QAAQ,MAAM,CACjD;CACF;CAEA,IAAI,QAAQ,gBAAgB,KAAA,GAC1B,OAAO,OAAO,oBACZ,IAAI,MACF,mGACF,CACF;CAEF,MAAM,YAAY,cAAc,WAAW,CAAC,IAAI;CAChD,MAAM,YAAY,UAAU,aAAa,uBAAuB;CAEhE,OAAO,OAAO,oBAAoB,uBAAuB,EAAE;EACzD,wBACE,UAAU,0BAA0B,uBAAuB;EAC7D,0BACE,UAAU,4BAA4B,uBAAuB;EAC/D,aAAa,UAAU,eAAe,uBAAuB;EAC7D;EACA,sBACE,UAAU,wBAAwB,uBAAuB;EAC3D,gBAAgB,UAAU,kBAAkB;CAC9C,CAAC,EAAE,KACD,OAAO,SAAQ,aACb,oBAAoB,UAAU,UAAU,aAAa,2BAA2B,CAAC,CACnF,CACF;AACF;;;;;AAMA,MAAa,0BAA0B,UAAgC,CAAC,MACtE,MAAM,OACJ,eACA,OAAO,IAAI,aAAa;CACtB,MAAM,SAAS,OAAO,OAAO,oBAAoB,mBAAmB,EAAE;EACpE,GAAG;EACH,GAAG,QAAQ;CACb,CAAC;CAED,MAAM,gBAAgB,OAAO,oBAAoB,OAAO;CAExD,OAAO,cAAc,GAAG,kBAAkB,QAAQ,aAAa,CAAC;AAClE,CAAC,EAAE,KAAK,OAAO,KAAK,CACtB;;;;AAKF,MAAa,qBAAqB,uBAAuB"}

package/dist/node/office-archive.d.mts

@@ -0,0 +1,51 @@
+import { OfficeArchiveError } from "../errors.mjs";
+import { OfficeFileFormat } from "../format.mjs";
+import { FileExtractorLimits } from "../limits.mjs";
+import { Effect } from "effect";
+
+//#region src/node/office-archive.d.ts
+type OfficeArchiveLimits = Pick<FileExtractorLimits, 'maxArchiveEntries' | 'maxExpandedBytes' | 'maxInputBytes'>;
+/** Inflated output is counted in slices of at most this many bytes. */
+declare const officeInflateChunkBytes: number;
+/**
+ * Whether a part SheetJS would decode as BOM-marked UTF-16 contains a hyperlink tag. Covers
+ * SheetJS `cc2str` UTF-16 BOM decoding (little- and big-endian from byte 2, including its
+ * `arr[1]/arr[2]` Buffer check) plus an extra odd-offset big-endian decode.
+ */
+declare const utf16PartHasHyperlink: (content: Uint8Array) => boolean;
+/** Hyperlink start tags (Latin-1 text of the original bytes) found while stripping, per part. */
+type StrippedHyperlinkTags = ReadonlyMap<string, ReadonlyArray<string>>;
+type NormalizedOfficeArchive = {
+  /** Every validated (and, for XLSX, hyperlink-stripped) part by entry name. */readonly parts: Readonly<Record<string, Uint8Array>>; /** XLSX only: removed hyperlink tags, at most `maxHyperlinkTags` across the workbook. */
+  readonly hyperlinkTags: StrippedHyperlinkTags;
+};
+type ReadOfficeArchiveOptions = {
+  /** XLSX: hyperlink start tags to capture across the workbook (default 0). */readonly maxHyperlinkTags?: number;
+};
+/** A fresh stored-entry ZIP of validated parts; the attacker's ZIP index is never reused. */
+declare const storedArchive: (parts: Readonly<Record<string, Uint8Array>>) => Uint8Array<ArrayBuffer>;
+/**
+ * Inflate bounded input chunks, count actual output, and return the validated parts. The
+ * attacker's ZIP index is discarded: parsers only get archives rebuilt from these parts.
+ *
+ * For XLSX, every part loses its `<hyperlink>` tags: SheetJS expands each hyperlink range into
+ * per-cell objects before any budget runs, so one `ref="A1:XFD1048576"` exhausts memory. The
+ * removed tags are returned so links can still be shown. XLSX input that SheetJS would route to
+ * its binary (XLSB), ODS, or Numbers parsers is rejected early with a clear error; the guarantee
+ * is that SheetJS only receives `buildSheetJsInput`'s allowlisted archive.
+ */
+declare const readOfficeArchive: (input: Uint8Array, format: OfficeFileFormat, limits: OfficeArchiveLimits, options?: ReadOfficeArchiveOptions) => Effect.Effect<NormalizedOfficeArchive, OfficeArchiveError, never>;
+/**
+ * Validate a DOCX, XLSX, or PPTX archive with bounded inflation and return a rebuilt stored-entry
+ * ZIP of every validated part, for storage or for other parsers. XLSX parts lose their hyperlink
+ * tags, and XLSX input with ODS or Numbers marker entries or XLSB parts is rejected; `.bin` parts
+ * SheetJS never parses (printer settings, OLE objects) are kept so stored files still open.
+ *
+ * The output is not SheetJS input. Never run SheetJS on it directly: extract XLSX text through
+ * `FileExtractor`, which hands SheetJS only an allowlisted archive it builds itself (worksheet,
+ * shared-string, style, and core-property parts with generated content types and relationships).
+ */
+declare const normalizeOfficeArchive: (bytes: Uint8Array, format: OfficeFileFormat, limits?: Partial<OfficeArchiveLimits>) => Effect.Effect<Uint8Array<ArrayBuffer>, OfficeArchiveError, never>;
+//#endregion
+export { NormalizedOfficeArchive, OfficeArchiveLimits, ReadOfficeArchiveOptions, StrippedHyperlinkTags, normalizeOfficeArchive, officeInflateChunkBytes, readOfficeArchive, storedArchive, utf16PartHasHyperlink };
+//# sourceMappingURL=office-archive.d.mts.map

package/dist/node/office-archive.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"office-archive.d.mts","names":[],"sources":["../../src/node/office-archive.ts"],"mappings":";;;;;;KAgBY,mBAAA,GAAsB,IAAI,CACpC,mBAAA;;cAgBW,uBAAA;;;;AAhBQ;AAgBrB;cA2Ia,qBAAA,GAAyB,OAAmB,EAAV,UAAU;;KAW7C,qBAAA,GAAwB,WAAW,SAAS,aAAA;AAAA,KAE5C,uBAAA;EAbC,uFAeF,KAAA,EAAO,QAAA,CAAS,MAAA,SAAe,UAAA;WAE/B,aAAA,EAAe,qBAAA;AAAA;AAAA,KAwCd,wBAAA;EA9CqB,sFAgDtB,gBAAgB;AAAA;AAhD0C;AAAA,cAoDxD,aAAA,GAAiB,KAAA,EAAO,QAAA,CAAS,MAAA,SAAe,UAAA,OAAY,UAAA,CAAA,WAAA;;;;;;;;;;;cAa5D,iBAAA,GACX,KAAA,EAAO,UAAA,EACP,MAAA,EAAQ,gBAAA,EACR,MAAA,EAAQ,mBAAA,EACR,OAAA,GAAS,wBAAA,KAA6B,MAAA,CAAA,MAAA,CAAA,uBAAA,EAAA,kBAAA;;;;;AA/DO;AAwC/C;;;;AAE2B;cA+Hd,sBAAA,GACX,KAAA,EAAO,UAAA,EACP,MAAA,EAAQ,gBAAA,EACR,MAAA,GAAQ,OAAA,CAAQ,mBAAA,MAAyB,MAAA,CAAA,MAAA,CAAA,UAAA,CAAA,WAAA,GAAA,kBAAA"}

package/dist/node/office-archive.mjs

@@ -0,0 +1,193 @@
+import { OfficeArchiveError } from "../errors.mjs";
+import { defaultFileExtractorLimits } from "../limits.mjs";
+import { sheetJsTextViews } from "./sheetjs-xml.mjs";
+import { contentTypesRouteToBinary, isAlternateFormatEntry, relationshipsRouteToBinary } from "./xlsx-routing.mjs";
+import { Effect } from "effect";
+import { Buffer } from "node:buffer";
+import { Readable } from "node:stream";
+import { createInflateRaw } from "node:zlib";
+import { zipSync } from "fflate";
+//#region src/node/office-archive.ts
+const invalid = () => new OfficeArchiveError({ message: "Invalid Office archive." });
+const tooLargeMessage = "Office archive expansion exceeds its declared size or limit.";
+const tooLarge = (expandedBytes) => expandedBytes === void 0 ? new OfficeArchiveError({ message: tooLargeMessage }) : new OfficeArchiveError({
+	message: tooLargeMessage,
+	expandedBytes
+});
+const compressedChunkBytes = 1024;
+/** Inflated output is counted in slices of at most this many bytes. */
+const officeInflateChunkBytes = 16 * 1024;
+const mainParts = {
+	docx: "word/document.xml",
+	pptx: "ppt/presentation.xml",
+	xlsx: "xl/workbook.xml"
+};
+/** Read the directory only as a bounded index. Its sizes are never trusted for allocation. */
+const archiveEntries = (bytes, limits) => {
+	let end = bytes.length - 22;
+	const earliest = Math.max(0, end - 65535);
+	while (end >= earliest && bytes.readUInt32LE(end) !== 101010256) end -= 1;
+	if (end < earliest || end + 22 + bytes.readUInt16LE(end + 20) !== bytes.length) throw invalid();
+	const count = bytes.readUInt16LE(end + 10);
+	const directorySize = bytes.readUInt32LE(end + 12);
+	const directoryOffset = bytes.readUInt32LE(end + 16);
+	if (bytes.readUInt32LE(end + 4) !== 0 || bytes.readUInt16LE(end + 8) !== count || count === 0 || count > limits.maxArchiveEntries || directoryOffset + directorySize !== end) throw invalid();
+	const entries = [];
+	const names = /* @__PURE__ */ new Set();
+	let offset = directoryOffset;
+	let declaredTotal = 0;
+	for (let index = 0; index < count; index += 1) {
+		if (offset + 46 > end || bytes.readUInt32LE(offset) !== 33639248) throw invalid();
+		const flags = bytes.readUInt16LE(offset + 8);
+		const method = bytes.readUInt16LE(offset + 10);
+		const compressedSize = bytes.readUInt32LE(offset + 20);
+		const originalSize = bytes.readUInt32LE(offset + 24);
+		const nameSize = bytes.readUInt16LE(offset + 28);
+		const extraSize = bytes.readUInt16LE(offset + 30);
+		const commentSize = bytes.readUInt16LE(offset + 32);
+		const local = bytes.readUInt32LE(offset + 42);
+		const next = offset + 46 + nameSize + extraSize + commentSize;
+		if (next > end || nameSize === 0 || nameSize > 1024 || (flags & -2063) !== 0 || method !== 0 && method !== 8 || bytes.readUInt16LE(offset + 34) !== 0 || compressedSize === 4294967295 || originalSize === 4294967295 || local + 30 > directoryOffset) throw invalid();
+		const nameBytes = bytes.subarray(offset + 46, offset + 46 + nameSize);
+		const name = new TextDecoder("utf-8", { fatal: true }).decode(nameBytes);
+		if (/[\\\u0000-\u001f]/.test(name) || name.startsWith("/") || name.includes("//") || name.split("/").some((part) => part === ".." || part === ".") || names.has(name.toLowerCase()) || /vbaProject\.bin$/i.test(name)) throw invalid();
+		names.add(name.toLowerCase());
+		if (bytes.readUInt32LE(local) !== 67324752 || bytes.readUInt16LE(local + 6) !== flags || bytes.readUInt16LE(local + 8) !== method || bytes.readUInt16LE(local + 26) !== nameSize) throw invalid();
+		const start = local + 30 + nameSize + bytes.readUInt16LE(local + 28);
+		if (start + compressedSize > directoryOffset || !bytes.subarray(local + 30, local + 30 + nameSize).equals(nameBytes)) throw invalid();
+		for (const [position, expected] of [[18, compressedSize], [22, originalSize]]) {
+			const value = bytes.readUInt32LE(local + position);
+			if (value !== expected && !((flags & 8) !== 0 && value === 0)) throw invalid();
+		}
+		declaredTotal += originalSize;
+		if (declaredTotal > limits.maxExpandedBytes) throw tooLarge();
+		entries.push({
+			name,
+			start,
+			compressedSize,
+			originalSize,
+			method
+		});
+		offset = next;
+	}
+	if (offset !== end) throw invalid();
+	return entries;
+};
+/**
+* A superset of SheetJS's `hlinkregex` (`/<(?:\w+:)?hyperlink [^<>]*>/`). A candidate never spans
+* a `<`, so each scan stops at the next tag and the strip stays linear in the part size.
+*/
+const hyperlinkTag = /<\/?(?:[\w.-]+:)?hyperlink\b[^<>]*>/gi;
+const hyperlinkTagStart = /<\/?(?:[\w.-]+:)?hyperlink\b/i;
+/**
+* Whether a part SheetJS would decode as BOM-marked UTF-16 contains a hyperlink tag. Covers
+* SheetJS `cc2str` UTF-16 BOM decoding (little- and big-endian from byte 2, including its
+* `arr[1]/arr[2]` Buffer check) plus an extra odd-offset big-endian decode.
+*/
+const utf16PartHasHyperlink = (content) => sheetJsTextViews(content).slice(1).some((text) => hyperlinkTagStart.test(text));
+const unsupportedXlsxParts = () => new OfficeArchiveError({ message: "XLSX archive contains binary (XLSB), ODS, or Numbers parts." });
+const inflateEntry = async (compressed, record) => {
+	function* inputChunks() {
+		for (let offset = 0; offset < compressed.length; offset += compressedChunkBytes) yield compressed.subarray(offset, offset + compressedChunkBytes);
+	}
+	const source = Readable.from(inputChunks(), { highWaterMark: 1 });
+	const inflater = createInflateRaw({
+		chunkSize: officeInflateChunkBytes,
+		readableHighWaterMark: officeInflateChunkBytes,
+		writableHighWaterMark: compressedChunkBytes
+	});
+	source.pipe(inflater);
+	try {
+		for await (const value of inflater) {
+			if (!Buffer.isBuffer(value)) throw invalid();
+			for (let offset = 0; offset < value.length; offset += officeInflateChunkBytes) record(value.subarray(offset, offset + officeInflateChunkBytes));
+		}
+		if (inflater.bytesWritten !== compressed.length) throw invalid();
+	} finally {
+		source.destroy();
+		inflater.destroy();
+	}
+};
+/** A fresh stored-entry ZIP of validated parts; the attacker's ZIP index is never reused. */
+const storedArchive = (parts) => zipSync({ ...parts }, { level: 0 });
+/**
+* Inflate bounded input chunks, count actual output, and return the validated parts. The
+* attacker's ZIP index is discarded: parsers only get archives rebuilt from these parts.
+*
+* For XLSX, every part loses its `<hyperlink>` tags: SheetJS expands each hyperlink range into
+* per-cell objects before any budget runs, so one `ref="A1:XFD1048576"` exhausts memory. The
+* removed tags are returned so links can still be shown. XLSX input that SheetJS would route to
+* its binary (XLSB), ODS, or Numbers parsers is rejected early with a clear error; the guarantee
+* is that SheetJS only receives `buildSheetJsInput`'s allowlisted archive.
+*/
+const readOfficeArchive = (input, format, limits, options = {}) => Effect.tryPromise({
+	try: async () => {
+		const bytes = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+		if (bytes.length < 22 || bytes.length > limits.maxInputBytes) throw invalid();
+		const entries = archiveEntries(bytes, limits);
+		const mainPart = mainParts[format];
+		const maxHyperlinkTags = options.maxHyperlinkTags ?? 0;
+		if (format === "xlsx" && entries.some((entry) => isAlternateFormatEntry(entry.name))) throw unsupportedXlsxParts();
+		if (!entries.some((entry) => entry.name === "[Content_Types].xml") || !entries.some((entry) => entry.name === mainPart)) throw invalid();
+		const validated = Object.create(null);
+		const hyperlinkTags = /* @__PURE__ */ new Map();
+		let capturedTags = 0;
+		let expandedBytes = 0;
+		for (const entry of entries) {
+			const chunks = [];
+			let entryBytes = 0;
+			const record = (chunk) => {
+				entryBytes += chunk.length;
+				expandedBytes += chunk.length;
+				if (expandedBytes > limits.maxExpandedBytes || entryBytes > entry.originalSize) throw tooLarge(expandedBytes);
+				chunks.push(chunk);
+			};
+			const compressed = bytes.subarray(entry.start, entry.start + entry.compressedSize);
+			if (entry.method === 0) record(compressed);
+			else await inflateEntry(compressed, record);
+			if (entryBytes !== entry.originalSize) throw invalid();
+			const content = Buffer.concat(chunks, entryBytes);
+			if (format !== "xlsx") {
+				validated[entry.name] = content;
+				continue;
+			}
+			const tags = [];
+			const rewritten = Buffer.from(content.toString("latin1").replace(hyperlinkTag, (tag) => {
+				if (!tag.startsWith("</") && capturedTags < maxHyperlinkTags) {
+					capturedTags += 1;
+					tags.push(tag);
+				}
+				return " ";
+			}), "latin1");
+			if (utf16PartHasHyperlink(rewritten)) throw invalid();
+			const lowerName = entry.name.toLowerCase();
+			if (lowerName === "[content_types].xml" && contentTypesRouteToBinary(rewritten) || lowerName.endsWith(".rels") && relationshipsRouteToBinary(rewritten)) throw unsupportedXlsxParts();
+			if (tags.length > 0) hyperlinkTags.set(entry.name, tags);
+			validated[entry.name] = rewritten;
+		}
+		return {
+			parts: validated,
+			hyperlinkTags
+		};
+	},
+	catch: (error) => error instanceof OfficeArchiveError ? error : invalid()
+});
+/**
+* Validate a DOCX, XLSX, or PPTX archive with bounded inflation and return a rebuilt stored-entry
+* ZIP of every validated part, for storage or for other parsers. XLSX parts lose their hyperlink
+* tags, and XLSX input with ODS or Numbers marker entries or XLSB parts is rejected; `.bin` parts
+* SheetJS never parses (printer settings, OLE objects) are kept so stored files still open.
+*
+* The output is not SheetJS input. Never run SheetJS on it directly: extract XLSX text through
+* `FileExtractor`, which hands SheetJS only an allowlisted archive it builds itself (worksheet,
+* shared-string, style, and core-property parts with generated content types and relationships).
+*/
+const normalizeOfficeArchive = (bytes, format, limits = {}) => readOfficeArchive(bytes, format, {
+	maxArchiveEntries: limits.maxArchiveEntries ?? defaultFileExtractorLimits.maxArchiveEntries,
+	maxExpandedBytes: limits.maxExpandedBytes ?? defaultFileExtractorLimits.maxExpandedBytes,
+	maxInputBytes: limits.maxInputBytes ?? defaultFileExtractorLimits.maxInputBytes
+}).pipe(Effect.map((normalized) => storedArchive(normalized.parts)));
+//#endregion
+export { normalizeOfficeArchive, officeInflateChunkBytes, readOfficeArchive, storedArchive, utf16PartHasHyperlink };
+
+//# sourceMappingURL=office-archive.mjs.map

package/dist/node/office-archive.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"office-archive.mjs","names":[],"sources":["../../src/node/office-archive.ts"],"sourcesContent":["import { Buffer } from 'node:buffer'\nimport { Readable } from 'node:stream'\nimport { createInflateRaw } from 'node:zlib'\nimport { Effect } from 'effect'\nimport { zipSync } from 'fflate'\nimport { OfficeArchiveError } from '../errors.ts'\nimport type { OfficeFileFormat } from '../format.ts'\nimport { defaultFileExtractorLimits } from '../limits.ts'\nimport type { FileExtractorLimits } from '../limits.ts'\nimport { sheetJsTextViews } from './sheetjs-xml.ts'\nimport {\n  contentTypesRouteToBinary,\n  isAlternateFormatEntry,\n  relationshipsRouteToBinary\n} from './xlsx-routing.ts'\n\nexport type OfficeArchiveLimits = Pick<\n  FileExtractorLimits,\n  'maxArchiveEntries' | 'maxExpandedBytes' | 'maxInputBytes'\n>\n\nconst invalid = () => new OfficeArchiveError({ message: 'Invalid Office archive.' })\n\nconst tooLargeMessage = 'Office archive expansion exceeds its declared size or limit.'\n\nconst tooLarge = (expandedBytes?: number) =>\n  expandedBytes === undefined\n    ? new OfficeArchiveError({ message: tooLargeMessage })\n    : new OfficeArchiveError({ message: tooLargeMessage, expandedBytes })\n\nconst compressedChunkBytes = 1024\n\n/** Inflated output is counted in slices of at most this many bytes. */\nexport const officeInflateChunkBytes = 16 * 1024\n\nconst mainParts: Readonly<Record<OfficeFileFormat, string>> = {\n  docx: 'word/document.xml',\n  pptx: 'ppt/presentation.xml',\n  xlsx: 'xl/workbook.xml'\n}\n\ntype ArchiveEntry = {\n  readonly name: string\n  readonly start: number\n  readonly compressedSize: number\n  readonly originalSize: number\n  readonly method: number\n}\n\n/** Read the directory only as a bounded index. Its sizes are never trusted for allocation. */\nconst archiveEntries = (bytes: Buffer, limits: OfficeArchiveLimits) => {\n  let end = bytes.length - 22\n  const earliest = Math.max(0, end - 65535)\n\n  while (end >= earliest && bytes.readUInt32LE(end) !== 0x06054b50) end -= 1\n\n  if (end < earliest || end + 22 + bytes.readUInt16LE(end + 20) !== bytes.length) throw invalid()\n\n  const count = bytes.readUInt16LE(end + 10)\n  const directorySize = bytes.readUInt32LE(end + 12)\n  const directoryOffset = bytes.readUInt32LE(end + 16)\n\n  if (\n    bytes.readUInt32LE(end + 4) !== 0 ||\n    bytes.readUInt16LE(end + 8) !== count ||\n    count === 0 ||\n    count > limits.maxArchiveEntries ||\n    directoryOffset + directorySize !== end\n  )\n    throw invalid()\n\n  const entries: Array<ArchiveEntry> = []\n  // OPC part names are case-insensitive, and SheetJS looks entries up ignoring case.\n  const names = new Set<string>()\n  let offset = directoryOffset\n  let declaredTotal = 0\n\n  for (let index = 0; index < count; index += 1) {\n    if (offset + 46 > end || bytes.readUInt32LE(offset) !== 0x02014b50) throw invalid()\n\n    const flags = bytes.readUInt16LE(offset + 8)\n    const method = bytes.readUInt16LE(offset + 10)\n    const compressedSize = bytes.readUInt32LE(offset + 20)\n    const originalSize = bytes.readUInt32LE(offset + 24)\n    const nameSize = bytes.readUInt16LE(offset + 28)\n    const extraSize = bytes.readUInt16LE(offset + 30)\n    const commentSize = bytes.readUInt16LE(offset + 32)\n    const local = bytes.readUInt32LE(offset + 42)\n    const next = offset + 46 + nameSize + extraSize + commentSize\n\n    // Reject encryption, unsupported methods, split/ZIP64 archives, and ambiguous paths.\n    if (\n      next > end ||\n      nameSize === 0 ||\n      nameSize > 1024 ||\n      (flags & ~0x080e) !== 0 ||\n      (method !== 0 && method !== 8) ||\n      bytes.readUInt16LE(offset + 34) !== 0 ||\n      compressedSize === 0xffffffff ||\n      originalSize === 0xffffffff ||\n      local + 30 > directoryOffset\n    )\n      throw invalid()\n\n    const nameBytes = bytes.subarray(offset + 46, offset + 46 + nameSize)\n    const name = new TextDecoder('utf-8', { fatal: true }).decode(nameBytes)\n\n    // `//` is rejected (SheetJS collapses the first one), but directory entries ending in `/` stay.\n    if (\n      /[\\\\\\u0000-\\u001f]/.test(name) ||\n      name.startsWith('/') ||\n      name.includes('//') ||\n      name.split('/').some(part => part === '..' || part === '.') ||\n      names.has(name.toLowerCase()) ||\n      /vbaProject\\.bin$/i.test(name)\n    )\n      throw invalid()\n\n    names.add(name.toLowerCase())\n\n    if (\n      bytes.readUInt32LE(local) !== 0x04034b50 ||\n      bytes.readUInt16LE(local + 6) !== flags ||\n      bytes.readUInt16LE(local + 8) !== method ||\n      bytes.readUInt16LE(local + 26) !== nameSize\n    )\n      throw invalid()\n\n    const start = local + 30 + nameSize + bytes.readUInt16LE(local + 28)\n\n    if (\n      start + compressedSize > directoryOffset ||\n      !bytes.subarray(local + 30, local + 30 + nameSize).equals(nameBytes)\n    )\n      throw invalid()\n\n    // Data descriptors may leave local sizes zero; all nonzero declarations must agree.\n    for (const [position, expected] of [\n      [18, compressedSize],\n      [22, originalSize]\n    ] as const) {\n      const value = bytes.readUInt32LE(local + position)\n\n      if (value !== expected && !((flags & 8) !== 0 && value === 0)) throw invalid()\n    }\n\n    declaredTotal += originalSize\n\n    if (declaredTotal > limits.maxExpandedBytes) throw tooLarge()\n\n    entries.push({ name, start, compressedSize, originalSize, method })\n    offset = next\n  }\n\n  if (offset !== end) throw invalid()\n\n  return entries\n}\n\n/**\n * A superset of SheetJS's `hlinkregex` (`/<(?:\\w+:)?hyperlink [^<>]*>/`). A candidate never spans\n * a `<`, so each scan stops at the next tag and the strip stays linear in the part size.\n */\nconst hyperlinkTag = /<\\/?(?:[\\w.-]+:)?hyperlink\\b[^<>]*>/gi\n\nconst hyperlinkTagStart = /<\\/?(?:[\\w.-]+:)?hyperlink\\b/i\n\n/**\n * Whether a part SheetJS would decode as BOM-marked UTF-16 contains a hyperlink tag. Covers\n * SheetJS `cc2str` UTF-16 BOM decoding (little- and big-endian from byte 2, including its\n * `arr[1]/arr[2]` Buffer check) plus an extra odd-offset big-endian decode.\n */\nexport const utf16PartHasHyperlink = (content: Uint8Array) =>\n  sheetJsTextViews(content)\n    .slice(1)\n    .some(text => hyperlinkTagStart.test(text))\n\nconst unsupportedXlsxParts = () =>\n  new OfficeArchiveError({\n    message: 'XLSX archive contains binary (XLSB), ODS, or Numbers parts.'\n  })\n\n/** Hyperlink start tags (Latin-1 text of the original bytes) found while stripping, per part. */\nexport type StrippedHyperlinkTags = ReadonlyMap<string, ReadonlyArray<string>>\n\nexport type NormalizedOfficeArchive = {\n  /** Every validated (and, for XLSX, hyperlink-stripped) part by entry name. */\n  readonly parts: Readonly<Record<string, Uint8Array>>\n  /** XLSX only: removed hyperlink tags, at most `maxHyperlinkTags` across the workbook. */\n  readonly hyperlinkTags: StrippedHyperlinkTags\n}\n\nconst inflateEntry = async (compressed: Buffer, record: (chunk: Buffer) => void): Promise<void> => {\n  function* inputChunks() {\n    for (let offset = 0; offset < compressed.length; offset += compressedChunkBytes) {\n      yield compressed.subarray(offset, offset + compressedChunkBytes)\n    }\n  }\n\n  const source = Readable.from(inputChunks(), { highWaterMark: 1 })\n\n  // Stream high-water marks are valid Transform options that `ZlibOptions` does not declare.\n  const inflateOptions = {\n    chunkSize: officeInflateChunkBytes,\n    readableHighWaterMark: officeInflateChunkBytes,\n    writableHighWaterMark: compressedChunkBytes\n  }\n\n  const inflater = createInflateRaw(inflateOptions)\n\n  source.pipe(inflater)\n\n  try {\n    // Async iteration may combine buffered chunks; bound accounting slices explicitly.\n    for await (const value of inflater) {\n      if (!Buffer.isBuffer(value)) throw invalid()\n\n      for (let offset = 0; offset < value.length; offset += officeInflateChunkBytes) {\n        record(value.subarray(offset, offset + officeInflateChunkBytes))\n      }\n    }\n\n    if (inflater.bytesWritten !== compressed.length) throw invalid()\n  } finally {\n    source.destroy()\n    inflater.destroy()\n  }\n}\n\nexport type ReadOfficeArchiveOptions = {\n  /** XLSX: hyperlink start tags to capture across the workbook (default 0). */\n  readonly maxHyperlinkTags?: number\n}\n\n/** A fresh stored-entry ZIP of validated parts; the attacker's ZIP index is never reused. */\nexport const storedArchive = (parts: Readonly<Record<string, Uint8Array>>) =>\n  zipSync({ ...parts }, { level: 0 })\n\n/**\n * Inflate bounded input chunks, count actual output, and return the validated parts. The\n * attacker's ZIP index is discarded: parsers only get archives rebuilt from these parts.\n *\n * For XLSX, every part loses its `<hyperlink>` tags: SheetJS expands each hyperlink range into\n * per-cell objects before any budget runs, so one `ref=\"A1:XFD1048576\"` exhausts memory. The\n * removed tags are returned so links can still be shown. XLSX input that SheetJS would route to\n * its binary (XLSB), ODS, or Numbers parsers is rejected early with a clear error; the guarantee\n * is that SheetJS only receives `buildSheetJsInput`'s allowlisted archive.\n */\nexport const readOfficeArchive = (\n  input: Uint8Array,\n  format: OfficeFileFormat,\n  limits: OfficeArchiveLimits,\n  options: ReadOfficeArchiveOptions = {}\n) =>\n  Effect.tryPromise({\n    try: async (): Promise<NormalizedOfficeArchive> => {\n      const bytes = Buffer.from(input.buffer, input.byteOffset, input.byteLength)\n\n      if (bytes.length < 22 || bytes.length > limits.maxInputBytes) throw invalid()\n\n      const entries = archiveEntries(bytes, limits)\n      const mainPart = mainParts[format]\n      const maxHyperlinkTags = options.maxHyperlinkTags ?? 0\n\n      if (format === 'xlsx' && entries.some(entry => isAlternateFormatEntry(entry.name)))\n        throw unsupportedXlsxParts()\n\n      if (\n        !entries.some(entry => entry.name === '[Content_Types].xml') ||\n        !entries.some(entry => entry.name === mainPart)\n      )\n        throw invalid()\n\n      const validated: Record<string, Uint8Array> = Object.create(null)\n      const hyperlinkTags = new Map<string, Array<string>>()\n      let capturedTags = 0\n      let expandedBytes = 0\n\n      for (const entry of entries) {\n        const chunks: Array<Buffer> = []\n        let entryBytes = 0\n\n        const record = (chunk: Buffer) => {\n          entryBytes += chunk.length\n          expandedBytes += chunk.length\n\n          if (expandedBytes > limits.maxExpandedBytes || entryBytes > entry.originalSize)\n            throw tooLarge(expandedBytes)\n\n          chunks.push(chunk)\n        }\n\n        const compressed = bytes.subarray(entry.start, entry.start + entry.compressedSize)\n\n        if (entry.method === 0) record(compressed)\n        else await inflateEntry(compressed, record)\n\n        if (entryBytes !== entry.originalSize) throw invalid()\n\n        const content = Buffer.concat(chunks, entryBytes)\n\n        if (format !== 'xlsx') {\n          validated[entry.name] = content\n          continue\n        }\n\n        // Relationship targets need not end in .xml, so scan every entry without changing other\n        // bytes (including UTF-8 and binary parts). A space prevents removal from joining\n        // attacker-controlled fragments into a new parser-accepted hyperlink tag.\n        const tags: Array<string> = []\n\n        const rewritten = Buffer.from(\n          content.toString('latin1').replace(hyperlinkTag, tag => {\n            if (!tag.startsWith('</') && capturedTags < maxHyperlinkTags) {\n              capturedTags += 1\n              tags.push(tag)\n            }\n\n            return ' '\n          }),\n          'latin1'\n        )\n\n        // SheetJS also decodes BOM-marked UTF-16 parts, which the Latin-1 strip cannot see\n        // through, and the strip itself can shift byte alignment or create a BOM. Check the exact\n        // bytes SheetJS will parse; Excel never writes UTF-16 parts, so reject rather than rewrite.\n        if (utf16PartHasHyperlink(rewritten)) throw invalid()\n\n        // Content types and relationships decide which parser SheetJS runs on each part.\n        const lowerName = entry.name.toLowerCase()\n\n        if (\n          (lowerName === '[content_types].xml' && contentTypesRouteToBinary(rewritten)) ||\n          (lowerName.endsWith('.rels') && relationshipsRouteToBinary(rewritten))\n        )\n          throw unsupportedXlsxParts()\n\n        if (tags.length > 0) hyperlinkTags.set(entry.name, tags)\n\n        validated[entry.name] = rewritten\n      }\n\n      return { parts: validated, hyperlinkTags }\n    },\n    // Out-of-range header reads (RangeError) and inflate failures are malformed archives too.\n    catch: error => (error instanceof OfficeArchiveError ? error : invalid())\n  })\n\n/**\n * Validate a DOCX, XLSX, or PPTX archive with bounded inflation and return a rebuilt stored-entry\n * ZIP of every validated part, for storage or for other parsers. XLSX parts lose their hyperlink\n * tags, and XLSX input with ODS or Numbers marker entries or XLSB parts is rejected; `.bin` parts\n * SheetJS never parses (printer settings, OLE objects) are kept so stored files still open.\n *\n * The output is not SheetJS input. Never run SheetJS on it directly: extract XLSX text through\n * `FileExtractor`, which hands SheetJS only an allowlisted archive it builds itself (worksheet,\n * shared-string, style, and core-property parts with generated content types and relationships).\n */\nexport const normalizeOfficeArchive = (\n  bytes: Uint8Array,\n  format: OfficeFileFormat,\n  limits: Partial<OfficeArchiveLimits> = {}\n) =>\n  readOfficeArchive(bytes, format, {\n    maxArchiveEntries: limits.maxArchiveEntries ?? defaultFileExtractorLimits.maxArchiveEntries,\n    maxExpandedBytes: limits.maxExpandedBytes ?? defaultFileExtractorLimits.maxExpandedBytes,\n    maxInputBytes: limits.maxInputBytes ?? defaultFileExtractorLimits.maxInputBytes\n  }).pipe(Effect.map(normalized => storedArchive(normalized.parts)))\n"],"mappings":"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"}

package/dist/node/pptx-text.d.mts

@@ -0,0 +1,6 @@
+//#region src/node/pptx-text.d.ts
+/** Slide text in slide order, then speaker notes, from the parts of a validated archive. */
+declare const extractPptxText: (parts: Readonly<Record<string, Uint8Array>>) => string;
+//#endregion
+export { extractPptxText };
+//# sourceMappingURL=pptx-text.d.mts.map

package/dist/node/pptx-text.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pptx-text.d.mts","names":[],"sources":["../../src/node/pptx-text.ts"],"mappings":";;cAkHa,eAAA,GAAmB,KAAA,EAAO,QAAA,CAAS,MAAA,SAAe,UAAA"}

package/dist/node/pptx-text.mjs

@@ -0,0 +1,63 @@
+import { decodeXmlEntities } from "./xml-text.mjs";
+import { strFromU8 } from "fflate";
+//#region src/node/pptx-text.ts
+const slideXmlFile = /^ppt\/slides\/slide(\d+)\.xml$/;
+const notesXmlFile = /^ppt\/notesSlides\/notesSlide(\d+)\.xml$/;
+const optionalXmlPrefix = `(?:[A-Za-z_][\\w.-]*:)?`;
+const xmlElement = (localName) => ({
+	start: new RegExp(`<${optionalXmlPrefix}${localName}\\b[^<>]*>`, "g"),
+	end: new RegExp(`</${optionalXmlPrefix}${localName}>`, "g")
+});
+const paragraphXml = xmlElement("p");
+const textXml = xmlElement("t");
+const lineBreakXml = new RegExp(`<${optionalXmlPrefix}br\\b[^<>]*/>`, "g");
+const tabXml = new RegExp(`<${optionalXmlPrefix}tab\\b[^<>]*/>`, "g");
+/** Each start tag paired with the next end tag after it (the old lazy `[\s\S]*?` match). */
+const elementMatches = (xml, element) => {
+	const matches = [];
+	let position = 0;
+	for (;;) {
+		element.start.lastIndex = position;
+		const start = element.start.exec(xml);
+		if (start === null) return matches;
+		const contentStart = start.index + start[0].length;
+		element.end.lastIndex = contentStart;
+		const end = element.end.exec(xml);
+		if (end === null) return matches;
+		position = end.index + end[0].length;
+		matches.push({
+			outer: xml.slice(start.index, position),
+			inner: xml.slice(contentStart, end.index)
+		});
+	}
+};
+const indexedXmlFile = (fileName, bytes, pattern, group) => {
+	const indexText = pattern.exec(fileName)?.[1];
+	if (indexText === void 0) return void 0;
+	const index = Number.parseInt(indexText, 10);
+	if (!Number.isInteger(index)) return void 0;
+	return {
+		fileName,
+		bytes,
+		group,
+		index
+	};
+};
+const pptxXmlFile = (fileName, bytes) => indexedXmlFile(fileName, bytes, slideXmlFile, 0) ?? indexedXmlFile(fileName, bytes, notesXmlFile, 1);
+const comparePptxXmlFiles = (left, right) => left.group - right.group || left.index - right.index || left.fileName.localeCompare(right.fileName);
+const extractParagraphText = (paragraph) => {
+	return elementMatches(paragraph.replace(lineBreakXml, "<a:t>\n</a:t>").replace(tabXml, "<a:t>	</a:t>"), textXml).map((match) => decodeXmlEntities(match.inner)).join("").trim();
+};
+const extractXmlText = (xml) => {
+	const paragraphs = elementMatches(xml, paragraphXml).map((match) => match.outer);
+	return (paragraphs.length > 0 ? paragraphs : [xml]).map(extractParagraphText).filter((text) => text.length > 0).join("\n");
+};
+/** Slide text in slide order, then speaker notes, from the parts of a validated archive. */
+const extractPptxText = (parts) => Object.entries(parts).flatMap(([fileName, fileBytes]) => {
+	const xmlFile = pptxXmlFile(fileName, fileBytes);
+	return xmlFile === void 0 ? [] : [xmlFile];
+}).sort(comparePptxXmlFiles).map((file) => extractXmlText(strFromU8(file.bytes))).filter((text) => text.length > 0).join("\n\n");
+//#endregion
+export { extractPptxText };
+
+//# sourceMappingURL=pptx-text.mjs.map

package/dist/node/pptx-text.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pptx-text.mjs","names":[],"sources":["../../src/node/pptx-text.ts"],"sourcesContent":["import { strFromU8 } from 'fflate'\nimport { decodeXmlEntities } from './xml-text.ts'\n\ntype PptxXmlFile = {\n  readonly fileName: string\n  readonly bytes: Uint8Array\n  readonly group: number\n  readonly index: number\n}\n\nconst slideXmlFile = /^ppt\\/slides\\/slide(\\d+)\\.xml$/\n\nconst notesXmlFile = /^ppt\\/notesSlides\\/notesSlide(\\d+)\\.xml$/\n\nconst xmlName = '[A-Za-z_][\\\\w.-]*'\n\nconst optionalXmlPrefix = `(?:${xmlName}:)?`\n\n// Every pattern stops at the next `<` (`[^<>]`), and elements are paired in one forward pass, so\n// extraction stays linear in the part size even for unterminated or unbalanced markup.\ntype XmlElement = { readonly start: RegExp; readonly end: RegExp }\n\nconst xmlElement = (localName: string): XmlElement => ({\n  start: new RegExp(`<${optionalXmlPrefix}${localName}\\\\b[^<>]*>`, 'g'),\n  end: new RegExp(`</${optionalXmlPrefix}${localName}>`, 'g')\n})\n\nconst paragraphXml = xmlElement('p')\n\nconst textXml = xmlElement('t')\n\nconst lineBreakXml = new RegExp(`<${optionalXmlPrefix}br\\\\b[^<>]*/>`, 'g')\n\nconst tabXml = new RegExp(`<${optionalXmlPrefix}tab\\\\b[^<>]*/>`, 'g')\n\ntype ElementMatch = {\n  /** Start tag through end tag. */\n  readonly outer: string\n  /** Text between the start and end tags. */\n  readonly inner: string\n}\n\n/** Each start tag paired with the next end tag after it (the old lazy `[\\s\\S]*?` match). */\nconst elementMatches = (xml: string, element: XmlElement): ReadonlyArray<ElementMatch> => {\n  const matches: Array<ElementMatch> = []\n  let position = 0\n\n  for (;;) {\n    element.start.lastIndex = position\n    const start = element.start.exec(xml)\n\n    if (start === null) return matches\n\n    const contentStart = start.index + start[0].length\n    element.end.lastIndex = contentStart\n    const end = element.end.exec(xml)\n\n    // No end tag after this start means none after any later start either.\n    if (end === null) return matches\n\n    position = end.index + end[0].length\n    matches.push({\n      outer: xml.slice(start.index, position),\n      inner: xml.slice(contentStart, end.index)\n    })\n  }\n}\n\nconst indexedXmlFile = (\n  fileName: string,\n  bytes: Uint8Array,\n  pattern: RegExp,\n  group: number\n): PptxXmlFile | undefined => {\n  const indexText = pattern.exec(fileName)?.[1]\n\n  if (indexText === undefined) return undefined\n\n  const index = Number.parseInt(indexText, 10)\n\n  if (!Number.isInteger(index)) return undefined\n\n  return { fileName, bytes, group, index }\n}\n\nconst pptxXmlFile = (fileName: string, bytes: Uint8Array): PptxXmlFile | undefined =>\n  indexedXmlFile(fileName, bytes, slideXmlFile, 0) ??\n  indexedXmlFile(fileName, bytes, notesXmlFile, 1)\n\nconst comparePptxXmlFiles = (left: PptxXmlFile, right: PptxXmlFile) =>\n  left.group - right.group ||\n  left.index - right.index ||\n  left.fileName.localeCompare(right.fileName)\n\nconst extractParagraphText = (paragraph: string) => {\n  const xml = paragraph.replace(lineBreakXml, '<a:t>\\n</a:t>').replace(tabXml, '<a:t>\\t</a:t>')\n\n  return elementMatches(xml, textXml)\n    .map(match => decodeXmlEntities(match.inner))\n    .join('')\n    .trim()\n}\n\nconst extractXmlText = (xml: string) => {\n  const paragraphs = elementMatches(xml, paragraphXml).map(match => match.outer)\n  const textSources = paragraphs.length > 0 ? paragraphs : [xml]\n\n  return textSources\n    .map(extractParagraphText)\n    .filter(text => text.length > 0)\n    .join('\\n')\n}\n\n/** Slide text in slide order, then speaker notes, from the parts of a validated archive. */\nexport const extractPptxText = (parts: Readonly<Record<string, Uint8Array>>) =>\n  Object.entries(parts)\n    .flatMap(([fileName, fileBytes]) => {\n      const xmlFile = pptxXmlFile(fileName, fileBytes)\n\n      return xmlFile === undefined ? [] : [xmlFile]\n    })\n    .sort(comparePptxXmlFiles)\n    .map(file => extractXmlText(strFromU8(file.bytes)))\n    .filter(text => text.length > 0)\n    .join('\\n\\n')\n"],"mappings":";;;AAUA,MAAM,eAAe;AAErB,MAAM,eAAe;AAIrB,MAAM,oBAAoB;AAM1B,MAAM,cAAc,eAAmC;CACrD,OAAO,IAAI,OAAO,IAAI,oBAAoB,UAAU,aAAa,GAAG;CACpE,KAAK,IAAI,OAAO,KAAK,oBAAoB,UAAU,IAAI,GAAG;AAC5D;AAEA,MAAM,eAAe,WAAW,GAAG;AAEnC,MAAM,UAAU,WAAW,GAAG;AAE9B,MAAM,eAAe,IAAI,OAAO,IAAI,kBAAkB,gBAAgB,GAAG;AAEzE,MAAM,SAAS,IAAI,OAAO,IAAI,kBAAkB,iBAAiB,GAAG;;AAUpE,MAAM,kBAAkB,KAAa,YAAqD;CACxF,MAAM,UAA+B,CAAC;CACtC,IAAI,WAAW;CAEf,SAAS;EACP,QAAQ,MAAM,YAAY;EAC1B,MAAM,QAAQ,QAAQ,MAAM,KAAK,GAAG;EAEpC,IAAI,UAAU,MAAM,OAAO;EAE3B,MAAM,eAAe,MAAM,QAAQ,MAAM,GAAG;EAC5C,QAAQ,IAAI,YAAY;EACxB,MAAM,MAAM,QAAQ,IAAI,KAAK,GAAG;EAGhC,IAAI,QAAQ,MAAM,OAAO;EAEzB,WAAW,IAAI,QAAQ,IAAI,GAAG;EAC9B,QAAQ,KAAK;GACX,OAAO,IAAI,MAAM,MAAM,OAAO,QAAQ;GACtC,OAAO,IAAI,MAAM,cAAc,IAAI,KAAK;EAC1C,CAAC;CACH;AACF;AAEA,MAAM,kBACJ,UACA,OACA,SACA,UAC4B;CAC5B,MAAM,YAAY,QAAQ,KAAK,QAAQ,IAAI;CAE3C,IAAI,cAAc,KAAA,GAAW,OAAO,KAAA;CAEpC,MAAM,QAAQ,OAAO,SAAS,WAAW,EAAE;CAE3C,IAAI,CAAC,OAAO,UAAU,KAAK,GAAG,OAAO,KAAA;CAErC,OAAO;EAAE;EAAU;EAAO;EAAO;CAAM;AACzC;AAEA,MAAM,eAAe,UAAkB,UACrC,eAAe,UAAU,OAAO,cAAc,CAAC,KAC/C,eAAe,UAAU,OAAO,cAAc,CAAC;AAEjD,MAAM,uBAAuB,MAAmB,UAC9C,KAAK,QAAQ,MAAM,SACnB,KAAK,QAAQ,MAAM,SACnB,KAAK,SAAS,cAAc,MAAM,QAAQ;AAE5C,MAAM,wBAAwB,cAAsB;CAGlD,OAAO,eAFK,UAAU,QAAQ,cAAc,eAAe,EAAE,QAAQ,QAAQ,cAErD,GAAG,OAAO,EAC/B,KAAI,UAAS,kBAAkB,MAAM,KAAK,CAAC,EAC3C,KAAK,EAAE,EACP,KAAK;AACV;AAEA,MAAM,kBAAkB,QAAgB;CACtC,MAAM,aAAa,eAAe,KAAK,YAAY,EAAE,KAAI,UAAS,MAAM,KAAK;CAG7E,QAFoB,WAAW,SAAS,IAAI,aAAa,CAAC,GAAG,GAG1D,IAAI,oBAAoB,EACxB,QAAO,SAAQ,KAAK,SAAS,CAAC,EAC9B,KAAK,IAAI;AACd;;AAGA,MAAa,mBAAmB,UAC9B,OAAO,QAAQ,KAAK,EACjB,SAAS,CAAC,UAAU,eAAe;CAClC,MAAM,UAAU,YAAY,UAAU,SAAS;CAE/C,OAAO,YAAY,KAAA,IAAY,CAAC,IAAI,CAAC,OAAO;AAC9C,CAAC,EACA,KAAK,mBAAmB,EACxB,KAAI,SAAQ,eAAe,UAAU,KAAK,KAAK,CAAC,CAAC,EACjD,QAAO,SAAQ,KAAK,SAAS,CAAC,EAC9B,KAAK,MAAM"}

package/dist/node/sheetjs-xml.d.mts

@@ -0,0 +1,89 @@
+//#region src/node/sheetjs-xml.d.ts
+/**
+ * The texts SheetJS can read from a part: its Latin-1 ("binary") view and, for BOM-marked parts,
+ * the UTF-16 decodings of `cc2str` (little- and big-endian from byte 2, including its
+ * `arr[1]/arr[2]` Buffer check) plus an extra odd-offset big-endian decode.
+ */
+declare const sheetJsTextViews: (content: Uint8Array) => ReadonlyArray<string>;
+type SheetJsTag = {
+  /** The tag up to its first space, line feed, or carriage return (SheetJS `y[0]`). */readonly head: string; /** Raw (still escaped) attribute values by SheetJS key, plus lower-cased copies. */
+  readonly attributes: ReadonlyMap<string, string>;
+};
+/**
+ * Port of SheetJS `parsexmltag`: exact-case keys (plus lower-cased copies), a namespace prefix
+ * dropped, an unprefixed name cut at its first `_`, the last value winning. Values are raw.
+ */
+declare const parseSheetJsTag: (tag: string) => SheetJsTag;
+/** Every tag SheetJS's pattern finds in `text`, in document order. */
+declare function sheetJsTags(text: string): Generator<SheetJsTag>;
+/** SheetJS `strip_ns`: the first `<prefix:` (or `</prefix:`) loses its prefix. */
+declare const stripSheetJsNamespace: (head: string) => string;
+/** SheetJS `utf8read` in Node: the Latin-1 ("binary") string read back as UTF-8. */
+declare const sheetJsUtf8Read: (binary: string) => string;
+/**
+ * SheetJS `unescapexml` for text without CDATA, quirks included: entity names match ignoring
+ * case but only lower-case ones map (`&QUOT;` becomes U+0000), `&#X41;` is read as decimal, and
+ * numeric references wrap at U+FFFF. Returns `undefined` for text with a CDATA marker, which
+ * SheetJS splits recursively (and never ends for an unterminated one).
+ */
+declare const sheetJsUnescapeXml: (text: string) => string | undefined;
+/** An attribute value as SheetJS reads text attributes: `unescapexml(utf8read(raw))`. */
+declare const sheetJsAttributeText: (raw: string) => string | undefined;
+/**
+ * Escape `text` for a double-quoted attribute of a generated UTF-8 part so that SheetJS's
+ * `unescapexml(utf8read(…))` returns `text` exactly: markup characters become entities, an `_`
+ * that would start an `_xHHHH_` code becomes `_x005F_`, and control characters, U+FFFE, U+FFFF,
+ * and lone surrogates become `_xHHHH_` codes.
+ */
+declare const sheetJsAttributeEscape: (text: string) => string;
+/** SheetJS's own `XML_HEADER`, used for every generated part. */
+declare const sheetJsXmlHeader = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\r\n";
+declare const spreadsheetMainNamespace = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+declare const officeDocumentRelationshipsNamespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+/**
+ * `text` without its simple opening tags, `<(?:[\w.-]+:)?[\w.-]+>`: a superset of the tags SheetJS
+ * removes before decoding (`<(?:\w+:)?(?:si|sstItem)>` in `parse_sst_xml`, `<(?:\w+:)?r>` in
+ * `parse_rs`). One forward scan: a `<` that does not start such a tag is kept and the scan resumes
+ * at the next `<`, so every character is read at most twice.
+ */
+declare const withoutSimpleTags: (text: string) => string;
+/**
+ * Whether SheetJS could meet a CDATA marker in this part. SheetJS's `unescapexml` handles CDATA by
+ * recursing on a string two characters shorter and copying the whole tail at every level, so an
+ * unterminated marker costs quadratic time and memory.
+ *
+ * What SheetJS hands to `unescapexml` in a worksheet or shared-strings part comes from the part
+ * text through two kinds of transformation:
+ *
+ * - Decodes: raw (`<v>` of every cell), `utf8read(raw)` (shared and inline strings), and
+ *   `utf8read(unescapexml(raw))` (cells of type `str`, decoded again after `utf8read`).
+ *   `utf8read` keeps only the low byte of each character, so U+013C from `_x013C_`, `&#x13C;`, or
+ *   `&#316;` becomes `<`.
+ * - Tag removal before decoding: `parse_sst_xml` removes every `<si>`/`<sstItem>` opening tag
+ *   from the whole shared-strings table, and `parse_rs` removes every `<r>` opening tag from rich
+ *   text (after `utf8read`). Inline strings (`t="inlineStr"`) call `parse_si` without options,
+ *   so their rich text is processed even with `cellHTML: false`. `A<<r>![CDATA[B` thus reaches
+ *   `unescapexml` as `A<![CDATA[B`.
+ *
+ * So the check rejects a text view (`sheetJsTextViews`) when:
+ *
+ * - the view, or `utf8read` of it, contains `<<` or `<!`. A marker assembled by removing tags
+ *   needs a literal `<` (in the view, or from `utf8read`) followed by a removed tag, or by `!`,
+ *   and every removed tag starts with `<`;
+ * - the view, or the view without any simple opening tag (`withoutSimpleTags`, a superset of
+ *   SheetJS's removals), meets the marker raw or after any chain of up to two steps of
+ *   `unescapexml` and `utf8read`, in any order (a superset of SheetJS's decode sequences).
+ *
+ * Every step is a linear pass, at most a few per view. The first rule deliberately fails closed:
+ * it also rejects XML comments, `<!DOCTYPE`, and any other `<!…` declaration, which Excel,
+ * LibreOffice, and Google Sheets never write in worksheets or shared strings (nor a literal `<<`).
+ */
+declare const sheetJsCouldReadCdata: (content: Uint8Array) => boolean;
+/**
+ * The `dc:title` of a core-properties part, read as SheetJS `parse_core_props` reads it, without
+ * handing the part to SheetJS. A title holding CDATA is ignored.
+ */
+declare const coreTitle: (content: Uint8Array | undefined) => string | undefined;
+//#endregion
+export { SheetJsTag, coreTitle, officeDocumentRelationshipsNamespace, parseSheetJsTag, sheetJsAttributeEscape, sheetJsAttributeText, sheetJsCouldReadCdata, sheetJsTags, sheetJsTextViews, sheetJsUnescapeXml, sheetJsUtf8Read, sheetJsXmlHeader, spreadsheetMainNamespace, stripSheetJsNamespace, withoutSimpleTags };
+//# sourceMappingURL=sheetjs-xml.d.mts.map

package/dist/node/sheetjs-xml.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sheetjs-xml.d.mts","names":[],"sources":["../../src/node/sheetjs-xml.ts"],"mappings":";;AAgBA;;;;cAAa,gBAAA,GAAoB,OAAA,EAAS,UAAA,KAAa,aAAa;AAAA,KA2BxD,UAAA;EA3B2C,8FA6B5C,IAAA,UA7ByD;EAAA,SA+BzD,UAAA,EAAY,WAAW;AAAA;;;;;cAOrB,eAAA,GAAmB,GAAA,aAAc,UAwC7C;;iBAGgB,WAAA,CAAY,IAAA,WAAe,SAAS,CAAC,UAAA;AA3CtD;AAAA,cAgDa,qBAAA,GAAyB,IAAY;;cAGrC,eAAA,GAAmB,MAAc;AAX7C;AAGD;;;;;AAHC,cA2BY,kBAAA,GAAsB,IAAY;;cAgBlC,oBAAA,GAAwB,GAAW;AAxCgB;AAKhE;;;;AAAkD;AALc,cAgEnD,sBAAA,GAA0B,IAAY;;cAuCtC,gBAAA;AAAA,cAEA,wBAAA;AAAA,cAEA,oCAAA;AAnFb;;;;AAA+C;AAgB/C;AAhBA,cAiIa,iBAAA,GAAqB,IAAY;;;AAjHE;AAwBhD;;;;AAAmD;AAuCnD;;;;AAA6B;AAE7B;;;;AAAqC;AAErC;;;;AAAiD;AA8CjD;;;;AAA8C;AA4D9C;;;cAAa,qBAAA,GAAyB,OAAmB,EAAV,UAAU;AAAA;AAkCzD;;;AAlCyD,cAkC5C,SAAA,GAAa,OAA+B,EAAtB,UAAU"}