@gmickel/gno 1.45.1 → 2.0.0

package/vendor/converters/markitdown-ts/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "markitdown-ts",
+  "version": "0.0.10",
+  "description": "",
+  "keywords": [],
+  "homepage": "https://github.com/dead8309/markitdown-ts#readme",
+  "bugs": {
+    "url": "https://github.com/dead8309/markitdown-ts/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dead8309/markitdown-ts.git"
+  },
+  "license": "MIT",
+  "author": "Vaibhav Raj",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@ai-sdk/openai": "^3.0.2",
+    "@types/jsdom": "^21.1.7",
+    "@types/mime-types": "^2.1.4",
+    "@types/node": "^22.10.2",
+    "@types/turndown": "^5.0.5",
+    "@types/unzipper": "^0.10.10",
+    "bumpp": "^9.9.1",
+    "is-ci": "^4.1.0",
+    "prettier": "^3.4.2",
+    "typescript": "^5.7.2",
+    "unbuild": "^3.0.1",
+    "vite": "^6.0.4",
+    "vitest": "^2.1.8",
+    "zod": "^4.1.8"
+  },
+  "dependencies": {
+    "@joplin/turndown-plugin-gfm": "^1.0.60",
+    "@xmldom/xmldom": "^0.9.6",
+    "ai": "^6.0.6",
+    "jsdom": "^25.0.1",
+    "mammoth": "^1.8.0",
+    "mime-types": "^2.1.35",
+    "pdf-parse": "^2.4.5",
+    "turndown": "^7.2.0",
+    "xlsx": "^0.18.5"
+  },
+  "peerDependencies": {
+    "unzipper": "^0.12.3",
+    "youtube-transcript": "^1.2.1"
+  },
+  "peerDependenciesMeta": {
+    "youtube-transcript": {
+      "optional": true
+    },
+    "unzipper": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "unbuild",
+    "format": "prettier --write src/**/*.ts",
+    "release": "bumpp --commit --push --tag && pnpm publish",
+    "preversion": "pnpm typecheck && pnpm build",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/vendor/converters/officeparser/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Harsh Ankur
+
+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/vendor/converters/officeparser/dist/OfficeConverter.d.ts

@@ -0,0 +1,47 @@
+import { BlobLike, ConversionResult, OfficeConverterConfig, SupportedDestination, SupportedFileType } from './types.js';
+/**
+ * Utility type to infer the file type from a file path string literal.
+ */
+type InferFileTypeFromPath<T> = T extends `${string}.${infer E}` ? (Lowercase<E> extends SupportedFileType ? Lowercase<E> : SupportedFileType) : SupportedFileType;
+/**
+ * Main converter class providing a streamlined one-step API for document conversion.
+ *
+ * This class coordinates the `OfficeParser` and `OfficeGenerator` to transform
+ * documents from one format to another (e.g., DOCX to Markdown, PDF to HTML).
+ */
+export declare class OfficeConverter {
+    /**
+     * Converts an office document from its source format to a specified destination format.
+     *
+     * This method:
+     * 1. Detects the source file type and parses it into a unified AST using `OfficeParser`.
+     * 2. Automatically configures the parser based on the generator requirements (e.g., enabling
+     *    attachment extraction if images are requested in the output).
+     * 3. Generates the destination document from the AST using `OfficeGenerator`.
+     *
+     * @template F The inferred type of the input file (path string or buffer).
+     * @template T The authoritative source file type (inferred from path or config).
+     *
+     * @param file - File path (string), Buffer, or ArrayBuffer containing the source document.
+     * @param destination - The target format (e.g., 'md', 'html', 'pdf', 'text', 'chunks').
+     * @param config - Optional unified configuration for both the parser and generator phases.
+     *
+     * @returns A promise resolving to the ConversionResult containing the value and messages.
+     * @throws {Error} If the source format is unsupported or parsing/generation fails.
+     *
+     * @example
+     * ```typescript
+     * // Convert Word to Markdown with a single call
+     * const { value: markdown } = await OfficeConverter.convert('report.docx', 'md');
+     *
+     * // Convert PDF to HTML (Note: OCR is disabled in this one-step API)
+     * const { value: html } = await OfficeConverter.convert(buffer, 'html', {
+     *   generatorConfig: {
+     *     includeImages: true
+     *   }
+     * });
+     * ```
+     */
+    static convert<F extends string | Buffer | ArrayBuffer | Uint8Array | BlobLike, T extends SupportedFileType = InferFileTypeFromPath<F>, D extends SupportedDestination<T> = SupportedDestination<T>>(file: F, destination: D, config?: OfficeConverterConfig<D, T>): Promise<ConversionResult<D>>;
+}
+export {};

package/vendor/converters/officeparser/dist/OfficeConverter.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfficeConverter = void 0;
+const OfficeGenerator_js_1 = require("./OfficeGenerator.js");
+const OfficeParser_js_1 = require("./OfficeParser.js");
+/**
+ * Main converter class providing a streamlined one-step API for document conversion.
+ *
+ * This class coordinates the `OfficeParser` and `OfficeGenerator` to transform
+ * documents from one format to another (e.g., DOCX to Markdown, PDF to HTML).
+ */
+class OfficeConverter {
+    /**
+     * Converts an office document from its source format to a specified destination format.
+     *
+     * This method:
+     * 1. Detects the source file type and parses it into a unified AST using `OfficeParser`.
+     * 2. Automatically configures the parser based on the generator requirements (e.g., enabling
+     *    attachment extraction if images are requested in the output).
+     * 3. Generates the destination document from the AST using `OfficeGenerator`.
+     *
+     * @template F The inferred type of the input file (path string or buffer).
+     * @template T The authoritative source file type (inferred from path or config).
+     *
+     * @param file - File path (string), Buffer, or ArrayBuffer containing the source document.
+     * @param destination - The target format (e.g., 'md', 'html', 'pdf', 'text', 'chunks').
+     * @param config - Optional unified configuration for both the parser and generator phases.
+     *
+     * @returns A promise resolving to the ConversionResult containing the value and messages.
+     * @throws {Error} If the source format is unsupported or parsing/generation fails.
+     *
+     * @example
+     * ```typescript
+     * // Convert Word to Markdown with a single call
+     * const { value: markdown } = await OfficeConverter.convert('report.docx', 'md');
+     *
+     * // Convert PDF to HTML (Note: OCR is disabled in this one-step API)
+     * const { value: html } = await OfficeConverter.convert(buffer, 'html', {
+     *   generatorConfig: {
+     *     includeImages: true
+     *   }
+     * });
+     * ```
+     */
+    static async convert(file, destination, config) {
+        // 1. Prepare Parser Configuration
+        // We prioritize the top-level onWarning if provided.
+        const parserConfig = {
+            ...config?.parseConfig,
+            onWarning: config?.onWarning || config?.parseConfig?.onWarning,
+        };
+        // Remove OCR settings for the streamlined converter as requested
+        parserConfig.ocr = false;
+        // Remove undefined keys to prevent overwriting defaults in resolveParserConfig
+        Object.keys(parserConfig).forEach((key) => parserConfig[key] === undefined && delete parserConfig[key]);
+        /**
+         * AUTOMATIC CONFIGURATION SYNC
+         * We sync extractAttachments from the generator configuration.
+         */
+        parserConfig.extractAttachments = (config?.generatorConfig?.includeImages !== false) || (config?.generatorConfig?.includeCharts !== false);
+        // 2. Parse the source document into the universal AST
+        const ast = await OfficeParser_js_1.OfficeParser.parseOffice(file, parserConfig);
+        // 3. Generate the destination document from the AST
+        const generatorConfig = {
+            ...config?.generatorConfig,
+            onWarning: config?.onWarning || config?.generatorConfig?.onWarning,
+        };
+        // The spread widens the object to an inferred literal; it is a `GeneratorConfig<D>` by
+        // construction (config.generatorConfig is already typed for D, and onWarning is common to
+        // every destination), so the cast restates what the types otherwise lose.
+        const result = await OfficeGenerator_js_1.OfficeGenerator.generate(ast, destination, generatorConfig);
+        result.messages = [...(ast.warnings || []), ...result.messages];
+        return result;
+    }
+}
+exports.OfficeConverter = OfficeConverter;

package/vendor/converters/officeparser/dist/OfficeGenerator.d.ts

@@ -0,0 +1,23 @@
+import { ConversionResult, GeneratorConfig, OfficeParserAST, SupportedDestination, SupportedFileType, UniversalGeneratorFormat } from './types.js';
+/**
+ * Main generator class providing document conversion functionality.
+ */
+export declare class OfficeGenerator {
+    /**
+     * Normalizes format aliases (e.g., 'txt' to 'text', 'markdown' to 'md') to standard internal formats.
+     */
+    static normalizeDestination(dest: string): UniversalGeneratorFormat;
+    /**
+     * Generates a file of the specified type from an AST.
+     * This is the single source of truth for generation logic.
+     *
+     * @param ast - The OfficeParserAST to generate from
+     * @param destination - The target format (e.g., 'text', 'md', 'html', 'pdf')
+     * @param config - Optional configuration for the generator
+     * @returns A promise resolving to the ConversionResult containing the value and messages
+     * @throws {Error} If the destination format is unsupported
+     */
+    static generate<T extends SupportedFileType, D extends SupportedDestination<T>>(ast: OfficeParserAST & {
+        type: T;
+    }, destination: D, config?: GeneratorConfig<D>): Promise<ConversionResult<D>>;
+}

package/vendor/converters/officeparser/dist/OfficeGenerator.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfficeGenerator = void 0;
+const ChunkingGenerator_js_1 = require("./generators/ChunkingGenerator.js");
+const CsvGenerator_js_1 = require("./generators/CsvGenerator.js");
+const EpubGenerator_js_1 = require("./generators/EpubGenerator.js");
+const HtmlGenerator_js_1 = require("./generators/HtmlGenerator.js");
+const MarkdownGenerator_js_1 = require("./generators/MarkdownGenerator.js");
+const PdfGenerator_js_1 = require("./generators/PdfGenerator.js");
+const RtfGenerator_js_1 = require("./generators/RtfGenerator.js");
+const TextGenerator_js_1 = require("./generators/TextGenerator.js");
+const types_js_1 = require("./types.js");
+const errorUtils_js_1 = require("./utils/errorUtils.js");
+/**
+ * Main generator class providing document conversion functionality.
+ */
+class OfficeGenerator {
+    /**
+     * Normalizes format aliases (e.g., 'txt' to 'text', 'markdown' to 'md') to standard internal formats.
+     */
+    static normalizeDestination(dest) {
+        const d = dest?.toLowerCase();
+        if (d === 'txt')
+            return 'text';
+        if (d === 'markdown')
+            return 'md';
+        return d;
+    }
+    /**
+     * Generates a file of the specified type from an AST.
+     * This is the single source of truth for generation logic.
+     *
+     * @param ast - The OfficeParserAST to generate from
+     * @param destination - The target format (e.g., 'text', 'md', 'html', 'pdf')
+     * @param config - Optional configuration for the generator
+     * @returns A promise resolving to the ConversionResult containing the value and messages
+     * @throws {Error} If the destination format is unsupported
+     */
+    static async generate(ast, destination, config) {
+        let generator;
+        const normalizedDestination = OfficeGenerator.normalizeDestination(destination);
+        switch (normalizedDestination) {
+            case 'text':
+                generator = new TextGenerator_js_1.TextGenerator(ast, config);
+                break;
+            case 'md':
+                generator = new MarkdownGenerator_js_1.MarkdownGenerator(ast, config);
+                break;
+            case 'html':
+                generator = new HtmlGenerator_js_1.HtmlGenerator(ast, config);
+                break;
+            case 'pdf':
+                generator = new PdfGenerator_js_1.PdfGenerator(ast, config);
+                break;
+            case 'csv':
+                generator = new CsvGenerator_js_1.CsvGenerator(ast, config);
+                break;
+            case 'rtf':
+                generator = new RtfGenerator_js_1.RtfGenerator(ast, config);
+                break;
+            case 'chunks':
+                generator = new ChunkingGenerator_js_1.ChunkingGenerator(ast, config);
+                break;
+            case 'epub':
+                generator = new EpubGenerator_js_1.EpubGenerator(ast, config);
+                break;
+            default:
+                throw (0, errorUtils_js_1.getOfficeError)(types_js_1.OfficeErrorType.FORMAT_UNSUPPORTED, undefined, destination);
+        }
+        return generator.generate();
+    }
+}
+exports.OfficeGenerator = OfficeGenerator;

package/vendor/converters/officeparser/dist/OfficeParser.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Office Parser - Main Entry Point
+ *
+ * This module provides the main `OfficeParser` class with a single static method
+ * that automatically detects file types and routes to the appropriate parser.
+ *
+ * **Supported Formats:**
+ * - DOCX (Word documents)
+ * - XLSX (Excel spreadsheets)
+ * - PPTX (PowerPoint presentations)
+ * - ODT, ODP, ODS (OpenDocument formats)
+ * - PDF (Portable Document Format)
+ * - RTF (Rich Text Format)
+ * - CSV (Comma-Separated Values)
+ * - MD (Markdown)
+ * - HTML (HyperText Markup Language)
+ * - EPUB (E-book format)
+ *
+ * **Usage:**
+ * ```typescript
+ * import { OfficeParser } from 'officeparser';
+ *
+ * // Parse from file path
+ * const ast = await OfficeParser.parseOffice('document.docx', {
+ *   extractAttachments: true,
+ *   ocr: true
+ * });
+ *
+ * // Parse from Buffer
+ * const buffer = fs.readFileSync('document.pdf');
+ * const ast = await OfficeParser.parseOffice(buffer);
+ *
+ * // Get plain text
+ * console.log((await ast.to('text')).value);
+ * ```
+ *
+ * @module OfficeParser
+ */
+import { BlobLike, OfficeParserAST, OfficeParserConfig } from './types.js';
+/**
+ * Main parser class providing office document parsing functionality.
+ *
+ * This class contains a single static method `parseOffice` that serves as the
+ * universal entry point for parsing any supported office document format.
+ */
+export declare class OfficeParser {
+    /**
+     * Parses an office document and returns a structured AST.
+     *
+     * This method:
+     * 1. Accepts a file path, Buffer, or ArrayBuffer
+     * 2. Detects the file type (from extension or content)
+     * 3. Routes to the appropriate format-specific parser
+     * 4. Returns a unified AST structure
+     *
+     * **File Type Detection:**
+     * - If a file path is provided, uses the file extension
+     * - If a Buffer is provided, uses magic bytes detection (file-type library)
+     *
+     * **Supported Formats and Routes:**
+     * - `.docx` → WordParser (OOXML)
+     * - `.xlsx` → ExcelParser (OOXML)
+     * - `.pptx` → PowerPointParser (OOXML)
+     * - `.odt`, `.odp`, `.ods` → OpenOfficeParser (ODF)
+     * - `.pdf` → PdfParser (PDF.js)
+     * - `.rtf` → RtfParser (custom RTF parser)
+     * - `.csv` → CsvParser
+     * - `.md` → MarkdownParser
+     * - `.html` → HtmlParser
+     * - `.epub` → EpubParser
+     *
+     * @param file - File path (string), Buffer, or ArrayBuffer containing the document
+     * @param config - Optional configuration object (defaults applied for all omitted options)
+     * @returns A promise resolving to the parsed OfficeParserAST
+     * @throws {Error} If file doesn't exist, format is unsupported, or parsing fails
+     *
+     * @example
+     * ```typescript
+     * // Parse a DOCX file
+     * const ast = await OfficeParser.parseOffice('report.docx', {
+     *   extractAttachments: true,
+     *   includeRawContent: false
+     * });
+     *
+     * // Parse a Buffer with OCR enabled
+     * const buffer = await retrieveData('document.pdf').then(r => r.arrayBuffer());
+     * const ast = await OfficeParser.parseOffice(buffer, {
+     *   ocr: true,
+     *   ocrLanguage: 'eng+fra'
+     * });
+     *
+     * // Extract text
+     * const text = ast.toText();
+     * ```
+     */
+    static parseOffice(file: string | Buffer | ArrayBuffer | Uint8Array | BlobLike, configOrCallback?: OfficeParserConfig | ((ast: OfficeParserAST, err?: any) => void), config?: OfficeParserConfig): Promise<OfficeParserAST>;
+    /**
+     * Terminates all active OCR workers and cleans up resources.
+     *
+     * This should be called when the application is shutting down or when OCR
+     * is no longer needed to prevent memory leaks and orphaned worker processes.
+     *
+     * @returns A promise that resolves when all workers have been terminated
+     */
+    static terminateOcr(): Promise<void>;
+}