@kreuzberg/wasm 4.0.0-rc.21 → 4.0.0-rc.24

package/dist/runtime.d.cts

@@ -1,256 +0,0 @@
-/**
- * Runtime detection and environment-specific utilities
- *
- * This module provides utilities for detecting the JavaScript runtime environment,
- * checking for feature availability, and enabling environment-specific WASM loading strategies.
- *
- * @example Basic Runtime Detection
- * ```typescript
- * import { detectRuntime, isBrowser, isNode } from '@kreuzberg/wasm/runtime';
- *
- * if (isBrowser()) {
- *   console.log('Running in browser');
- * } else if (isNode()) {
- *   console.log('Running in Node.js');
- * }
- * ```
- *
- * @example Feature Detection
- * ```typescript
- * import { hasFileApi, hasWorkers } from '@kreuzberg/wasm/runtime';
- *
- * if (hasFileApi()) {
- *   // Can use File API for browser file uploads
- * }
- *
- * if (hasWorkers()) {
- *   // Can use Web Workers for parallel processing
- * }
- * ```
- */
-type RuntimeType = "browser" | "node" | "deno" | "bun" | "unknown";
-/**
- * WebAssembly capabilities available in the runtime
- */
-interface WasmCapabilities {
-    /** Runtime environment type */
-    runtime: RuntimeType;
-    /** WebAssembly support available */
-    hasWasm: boolean;
-    /** Streaming WebAssembly instantiation available */
-    hasWasmStreaming: boolean;
-    /** File API available (browser) */
-    hasFileApi: boolean;
-    /** Blob API available */
-    hasBlob: boolean;
-    /** Worker support available */
-    hasWorkers: boolean;
-    /** SharedArrayBuffer available (may be restricted) */
-    hasSharedArrayBuffer: boolean;
-    /** Module Workers available */
-    hasModuleWorkers: boolean;
-    /** BigInt support */
-    hasBigInt: boolean;
-    /** Specific runtime version if available */
-    runtimeVersion?: string;
-}
-/**
- * Detect the current JavaScript runtime
- *
- * Checks for various global objects and properties to determine
- * which JavaScript runtime environment is currently executing.
- *
- * @returns The detected runtime type
- *
- * @example
- * ```typescript
- * import { detectRuntime } from '@kreuzberg/wasm/runtime';
- *
- * const runtime = detectRuntime();
- * switch (runtime) {
- *   case 'browser':
- *     console.log('Running in browser');
- *     break;
- *   case 'node':
- *     console.log('Running in Node.js');
- *     break;
- *   case 'deno':
- *     console.log('Running in Deno');
- *     break;
- *   case 'bun':
- *     console.log('Running in Bun');
- *     break;
- * }
- * ```
- */
-declare function detectRuntime(): RuntimeType;
-/**
- * Check if running in a browser environment
- *
- * @returns True if running in a browser, false otherwise
- */
-declare function isBrowser(): boolean;
-/**
- * Check if running in Node.js
- *
- * @returns True if running in Node.js, false otherwise
- */
-declare function isNode(): boolean;
-/**
- * Check if running in Deno
- *
- * @returns True if running in Deno, false otherwise
- */
-declare function isDeno(): boolean;
-/**
- * Check if running in Bun
- *
- * @returns True if running in Bun, false otherwise
- */
-declare function isBun(): boolean;
-/**
- * Check if running in a web environment (browser or similar)
- *
- * @returns True if running in a web browser, false otherwise
- */
-declare function isWebEnvironment(): boolean;
-/**
- * Check if running in a server-like environment (Node.js, Deno, Bun)
- *
- * @returns True if running on a server runtime, false otherwise
- */
-declare function isServerEnvironment(): boolean;
-/**
- * Check if File API is available
- *
- * The File API is required for handling browser file uploads.
- *
- * @returns True if File API is available, false otherwise
- *
- * @example
- * ```typescript
- * if (hasFileApi()) {
- *   const fileInput = document.getElementById('file');
- *   fileInput.addEventListener('change', (e) => {
- *     const file = e.target.files?.[0];
- *     // Handle file
- *   });
- * }
- * ```
- */
-declare function hasFileApi(): boolean;
-/**
- * Check if Blob API is available
- *
- * @returns True if Blob API is available, false otherwise
- */
-declare function hasBlob(): boolean;
-/**
- * Check if Web Workers are available
- *
- * @returns True if Web Workers can be created, false otherwise
- */
-declare function hasWorkers(): boolean;
-/**
- * Check if SharedArrayBuffer is available
- *
- * Note: SharedArrayBuffer is restricted in some browser contexts
- * due to security considerations (Spectre/Meltdown mitigations).
- *
- * @returns True if SharedArrayBuffer is available, false otherwise
- */
-declare function hasSharedArrayBuffer(): boolean;
-/**
- * Check if module workers are available
- *
- * Module workers allow importing ES modules in worker threads.
- *
- * @returns True if module workers are supported, false otherwise
- */
-declare function hasModuleWorkers(): boolean;
-/**
- * Check if WebAssembly is available
- *
- * @returns True if WebAssembly is supported, false otherwise
- */
-declare function hasWasm(): boolean;
-/**
- * Check if WebAssembly.instantiateStreaming is available
- *
- * Streaming instantiation is more efficient than buffering the entire WASM module.
- *
- * @returns True if streaming WebAssembly is supported, false otherwise
- */
-declare function hasWasmStreaming(): boolean;
-/**
- * Check if BigInt is available
- *
- * @returns True if BigInt type is supported, false otherwise
- */
-declare function hasBigInt(): boolean;
-/**
- * Get runtime version information
- *
- * @returns Version string if available, undefined otherwise
- *
- * @example
- * ```typescript
- * const version = getRuntimeVersion();
- * console.log(`Running on Node ${version}`); // "Running on Node 18.12.0"
- * ```
- */
-declare function getRuntimeVersion(): string | undefined;
-/**
- * Get comprehensive WebAssembly capabilities for current runtime
- *
- * Returns detailed information about WASM and related APIs available
- * in the current runtime environment.
- *
- * @returns Object describing available WASM capabilities
- *
- * @example
- * ```typescript
- * import { getWasmCapabilities } from '@kreuzberg/wasm/runtime';
- *
- * const caps = getWasmCapabilities();
- * console.log(`WASM available: ${caps.hasWasm}`);
- * console.log(`Streaming WASM: ${caps.hasWasmStreaming}`);
- * console.log(`Workers available: ${caps.hasWorkers}`);
- *
- * if (caps.hasWasm && caps.hasWorkers) {
- *   // Can offload WASM processing to workers
- * }
- * ```
- */
-declare function getWasmCapabilities(): WasmCapabilities;
-/**
- * Get comprehensive runtime information
- *
- * Returns detailed information about the current runtime environment,
- * capabilities, and identifying information.
- *
- * @returns Object with runtime details and capabilities
- *
- * @example
- * ```typescript
- * const info = getRuntimeInfo();
- * console.log(info.runtime); // 'browser' | 'node' | 'deno' | 'bun'
- * console.log(info.isBrowser); // true/false
- * console.log(info.userAgent); // Browser user agent string
- * console.log(info.capabilities); // Detailed capability information
- * ```
- */
-declare function getRuntimeInfo(): {
-    runtime: RuntimeType;
-    isBrowser: boolean;
-    isNode: boolean;
-    isDeno: boolean;
-    isBun: boolean;
-    isWeb: boolean;
-    isServer: boolean;
-    runtimeVersion: string | undefined;
-    userAgent: string;
-    capabilities: WasmCapabilities;
-};
-
-export { type RuntimeType, type WasmCapabilities, detectRuntime, getRuntimeInfo, getRuntimeVersion, getWasmCapabilities, hasBigInt, hasBlob, hasFileApi, hasModuleWorkers, hasSharedArrayBuffer, hasWasm, hasWasmStreaming, hasWorkers, isBrowser, isBun, isDeno, isNode, isServerEnvironment, isWebEnvironment };

