@yolk-sdk/extractors 0.1.0-canary.100

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yolk SDK contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,333 @@
+# @yolk-sdk/extractors
+
+Bounded text extraction for PDF, DOCX, XLSX, PPTX, CSV, JSON, Markdown, and plain-text files: an
+Effect `FileExtractor` service with Office archive validation, hyperlink-safe XLSX text, and a
+`KnowledgeExtractor` adapter for `@yolk-sdk/knowledge`.
+
+## Install
+
+```bash
+pnpm add @yolk-sdk/extractors@canary effect@4.0.0
+# Only if you extract .xlsx files: SheetJS from the SheetJS CDN, not npm.
+pnpm add https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz
+```
+
+With knowledge ingestion (`@yolk-sdk/extractors/knowledge`):
+
+```bash
+pnpm add @yolk-sdk/extractors@canary @yolk-sdk/knowledge@canary effect@4.0.0
+```
+
+Canary APIs are unstable. Keep all `@yolk-sdk/*` packages on the same version.
+Use the SDK's matching Effect version (`4.0.0`) in host code.
+Requires Node.js 22+. `@yolk-sdk/extractors/node` is server-only.
+
+### Why SheetJS comes from its CDN
+
+SheetJS (`xlsx`) is an optional peer dependency (`>=0.20.3`), loaded with a dynamic import only
+when an XLSX file is extracted. The `xlsx` package on npm is unmaintained at 0.18.5, which has
+CVE-2023-30533 (prototype pollution from a crafted file, fixed in 0.19.3) and CVE-2024-22363
+(regular-expression denial of service, fixed in 0.20.2). Fixed releases are published only as
+tarballs on `cdn.sheetjs.com`. A published package must not depend on a URL, so the host installs
+the tarball itself.
+
+pnpm records the tarball URL and its integrity hash in the lockfile. A direct tarball dependency
+needs no extra pnpm 11 settings. `blockExoticSubdeps` (default `true`) rejects tarball and git
+dependencies only below the top level. `minimumReleaseAge` (default one day) checks registry
+publish times, and a URL tarball has none. Because the peer is optional, SheetJS cannot arrive
+transitively: each host adds it directly.
+
+If SheetJS is missing, is not a SheetJS build, or is older than 0.20.3 (for example a leftover npm
+`xlsx@0.18.5`, or a 0.20.3 prerelease), XLSX extraction fails with `SheetJsUnavailableError`
+(`reason: 'missing' | 'invalid' | 'outdated'`). A `version` that is not strict SemVer counts as
+`invalid`. Its message includes the install command. Other formats never load SheetJS.
+
+## Subpaths
+
+| Subpath                                       | Purpose                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@yolk-sdk/extractors`                        | Runtime-portable contract. No parser imports. The `FileExtractor` service tag and `FileExtractorApi` type; the `FileInput`, `ExtractedFile`, `ExtractedFileMetadata`, `ExtractedFileFormat`, `OfficeFileFormat`, and `FileExtractorError` types; `extractedFileFormats`, `fileFormatFor`, `isOfficeFileFormat`; `defaultFileExtractorLimits` and the `FileExtractorLimits` schema; `sanitizeExtractedText`; the errors and the `FileExtractionFailureReason` schema; `minimumSheetJsVersion` and `sheetJsInstallCommand`. |
+| `@yolk-sdk/extractors/node`                   | `FileExtractorLayer` and `makeFileExtractorLayer(options)`: the Node implementation (unpdf, mammoth, SheetJS, fflate, `node:zlib`). Also `defaultWorkerIsolation` and `normalizeOfficeArchive` (see below), and the `FileExtractorOptions`, `FileExtractorIsolation`, `WorkerIsolationOptions`, `OfficeArchiveLimits`, and `SheetJsLoader` types. Re-exports `FileExtractor` and `FileExtractorApi`.                                                                                                                      |
+| `@yolk-sdk/extractors/node/extraction-worker` | The worker entry the Node layer starts per extraction (not imported directly; see Worker isolation).                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `@yolk-sdk/extractors/knowledge`              | `FileKnowledgeExtractorLayer`: a `@yolk-sdk/knowledge/extraction` `KnowledgeExtractor` backed by the `FileExtractor` in context, and `makeFileKnowledgeExtractor`.                                                                                                                                                                                                                                                                                                                                                        |
+
+## Example
+
+```ts
+import { Effect } from 'effect'
+import { FileExtractor } from '@yolk-sdk/extractors'
+import { makeFileExtractorLayer } from '@yolk-sdk/extractors/node'
+
+const FileExtractorLive = makeFileExtractorLayer({ limits: { maxInputBytes: 10 * 1024 * 1024 } })
+
+const program = Effect.gen(function* () {
+  const extractor = yield* FileExtractor
+
+  return yield* extractor.extract({ filename: 'report.xlsx', mediaType: '', bytes })
+}).pipe(Effect.provide(FileExtractorLive))
+```
+
+`bytes` is a host-owned `Uint8Array`. `FileExtractorLayer` is the same layer with default limits.
+The extractor copies the input before a parser reads it, so the caller's buffer is never
+detached.
+
+### Worker isolation
+
+PDF, DOCX, XLSX, and PPTX files are parsed in a fresh Node `worker_threads` worker per
+extraction. Only the extracted text and metadata come back. Text formats are decoded in the
+calling thread; no parser reads them.
+
+```ts
+const FileExtractorLive = makeFileExtractorLayer({
+  isolation: { maxOldGenerationSizeMb: 512, timeoutMs: 60_000 }
+})
+```
+
+| `isolation` option         | Default                  | Bounds                                                                    |
+| -------------------------- | ------------------------ | ------------------------------------------------------------------------- |
+| `maxOldGenerationSizeMb`   | 256                      | V8 old-generation heap of each worker                                     |
+| `maxYoungGenerationSizeMb` | 32                       | V8 young-generation heap of each worker                                   |
+| `stackSizeMb`              | 4                        | Stack of each worker (Node's default)                                     |
+| `timeoutMs`                | 30,000                   | Wall-clock time per worker (a real timer, not Effect's clock; ≤ 2³¹−1 ms) |
+| `maxConcurrentWorkers`     | 4                        | This layer's share of the realm-wide pool of 4 workers (1 to 4)           |
+| `maxQueueWaitMs`           | the layer's `timeoutMs`  | Wait for a worker slot (≤ 2³¹−1 ms); then it fails with `busy`            |
+| `workerUrl`                | the package's own worker | The worker entry, for hosts that bundle or relocate the package           |
+
+**Cap per JavaScript realm.** Every layer in a JavaScript realm (the main thread, or each worker
+thread that builds the layer) shares one pool of 4 workers, however often the layer is built (a
+per-request `Effect.provide` builds a new one each time). The pool is kept on `globalThis`, so
+duplicated copies of the package in that realm share it too. A host that runs its request
+handlers in a pool of worker threads gets 4 workers per thread. A layer's
+`maxConcurrentWorkers` can only lower its own share. Slots are handed out first come, first
+served. An extraction waits for a slot at most `maxQueueWaitMs`, then fails with
+`reason: 'busy'` without starting a worker; a slot freed after that deadline never admits it.
+A freed slot is handed to the next waiter, which resumes on a later microtask, so a long queue
+of extractions that fail at once drains without deepening the stack.
+
+**What the worker bounds.** Each worker's V8 heap, stack, and running time. When a worker runs
+out of heap, times out, cannot start, or exits without a result, it is terminated and the
+extraction fails with `FileExtractionError` and `reason` set to `resource-limit`, `timeout`,
+`worker-unavailable`, or `worker-failed`. A worker that cannot start never falls back to parsing
+in-process. Four workers at the default heap add up to about 1 GB of V8 heap.
+
+**What it does not bound.** Total process memory (RSS) and memory outside the V8 heap: Buffers,
+inflated archive parts, and native allocations. Those are limited only by the 50 MiB input and
+Office expanded-size limits, per running worker. PDF.js's decoded images, fonts, and streams have
+no separate cap in this package, which is a residual risk for crafted PDFs. Your host's memory
+limit (container or serverless function) is the outer bound: size it for four workers plus your
+own load, or lower the limits.
+
+The 30 s default is a backstop against runaway work, not a measure of normal parse time. Before
+lowering `timeoutMs`, measure extraction with representative files from your own uploads.
+
+`isolation: 'none'` parses in the calling thread, for runtimes without worker threads. It is
+**unsafe for untrusted input**: a crafted file can then exhaust the process heap or block the
+event loop. It is also the only mode that accepts a `loadSheetJs` function (tests use it to
+observe SheetJS). A worker always imports the installed `xlsx` itself, so passing `loadSheetJs`
+with worker isolation is a defect when the layer is built.
+
+Knowledge ingestion:
+
+```ts
+import { Layer } from 'effect'
+import { FileKnowledgeExtractorLayer } from '@yolk-sdk/extractors/knowledge'
+import { FileExtractorLayer } from '@yolk-sdk/extractors/node'
+
+const KnowledgeExtractorLive = FileKnowledgeExtractorLayer.pipe(Layer.provide(FileExtractorLayer))
+```
+
+The adapter passes string `content` through unchanged (blank text fails). Bytes are extracted with
+the format chosen from the source's name (`File` name or ref, `Url` path, `Text` label) and media
+type (`LoadedKnowledgeSource.mediaType`, then the `File` source's, then `text/plain` for `Text`
+sources). The extracted title becomes the document title. `format`, `pageCount`, and `sheetNames`
+merge under the source's own metadata, so host keys win. Failures become
+`KnowledgeExtractionError` with the original error as `cause`.
+
+## Output
+
+| Format                            | Text                                                                                        | Metadata                                 |
+| --------------------------------- | ------------------------------------------------------------------------------------------- | ---------------------------------------- |
+| `text`, `markdown`, `csv`, `json` | UTF-8 decoded                                                                               | `title` = filename                       |
+| `pdf`                             | Text of all pages (unpdf)                                                                   | PDF `Title` if set, `pageCount`          |
+| `docx`                            | Raw text (mammoth)                                                                          | `title` = filename                       |
+| `xlsx`                            | One `# <sheet>` section per worksheet with bounded CSV rows; external links as `text <url>` | workbook title or filename, `sheetNames` |
+| `pptx`                            | Slide text by slide part number (`slide<n>.xml`), then speaker notes                        | `title` = filename                       |
+
+XLSX cells show their cached value as Excel displays it: SheetJS applies the number formats, and
+format codes longer than Excel's own 255-character limit show as General. Formulas are not
+parsed: a formula cell shows its cached result, and a formula cell without a cached value is
+empty, never `=formula`. Excel, LibreOffice, and Google Sheets always store cached values; files
+generated by code (openpyxl, ExcelJS, the SheetJS writer) may not. A worksheet is read when its
+workbook relationship points at an `.xml` part; chart sheets and parts under another extension
+are listed in `sheetNames` but have no rows. Comments, drawings, and other parts SheetJS does not
+need for cell text are never parsed.
+
+All text is sanitized: line endings are normalized, control characters dropped, and runs of
+spaces, dots, and blank lines collapsed. Empty results fail with `FileExtractionError`. The format
+comes from the filename extension first, then the media type, then any `text/*` media type as
+plain text. Everything else fails with `UnsupportedFileFormatError`.
+
+## Limits
+
+`defaultFileExtractorLimits` (conservative defaults); override any of them
+through `makeFileExtractorLayer({ limits })`. Invalid values are a defect when the layer is built.
+
+| Limit                   | Default | Bounds                                                                    |
+| ----------------------- | ------- | ------------------------------------------------------------------------- |
+| `maxInputBytes`         | 50 MiB  | Input size, every format                                                  |
+| `maxArchiveEntries`     | 10,000  | ZIP entries in DOCX, XLSX, PPTX                                           |
+| `maxExpandedBytes`      | 50 MiB  | Inflated bytes of an Office archive, counted while inflating              |
+| `maxXlsxSheets`         | 100     | Worksheets                                                                |
+| `maxXlsxCellVisits`     | 100,000 | Cells inside every sheet's declared range, absent cells included          |
+| `maxXlsxTextCharacters` | 512 Ki  | XLSX text, annotations and the omission marker included; at least 62      |
+| `maxXlsxHyperlinks`     | 10,000  | Hyperlinks read per workbook. Extra links are dropped but still stripped. |
+
+Exceeding a limit fails the extraction with `FileExtractionError`. The exceptions are hyperlink
+annotations and links beyond the cap, described below.
+
+## Security model
+
+- **Office archives** (DOCX, XLSX, PPTX) are validated before any parser sees them. The ZIP
+  directory is read only as an index and its sizes are never trusted. Each entry is inflated in
+  bounded chunks, and the real output is counted against its declared size and
+  `maxExpandedBytes`. Encrypted, ZIP64, split, and duplicate-name archives fail (names that differ
+  only in case count as duplicates, as in OPC), as do archives with ambiguous paths (`..`, `.`,
+  `//`, absolute, backslashes, control characters) or macro projects (`vbaProject.bin`). Directory
+  entries ending in `/` are fine. Parsers then get archives rebuilt from the validated bytes. OOXML
+  input missing `[Content_Types].xml` or its main part (`word/document.xml`, `xl/workbook.xml`,
+  `ppt/presentation.xml`) fails; this is deliberately strict.
+- **Worker isolation.** Every parser runs in a worker with V8 heap, stack, and time limits and a
+  cap of 4 workers per JavaScript realm (see above). A parser path nobody has found yet that
+  exhausts the worker's heap or runs too long ends in a typed error. Memory outside the V8 heap is
+  bounded only by the input and expanded-size limits and your host's memory limit.
+- **Generated SheetJS input.** SheetJS picks its parser from the archive, not the file name, and
+  several of its XML parsers do work far beyond the size of the part. So SheetJS never receives
+  the uploaded archive. The extractor builds a new one:
+  - generated: `[Content_Types].xml`, `_rels/.rels`, and `xl/_rels/workbook.xml.rels`, so no
+    attacker content type, part name, or relationship reaches SheetJS;
+  - generated `xl/workbook.xml`: the sheets in order (name, `sheetId`, hidden state, a fresh
+    relationship id each) and the 1904 date system, nothing else. SheetJS's defined-name handling
+    is quadratic, and with shared relationship ids it parses one worksheet once per sheet. A
+    workbook whose sheets the extractor and SheetJS's own tag grammar count or name differently,
+    whose names repeat ignoring case, or whose sheets share a worksheet part is rejected;
+  - generated `xl/styles.xml`: number formats (at most 255 characters after unescaping, at most
+    1,000) and one cell format per source cell format, in order (at most 64,000). SheetJS
+    re-parses a cell's format for every cell, so one huge format used by many cells would
+    otherwise amplify;
+  - copied: the worksheets (any `.xml` part related as a worksheet, stored as
+    `xl/worksheets/sheet<n>.xml`) and `xl/sharedStrings.xml`, validated and hyperlink-stripped.
+    Parts where SheetJS could meet a CDATA marker are rejected: SheetJS's unescaping recurses
+    over an unterminated CDATA section with quadratic output, and Excel never writes CDATA there.
+    SheetJS reaches that unescaping in two ways the check models. It decodes: up to two of
+    `unescapexml` and `utf8read` (which keeps only each character's low byte, so `&#x13C;` in a
+    `str` cell becomes `<` between its two decodes). And it removes tags before decoding: every
+    `<si>` in the shared-strings table, and every `<r>` in rich text, so `A<<r>![CDATA[B` becomes
+    `A<![CDATA[B`. Inline strings take the rich-text path even with `cellHTML: false`. So a part is
+    rejected when its text, or its text after `utf8read`, contains `<<` or `<!`, or when its text,
+    as is or with every simple opening tag removed, meets the marker after any chain of up to two
+    conversions. This deliberately fails closed: XML comments, `<!DOCTYPE` and any other `<!…`
+    declaration, and a literal `<<` in a worksheet or the shared strings are rejected as
+    unsupported markup (CDATA, comments or declarations). Excel, LibreOffice, and Google Sheets
+    never write them there. Some forms are rejected only because they fall in this superset, not
+    because SheetJS 0.20.3 would expand them (for example `&lt;<r>![CDATA[`, which it decodes
+    after its CDATA check).
+
+  The title comes from `docProps/core.xml`, read by the extractor. With no marker entries and no
+  `.bin` entries, SheetJS can only take its XLSX path. Everything else (comments, VML, drawings,
+  `.bin` parts, external links, pivot caches, `customXml`, …) is left out.
+
+- **Early rejection.** For a clear error instead of "Could not read XLSX", XLSX input that SheetJS
+  would route elsewhere fails before SheetJS loads: ODS and Numbers marker entries
+  (`META-INF/manifest.xml`, `objectdata.xml`, `Index/Document.iwa`, `Index.zip`, any `Root Entry/`
+  name), matched after SheetJS's own path normalisation (first `//` collapsed, `Root Entry/`
+  stripped, `\` as `/`, any case); XLSB content types in `[Content_Types].xml` overrides; and
+  relationship targets or override part names ending in `.bin`, unless they are types SheetJS
+  never parses (printer settings, OLE and ActiveX binaries, custom properties, attached toolbars).
+  Tags and attributes are read exactly as SheetJS reads them (quoted values may contain `<`;
+  attribute names are case-sensitive). `.bin` elsewhere in a name (`data.bin.xml`, an
+  `archive.bin/` directory, `Id="rId.bin"`) is fine.
+- **Formulas off.** SheetJS runs with `cellFormula: false` (and without HTML, styles, stubs, or
+  VBA), so shared formulas are never copied onto every dependent cell and array formulas are never
+  rescanned per cell. Only cached values are read (see Output).
+- **`normalizeOfficeArchive`** returns a validated, rebuilt archive of every part for storage or
+  for other parsers. It applies the same archive checks and, for XLSX, the hyperlink strip and the
+  early rejections, but it keeps parts SheetJS must never see (printer settings, comments, …).
+  Never run SheetJS on its output directly: extract XLSX text through `FileExtractor`, which builds
+  the allowlisted input.
+- **XLSX hyperlinks.** Before parsing, SheetJS (0.18.5 and 0.20.3) expands every
+  `<hyperlink ref>` range into per-cell objects. A 6 KB file with `ref="A1:XFD1048576"`
+  exhausts a 1 GB heap. So the extractor reads each `<hyperlink>` itself (`ref`, `r:id` to the
+  worksheet relationship target, `location`, `display`), up to `maxXlsxHyperlinks` per workbook. It
+  removes every hyperlink tag from every archive part, replacing each with a space so fragments
+  cannot join into a new tag. SheetJS never sees one. In the text, every existing cell of the
+  visited range that falls inside a link is written as `text <url>`. An indexed lookup over the
+  visited range keeps this at O((links + cells) · log) instead of a scan of every link per cell.
+  Only `http:`, `https:`, and `mailto:` targets are shown (normalized; links whose target is
+  longer than 2,048 characters are dropped). `display` labels are cut to 1,024 characters ending
+  in `…`, and an annotation that cannot fit the remaining budget is rejected by its length before
+  it is built. Internal `#Sheet!A1` locations and other schemes are omitted. Plain text is
+  rendered first and links use only the budget left over. When an annotation does not fit, or
+  links exceed the cap, the cell is written plain and the output ends with one
+  `[Some hyperlinks omitted: output limit]` (or `hyperlink limit`) marker, inside the budget.
+- **UTF-16 parts.** SheetJS decodes BOM-marked UTF-16 parts itself, and the byte-level strip
+  cannot see tags inside them. Any XLSX part whose stripped bytes would decode as UTF-16 with a
+  hyperlink tag is rejected. Excel never writes UTF-16 parts. The markup rule can also reject a
+  legitimate BOM-marked UTF-16 part, when a character's low byte forms `<<` or `<!`.
+- **Bounded XLSX text.** Every sheet range is checked strictly against Excel's grid, and the
+  cell-visit total is checked before any cell is read. CSV is generated incrementally against
+  the character budget (never `sheet_to_csv`). Cells and sheets are read as own properties only.
+  The renderer uses SheetJS's display text. SheetJS evaluates number formats inside `read`, before
+  this budget, which is why it only ever reads the generated, bounded stylesheet.
+- **SheetJS version.** Only SheetJS 0.20.3+ is used (see above). The prototype-pollution
+  regression (CVE-2023-30533) is covered by a test with a crafted comment: the comment never
+  reaches SheetJS, and SheetJS 0.20.3 parsing the file directly is not polluted either.
+
+- **Residual risk.** SheetJS still parses the worksheets and shared strings as uploaded (after
+  validation, the hyperlink strip, and the CDATA check, which models SheetJS 0.20.3's decodes and
+  tag removals), and unpdf, mammoth, and the PPTX reader
+  parse their parts. No other super-linear path is known in these parsers with the options used,
+  but any one found later runs before the extractor's budgets. The worker's heap, stack, and time
+  limits are the backstop for that, and they do not bound memory outside the V8 heap (PDF.js's
+  decoded buffers included). With `isolation: 'none'` there is no backstop: a number format of up
+  to 255 tokens still multiplies SheetJS's per-cell work and memory by up to about 255.
+
+## Next.js
+
+`@yolk-sdk/extractors/node` uses Node APIs and starts its worker from the package's
+`dist/node/extraction-worker.mjs`: one self-contained file with Effect, fflate, mammoth, unpdf, and
+the package's own code inlined. Its only other import is the optional `xlsx` peer, loaded
+dynamically with its version check. Keep both packages unbundled in server code:
+
+```ts
+// next.config.ts
+const nextConfig = {
+  serverExternalPackages: ['@yolk-sdk/extractors', 'xlsx']
+}
+```
+
+The default worker location is found from the package's own module (`dist/node/…` installed, or
+`src/node/…` in a workspace that links the source, which needs the package built first). If a
+bundler moves that module into a chunk of another name, there is no default: extraction fails
+closed with `reason: 'worker-unavailable'` and starts nothing. Then copy
+`@yolk-sdk/extractors/node/extraction-worker` somewhere with `xlsx` resolvable beside it and pass
+its URL as `isolation.workerUrl`. With the package external, Next.js 16 (Turbopack) output file
+tracing includes the worker. This was checked with an `output: 'standalone'` build that runs from
+a copy of the traced files. If your tracer misses `dist/node/extraction-worker.mjs`, add it (and
+`xlsx`) with `outputFileTracingIncludes`.
+
+## Host responsibilities
+
+- Upload size and auth policy, storage, and any per-user quotas.
+- Choosing limits that fit your runtime's memory and the model context you feed the text to. The
+  worker limits bound V8 heap and time, not the process: your platform's memory limit is the
+  outer bound (see Worker isolation).
+- Installing SheetJS from the CDN when XLSX extraction is needed.
+
+## Boundaries
+
+- Domain-free: no upload, auth, storage, or product concepts. The host decides where bytes come
+  from and what the text is used for.
+- The root and `./knowledge` are runtime-portable: no Node built-ins and no parsers. Parsers live
+  only behind `./node`.
+- `./knowledge` is the only bridge to `@yolk-sdk/knowledge`; the knowledge package never imports
+  extractors.

