@yolk-sdk/extractors 0.1.0-canary.98

package/src/errors.ts

@@ -0,0 +1,96 @@
+import { Match } from 'effect'
+import * as Schema from 'effect/Schema'
+
+/** The SheetJS tarball consumers install; npm `xlsx` stops at the vulnerable 0.18.5. */
+export 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. */
+export 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.
+ */
+export const FileExtractionFailureReason = Schema.Literals([
+  'resource-limit',
+  'timeout',
+  'worker-unavailable',
+  'worker-failed',
+  'busy'
+])
+
+export type FileExtractionFailureReason = typeof FileExtractionFailureReason.Type
+
+/**
+ * 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`).
+ */
+export class FileExtractionError extends Schema.TaggedError<FileExtractionError>()(
+  '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. */
+export class UnsupportedFileFormatError extends Schema.TaggedError<UnsupportedFileFormatError>()(
+  'UnsupportedFileFormatError',
+  {
+    filename: Schema.String,
+    mediaType: Schema.String
+  }
+) {
+  get message(): string {
+    return `Unsupported file format: ${this.filename}`
+  }
+}
+
+/** A DOCX, XLSX, or PPTX ZIP archive failed bounded validation or normalization. */
+export class OfficeArchiveError extends Schema.TaggedError<OfficeArchiveError>()(
+  '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.
+ */
+export class SheetJsUnavailableError extends Schema.TaggedError<SheetJsUnavailableError>()(
+  'SheetJsUnavailableError',
+  {
+    reason: Schema.Literals(['missing', 'invalid', 'outdated']),
+    installedVersion: Schema.optional(Schema.String),
+    cause: Schema.optional(Schema.Unknown)
+  }
+) {
+  get message(): string {
+    const problem = 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
+    )
+
+    return `${problem}. XLSX extraction needs SheetJS ${minimumSheetJsVersion} or newer from the SheetJS CDN (npm xlsx is unmaintained and vulnerable): ${sheetJsInstallCommand}`
+  }
+}
+
+export type FileExtractorError =
+  | FileExtractionError
+  | UnsupportedFileFormatError
+  | SheetJsUnavailableError

package/src/format.ts

@@ -0,0 +1,84 @@
+export const extractedFileFormats = [
+  'csv',
+  'docx',
+  'json',
+  'markdown',
+  'pdf',
+  'pptx',
+  'text',
+  'xlsx'
+] as const
+
+export type ExtractedFileFormat = (typeof extractedFileFormats)[number]
+
+/** Office Open XML formats; their ZIP archives are validated before any parser reads them. */
+export type OfficeFileFormat = 'docx' | 'pptx' | 'xlsx'
+
+export type FileInput = {
+  readonly filename: string
+  readonly mediaType: string
+  readonly bytes: Uint8Array
+}
+
+export type ExtractedFileMetadata = {
+  readonly format: ExtractedFileFormat
+  readonly title?: string
+  readonly pageCount?: number
+  readonly sheetNames?: ReadonlyArray<string>
+}
+
+export type ExtractedFile = {
+  readonly content: string
+  readonly metadata: ExtractedFileMetadata
+}
+
+const extensionFor = (filename: string) => {
+  const lower = filename.toLowerCase()
+  const dotIndex = lower.lastIndexOf('.')
+
+  return dotIndex === -1 ? '' : lower.slice(dotIndex + 1)
+}
+
+const formatsByExtension: ReadonlyMap<string, ExtractedFileFormat> = new Map([
+  ['txt', 'text'],
+  ['md', 'markdown'],
+  ['markdown', 'markdown'],
+  ['csv', 'csv'],
+  ['json', 'json'],
+  ['pdf', 'pdf'],
+  ['docx', 'docx'],
+  ['xlsx', 'xlsx'],
+  ['pptx', 'pptx']
+])
+
+const formatsByMediaType: ReadonlyMap<string, ExtractedFileFormat> = 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.
+ */
+export const fileFormatFor = (input: {
+  readonly filename: string
+  readonly mediaType: string
+}): ExtractedFileFormat | undefined => {
+  const byExtension = formatsByExtension.get(extensionFor(input.filename))
+
+  if (byExtension !== undefined) return byExtension
+
+  const byMediaType = formatsByMediaType.get(input.mediaType)
+
+  if (byMediaType !== undefined) return byMediaType
+
+  return input.mediaType.startsWith('text/') ? 'text' : undefined
+}
+
+export const isOfficeFileFormat = (format: ExtractedFileFormat): format is OfficeFileFormat =>
+  format === 'docx' || format === 'pptx' || format === 'xlsx'

package/src/index.ts

@@ -0,0 +1,32 @@
+// Runtime-portable root: types, errors, format detection, limits, and the service tag. Parsers
+// live behind `@yolk-sdk/extractors/node`.
+
+export {
+  FileExtractionError,
+  FileExtractionFailureReason,
+  minimumSheetJsVersion,
+  OfficeArchiveError,
+  SheetJsUnavailableError,
+  sheetJsInstallCommand,
+  UnsupportedFileFormatError
+} from './errors.ts'
+
+export type { FileExtractorError } from './errors.ts'
+
+export { extractedFileFormats, fileFormatFor, isOfficeFileFormat } from './format.ts'
+
+export type {
+  ExtractedFile,
+  ExtractedFileFormat,
+  ExtractedFileMetadata,
+  FileInput,
+  OfficeFileFormat
+} from './format.ts'
+
+export { defaultFileExtractorLimits, FileExtractorLimits } from './limits.ts'
+
+export { sanitizeExtractedText } from './sanitize.ts'
+
+export { FileExtractor } from './service.ts'
+
+export type { FileExtractorApi } from './service.ts'

package/src/knowledge.ts

@@ -0,0 +1,101 @@
+import { Effect, Layer, Match, Predicate } from 'effect'
+import type { ExtractedKnowledgeDocument, KnowledgeSource } from '@yolk-sdk/knowledge/documents'
+import { KnowledgeExtractionError } from '@yolk-sdk/knowledge/errors'
+import { KnowledgeExtractor } from '@yolk-sdk/knowledge/extraction'
+import type { KnowledgeExtractorApi, LoadedKnowledgeSource } from '@yolk-sdk/knowledge/extraction'
+import type { ExtractedFile } from './format.ts'
+import { FileExtractor } from './service.ts'
+import type { FileExtractorApi } from './service.ts'
+
+/** Percent-decode a path segment; malformed escapes (`%zz`, invalid UTF-8) stay encoded. */
+const decodeSegment = (segment: string) => {
+  try {
+    return decodeURIComponent(segment)
+  } catch {
+    return segment
+  }
+}
+
+const urlFilename = (url: string) => {
+  if (!URL.canParse(url)) return url
+
+  const segments = new URL(url).pathname.split('/').filter(segment => segment.length > 0)
+  const last = segments.at(-1)
+
+  return last === undefined ? url : decodeSegment(last)
+}
+
+/** The filename used for format detection: file name or ref, URL path, or text label. */
+const filenameFor = (source: KnowledgeSource) =>
+  Match.value(source).pipe(
+    Match.tagsExhaustive({
+      File: file => file.name ?? file.ref,
+      Url: url => urlFilename(url.url),
+      Text: text => text.label ?? 'text'
+    })
+  )
+
+/** Loaded media type first, then the file source's, then `text/plain` for text sources. */
+const mediaTypeFor = (loaded: LoadedKnowledgeSource) => {
+  if (loaded.mediaType !== undefined) return loaded.mediaType
+
+  if (Predicate.isTagged(loaded.source, 'File') && loaded.source.mediaType !== undefined)
+    return loaded.source.mediaType
+
+  return Predicate.isTagged(loaded.source, 'Text') ? 'text/plain' : ''
+}
+
+const documentFrom = (
+  loaded: LoadedKnowledgeSource,
+  extracted: ExtractedFile
+): ExtractedKnowledgeDocument => {
+  const { title, ...fileMetadata } = extracted.metadata
+  const metadata = { ...fileMetadata, ...loaded.metadata }
+
+  return title === undefined || title.trim().length === 0
+    ? { content: extracted.content, metadata }
+    : { content: extracted.content, title: title.trim(), metadata }
+}
+
+/**
+ * A `KnowledgeExtractor` backed by a `FileExtractor`. String content is already text and passes
+ * through unchanged (it must not be blank); bytes are extracted with the format chosen from the
+ * source name and media type. File metadata (`format`, `pageCount`, `sheetNames`) is merged
+ * under the loaded source's own metadata, and the extracted title becomes the document title.
+ */
+export const makeFileKnowledgeExtractor = (extractor: FileExtractorApi): KnowledgeExtractorApi => ({
+  extract: loaded => {
+    if (Predicate.isString(loaded.content)) {
+      const content = loaded.content
+
+      return content.trim().length === 0
+        ? Effect.fail(new KnowledgeExtractionError({ message: 'Knowledge source text is empty' }))
+        : Effect.succeed(
+            loaded.metadata === undefined ? { content } : { content, metadata: loaded.metadata }
+          )
+    }
+
+    return extractor
+      .extract({
+        filename: filenameFor(loaded.source),
+        mediaType: mediaTypeFor(loaded),
+        bytes: loaded.content
+      })
+      .pipe(
+        Effect.map(extracted => documentFrom(loaded, extracted)),
+        Effect.mapError(
+          error => new KnowledgeExtractionError({ message: error.message, cause: error })
+        )
+      )
+  }
+})
+
+/** Provide `KnowledgeExtractor` from the `FileExtractor` in context (for example the Node layer). */
+export const FileKnowledgeExtractorLayer = Layer.effect(
+  KnowledgeExtractor,
+  Effect.gen(function* () {
+    const extractor = yield* FileExtractor
+
+    return KnowledgeExtractor.of(makeFileKnowledgeExtractor(extractor))
+  })
+)

package/src/limits.ts

@@ -0,0 +1,49 @@
+import * as Schema from 'effect/Schema'
+
+const PositiveSafeInteger = Schema.Int.pipe(
+  Schema.check(Schema.isGreaterThan(0)),
+  Schema.check(Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER))
+)
+
+/**
+ * Smallest `maxXlsxTextCharacters`: one more than the space always reserved for the
+ * `[Some hyperlinks omitted: output limit and hyperlink limit]` marker (61 characters with its
+ * leading blank line), so a workbook with links can still produce text.
+ */
+export const minimumXlsxTextCharacters = 62
+
+/**
+ * Work and output bounds for one `extract` call. Every value is a positive integer, and
+ * `maxXlsxTextCharacters` is at least `minimumXlsxTextCharacters`.
+ */
+export const FileExtractorLimits = Schema.Struct({
+  /** Input bytes accepted for any format. */
+  maxInputBytes: PositiveSafeInteger,
+  /** Entries in a DOCX, XLSX, or PPTX ZIP archive. */
+  maxArchiveEntries: PositiveSafeInteger,
+  /** Total inflated bytes of a DOCX, XLSX, or PPTX archive, counted while inflating. */
+  maxExpandedBytes: PositiveSafeInteger,
+  /** Worksheets in a workbook. */
+  maxXlsxSheets: PositiveSafeInteger,
+  /** Cells visited across all worksheet ranges (absent cells count too). */
+  maxXlsxCellVisits: PositiveSafeInteger,
+  /** Characters of XLSX text, including hyperlink annotations and the omitted-links marker. */
+  maxXlsxTextCharacters: PositiveSafeInteger.pipe(
+    Schema.check(Schema.isGreaterThanOrEqualTo(minimumXlsxTextCharacters))
+  ),
+  /** Hyperlinks read per workbook; later ones are ignored (still removed before SheetJS). */
+  maxXlsxHyperlinks: PositiveSafeInteger
+})
+
+export type FileExtractorLimits = typeof FileExtractorLimits.Type
+
+/** Default limits; override any of them through `makeFileExtractorLayer({ limits })`. */
+export const defaultFileExtractorLimits: FileExtractorLimits = {
+  maxInputBytes: 50 * 1024 * 1024,
+  maxArchiveEntries: 10_000,
+  maxExpandedBytes: 50 * 1024 * 1024,
+  maxXlsxSheets: 100,
+  maxXlsxCellVisits: 100_000,
+  maxXlsxTextCharacters: 512 * 1024,
+  maxXlsxHyperlinks: 10_000
+}

