officeparser 6.0.6 → 6.1.0

package/dist/utils/xmlUtils.d.ts

@@ -10,23 +10,22 @@
  * @module xmlUtils
  */
 import { OfficeMetadata } from '../types';
+/**
+ * Type guard for Element nodes.
+ */
+export declare const isElement: (node: Node) => node is Element;
 /**
  * Parses an XML string into a DOM Document object.
  *
  * Uses the @xmldom/xmldom library to parse XML strings in a Node.js environment.
- * This is necessary because Node.js doesn't have a built-in DOM parser like browsers do.
  *
  * @param xml - The XML content as a string
+ * @param options - Optional parser settings (e.g., enable locators for source mapping)
  * @returns A Document object that can be queried using standard DOM methods
- * @example
- * ```typescript
- * const xmlString = '<root><item>Hello</item></root>';
- * const doc = parseXmlString(xmlString);
- * const items = doc.getElementsByTagName('item');
- * console.log(items[0].textContent); // "Hello"
- * ```
  */
-export declare const parseXmlString: (xml: string) => Document;
+export declare const parseXmlString: (xml: string, options?: {
+    locator?: boolean;
+}) => Document;
 /**
  * Gets all elements with a specific tag name and returns them as an array.
  *
@@ -43,6 +42,54 @@ export declare const parseXmlString: (xml: string) => Document;
  * ```
  */
 export declare const getElementsByTagName: (element: Element | Document, tagName: string) => Element[];
+/**
+ * Serializes a DOM Node (Document, Element, etc.) back into an XML string.
+ * This is cross-platform and works in both Node.js and Browser environments.
+ *
+ * @param node - The DOM node to serialize
+ * @param options - Serialization options
+ * @returns The XML string representation
+ */
+export declare const serializeXml: (node: Node, options?: {
+    preserveWhitespace?: boolean;
+}) => string;
+/**
+ * Attempts to extract the original raw substring from the source XML for a given node.
+ * Requires the document to have been parsed with { locator: true }.
+ *
+ * @param node - The DOM node to extract source for
+ * @param sourceXml - The original XML source string
+ * @returns The raw XML substring, or undefined if it cannot be reliably determined
+ */
+export declare const getSourceSubstring: (node: any, sourceXml: string) => string | undefined;
+/**
+ * High-level helper to get raw content for a node based on OfficeParserConfig.
+ *
+ * @param node - The DOM node
+ * @param sourceXml - The original source XML string
+ * @param config - The parser configuration
+ * @returns The raw content string (serialized or original)
+ */
+export declare const getRawContent: (node: Node, sourceXml: string, config: {
+    serializeRawContent?: boolean;
+    preserveXmlWhitespace?: boolean;
+}) => string;
+/**
+ * Gets the first element with the specified tag name within a parent element.
+ *
+ * @param parent - The parent element or document to search within
+ * @param tagName - The tag name to search for
+ * @returns The first matching element, or undefined if none found
+ */
+export declare const getFirstElementByTagName: (parent: Element | Document, tagName: string) => Element | undefined;
+/**
+ * Gets the value of an attribute from an element.
+ *
+ * @param element - The element to get the attribute from
+ * @param attrName - The name of the attribute
+ * @returns The attribute value or undefined if not set
+ */
+export declare const getAttribute: (element: Element, attrName: string) => string | undefined;
 /**
  * Gets direct child elements with a specific tag name.
  * Unlike getElementsByTagName, this does not search recursively.
@@ -81,3 +128,27 @@ export declare const getDirectChildren: (parent: Element, tagName: string) => El
  * @see https://learn.microsoft.com/en-us/openspecs/office_standards/ms-oe376/6c085e39-c695-4f83-91e8-3f277bb4e111
  */
 export declare const parseOfficeMetadata: (xmlContent: string) => OfficeMetadata;