package/dist/errors.d.mts

@@ -0,0 +1,60 @@
+import * as Schema from "effect/Schema";
+
+//#region src/errors.d.ts
+/** The SheetJS tarball consumers install; npm `xlsx` stops at the vulnerable 0.18.5. */
+declare const sheetJsInstallCommand = "pnpm add https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz";
+/** Lowest SheetJS release with fixes for CVE-2023-30533 and CVE-2024-22363. */
+declare const minimumSheetJsVersion = "0.20.3";
+/**
+ * Why an isolated extraction stopped before the parsers finished:
+ *
+ * - `resource-limit`: the worker ran out of its V8 heap (`maxOldGenerationSizeMb`, …);
+ * - `timeout`: the worker exceeded `timeoutMs` and was terminated;
+ * - `worker-unavailable`: the worker could not start (a missing or unloadable worker file);
+ * - `worker-failed`: the worker crashed or exited without a result;
+ * - `busy`: no worker slot freed up within `maxQueueWaitMs`, so no worker was started.
+ */
+declare const FileExtractionFailureReason: Schema.Literals<readonly ["resource-limit", "timeout", "worker-unavailable", "worker-failed", "busy"]>;
+type FileExtractionFailureReason = typeof FileExtractionFailureReason.Type;
+declare const FileExtractionError_base: Schema.Class<FileExtractionError, Schema.TaggedStruct<"FileExtractionError", {
+  readonly message: Schema.String;
+  readonly format: Schema.String;
+  readonly reason: Schema.optional<Schema.Literals<readonly ["resource-limit", "timeout", "worker-unavailable", "worker-failed", "busy"]>>;
+  readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Reading, validating, or bounding a file failed. `message` is safe to show to users. `reason`
+ * is set only when an isolated worker was stopped or never admitted (see
+ * `FileExtractionFailureReason`).
+ */
+declare class FileExtractionError extends FileExtractionError_base {}
+declare const UnsupportedFileFormatError_base: Schema.Class<UnsupportedFileFormatError, Schema.TaggedStruct<"UnsupportedFileFormatError", {
+  readonly filename: Schema.String;
+  readonly mediaType: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Neither the filename extension nor the media type maps to a supported format. */
+declare class UnsupportedFileFormatError extends UnsupportedFileFormatError_base {
+  get message(): string;
+}
+declare const OfficeArchiveError_base: Schema.Class<OfficeArchiveError, Schema.TaggedStruct<"OfficeArchiveError", {
+  readonly message: Schema.String;
+  readonly expandedBytes: Schema.optional<Schema.Number>;
+}>, import("effect/Cause").YieldableError>;
+/** A DOCX, XLSX, or PPTX ZIP archive failed bounded validation or normalization. */
+declare class OfficeArchiveError extends OfficeArchiveError_base {}
+declare const SheetJsUnavailableError_base: Schema.Class<SheetJsUnavailableError, Schema.TaggedStruct<"SheetJsUnavailableError", {
+  readonly reason: Schema.Literals<readonly ["missing", "invalid", "outdated"]>;
+  readonly installedVersion: Schema.optional<Schema.String>;
+  readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * SheetJS (`xlsx`, an optional peer) is missing, is not a usable SheetJS module, or is older than
+ * 0.20.3. This is host misconfiguration, not a problem with the uploaded file.
+ */
+declare class SheetJsUnavailableError extends SheetJsUnavailableError_base {
+  get message(): string;
+}
+type FileExtractorError = FileExtractionError | UnsupportedFileFormatError | SheetJsUnavailableError;
+//#endregion
+export { FileExtractionError, FileExtractionFailureReason, FileExtractorError, OfficeArchiveError, SheetJsUnavailableError, UnsupportedFileFormatError, minimumSheetJsVersion, sheetJsInstallCommand };
+//# sourceMappingURL=errors.d.mts.map

package/dist/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/errors.ts"],"mappings":";;;;cAIa,qBAAA;AAAb;AAAA,cAGa,qBAAA;;;AAHqB;AAGlC;;;;AAAkC;AAWlC;cAAa,2BAAA,EAA2B,MAAA,CAAA,QAAA;AAAA,KAQ5B,2BAAA,UAAqC,2BAAA,CAA4B,IAAI;AAAA,cAAA,wBAAA;;;;;;AAAA;AAAA;;;;AAAA,cAOpE,mBAAA,SAA4B,wBAQxC;AAAA,cAAG,+BAAA;;;;;cAGS,0BAAA,SAAmC,+BAM/C;EAAA,IACK,OAAO,CAAA;AAAA;AAAA,cAGZ,uBAAA;;;;;cAGY,kBAAA,SAA2B,uBAMvC;AAAA,cAAG,4BAAA;;;;;;;;;cAMS,uBAAA,SAAgC,4BAO5C;EAAA,IACK,OAAO,CAAA;AAAA;AAAA,KAeD,kBAAA,GACR,mBAAA,GACA,0BAAA,GACA,uBAAA"}

package/dist/errors.mjs

@@ -0,0 +1,69 @@
+import { Match } from "effect";
+import * as Schema from "effect/Schema";
+//#region src/errors.ts
+/** The SheetJS tarball consumers install; npm `xlsx` stops at the vulnerable 0.18.5. */
+const sheetJsInstallCommand = "pnpm add https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz";
+/** Lowest SheetJS release with fixes for CVE-2023-30533 and CVE-2024-22363. */
+const minimumSheetJsVersion = "0.20.3";
+/**
+* Why an isolated extraction stopped before the parsers finished:
+*
+* - `resource-limit`: the worker ran out of its V8 heap (`maxOldGenerationSizeMb`, …);
+* - `timeout`: the worker exceeded `timeoutMs` and was terminated;
+* - `worker-unavailable`: the worker could not start (a missing or unloadable worker file);
+* - `worker-failed`: the worker crashed or exited without a result;
+* - `busy`: no worker slot freed up within `maxQueueWaitMs`, so no worker was started.
+*/
+const FileExtractionFailureReason = Schema.Literals([
+	"resource-limit",
+	"timeout",
+	"worker-unavailable",
+	"worker-failed",
+	"busy"
+]);
+/**
+* Reading, validating, or bounding a file failed. `message` is safe to show to users. `reason`
+* is set only when an isolated worker was stopped or never admitted (see
+* `FileExtractionFailureReason`).
+*/
+var FileExtractionError = class extends Schema.TaggedError()("FileExtractionError", {
+	message: Schema.String,
+	format: Schema.String,
+	reason: Schema.optional(FileExtractionFailureReason),
+	cause: Schema.optional(Schema.Unknown)
+}) {};
+/** Neither the filename extension nor the media type maps to a supported format. */
+var UnsupportedFileFormatError = class extends Schema.TaggedError()("UnsupportedFileFormatError", {
+	filename: Schema.String,
+	mediaType: Schema.String
+}) {
+	get message() {
+		return `Unsupported file format: ${this.filename}`;
+	}
+};
+/** A DOCX, XLSX, or PPTX ZIP archive failed bounded validation or normalization. */
+var OfficeArchiveError = class extends Schema.TaggedError()("OfficeArchiveError", {
+	message: Schema.String,
+	expandedBytes: Schema.optional(Schema.Number)
+}) {};
+/**
+* SheetJS (`xlsx`, an optional peer) is missing, is not a usable SheetJS module, or is older than
+* 0.20.3. This is host misconfiguration, not a problem with the uploaded file.
+*/
+var SheetJsUnavailableError = class extends Schema.TaggedError()("SheetJsUnavailableError", {
+	reason: Schema.Literals([
+		"missing",
+		"invalid",
+		"outdated"
+	]),
+	installedVersion: Schema.optional(Schema.String),
+	cause: Schema.optional(Schema.Unknown)
+}) {
+	get message() {
+		return `${Match.value(this.reason).pipe(Match.when("missing", () => "SheetJS (xlsx) is not installed"), Match.when("outdated", () => `SheetJS ${this.installedVersion ?? "unknown"} is older than ${minimumSheetJsVersion}`), Match.when("invalid", () => "The installed xlsx module is not a usable SheetJS build"), Match.exhaustive)}. XLSX extraction needs SheetJS ${minimumSheetJsVersion} or newer from the SheetJS CDN (npm xlsx is unmaintained and vulnerable): ${sheetJsInstallCommand}`;
+	}
+};
+//#endregion
+export { FileExtractionError, FileExtractionFailureReason, OfficeArchiveError, SheetJsUnavailableError, UnsupportedFileFormatError, minimumSheetJsVersion, sheetJsInstallCommand };
+
+//# sourceMappingURL=errors.mjs.map

package/dist/errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["import { Match } from 'effect'\nimport * as Schema from 'effect/Schema'\n\n/** The SheetJS tarball consumers install; npm `xlsx` stops at the vulnerable 0.18.5. */\nexport const sheetJsInstallCommand = 'pnpm add https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz'\n\n/** Lowest SheetJS release with fixes for CVE-2023-30533 and CVE-2024-22363. */\nexport const minimumSheetJsVersion = '0.20.3'\n\n/**\n * Why an isolated extraction stopped before the parsers finished:\n *\n * - `resource-limit`: the worker ran out of its V8 heap (`maxOldGenerationSizeMb`, …);\n * - `timeout`: the worker exceeded `timeoutMs` and was terminated;\n * - `worker-unavailable`: the worker could not start (a missing or unloadable worker file);\n * - `worker-failed`: the worker crashed or exited without a result;\n * - `busy`: no worker slot freed up within `maxQueueWaitMs`, so no worker was started.\n */\nexport const FileExtractionFailureReason = Schema.Literals([\n  'resource-limit',\n  'timeout',\n  'worker-unavailable',\n  'worker-failed',\n  'busy'\n])\n\nexport type FileExtractionFailureReason = typeof FileExtractionFailureReason.Type\n\n/**\n * Reading, validating, or bounding a file failed. `message` is safe to show to users. `reason`\n * is set only when an isolated worker was stopped or never admitted (see\n * `FileExtractionFailureReason`).\n */\nexport class FileExtractionError extends Schema.TaggedError<FileExtractionError>()(\n  'FileExtractionError',\n  {\n    message: Schema.String,\n    format: Schema.String,\n    reason: Schema.optional(FileExtractionFailureReason),\n    cause: Schema.optional(Schema.Unknown)\n  }\n) {}\n\n/** Neither the filename extension nor the media type maps to a supported format. */\nexport class UnsupportedFileFormatError extends Schema.TaggedError<UnsupportedFileFormatError>()(\n  'UnsupportedFileFormatError',\n  {\n    filename: Schema.String,\n    mediaType: Schema.String\n  }\n) {\n  get message(): string {\n    return `Unsupported file format: ${this.filename}`\n  }\n}\n\n/** A DOCX, XLSX, or PPTX ZIP archive failed bounded validation or normalization. */\nexport class OfficeArchiveError extends Schema.TaggedError<OfficeArchiveError>()(\n  'OfficeArchiveError',\n  {\n    message: Schema.String,\n    expandedBytes: Schema.optional(Schema.Number)\n  }\n) {}\n\n/**\n * SheetJS (`xlsx`, an optional peer) is missing, is not a usable SheetJS module, or is older than\n * 0.20.3. This is host misconfiguration, not a problem with the uploaded file.\n */\nexport class SheetJsUnavailableError extends Schema.TaggedError<SheetJsUnavailableError>()(\n  'SheetJsUnavailableError',\n  {\n    reason: Schema.Literals(['missing', 'invalid', 'outdated']),\n    installedVersion: Schema.optional(Schema.String),\n    cause: Schema.optional(Schema.Unknown)\n  }\n) {\n  get message(): string {\n    const problem = Match.value(this.reason).pipe(\n      Match.when('missing', () => 'SheetJS (xlsx) is not installed'),\n      Match.when(\n        'outdated',\n        () => `SheetJS ${this.installedVersion ?? 'unknown'} is older than ${minimumSheetJsVersion}`\n      ),\n      Match.when('invalid', () => 'The installed xlsx module is not a usable SheetJS build'),\n      Match.exhaustive\n    )\n\n    return `${problem}. XLSX extraction needs SheetJS ${minimumSheetJsVersion} or newer from the SheetJS CDN (npm xlsx is unmaintained and vulnerable): ${sheetJsInstallCommand}`\n  }\n}\n\nexport type FileExtractorError =\n  | FileExtractionError\n  | UnsupportedFileFormatError\n  | SheetJsUnavailableError\n"],"mappings":";;;;AAIA,MAAa,wBAAwB;;AAGrC,MAAa,wBAAwB;;;;;;;;;;AAWrC,MAAa,8BAA8B,OAAO,SAAS;CACzD;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;;AASD,IAAa,sBAAb,cAAyC,OAAO,YAAiC,EAC/E,uBACA;CACE,SAAS,OAAO;CAChB,QAAQ,OAAO;CACf,QAAQ,OAAO,SAAS,2BAA2B;CACnD,OAAO,OAAO,SAAS,OAAO,OAAO;AACvC,CACF,EAAE,CAAC;;AAGH,IAAa,6BAAb,cAAgD,OAAO,YAAwC,EAC7F,8BACA;CACE,UAAU,OAAO;CACjB,WAAW,OAAO;AACpB,CACF,EAAE;CACA,IAAI,UAAkB;EACpB,OAAO,4BAA4B,KAAK;CAC1C;AACF;;AAGA,IAAa,qBAAb,cAAwC,OAAO,YAAgC,EAC7E,sBACA;CACE,SAAS,OAAO;CAChB,eAAe,OAAO,SAAS,OAAO,MAAM;AAC9C,CACF,EAAE,CAAC;;;;;AAMH,IAAa,0BAAb,cAA6C,OAAO,YAAqC,EACvF,2BACA;CACE,QAAQ,OAAO,SAAS;EAAC;EAAW;EAAW;CAAU,CAAC;CAC1D,kBAAkB,OAAO,SAAS,OAAO,MAAM;CAC/C,OAAO,OAAO,SAAS,OAAO,OAAO;AACvC,CACF,EAAE;CACA,IAAI,UAAkB;EAWpB,OAAO,GAVS,MAAM,MAAM,KAAK,MAAM,EAAE,KACvC,MAAM,KAAK,iBAAiB,iCAAiC,GAC7D,MAAM,KACJ,kBACM,WAAW,KAAK,oBAAoB,UAAU,iBAAiB,uBACvE,GACA,MAAM,KAAK,iBAAiB,yDAAyD,GACrF,MAAM,UAGQ,EAAE,kCAAkC,sBAAsB,4EAA4E;CACxJ;AACF"}

package/dist/format.d.mts

@@ -0,0 +1,32 @@
+//#region src/format.d.ts
+declare const extractedFileFormats: readonly ["csv", "docx", "json", "markdown", "pdf", "pptx", "text", "xlsx"];
+type ExtractedFileFormat = (typeof extractedFileFormats)[number];
+/** Office Open XML formats; their ZIP archives are validated before any parser reads them. */
+type OfficeFileFormat = 'docx' | 'pptx' | 'xlsx';
+type FileInput = {
+  readonly filename: string;
+  readonly mediaType: string;
+  readonly bytes: Uint8Array;
+};
+type ExtractedFileMetadata = {
+  readonly format: ExtractedFileFormat;
+  readonly title?: string;
+  readonly pageCount?: number;
+  readonly sheetNames?: ReadonlyArray<string>;
+};
+type ExtractedFile = {
+  readonly content: string;
+  readonly metadata: ExtractedFileMetadata;
+};
+/**
+ * Pick the extraction format: the filename extension wins, then the media type, then any
+ * `text/*` media type as plain text. `undefined` means the file is unsupported.
+ */
+declare const fileFormatFor: (input: {
+  readonly filename: string;
+  readonly mediaType: string;
+}) => ExtractedFileFormat | undefined;
+declare const isOfficeFileFormat: (format: ExtractedFileFormat) => format is OfficeFileFormat;
+//#endregion
+export { ExtractedFile, ExtractedFileFormat, ExtractedFileMetadata, FileInput, OfficeFileFormat, extractedFileFormats, fileFormatFor, isOfficeFileFormat };
+//# sourceMappingURL=format.d.mts.map

package/dist/format.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.mts","names":[],"sources":["../src/format.ts"],"mappings":";cAAa,oBAAA;AAAA,KAWD,mBAAA,WAA8B,oBAAoB;;KAGlD,gBAAA;AAAA,KAEA,SAAA;EAAA,SACD,QAAA;EAAA,SACA,SAAA;EAAA,SACA,KAAA,EAAO,UAAU;AAAA;AAAA,KAGhB,qBAAA;EAAA,SACD,MAAA,EAAQ,mBAAA;EAAA,SACR,KAAA;EAAA,SACA,SAAA;EAAA,SACA,UAAA,GAAa,aAAa;AAAA;AAAA,KAGzB,aAAA;EAAA,SACD,OAAA;EAAA,SACA,QAAA,EAAU,qBAAqB;AAAA;;;;;cAoC7B,aAAA,GAAiB,KAAA;EAAA,SACnB,QAAA;EAAA,SACA,SAAA;AAAA,MACP,mBAAmB;AAAA,cAYV,kBAAA,GAAsB,MAAA,EAAQ,mBAAA,KAAsB,MAAA,IAAU,gBACd"}

package/dist/format.mjs

@@ -0,0 +1,52 @@
+//#region src/format.ts
+const extractedFileFormats = [
+	"csv",
+	"docx",
+	"json",
+	"markdown",
+	"pdf",
+	"pptx",
+	"text",
+	"xlsx"
+];
+const extensionFor = (filename) => {
+	const lower = filename.toLowerCase();
+	const dotIndex = lower.lastIndexOf(".");
+	return dotIndex === -1 ? "" : lower.slice(dotIndex + 1);
+};
+const formatsByExtension = new Map([
+	["txt", "text"],
+	["md", "markdown"],
+	["markdown", "markdown"],
+	["csv", "csv"],
+	["json", "json"],
+	["pdf", "pdf"],
+	["docx", "docx"],
+	["xlsx", "xlsx"],
+	["pptx", "pptx"]
+]);
+const formatsByMediaType = new Map([
+	["application/pdf", "pdf"],
+	["application/vnd.openxmlformats-officedocument.wordprocessingml.document", "docx"],
+	["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "xlsx"],
+	["application/vnd.openxmlformats-officedocument.presentationml.presentation", "pptx"],
+	["application/json", "json"],
+	["text/csv", "csv"],
+	["text/markdown", "markdown"]
+]);
+/**
+* Pick the extraction format: the filename extension wins, then the media type, then any
+* `text/*` media type as plain text. `undefined` means the file is unsupported.
+*/
+const fileFormatFor = (input) => {
+	const byExtension = formatsByExtension.get(extensionFor(input.filename));
+	if (byExtension !== void 0) return byExtension;
+	const byMediaType = formatsByMediaType.get(input.mediaType);
+	if (byMediaType !== void 0) return byMediaType;
+	return input.mediaType.startsWith("text/") ? "text" : void 0;
+};
+const isOfficeFileFormat = (format) => format === "docx" || format === "pptx" || format === "xlsx";
+//#endregion
+export { extractedFileFormats, fileFormatFor, isOfficeFileFormat };
+
+//# sourceMappingURL=format.mjs.map

package/dist/format.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.mjs","names":[],"sources":["../src/format.ts"],"sourcesContent":["export const extractedFileFormats = [\n  'csv',\n  'docx',\n  'json',\n  'markdown',\n  'pdf',\n  'pptx',\n  'text',\n  'xlsx'\n] as const\n\nexport type ExtractedFileFormat = (typeof extractedFileFormats)[number]\n\n/** Office Open XML formats; their ZIP archives are validated before any parser reads them. */\nexport type OfficeFileFormat = 'docx' | 'pptx' | 'xlsx'\n\nexport type FileInput = {\n  readonly filename: string\n  readonly mediaType: string\n  readonly bytes: Uint8Array\n}\n\nexport type ExtractedFileMetadata = {\n  readonly format: ExtractedFileFormat\n  readonly title?: string\n  readonly pageCount?: number\n  readonly sheetNames?: ReadonlyArray<string>\n}\n\nexport type ExtractedFile = {\n  readonly content: string\n  readonly metadata: ExtractedFileMetadata\n}\n\nconst extensionFor = (filename: string) => {\n  const lower = filename.toLowerCase()\n  const dotIndex = lower.lastIndexOf('.')\n\n  return dotIndex === -1 ? '' : lower.slice(dotIndex + 1)\n}\n\nconst formatsByExtension: ReadonlyMap<string, ExtractedFileFormat> = new Map([\n  ['txt', 'text'],\n  ['md', 'markdown'],\n  ['markdown', 'markdown'],\n  ['csv', 'csv'],\n  ['json', 'json'],\n  ['pdf', 'pdf'],\n  ['docx', 'docx'],\n  ['xlsx', 'xlsx'],\n  ['pptx', 'pptx']\n])\n\nconst formatsByMediaType: ReadonlyMap<string, ExtractedFileFormat> = new Map([\n  ['application/pdf', 'pdf'],\n  ['application/vnd.openxmlformats-officedocument.wordprocessingml.document', 'docx'],\n  ['application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', 'xlsx'],\n  ['application/vnd.openxmlformats-officedocument.presentationml.presentation', 'pptx'],\n  ['application/json', 'json'],\n  ['text/csv', 'csv'],\n  ['text/markdown', 'markdown']\n])\n\n/**\n * Pick the extraction format: the filename extension wins, then the media type, then any\n * `text/*` media type as plain text. `undefined` means the file is unsupported.\n */\nexport const fileFormatFor = (input: {\n  readonly filename: string\n  readonly mediaType: string\n}): ExtractedFileFormat | undefined => {\n  const byExtension = formatsByExtension.get(extensionFor(input.filename))\n\n  if (byExtension !== undefined) return byExtension\n\n  const byMediaType = formatsByMediaType.get(input.mediaType)\n\n  if (byMediaType !== undefined) return byMediaType\n\n  return input.mediaType.startsWith('text/') ? 'text' : undefined\n}\n\nexport const isOfficeFileFormat = (format: ExtractedFileFormat): format is OfficeFileFormat =>\n  format === 'docx' || format === 'pptx' || format === 'xlsx'\n"],"mappings":";AAAA,MAAa,uBAAuB;CAClC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAyBA,MAAM,gBAAgB,aAAqB;CACzC,MAAM,QAAQ,SAAS,YAAY;CACnC,MAAM,WAAW,MAAM,YAAY,GAAG;CAEtC,OAAO,aAAa,KAAK,KAAK,MAAM,MAAM,WAAW,CAAC;AACxD;AAEA,MAAM,qBAA+D,IAAI,IAAI;CAC3E,CAAC,OAAO,MAAM;CACd,CAAC,MAAM,UAAU;CACjB,CAAC,YAAY,UAAU;CACvB,CAAC,OAAO,KAAK;CACb,CAAC,QAAQ,MAAM;CACf,CAAC,OAAO,KAAK;CACb,CAAC,QAAQ,MAAM;CACf,CAAC,QAAQ,MAAM;CACf,CAAC,QAAQ,MAAM;AACjB,CAAC;AAED,MAAM,qBAA+D,IAAI,IAAI;CAC3E,CAAC,mBAAmB,KAAK;CACzB,CAAC,2EAA2E,MAAM;CAClF,CAAC,qEAAqE,MAAM;CAC5E,CAAC,6EAA6E,MAAM;CACpF,CAAC,oBAAoB,MAAM;CAC3B,CAAC,YAAY,KAAK;CAClB,CAAC,iBAAiB,UAAU;AAC9B,CAAC;;;;;AAMD,MAAa,iBAAiB,UAGS;CACrC,MAAM,cAAc,mBAAmB,IAAI,aAAa,MAAM,QAAQ,CAAC;CAEvE,IAAI,gBAAgB,KAAA,GAAW,OAAO;CAEtC,MAAM,cAAc,mBAAmB,IAAI,MAAM,SAAS;CAE1D,IAAI,gBAAgB,KAAA,GAAW,OAAO;CAEtC,OAAO,MAAM,UAAU,WAAW,OAAO,IAAI,SAAS,KAAA;AACxD;AAEA,MAAa,sBAAsB,WACjC,WAAW,UAAU,WAAW,UAAU,WAAW"}

package/dist/index.d.mts

@@ -0,0 +1,6 @@
+import { FileExtractionError, FileExtractionFailureReason, FileExtractorError, OfficeArchiveError, SheetJsUnavailableError, UnsupportedFileFormatError, minimumSheetJsVersion, sheetJsInstallCommand } from "./errors.mjs";
+import { ExtractedFile, ExtractedFileFormat, ExtractedFileMetadata, FileInput, OfficeFileFormat, extractedFileFormats, fileFormatFor, isOfficeFileFormat } from "./format.mjs";
+import { FileExtractorLimits, defaultFileExtractorLimits } from "./limits.mjs";
+import { sanitizeExtractedText } from "./sanitize.mjs";
+import { FileExtractor, FileExtractorApi } from "./service.mjs";
+export { type ExtractedFile, type ExtractedFileFormat, type ExtractedFileMetadata, FileExtractionError, FileExtractionFailureReason, FileExtractor, type FileExtractorApi, type FileExtractorError, FileExtractorLimits, type FileInput, OfficeArchiveError, type OfficeFileFormat, SheetJsUnavailableError, UnsupportedFileFormatError, defaultFileExtractorLimits, extractedFileFormats, fileFormatFor, isOfficeFileFormat, minimumSheetJsVersion, sanitizeExtractedText, sheetJsInstallCommand };

package/dist/index.mjs

@@ -0,0 +1,6 @@
+import { FileExtractionError, FileExtractionFailureReason, OfficeArchiveError, SheetJsUnavailableError, UnsupportedFileFormatError, minimumSheetJsVersion, sheetJsInstallCommand } from "./errors.mjs";
+import { extractedFileFormats, fileFormatFor, isOfficeFileFormat } from "./format.mjs";
+import { FileExtractorLimits, defaultFileExtractorLimits } from "./limits.mjs";
+import { sanitizeExtractedText } from "./sanitize.mjs";
+import { FileExtractor } from "./service.mjs";
+export { FileExtractionError, FileExtractionFailureReason, FileExtractor, FileExtractorLimits, OfficeArchiveError, SheetJsUnavailableError, UnsupportedFileFormatError, defaultFileExtractorLimits, extractedFileFormats, fileFormatFor, isOfficeFileFormat, minimumSheetJsVersion, sanitizeExtractedText, sheetJsInstallCommand };