@gmickel/gno 1.46.0 → 2.0.0

package/vendor/converters/officeparser/dist/utils/zipUtils.d.ts

@@ -0,0 +1,134 @@
+/**
+ * ZIP Archive Extraction Utilities
+ *
+ * Provides functions for extracting files from ZIP archives.
+ * Essential for parsing OOXML (DOCX, XLSX, PPTX) and ODF (ODT, ODP, ODS) files,
+ * which are all ZIP archives containing XML and media files.
+ *
+ * Office File Structure:
+ * - DOCX: ZIP containing word/document.xml, word/styles.xml, word/media/*, etc.
+ * - XLSX: ZIP containing xl/workbook.xml, xl/worksheets/sheet1.xml, etc.
+ * - PPTX: ZIP containing ppt/slides/slide1.xml, ppt/media/*, etc.
+ * - ODF: Similar structure with content.xml, styles.xml, etc.
+ *
+ * @module zipUtils
+ */
+import { DecompressionLimits, OfficeParserConfig, SupportedFileType } from '../types.js';
+/**
+ * Represents a file extracted from a ZIP archive.
+ * Contains the file's path within the archive and its content as a Buffer.
+ */
+export interface ZipFileContent {
+    /**
+     * The relative path of the file within the ZIP archive.
+     * @example "word/document.xml", "xl/worksheets/sheet1.xml", "ppt/slides/slide1.xml"
+     */
+    path: string;
+    /**
+     * The file content as a Node.js Buffer.
+     * Can be converted to string for XML files or used directly for binary files (images, etc.).
+     * @example Buffer containing XML text or binary image data
+     */
+    content: Buffer;
+}
+/**
+ * Extracts files from a ZIP archive with optional filtering.
+ *
+ * This function:
+ * 1. Opens the ZIP archive from a Buffer
+ * 2. Iterates through all entries in the archive
+ * 3. Applies a filter function to determine which files to extract
+ * 4. Extracts matching files and returns them as an array
+ *
+ * Uses lazy entry reading for better memory efficiency with large archives.
+ * Files are extracted asynchronously and collected into an array.
+ *
+ * @param zipInput - The ZIP file as a Node.js Buffer
+ * @param filterFn - A predicate function to determine which files to extract.
+ *                   Receives the filename and returns true to extract, false to skip.
+ * @param limits - Decompression limits guarding against zip bombs
+ * @param config - Parser configuration, so extraction failures honour `onWarning` /
+ *                 `outputErrorToConsole` like every other reported issue
+ * @returns A promise resolving to an array of extracted files
+ * @throws {Error} If the ZIP file cannot be opened or an entry cannot be read
+ *
+ * @example
+ * ```typescript
+ * // Extract only XML files from a DOCX
+ * const files = await extractFiles(docxBuffer, (fileName) => fileName.endsWith('.xml'));
+ *
+ * // Extract document.xml specifically
+ * const files = await extractFiles(docxBuffer, (fileName) =>
+ *   fileName === 'word/document.xml'
+ * );
+ *
+ * // Extract all files
+ * const allFiles = await extractFiles(zipBuffer, () => true);
+ *
+ * // Extract everything except media files
+ * const files = await extractFiles(zipBuffer, (fileName) =>
+ *   !fileName.startsWith('word/media/')
+ * );
+ * ```
+ *
+ * @see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT ZIP file format specification
+ */
+export declare const extractFiles: (zipInput: Buffer, filterFn: (fileName: string) => boolean, limits: DecompressionLimits, config?: OfficeParserConfig) => Promise<ZipFileContent[]>;
+/**
+ * Finds the archive part that every document of a given format must contain, and fails loudly
+ * when it is absent.
+ *
+ * A readable ZIP archive is not by itself a document: an archive can decompress perfectly and
+ * still be a renamed photo bundle, a partial upload, or a file mislabeled with the wrong
+ * extension. Without this check a parser finds no content to walk and returns an empty AST,
+ * which a caller cannot distinguish from a document that genuinely has nothing in it. Every
+ * ZIP-backed format has one part it cannot be valid without, so its absence is a hard error.
+ *
+ * Pass the parser's own regex/predicate for the part rather than a fresh copy of the path, so
+ * this check and the code that later reads the part cannot drift apart.
+ *
+ * @param files - The entries extracted from the archive
+ * @param matcher - Predicate identifying the required part by its path within the archive
+ * @param config - Parser configuration, so the error is reported through the caller's handlers
+ * @param info - The document format and the human-readable part name, used in the message
+ * @returns The matching entry
+ * @throws {Error} A typed REQUIRED_PART_MISSING error when no entry matches
+ *
+ * @example
+ * ```typescript
+ * const document = findRequiredPart(files, p => !!p.match(documentFileRegex), config,
+ *     { fileType: 'docx', part: 'word/document.xml' });
+ * ```
+ */
+export declare const findRequiredPart: (files: ZipFileContent[], matcher: (path: string) => boolean, config: OfficeParserConfig, info: {
+    fileType: string;
+    part: string;
+}) => ZipFileContent;
+/**
+ * Resolves which office format a ZIP archive actually holds, by reading the part that names it.
+ *
+ * This exists because magic-byte sniffing is a heuristic that gives up. `file-type` identifies an
+ * OOXML package by parsing `[Content_Types].xml`, but it walks the archive under fixed budgets:
+ * at most 1024 entries, and (for entries whose sizes are deferred to a trailing data descriptor,
+ * general-purpose flag bit 3) about 1 MiB of scanning to locate those descriptors. An archive
+ * that puts enough data before `[Content_Types].xml` to exhaust either budget is reported as a
+ * generic `zip`, which previously surfaced to the caller as "add support for zip files" for a
+ * perfectly valid document. Both layouts occur in the wild: streaming ZIP writers set bit 3, and
+ * a media-heavy deck can hold more than 1024 parts.
+ *
+ * We already ship a ZIP reader that has neither limitation, so rather than guessing from the
+ * first bytes this opens the archive and reads the declaration directly. It is deliberately the
+ * fallback rather than the primary check, since the byte-level sniff is far cheaper and settles
+ * every non-ZIP format.
+ *
+ * @param zipInput - The candidate archive
+ * @param limits - Decompression limits, so sniffing an untrusted file stays bounded
+ * @returns The format the archive declares, or `undefined` if it declares none or cannot be read
+ *
+ * @example
+ * ```typescript
+ * // A presentation whose [Content_Types].xml sits behind 2 MiB of streamed entries
+ * await detectOfficeTypeFromZip(buffer, limits); // -> 'pptx'
+ * ```
+ */
+export declare const detectOfficeTypeFromZip: (zipInput: Buffer, limits: DecompressionLimits) => Promise<SupportedFileType | undefined>;