+/**
+ * Parses OOXML custom document properties from `docProps/custom.xml`.
+ *
+ * Custom properties are user-defined key/value pairs that authors can attach to OOXML documents
+ * (DOCX, XLSX, PPTX). They are stored in `docProps/custom.xml` inside the ZIP archive.
+ *
+ * Property values are typed using the `vt:` namespace (docPropsVTypes):
+ * - `vt:lpwstr` / `vt:lpstr` / `vt:bstr` → string
+ * - `vt:bool` → boolean
+ * - `vt:i1`..`vt:i8`, `vt:int`, `vt:r4`, `vt:r8`, `vt:decimal` → number
+ * - `vt:filetime` / `vt:date` → Date
+ *
+ * @param xmlContent - Raw XML string from `docProps/custom.xml`
+ * @returns A record of property name → typed value (empty object if none found)
+ * @example
+ * ```typescript
+ * const customXml = files.find(f => f.path === 'docProps/custom.xml').content.toString();
+ * const props = parseOOXMLCustomProperties(customXml);
+ * console.log(props['Department']); // "Engineering"
+ * console.log(props['Priority']);   // 1  (number)
+ * console.log(props['Reviewed']);   // true (boolean)
+ * ```
+ */
+export declare const parseOOXMLCustomProperties: (xmlContent: string) => Record<string, string | number | boolean | Date>;

package/dist/utils/xmlUtils.js

@@ -11,27 +11,32 @@
  * @module xmlUtils
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseOfficeMetadata = exports.getDirectChildren = exports.getElementsByTagName = exports.parseXmlString = void 0;
+exports.parseOOXMLCustomProperties = exports.parseOfficeMetadata = exports.getDirectChildren = exports.getAttribute = exports.getFirstElementByTagName = exports.getRawContent = exports.getSourceSubstring = exports.serializeXml = exports.getElementsByTagName = exports.parseXmlString = exports.isElement = void 0;
 const xmldom_1 = require("@xmldom/xmldom");
+const dateUtils_js_1 = require("./dateUtils.js");
+/**
+ * Type guard for Element nodes.
+ */
+const isElement = (node) => {
+    return node.nodeType === 1;
+};
+exports.isElement = isElement;
 /**
  * Parses an XML string into a DOM Document object.
  *
  * Uses the @xmldom/xmldom library to parse XML strings in a Node.js environment.
- * This is necessary because Node.js doesn't have a built-in DOM parser like browsers do.
  *
  * @param xml - The XML content as a string
+ * @param options - Optional parser settings (e.g., enable locators for source mapping)
  * @returns A Document object that can be queried using standard DOM methods
- * @example
- * ```typescript
- * const xmlString = '<root><item>Hello</item></root>';
- * const doc = parseXmlString(xmlString);
- * const items = doc.getElementsByTagName('item');
- * console.log(items[0].textContent); // "Hello"
- * ```
  */