package/src/node/extract-file.ts

@@ -0,0 +1,269 @@
+import { Buffer } from 'node:buffer'
+import { Effect, Option, Predicate } from 'effect'
+import { FileExtractionError } from '../errors.ts'
+import type { FileExtractorError } from '../errors.ts'
+import type {
+  ExtractedFile,
+  ExtractedFileFormat,
+  ExtractedFileMetadata,
+  FileInput,
+  OfficeFileFormat
+} from '../format.ts'
+import type { FileExtractorLimits } from '../limits.ts'
+import { sanitizeExtractedText } from '../sanitize.ts'
+import { readOfficeArchive, storedArchive } from './office-archive.ts'
+import type { NormalizedOfficeArchive } from './office-archive.ts'
+import { extractPptxText } from './pptx-text.ts'
+import { asXlsxWorkbook, loadSheetJs } from './sheetjs.ts'
+import type { SheetJsLoader } from './sheetjs.ts'
+import { resolveXlsxHyperlinks } from './xlsx-hyperlinks.ts'
+import { buildSheetJsInput } from './xlsx-sheetjs-input.ts'
+import { extractBoundedXlsxText } from './xlsx-text.ts'
+
+/** Formats whose bytes go through a parser (and, by default, an isolated worker). */
+export type ParsedFileFormat = 'pdf' | OfficeFileFormat
+
+export const isParsedFileFormat = (format: ExtractedFileFormat): format is ParsedFileFormat =>
+  format === 'pdf' || format === 'docx' || format === 'pptx' || format === 'xlsx'
+
+/** Sanitize extracted text; empty results fail. */
+export const makeExtractedFile = (content: string, metadata: ExtractedFileMetadata) => {
+  const sanitized = sanitizeExtractedText(content)
+
+  if (sanitized.length === 0)
+    return Effect.fail(
+      new FileExtractionError({
+        message: 'Extracted file content is empty',
+        format: metadata.format
+      })
+    )
+
+  return Effect.succeed<ExtractedFile>({ content: sanitized, metadata })
+}
+
+/**
+ * PDF.js 6 releases a document through its loading task (`PDFDocumentProxy` no longer has
+ * `destroy()`); unpdf releases the documents it opens the same way.
+ */
+type PdfDocumentResource = {
+  readonly loadingTask: { readonly destroy: () => Promise<void> }
+}
+
+/** Run `use` with an opened PDF document and always release the parser afterwards. */
+export const withAcquiredPdfDocument = <D extends PdfDocumentResource, A, E, R>(
+  open: Effect.Effect<D, E, R>,
+  use: (document: D) => Effect.Effect<A, E, R>,
+  format: ExtractedFileFormat
+) =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const document = yield* Effect.acquireRelease(open, document =>
+        Effect.tryPromise({
+          try: () => document.loadingTask.destroy(),
+          catch: () => new FileExtractionError({ message: 'Could not release PDF parser', format })
+        }).pipe(Effect.ignore)
+      )
+
+      return yield* use(document)
+    })
+  )
+
+const extractPdf = (input: FileInput) =>
+  Effect.gen(function* () {
+    // Loaded on first use, so a worker extracting another format never loads PDF.js.
+    const { extractText, getDocumentProxy, getMeta } = yield* Effect.tryPromise({
+      try: () => import('unpdf'),
+      catch: cause =>
+        new FileExtractionError({ message: 'Could not read PDF', format: 'pdf', cause })
+    })
+
+    return yield* withAcquiredPdfDocument(
+      Effect.tryPromise({
+        // PDF.js may detach the buffer it is given; never hand it the caller's bytes.
+        try: () => getDocumentProxy(new Uint8Array(input.bytes)),
+        catch: cause =>
+          new FileExtractionError({ message: 'Could not read PDF', format: 'pdf', cause })
+      }),
+      document =>
+        Effect.gen(function* () {
+          const extracted = yield* Effect.tryPromise({
+            try: () => extractText(document, { mergePages: true }),
+            catch: cause =>
+              new FileExtractionError({
+                message: 'Could not extract PDF text',
+                format: 'pdf',
+                cause
+              })
+          })
+
+          const meta = yield* Effect.tryPromise({
+            try: () => getMeta(document),
+            catch: cause =>
+              new FileExtractionError({
+                message: 'Could not read PDF metadata',
+                format: 'pdf',
+                cause
+              })
+          }).pipe(Effect.option)
+
+          const rawTitle = Option.isSome(meta) ? meta.value.info.Title : undefined
+          const title = Predicate.isString(rawTitle) && rawTitle.length > 0 ? rawTitle : undefined
+
+          const metadata: ExtractedFileMetadata =
+            title === undefined
+              ? { format: 'pdf', pageCount: extracted.totalPages }
+              : { format: 'pdf', title, pageCount: extracted.totalPages }
+
+          return yield* makeExtractedFile(extracted.text, metadata)
+        }),
+      'pdf'
+    )
+  })
+
+const validatedArchive = (
+  input: FileInput,
+  format: OfficeFileFormat,
+  limits: FileExtractorLimits
+): Effect.Effect<NormalizedOfficeArchive, FileExtractionError> =>
+  readOfficeArchive(
+    input.bytes,
+    format,
+    limits,
+    // One extra tag detects a workbook over the cap.
+    format === 'xlsx' ? { maxHyperlinkTags: limits.maxXlsxHyperlinks + 1 } : {}
+  ).pipe(
+    Effect.mapError(
+      error => new FileExtractionError({ message: error.message, format, cause: error })
+    )
+  )
+
+const extractDocx = (input: FileInput, limits: FileExtractorLimits) =>
+  Effect.gen(function* () {
+    const { parts } = yield* validatedArchive(input, 'docx', limits)
+
+    const result = yield* Effect.tryPromise({
+      try: async () => {
+        const { default: mammoth } = await import('mammoth')
+
+        return await mammoth.extractRawText({ buffer: Buffer.from(storedArchive(parts)) })
+      },
+      catch: cause =>
+        new FileExtractionError({ message: 'Could not extract DOCX text', format: 'docx', cause })
+    })
+
+    return yield* makeExtractedFile(result.value, { format: 'docx', title: input.filename })
+  })
+
+/** Keep the first `max` tags in archive order. */
+const capHyperlinkTags = (
+  tagsByPart: ReadonlyMap<string, ReadonlyArray<string>>,
+  max: number
+): ReadonlyMap<string, ReadonlyArray<string>> => {
+  const capped = new Map<string, ReadonlyArray<string>>()
+  let remaining = max
+
+  for (const [part, tags] of tagsByPart) {
+    if (remaining <= 0) break
+
+    const kept = tags.slice(0, remaining)
+    remaining -= kept.length
+    capped.set(part, kept)
+  }
+
+  return capped
+}
+
+const extractXlsx = (input: FileInput, limits: FileExtractorLimits, loader: SheetJsLoader) =>
+  Effect.gen(function* () {
+    const normalized = yield* validatedArchive(input, 'xlsx', limits)
+
+    // SheetJS never sees the uploaded archive: only this allowlisted rebuild of its parts.
+    const sheetJsInput = yield* Effect.try({
+      try: () => buildSheetJsInput(normalized.parts, limits.maxXlsxSheets),
+      catch: cause =>
+        cause instanceof FileExtractionError
+          ? cause
+          : new FileExtractionError({ message: 'Could not read XLSX', format: 'xlsx', cause })
+    })
+
+    const sheetJs = yield* loadSheetJs(loader)
+
+    const parsed = yield* Effect.try({
+      try: () => sheetJs.read(sheetJsInput.archive),
+      catch: cause =>
+        new FileExtractionError({ message: 'Could not read XLSX', format: 'xlsx', cause })
+    })
+
+    const workbook = asXlsxWorkbook(parsed)
+
+    if (workbook === undefined)
+      return yield* Effect.fail(
+        new FileExtractionError({ message: 'Could not read XLSX', format: 'xlsx' })
+      )
+
+    // One extra tag was captured to detect that the workbook exceeds the hyperlink cap.
+    const capturedTags = [...normalized.hyperlinkTags.values()].reduce(
+      (total, tags) => total + tags.length,
+      0
+    )
+
+    const hyperlinksTruncated = capturedTags > limits.maxXlsxHyperlinks
+
+    const hyperlinks = resolveXlsxHyperlinks(
+      normalized.parts,
+      hyperlinksTruncated
+        ? capHyperlinkTags(normalized.hyperlinkTags, limits.maxXlsxHyperlinks)
+        : normalized.hyperlinkTags,
+      sheetJsInput.sheets
+    )
+
+    const content = yield* Effect.try({
+      try: () => extractBoundedXlsxText(workbook, limits, { hyperlinks, hyperlinksTruncated }),
+      catch: cause =>
+        cause instanceof FileExtractionError
+          ? cause
+          : new FileExtractionError({
+              message: 'Could not extract XLSX text',
+              format: 'xlsx',
+              cause
+            })
+    })
+
+    return yield* makeExtractedFile(content, {
+      format: 'xlsx',
+      title: sheetJsInput.title ?? input.filename,
+      sheetNames: workbook.SheetNames
+    })
+  })
+
+const extractPptx = (input: FileInput, limits: FileExtractorLimits) =>
+  Effect.gen(function* () {
+    const { parts } = yield* validatedArchive(input, 'pptx', limits)
+
+    const text = yield* Effect.try({
+      try: () => extractPptxText(parts),
+      catch: cause =>
+        new FileExtractionError({ message: 'Could not extract PPTX text', format: 'pptx', cause })
+    })
+
+    return yield* makeExtractedFile(text, { format: 'pptx', title: input.filename })
+  })
+
+/**
+ * Extract a PDF, DOCX, XLSX, or PPTX file in the current thread. The Node layer runs this inside
+ * an isolated worker unless `isolation: 'none'` is configured.
+ */
+export const extractParsedFile = (
+  input: FileInput,
+  format: ParsedFileFormat,
+  limits: FileExtractorLimits,
+  loader: SheetJsLoader
+): Effect.Effect<ExtractedFile, FileExtractorError> => {
+  if (format === 'pdf') return extractPdf(input)
+
+  if (format === 'docx') return extractDocx(input, limits)
+
+  if (format === 'xlsx') return extractXlsx(input, limits, loader)
+
+  return extractPptx(input, limits)
+}