package/vendor/converters/officeparser/dist/utils/zipUtils.js

@@ -0,0 +1,337 @@
+"use strict";
+/**
+ * ZIP Archive Extraction Utilities
+ *
+ * Provides functions for extracting files from ZIP archives.
+ * Essential for parsing OOXML (DOCX, XLSX, PPTX) and ODF (ODT, ODP, ODS) files,
+ * which are all ZIP archives containing XML and media files.
+ *
+ * Office File Structure:
+ * - DOCX: ZIP containing word/document.xml, word/styles.xml, word/media/*, etc.
+ * - XLSX: ZIP containing xl/workbook.xml, xl/worksheets/sheet1.xml, etc.
+ * - PPTX: ZIP containing ppt/slides/slide1.xml, ppt/media/*, etc.
+ * - ODF: Similar structure with content.xml, styles.xml, etc.
+ *
+ * @module zipUtils
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectOfficeTypeFromZip = exports.findRequiredPart = exports.extractFiles = void 0;
+const fflate_1 = require("fflate");
+const types_js_1 = require("../types.js");
+const errorUtils_js_1 = require("./errorUtils.js");
+/**
+ * Signature of the End Of Central Directory record ("PK\x05\x06"), the trailer every ZIP
+ * archive ends with. Its presence is what distinguishes a complete archive from one that
+ * was cut off in transfer.
+ */
+const EOCD_SIGNATURE = Buffer.from([0x50, 0x4b, 0x05, 0x06]);
+/** Size of the fixed portion of an End Of Central Directory record, in bytes. */
+const EOCD_RECORD_MIN_BYTES = 22;
+/** Maximum size of the optional archive comment that may trail the EOCD record, in bytes. */
+const ZIP_MAX_COMMENT_BYTES = 65535;
+/**
+ * How far back from the end of the input the EOCD record may start. The record is last in
+ * the file apart from its own variable-length comment, so searching this window is
+ * sufficient and bounded regardless of archive size.
+ */
+const EOCD_SEARCH_WINDOW_BYTES = EOCD_RECORD_MIN_BYTES + ZIP_MAX_COMMENT_BYTES;
+/**
+ * Extracts files from a ZIP archive with optional filtering.
+ *
+ * This function:
+ * 1. Opens the ZIP archive from a Buffer
+ * 2. Iterates through all entries in the archive
+ * 3. Applies a filter function to determine which files to extract
+ * 4. Extracts matching files and returns them as an array
+ *
+ * Uses lazy entry reading for better memory efficiency with large archives.
+ * Files are extracted asynchronously and collected into an array.
+ *
+ * @param zipInput - The ZIP file as a Node.js Buffer
+ * @param filterFn - A predicate function to determine which files to extract.
+ *                   Receives the filename and returns true to extract, false to skip.
+ * @param limits - Decompression limits guarding against zip bombs
+ * @param config - Parser configuration, so extraction failures honour `onWarning` /
+ *                 `outputErrorToConsole` like every other reported issue
+ * @returns A promise resolving to an array of extracted files
+ * @throws {Error} If the ZIP file cannot be opened or an entry cannot be read
+ *
+ * @example
+ * ```typescript
+ * // Extract only XML files from a DOCX
+ * const files = await extractFiles(docxBuffer, (fileName) => fileName.endsWith('.xml'));
+ *
+ * // Extract document.xml specifically
+ * const files = await extractFiles(docxBuffer, (fileName) =>
+ *   fileName === 'word/document.xml'
+ * );
+ *
+ * // Extract all files
+ * const allFiles = await extractFiles(zipBuffer, () => true);
+ *
+ * // Extract everything except media files
+ * const files = await extractFiles(zipBuffer, (fileName) =>
+ *   !fileName.startsWith('word/media/')
+ * );
+ * ```
+ *
+ * @see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT ZIP file format specification
+ */
+const extractFiles = (zipInput, filterFn, limits, config) => {
+    const maxUncompressedBytes = limits?.maxUncompressedBytes !== undefined && Number.isFinite(limits.maxUncompressedBytes) && limits.maxUncompressedBytes >= 0
+        ? limits.maxUncompressedBytes
+        : 512 * 1024 * 1024;
+    const maxZipEntries = limits?.maxZipEntries !== undefined && Number.isFinite(limits.maxZipEntries) && limits.maxZipEntries >= 0
+        ? limits.maxZipEntries
+        : 10000;
+    return new Promise((resolve, reject) => {
+        // Decompress as a stream and cap on the ACTUAL inflated byte count rather than
+        // the size declared in the ZIP header. The declared size is attacker-controlled,
+        // so a "zip bomb" can understate it and still inflate to gigabytes; counting real
+        // output bytes and aborting once the limit is crossed is the only reliable guard.
+        const results = [];
+        let totalEntryCount = 0;
+        let actualTotalBytes = 0;
+        let pendingFiles = 0;
+        let pushComplete = false;
+        let settled = false;
+        const fail = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(err);
+        };
+        const maybeResolve = () => {
+            if (!settled && pushComplete && pendingFiles === 0) {
+                settled = true;
+                resolve(results);
+            }
+        };
+        const unzipper = new fflate_1.Unzip((file) => {
+            if (settled)
+                return;
+            totalEntryCount++;
+            if (totalEntryCount > maxZipEntries) {
+                fail((0, errorUtils_js_1.getOfficeError)(types_js_1.OfficeErrorType.ZIP_ENTRY_COUNT_LIMIT_EXCEEDED, config, maxZipEntries));
+                return;
+            }
+            if (!filterFn(file.name))
+                return;
+            const name = file.name;
+            const chunks = [];
+            pendingFiles++;
+            file.ondata = (err, chunk, final) => {
+                if (settled)
+                    return;
+                if (err) {
+                    fail(err);
+                    return;
+                }
+                if (chunk && chunk.length) {
+                    actualTotalBytes += chunk.length;
+                    if (actualTotalBytes > maxUncompressedBytes) {
+                        fail((0, errorUtils_js_1.getOfficeError)(types_js_1.OfficeErrorType.ZIP_SIZE_LIMIT_EXCEEDED, config, maxUncompressedBytes));
+                        return;
+                    }
+                    chunks.push(Buffer.from(chunk));
+                }
+                if (final) {
+                    results.push({ path: name, content: Buffer.concat(chunks) });
+                    pendingFiles--;
+                    maybeResolve();
+                }
+            };
+            try {
+                file.start();
+            }
+            catch (e) {
+                fail(e);
+            }
+        });
+        unzipper.register(fflate_1.UnzipInflate);
+        const src = new Uint8Array(zipInput.buffer, zipInput.byteOffset, zipInput.byteLength);
+        // Feed the compressed input in bounded chunks so the actual-size check can abort a
+        // bomb early; the worst-case overshoot is one chunk's worth of inflation.
+        const PUSH_CHUNK = 1 << 16; // 64 KiB
+        try {
+            let offset = 0;
+            while (offset < src.length && !settled) {
+                const end = Math.min(offset + PUSH_CHUNK, src.length);
+                unzipper.push(src.subarray(offset, end), end >= src.length);
+                offset = end;
+            }
+        }
+        catch (e) {
+            fail(e);
+            return;
+        }
+        pushComplete = true;
+        // fflate's streaming Unzip emits nothing, and no error, when the input is not a
+        // ZIP archive, unlike the central-directory-based unzip() this replaced (which
+        // rejected with "invalid zip data"). Zero entries can never be a valid document
+        // here, since every ZIP-backed format requires at least one part, so treat it as
+        // corrupt input rather than resolving into an empty, successfully-parsed document.
+        //
+        // This is checked before the truncation check below because it produces the better
+        // message for input that is not an archive at all, and because garbage that happens
+        // to contain the EOCD signature would otherwise slip past.
+        if (totalEntryCount === 0) {
+            fail((0, errorUtils_js_1.getOfficeError)(types_js_1.OfficeErrorType.ZIP_NO_ENTRIES_FOUND, config));
+            return;
+        }
+        // The streaming reader recovers entries from local file headers alone, so an archive
+        // cut short still yields whatever entries preceded the cut - silently, and possibly
+        // missing parts that came after it. The central-directory-based reader used before
+        // 7.3.0 rejected such input outright. Requiring the trailer that terminates every
+        // complete archive restores that: absent it, the data is truncated and the entries
+        // recovered cannot be trusted to be the whole document.
+        //
+        // Deliberately not gated on pendingFiles: when a cut lands inside an entry's
+        // compressed data that entry's final callback never fires, so this is also what
+        // settles the promise instead of leaving the caller waiting forever.
+        const tail = zipInput.subarray(Math.max(0, zipInput.length - EOCD_SEARCH_WINDOW_BYTES));
+        const eocdIndex = tail.lastIndexOf(EOCD_SIGNATURE);
+        if (eocdIndex === -1 || eocdIndex + EOCD_RECORD_MIN_BYTES > tail.length) {
+            fail((0, errorUtils_js_1.getOfficeError)(types_js_1.OfficeErrorType.ZIP_TRUNCATED, config));
+            return;
+        }
+        maybeResolve();
+    });
+};
+exports.extractFiles = extractFiles;
+/**
+ * Finds the archive part that every document of a given format must contain, and fails loudly
+ * when it is absent.
+ *
+ * A readable ZIP archive is not by itself a document: an archive can decompress perfectly and
+ * still be a renamed photo bundle, a partial upload, or a file mislabeled with the wrong
+ * extension. Without this check a parser finds no content to walk and returns an empty AST,
+ * which a caller cannot distinguish from a document that genuinely has nothing in it. Every
+ * ZIP-backed format has one part it cannot be valid without, so its absence is a hard error.
+ *
+ * Pass the parser's own regex/predicate for the part rather than a fresh copy of the path, so
+ * this check and the code that later reads the part cannot drift apart.
+ *
+ * @param files - The entries extracted from the archive
+ * @param matcher - Predicate identifying the required part by its path within the archive
+ * @param config - Parser configuration, so the error is reported through the caller's handlers
+ * @param info - The document format and the human-readable part name, used in the message
+ * @returns The matching entry
+ * @throws {Error} A typed REQUIRED_PART_MISSING error when no entry matches
+ *
+ * @example
+ * ```typescript
+ * const document = findRequiredPart(files, p => !!p.match(documentFileRegex), config,
+ *     { fileType: 'docx', part: 'word/document.xml' });
+ * ```
+ */
+const findRequiredPart = (files, matcher, config, info) => {
+    const found = files.find(file => matcher(file.path));
+    if (!found)
+        throw (0, errorUtils_js_1.getOfficeError)(types_js_1.OfficeErrorType.REQUIRED_PART_MISSING, config, info);
+    return found;
+};
+exports.findRequiredPart = findRequiredPart;
+/** The part naming an OOXML package's document type. */
+const OOXML_CONTENT_TYPES_PATH = '[Content_Types].xml';
+/** The part naming an ODF or EPUB package's document type. */
+const ODF_MIMETYPE_PATH = 'mimetype';
+/**
+ * Substrings of the main-part content type each OOXML format declares in
+ * `[Content_Types].xml`, matched as plain text because only this one value is needed.
+ */
+const OOXML_MAIN_CONTENT_TYPES = [
+    ['wordprocessingml.document.main+xml', 'docx'],
+    ['spreadsheetml.sheet.main+xml', 'xlsx'],
+    ['presentationml.presentation.main+xml', 'pptx'],
+];
+/** Exact `mimetype` entry contents for the packages that carry one. */
+const PACKAGE_MIMETYPES = {
+    'application/vnd.oasis.opendocument.text': 'odt',
+    'application/vnd.oasis.opendocument.spreadsheet': 'ods',
+    'application/vnd.oasis.opendocument.presentation': 'odp',
+    'application/epub+zip': 'epub',
+};
+/** First two bytes of every ZIP local file header ("PK"). */
+const ZIP_MAGIC_BYTES = [0x50, 0x4b];
+/**
+ * Reporting is suppressed while sniffing: the input is not yet known to be a document, so a
+ * failure here is an inconclusive guess rather than something the caller did wrong. Without a
+ * config, `getOfficeError` would write these to the console.
+ */
+const SILENT_DETECTION_CONFIG = { outputErrorToConsole: false };
+/** Whether a buffer starts with the ZIP local file header signature. */
+const looksLikeZip = (buffer) => buffer.length >= ZIP_MAGIC_BYTES.length && ZIP_MAGIC_BYTES.every((byte, i) => buffer[i] === byte);
+/**
+ * How much a type sniff may inflate before giving up, in bytes.
+ *
+ * The two parts read here name the format and nothing else, so they are tiny in any real
+ * document: a few hundred bytes of `mimetype`, a few kilobytes of `[Content_Types].xml`. A
+ * crafted archive could declare them as hundreds of megabytes, and since the document is
+ * inflated again during the parse that follows, honouring the full decompression budget here
+ * would let a single call spend it twice. This cap keeps sniffing cheap; an archive that
+ * exceeds it is simply reported as unidentified.
+ */
+const MAX_DETECTION_INFLATED_BYTES = 4 * 1024 * 1024;
+/**
+ * Resolves which office format a ZIP archive actually holds, by reading the part that names it.
+ *
+ * This exists because magic-byte sniffing is a heuristic that gives up. `file-type` identifies an
+ * OOXML package by parsing `[Content_Types].xml`, but it walks the archive under fixed budgets:
+ * at most 1024 entries, and (for entries whose sizes are deferred to a trailing data descriptor,
+ * general-purpose flag bit 3) about 1 MiB of scanning to locate those descriptors. An archive
+ * that puts enough data before `[Content_Types].xml` to exhaust either budget is reported as a
+ * generic `zip`, which previously surfaced to the caller as "add support for zip files" for a
+ * perfectly valid document. Both layouts occur in the wild: streaming ZIP writers set bit 3, and
+ * a media-heavy deck can hold more than 1024 parts.
+ *
+ * We already ship a ZIP reader that has neither limitation, so rather than guessing from the
+ * first bytes this opens the archive and reads the declaration directly. It is deliberately the
+ * fallback rather than the primary check, since the byte-level sniff is far cheaper and settles
+ * every non-ZIP format.
+ *
+ * @param zipInput - The candidate archive
+ * @param limits - Decompression limits, so sniffing an untrusted file stays bounded
+ * @returns The format the archive declares, or `undefined` if it declares none or cannot be read
+ *
+ * @example
+ * ```typescript
+ * // A presentation whose [Content_Types].xml sits behind 2 MiB of streamed entries
+ * await detectOfficeTypeFromZip(buffer, limits); // -> 'pptx'
+ * ```
+ */
+const detectOfficeTypeFromZip = async (zipInput, limits) => {
+    if (!looksLikeZip(zipInput))
+        return undefined;
+    let files;
+    try {
+        files = await (0, exports.extractFiles)(zipInput, name => name === OOXML_CONTENT_TYPES_PATH || name === ODF_MIMETYPE_PATH, 
+        // Never inflate more for a sniff than the caller already allows for the parse, and
+        // never more than a sniff could legitimately need.
+        {
+            ...limits,
+            maxUncompressedBytes: Math.min(limits?.maxUncompressedBytes ?? MAX_DETECTION_INFLATED_BYTES, MAX_DETECTION_INFLATED_BYTES),
+        }, SILENT_DETECTION_CONFIG);
+    }
+    catch {
+        // Unreadable, truncated, or not an archive at all. The caller keeps whatever the
+        // byte-level sniff decided, and the parser it dispatches to reports the real problem.
+        return undefined;
+    }
+    // ODF and EPUB state their type outright, so prefer that over inspecting OOXML parts.
+    const mimetypeEntry = files.find(file => file.path === ODF_MIMETYPE_PATH);
+    if (mimetypeEntry) {
+        const declared = PACKAGE_MIMETYPES[mimetypeEntry.content.toString().trim()];
+        if (declared)
+            return declared;
+    }
+    const contentTypesEntry = files.find(file => file.path === OOXML_CONTENT_TYPES_PATH);
+    if (contentTypesEntry) {
+        const contentTypes = contentTypesEntry.content.toString();
+        const match = OOXML_MAIN_CONTENT_TYPES.find(([marker]) => contentTypes.includes(marker));
+        if (match)
+            return match[1];
+    }
+    return undefined;
+};
+exports.detectOfficeTypeFromZip = detectOfficeTypeFromZip;