-const parseXmlString = (xml) => {
-    const parser = new xmldom_1.DOMParser();
-    return parser.parseFromString(xml, "text/xml");
+const parseXmlString = (xml, options = {}) => {
+    const parser = new xmldom_1.DOMParser(options);
+    // @xmldom/xmldom 0.9.x is strict: a UTF-8 BOM (U+FEFF) prepended to the
+    // XML string causes a fatalError because the XML declaration is no longer
+    // at position 0. Strip it before parsing.
+    const sanitized = xml.charCodeAt(0) === 0xFEFF ? xml.slice(1) : xml.trim();
+    return parser.parseFromString(sanitized, "text/xml");
 };
 exports.parseXmlString = parseXmlString;
 /**
@@ -50,9 +55,115 @@ exports.parseXmlString = parseXmlString;
  * ```
  */
 const getElementsByTagName = (element, tagName) => {
-    return Array.from(element.getElementsByTagName(tagName));
+    const results = Array.from(element.getElementsByTagName(tagName));
+    // Resilience: If prefixed tag (e.g., 'dc:title') not found, try local name (e.g., 'title')
+    if (results.length === 0 && tagName.includes(':')) {
+        const localName = tagName.split(':').pop();
+        return Array.from(element.getElementsByTagName(localName));
+    }
+    return results;
 };
 exports.getElementsByTagName = getElementsByTagName;
+/**
+ * Serializes a DOM Node (Document, Element, etc.) back into an XML string.
+ * This is cross-platform and works in both Node.js and Browser environments.
+ *
+ * @param node - The DOM node to serialize
+ * @param options - Serialization options
+ * @returns The XML string representation
+ */
+const serializeXml = (node, options = {}) => {
+    // Note: xmldom's XMLSerializer doesn't natively support a 'pretty' or 'preserve' 
+    // flag in a way that matches all user expectations, but it defaults to 
+    // preserving structure. Formatting (indentation) is usually handled by the 
+    // parser's initial whitespace handling.
+    // @ts-ignore - xmldom's Node is compatible with the global Node interface
+    return new xmldom_1.XMLSerializer().serializeToString(node);
+};
+exports.serializeXml = serializeXml;
+/**
+ * Attempts to extract the original raw substring from the source XML for a given node.
+ * Requires the document to have been parsed with { locator: true }.
+ *
+ * @param node - The DOM node to extract source for
+ * @param sourceXml - The original XML source string
+ * @returns The raw XML substring, or undefined if it cannot be reliably determined
+ */
+const getSourceSubstring = (node, sourceXml) => {
+    if (!node || typeof node.lineNumber !== 'number' || typeof node.columnNumber !== 'number') {
+        return undefined;
+    }
+    // Convert line/column to absolute index
+    const lines = sourceXml.split('\n');
+    let startIdx = 0;
+    for (let i = 0; i < node.lineNumber - 1; i++) {
+        startIdx += lines[i].length + 1; // +1 for newline
+    }
+    startIdx += node.columnNumber - 1;
+    // To find the end of the node, we look for the closing tag.
+    // This is a heuristic approach that works well for simple structured nodes (p, tbl, etc.)
+    // but might be complex for overlapping namespaces or malformed XML.
+    if ((0, exports.isElement)(node)) {
+        const tagName = node.tagName;
+        const closingTag = `</${tagName}>`;
+        const endIdx = sourceXml.indexOf(closingTag, startIdx);
+        if (endIdx !== -1) {
+            return sourceXml.substring(startIdx, endIdx + closingTag.length);
+        }
+        // Self-closing tag handling (e.g., <w:p/>)
+        const selfClosingEnd = sourceXml.indexOf('/>', startIdx);
+        const nextOpenTag = sourceXml.indexOf('<', startIdx + 1);
+        if (selfClosingEnd !== -1 && (nextOpenTag === -1 || selfClosingEnd < nextOpenTag)) {
+            return sourceXml.substring(startIdx, selfClosingEnd + 2);
+        }
+    }
+    return undefined;
+};
+exports.getSourceSubstring = getSourceSubstring;
+/**
+ * High-level helper to get raw content for a node based on OfficeParserConfig.
+ *
+ * @param node - The DOM node
+ * @param sourceXml - The original source XML string
+ * @param config - The parser configuration
+ * @returns The raw content string (serialized or original)
+ */
+const getRawContent = (node, sourceXml, config) => {
+    if (config.serializeRawContent === false) {
+        const original = (0, exports.getSourceSubstring)(node, sourceXml);
+        if (original)
+            return original;
+    }
+    return (0, exports.serializeXml)(node, { preserveWhitespace: config.preserveXmlWhitespace });
+};
+exports.getRawContent = getRawContent;
+/**
+ * Gets the first element with the specified tag name within a parent element.
+ *
+ * @param parent - The parent element or document to search within
+ * @param tagName - The tag name to search for
+ * @returns The first matching element, or undefined if none found
+ */
+const getFirstElementByTagName = (parent, tagName) => {
+    const elements = parent.getElementsByTagName(tagName);
+    if (elements && elements.length > 0) {
+        return elements[0];
+    }
+    return undefined;
+};
+exports.getFirstElementByTagName = getFirstElementByTagName;
+/**
+ * Gets the value of an attribute from an element.
+ *
+ * @param element - The element to get the attribute from
+ * @param attrName - The name of the attribute
+ * @returns The attribute value or undefined if not set
+ */
+const getAttribute = (element, attrName) => {
+    const attr = element.getAttribute(attrName);
+    return attr !== null ? attr : undefined;
+};
+exports.getAttribute = getAttribute;
 /**
  * Gets direct child elements with a specific tag name.
  * Unlike getElementsByTagName, this does not search recursively.
@@ -67,7 +178,7 @@ const getDirectChildren = (parent, tagName) => {
         return result;
     for (let i = 0; i < parent.childNodes.length; i++) {
         const child = parent.childNodes[i];
-        if (child.nodeType === 1 && child.tagName === tagName) { // 1 = ELEMENT_NODE
+        if ((0, exports.isElement)(child) && child.tagName === tagName) {
             result.push(child);
         }
     }
@@ -124,11 +235,18 @@ const parseOfficeMetadata = (xmlContent) => {
         // Step 6: Extract creation date (Dublin Core Terms element)
         const created = (0, exports.getElementsByTagName)(coreProperties, "dcterms:created")[0];
         if (created && created.textContent)
-            metadata.created = new Date(created.textContent);
+            metadata.created = (0, dateUtils_js_1.parseOfficeDate)(created.textContent);
         // Step 7: Extract last modification date (Dublin Core Terms element)
         const modified = (0, exports.getElementsByTagName)(coreProperties, "dcterms:modified")[0];
         if (modified && modified.textContent)
-            metadata.modified = new Date(modified.textContent);
+            metadata.modified = (0, dateUtils_js_1.parseOfficeDate)(modified.textContent);
+        // Step 8: Extract description and subject (Dublin Core elements)
+        const description = (0, exports.getElementsByTagName)(coreProperties, "dc:description")[0];
+        if (description && description.textContent)
+            metadata.description = description.textContent;
+        const subject = (0, exports.getElementsByTagName)(coreProperties, "dc:subject")[0];
+        if (subject && subject.textContent)
+            metadata.subject = subject.textContent;
         return metadata;
     }
     // Check for ODF Meta
@@ -148,11 +266,111 @@ const parseOfficeMetadata = (xmlContent) => {
             metadata.subject = subject.textContent;
         const created = (0, exports.getElementsByTagName)(officeMeta, "meta:creation-date")[0];
         if (created && created.textContent)
-            metadata.created = new Date(created.textContent);
+            metadata.created = (0, dateUtils_js_1.parseOfficeDate)(created.textContent);
         const modified = (0, exports.getElementsByTagName)(officeMeta, "dc:date")[0];
         if (modified && modified.textContent)
-            metadata.modified = new Date(modified.textContent);
+            metadata.modified = (0, dateUtils_js_1.parseOfficeDate)(modified.textContent);
+        // Extract user-defined custom properties (meta:user-defined)
+        const userDefined = (0, exports.getElementsByTagName)(officeMeta, "meta:user-defined");
+        if (userDefined.length > 0) {
+            const customProperties = {};
+            for (const el of userDefined) {
+                const name = el.getAttribute("meta:name");
+                if (!name || !el.textContent)
+                    continue;
+                const valueType = el.getAttribute("meta:value-type") || "string";
+                const raw = el.textContent;
+                if (valueType === "boolean") {
+                    customProperties[name] = raw.toLowerCase() === "true";
+                }
+                else if (valueType === "float") {
+                    const num = Number(raw);
+                    if (!isNaN(num))
+                        customProperties[name] = num;
+                }
+                else if (valueType === "date" || valueType === "time") {
+                    const date = (0, dateUtils_js_1.parseOfficeDate)(raw);
+                    if (date)
+                        customProperties[name] = date;
+                    else
+                        customProperties[name] = raw;
+                }
+                else {
+                    customProperties[name] = raw;
+                }
+            }
+            if (Object.keys(customProperties).length > 0) {
+                metadata.customProperties = customProperties;
+            }
+        }
     }
     return metadata;
 };
 exports.parseOfficeMetadata = parseOfficeMetadata;
+/**
+ * Parses OOXML custom document properties from `docProps/custom.xml`.
+ *
+ * Custom properties are user-defined key/value pairs that authors can attach to OOXML documents
+ * (DOCX, XLSX, PPTX). They are stored in `docProps/custom.xml` inside the ZIP archive.
+ *
+ * Property values are typed using the `vt:` namespace (docPropsVTypes):
+ * - `vt:lpwstr` / `vt:lpstr` / `vt:bstr` → string
+ * - `vt:bool` → boolean
+ * - `vt:i1`..`vt:i8`, `vt:int`, `vt:r4`, `vt:r8`, `vt:decimal` → number
+ * - `vt:filetime` / `vt:date` → Date
+ *
+ * @param xmlContent - Raw XML string from `docProps/custom.xml`
+ * @returns A record of property name → typed value (empty object if none found)
+ * @example
+ * ```typescript
+ * const customXml = files.find(f => f.path === 'docProps/custom.xml').content.toString();
+ * const props = parseOOXMLCustomProperties(customXml);
+ * console.log(props['Department']); // "Engineering"
+ * console.log(props['Priority']);   // 1  (number)
+ * console.log(props['Reviewed']);   // true (boolean)
+ * ```
+ */
+const parseOOXMLCustomProperties = (xmlContent) => {
+    const xml = (0, exports.parseXmlString)(xmlContent);
+    const result = {};
+    const properties = (0, exports.getElementsByTagName)(xml, "property");
+    for (const prop of properties) {
+        const name = prop.getAttribute("name");
+        if (!name)
+            continue;
+        // The value is the first child element (typed using vt: namespace)
+        for (let i = 0; i < prop.childNodes.length; i++) {
+            const child = prop.childNodes[i];
+            if (child.nodeType !== 1)
+                continue; // skip non-elements
+            const el = child;
+            const tag = el.tagName || '';
+            const text = el.textContent || '';
+            if (/vt:lpwstr|vt:lpstr|vt:bstr/.test(tag)) {
+                result[name] = text;
+            }
+            else if (/vt:bool/.test(tag)) {
+                result[name] = text.toLowerCase() === 'true';
+            }
+            else if (/vt:(i[1248]|ui[1248]|int|uint|r4|r8|decimal)/.test(tag)) {
+                const num = Number(text);
+                if (!isNaN(num))
+                    result[name] = num;
+            }
+            else if (/vt:filetime|vt:date/.test(tag)) {
+                const date = (0, dateUtils_js_1.parseOfficeDate)(text);
+                if (date)
+                    result[name] = date;
+                else
+                    result[name] = text;
+            }
+            else if (text) {
+                // Fallback: store as string for any other vt: type
+                result[name] = text;
+            }
+            break; // only one value element per property
+        }
+    }
+    return result;
+};
+exports.parseOOXMLCustomProperties = parseOOXMLCustomProperties;

package/dist/utils/zipUtils.js

@@ -14,13 +14,9 @@
  *
  * @module zipUtils
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractFiles = void 0;
-const yauzl_1 = __importDefault(require("yauzl"));
-const concat_stream_1 = __importDefault(require("concat-stream"));
+const fflate_1 = require("fflate");
 /**
  * Extracts files from a ZIP archive with optional filtering.
  *
@@ -62,50 +58,13 @@ const concat_stream_1 = __importDefault(require("concat-stream"));
  */
 const extractFiles = (zipInput, filterFn) => {
     return new Promise((resolve, reject) => {
-        // Step 1: Open the ZIP archive from the buffer
-        // lazyEntries: true means we manually control when to read each entry (better memory usage)
-        yauzl_1.default.fromBuffer(zipInput, { lazyEntries: true }, (err, zipfile) => {
+        (0, fflate_1.unzip)(new Uint8Array(zipInput.buffer, zipInput.byteOffset, zipInput.byteLength), { filter: (file) => filterFn(file.name) }, (err, decompressed) => {
             if (err)
                 return reject(err);
-            if (!zipfile)
-                return reject(new Error("Failed to open zip file"));
-            // Array to collect all extracted files
-            const extractedFiles = [];
-            // Step 2: Start reading the first entry
-            // This triggers the 'entry' event
-            zipfile.readEntry();
-            // Step 3: Handle each entry (file or directory) in the ZIP
-            zipfile.on('entry', (entry) => {
-                // Step 3a: Check if this file should be extracted using the filter function
-                if (filterFn(entry.fileName)) {
-                    // Step 3b: Open a read stream for this entry
-                    zipfile.openReadStream(entry, (err, readStream) => {
-                        if (err)
-                            return reject(err);
-                        if (!readStream)
-                            return reject(new Error("Failed to open read stream"));
-                        // Step 3c: Pipe the stream through concat to collect all data into a single Buffer
-                        // This is necessary because streams deliver data in chunks
-                        readStream.pipe((0, concat_stream_1.default)((data) => {
-                            // Step 3d: Add the extracted file to our results
-                            extractedFiles.push({
-                                path: entry.fileName,
-                                content: data
-                            });
-                            // Step 3e: Continue to the next entry
-                            zipfile.readEntry();
-                        }));
-                    });
-                }
-                else {
-                    // Step 3f: Skip this entry and move to the next one
-                    zipfile.readEntry();
-                }
-            });
-            // Step 4: All entries have been processed
-            zipfile.on('end', () => resolve(extractedFiles));
-            // Step 5: Handle any errors during extraction
-            zipfile.on('error', reject);
+            resolve(Object.entries(decompressed).map(([path, data]) => ({
+                path,
+                content: Buffer.from(data)
+            })));
         });
     });
 };

package/package.json

@@ -1,9 +1,20 @@
 {
   "name": "officeparser",
-  "version": "6.0.6",
+  "version": "6.1.0",
   "description": "A robust, strictly-typed Node.js and Browser library for parsing office files (.docx, .pptx, .xlsx, .odt, .odp, .ods, .pdf, .rtf) into structured AST with rich metadata, formatting, and attachment support.",
+  "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"
+    }
+  },
   "sideEffects": false,
   "engines": {
     "node": ">=18.0.0"
@@ -12,14 +23,21 @@
     "dist"
   ],
   "scripts": {
-    "build": "npm run sync:versions && npm run build:node && npm run build:browser",
+    "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",
     "build:browser": "node build_browser.js && npm run sync:docs",
     "sync:versions": "node scripts/sync-pdfjs-versions.js",
-    "sync:docs": "mkdir -p docs/dist && cp dist/officeparser.browser.js docs/dist/",
-    "test": "npm run test:clean && npm run build && npx tsx test/testOfficeParser.ts",
+    "sync:docs": "mkdir -p docs/dist && cp dist/officeparser.browser.iife.js docs/dist/ && cp dist/officeparser.browser.mjs docs/dist/",
+    "test": "npm run test:clean && npm run build && npm run test:license && npm run test:artifacts && npm run test:parser",
+    "test:baseline": "npm run test baseline",
+    "test:parser": "npx tsx test/testOfficeParser.ts",
+    "test:artifacts": "npx tsx test/testShippingArtifacts.ts",
+    "test:license": "npm run sbom && node scripts/validate-licenses.js",
     "test:clean": "rm -rf test/results",
     "clean": "rm -rf dist && 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"
   },
@@ -28,7 +46,11 @@
     "url": "git+https://github.com/harshankur/officeParser.git"
   },
   "bin": {
-    "officeparser": "dist/index.js"
+    "officeparser": "dist/cli.js"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
   },
   "keywords": [
     "office",
@@ -67,24 +89,23 @@
   "bugs": {
     "url": "https://github.com/harshankur/officeParser/issues"
   },
-  "homepage": "https://harshankur.github.io/officeParser/",
+  "homepage": "https://officeparser.harshankur.com",
   "dependencies": {
-    "@xmldom/xmldom": "^0.8.11",
-    "concat-stream": "^2.0.0",
-    "file-type": "^19.6.0",
-    "pdfjs-dist": "^5.5.207",
-    "tesseract.js": "^7.0.0",
-    "yauzl": "^3.2.1"
+    "@xmldom/xmldom": "^0.9.9",
+    "fflate": "^0.8.2",
+    "file-type": "^22.0.1",
+    "pdfjs-dist": "5.6.205",
+    "tesseract.js": "^7.0.0"
   },
   "devDependencies": {
-    "@types/concat-stream": "^2.0.3",
-    "@types/node": "^22.13.10",
-    "@types/xmldom": "^0.1.34",
-    "@types/yauzl": "^2.10.3",
+    "@types/node": "^25.5.0",
+    "buffer": "^6.0.3",
+    "dts-bundle-generator": "^9.5.1",
     "esbuild": "^0.27.4",
-    "esbuild-plugin-polyfill-node": "^0.3.0",
+    "esbuild-plugins-node-modules-polyfill": "^1.8.1",
     "husky": "^9.1.7",
+    "process": "^0.11.10",
     "tsx": "^4.21.0",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.2"
   }
 }