package/dist/types-CKjcIYcX.d.cts

@@ -1,294 +0,0 @@
-/**
- * Type definitions for Kreuzberg WASM bindings
- *
- * These types are generated from the Rust core library and define
- * the interface for extraction, configuration, and results.
- */
-/**
- * Token reduction configuration
- */
-interface TokenReductionConfig {
-    /** Token reduction mode */
-    mode?: string;
-    /** Preserve important words during reduction */
-    preserveImportantWords?: boolean;
-}
-/**
- * Post-processor configuration
- */
-interface PostProcessorConfig {
-    /** Whether post-processing is enabled */
-    enabled?: boolean;
-    /** List of enabled processors */
-    enabledProcessors?: string[];
-    /** List of disabled processors */
-    disabledProcessors?: string[];
-}
-/**
- * Configuration for document extraction
- */
-interface ExtractionConfig {
-    /** OCR configuration */
-    ocr?: OcrConfig;
-    /** Chunking configuration */
-    chunking?: ChunkingConfig;
-    /** Image extraction configuration */
-    images?: ImageExtractionConfig;
-    /** Page extraction configuration */
-    pages?: PageExtractionConfig;
-    /** Language detection configuration */
-    languageDetection?: LanguageDetectionConfig;
-    /** PDF extraction options */
-    pdfOptions?: PdfConfig;
-    /** Token reduction configuration */
-    tokenReduction?: TokenReductionConfig;
-    /** Post-processor configuration */
-    postprocessor?: PostProcessorConfig;
-    /** Whether to use caching */
-    useCache?: boolean;
-    /** Enable quality processing */
-    enableQualityProcessing?: boolean;
-    /** Force OCR even if text is available */
-    forceOcr?: boolean;
-    /** Maximum concurrent extractions */
-    maxConcurrentExtractions?: number;
-}
-/**
- * Tesseract OCR configuration
- */
-interface TesseractConfig {
-    /** Tesseract page segmentation mode */
-    psm?: number;
-    /** Enable table detection */
-    enableTableDetection?: boolean;
-    /** Character whitelist for recognition */
-    tesseditCharWhitelist?: string;
-}
-/**
- * OCR configuration
- */
-interface OcrConfig {
-    /** OCR backend to use */
-    backend?: string;
-    /** Language codes (ISO 639) */
-    languages?: string[];
-    /** Whether to perform OCR */
-    enabled?: boolean;
-    /** Tesseract-specific configuration */
-    tesseractConfig?: TesseractConfig;
-    /** Language code for OCR */
-    language?: string;
-}
-/**
- * Chunking configuration
- */
-interface ChunkingConfig {
-    /** Maximum characters per chunk */
-    maxChars?: number;
-    /** Overlap between chunks */
-    maxOverlap?: number;
-}
-/**
- * Image extraction configuration
- */
-interface ImageExtractionConfig {
-    /** Whether to extract images */
-    enabled?: boolean;
-    /** Target DPI for image extraction */
-    targetDpi?: number;
-    /** Maximum image dimension in pixels */
-    maxImageDimension?: number;
-    /** Automatically adjust DPI */
-    autoAdjustDpi?: boolean;
-    /** Minimum DPI threshold */
-    minDpi?: number;
-    /** Maximum DPI threshold */
-    maxDpi?: number;
-}
-/**
- * PDF extraction configuration
- */
-interface PdfConfig {
-    /** Whether to extract images from PDF */
-    extractImages?: boolean;
-    /** Passwords for encrypted PDFs */
-    passwords?: string[];
-    /** Whether to extract metadata */
-    extractMetadata?: boolean;
-}
-/**
- * Page extraction configuration
- */
-interface PageExtractionConfig {
-    /** Whether to extract per-page content */
-    enabled?: boolean;
-}
-/**
- * Language detection configuration
- */
-interface LanguageDetectionConfig {
-    /** Whether to detect languages */
-    enabled?: boolean;
-}
-/**
- * Result of document extraction
- */
-interface ExtractionResult {
-    /** Extracted text content */
-    content: string;
-    /** MIME type of the document */
-    mimeType: string;
-    /** Document metadata */
-    metadata: Metadata;
-    /** Extracted tables */
-    tables: Table[];
-    /** Detected languages (ISO 639 codes) */
-    detectedLanguages?: string[] | null;
-    /** Text chunks when chunking is enabled */
-    chunks?: Chunk[] | null;
-    /** Extracted images */
-    images?: ExtractedImage[] | null;
-    /** Per-page content */
-    pages?: PageContent[] | null;
-}
-/**
- * Document metadata
- */
-interface Metadata {
-    /** Document title */
-    title?: string;
-    /** Document subject or description */
-    subject?: string;
-    /** Document author(s) */
-    authors?: string[];
-    /** Keywords/tags */
-    keywords?: string[];
-    /** Primary language (ISO 639 code) */
-    language?: string;
-    /** Creation timestamp (ISO 8601 format) */
-    createdAt?: string;
-    /** Last modification timestamp (ISO 8601 format) */
-    modifiedAt?: string;
-    /** User who created the document */
-    creator?: string;
-    /** User who last modified the document */
-    lastModifiedBy?: string;
-    /** Number of pages/slides */
-    pageCount?: number;
-    /** Format-specific metadata */
-    formatMetadata?: unknown;
-    /**
-     * Additional fields may be added at runtime by postprocessors.
-     * Use bracket notation to safely access unexpected properties.
-     */
-    [key: string]: unknown;
-}
-/**
- * Extracted table
- */
-interface Table {
-    /** Table cells/rows */
-    cells?: string[][];
-    /** Table markdown representation */
-    markdown?: string;
-    /** Page number if available */
-    pageNumber?: number;
-    /** Table headers */
-    headers?: string[];
-    /** Table rows */
-    rows?: string[][];
-}
-/**
- * Chunk metadata
- */
-interface ChunkMetadata {
-    /** Character start position in original content */
-    charStart: number;
-    /** Character end position in original content */
-    charEnd: number;
-    /** Token count if available */
-    tokenCount: number | null;
-    /** Index of this chunk */
-    chunkIndex: number;
-    /** Total number of chunks */
-    totalChunks: number;
-}
-/**
- * Text chunk from chunked content
- */
-interface Chunk {
-    /** Chunk text content */
-    content: string;
-    /** Chunk metadata */
-    metadata?: ChunkMetadata;
-    /** Character position in original content (legacy) */
-    charIndex?: number;
-    /** Token count if available (legacy) */
-    tokenCount?: number;
-    /** Embedding vector if computed */
-    embedding?: number[] | null;
-}
-/**
- * Extracted image from document
- */
-interface ExtractedImage {
-    /** Image data as Uint8Array or base64 string */
-    data: Uint8Array | string;
-    /** Image format/MIME type */
-    format?: string;
-    /** MIME type of the image */
-    mimeType?: string;
-    /** Image index in document */
-    imageIndex?: number;
-    /** Page number if available */
-    pageNumber?: number | null;
-    /** Image width in pixels */
-    width?: number | null;
-    /** Image height in pixels */
-    height?: number | null;
-    /** Color space of the image */
-    colorspace?: string | null;
-    /** Bits per color component */
-    bitsPerComponent?: number | null;
-    /** Whether this is a mask image */
-    isMask?: boolean;
-    /** Image description */
-    description?: string | null;
-    /** Optional OCR result from the image */
-    ocrResult?: ExtractionResult | string | null;
-}
-/**
- * Per-page content
- */
-interface PageContent {
-    /** Page number (1-indexed) */
-    pageNumber: number;
-    /** Text content of the page */
-    content: string;
-    /** Tables on this page */
-    tables?: Table[];
-    /** Images on this page */
-    images?: ExtractedImage[];
-}
-/**
- * OCR backend protocol/interface
- */
-interface OcrBackendProtocol {
-    /** Get the backend name */
-    name(): string;
-    /** Get supported language codes */
-    supportedLanguages?(): string[];
-    /** Initialize the backend */
-    initialize(options?: Record<string, unknown>): void | Promise<void>;
-    /** Shutdown the backend */
-    shutdown?(): void | Promise<void>;
-    /** Process an image with OCR */
-    processImage(imageData: Uint8Array | string, language?: string): Promise<{
-        content: string;
-        mime_type: string;
-        metadata?: Record<string, unknown>;
-        tables?: unknown[];
-    } | string>;
-}
-
-export type { Chunk as C, ExtractionConfig as E, ImageExtractionConfig as I, LanguageDetectionConfig as L, Metadata as M, OcrBackendProtocol as O, PageContent as P, Table as T, ExtractionResult as a, ChunkingConfig as b, ChunkMetadata as c, ExtractedImage as d, OcrConfig as e, PageExtractionConfig as f, PdfConfig as g, PostProcessorConfig as h, TesseractConfig as i, TokenReductionConfig as j };