package/vendor/converters/officeparser/package.json

@@ -0,0 +1,147 @@
+{
+  "name": "officeparser",
+  "version": "7.8.0",
+  "description": "A robust, strictly-typed Node.js and Browser library for parsing office files (.docx, .pptx, .xlsx, .odt, .odp, .ods, .pdf, .rtf, .csv, .md, .html, .epub) and generating high-fidelity outputs in Markdown, HTML, CSV, RTF, PDF, EPUB, and RAG-focused chunks.",
+  "funding": "https://github.com/sponsors/harshankur",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "browser": "./dist/officeparser.browser.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "browser": "./dist/officeparser.browser.mjs",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./slim": {
+      "types": "./dist/officeparser.browser.slim.d.ts",
+      "browser": "./dist/officeparser.browser.slim.mjs",
+      "import": "./dist/officeparser.browser.slim.mjs"
+    }
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "npm run sync:versions && npm run build:node && npm run build:esm-wrapper && npm run build:browser:types && npm run build:browser",
+    "build:node": "tsc",
+    "build:esm-wrapper": "node scripts/generate-esm-wrapper.js",
+    "build:browser:types": "dts-bundle-generator --no-check -o dist/officeparser.browser.d.ts src/index.ts && node -e \"require('fs').copyFileSync('dist/officeparser.browser.d.ts','dist/officeparser.browser.slim.d.ts')\"",
+    "build:browser": "node build_browser.js && npm run sync:docs",
+    "sync:versions": "node scripts/sync-pdfjs-versions.js",
+    "sync:docs": "node -e \"const fs=require('fs');fs.mkdirSync('docs/dist',{recursive:true});for(const f of ['officeparser.browser.iife.js','officeparser.browser.mjs','officeparser.browser.slim.iife.js','officeparser.browser.slim.mjs'])fs.copyFileSync('dist/'+f,'docs/dist/'+f);fs.mkdirSync('docs/test/files',{recursive:true});fs.cpSync('test/files','docs/test/files',{recursive:true})\"",
+    "lint": "eslint src",
+    "test": "npm run lint && npm run test:clean && npm run build && npm run test:license && npm run test:artifacts && npm run test:parser && npm run test:exhaustive && npm run test:generator && npm run test:security && npm run test:cli",
+    "test:fast": "npm run lint && npm run test:parser:fast && npm run test:exhaustive && npm run test:generator:fast && npm run test:security && npm run test:cli:fast",
+    "test:exhaustive": "npx tsx test/testExhaustive.ts",
+    "test:security": "npx tsx test/security/testSanitization.ts",
+    "test:baseline": "npm run test:parser:baseline && npm run test:generator:baseline",
+    "test:parser": "npx tsx test/parser/testOfficeParser.ts",
+    "test:parser:fast": "npx tsx test/parser/testOfficeParser.ts fast",
+    "test:parser:baseline": "npx tsx test/parser/testOfficeParser.ts baseline",
+    "test:generator": "npx tsx test/generator/testOfficeGenerator.ts",
+    "test:generator:fast": "npx tsx test/generator/testOfficeGenerator.ts fast",
+    "test:generator:baseline": "npx tsx test/generator/testOfficeGenerator.ts baseline",
+    "test:artifacts": "npx tsx test/testShippingArtifacts.ts",
+    "test:cli": "npx tsx test/cli/testCli.ts",
+    "test:cli:fast": "npx tsx test/cli/testCli.ts fast",
+    "test:visualizer": "node test/testVisualizer.js",
+    "test:integration": "node test/testIntegration.js",
+    "test:license": "npm run sbom && node scripts/validate-licenses.js",
+    "test:clean": "node -e \"for(const d of ['test/results','test/generator/results','test/generator/output','test/parser/results','test/parser/output','test/cli/results'])require('fs').rmSync(d,{recursive:true,force:true})\"",
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && npm run test:clean",
+    "sbom": "npx --yes @cyclonedx/cyclonedx-npm --output-format json --output-file dist/sbom.cdx.json --omit dev",
+    "prepublishOnly": "npm run build",
+    "prepare": "husky"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/harshankur/officeParser.git"
+  },
+  "bin": {
+    "officeparser": "dist/cli.js"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "keywords": [
+    "office",
+    "docx",
+    "pptx",
+    "xlsx",
+    "odt",
+    "odp",
+    "ods",
+    "pdf",
+    "rtf",
+    "csv",
+    "parser",
+    "text extraction",
+    "document parser",
+    "word",
+    "excel",
+    "powerpoint",
+    "spreadsheet",
+    "presentation",
+    "slides",
+    "ast",
+    "ocr",
+    "typescript",
+    "browser",
+    "metadata",
+    "formatting",
+    "attachments",
+    "tesseract",
+    "pdf.js",
+    "structured-data",
+    "openoffice",
+    "libreoffice",
+    "generator",
+    "rag",
+    "chunking",
+    "markdown",
+    "html",
+    "epub",
+    "ebook"
+  ],
+  "author": "Harsh Ankur",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/harshankur/officeParser/issues"
+  },
+  "homepage": "https://officeparser.harshankur.com",
+  "dependencies": {
+    "@xmldom/xmldom": "^0.9.10",
+    "fflate": "^0.8.3",
+    "file-type": "^22.0.1",
+    "pdfjs-dist": "6.1.200",
+    "tesseract.js": "^7.0.0"
+  },
+  "peerDependenciesMeta": {
+    "puppeteer": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.1",
+    "@typescript-eslint/eslint-plugin": "^8.65.0",
+    "@typescript-eslint/parser": "^8.65.0",
+    "buffer": "^6.0.3",
+    "dts-bundle-generator": "^9.5.1",
+    "esbuild": "^0.28.1",
+    "esbuild-plugins-node-modules-polyfill": "^1.8.2",
+    "eslint": "^10.8.0",
+    "husky": "^9.1.7",
+    "postject": "^1.0.0-alpha.6",
+    "process": "^0.11.10",
+    "puppeteer": "^24.43.1",
+    "tsx": "^4.23.1",
+    "typescript": "^6.0.3"
+  }
+}