@kreuzberg/wasm 4.0.0-rc.6

package/dist/runtime.d.mts

@@ -0,0 +1,256 @@
+/**
+ * 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/runtime.d.ts

@@ -0,0 +1,256 @@
+/**
+ * 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/runtime.js

@@ -0,0 +1,172 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runtime_exports = {};
+__export(runtime_exports, {
+  detectRuntime: () => detectRuntime,
+  getRuntimeInfo: () => getRuntimeInfo,
+  getRuntimeVersion: () => getRuntimeVersion,
+  getWasmCapabilities: () => getWasmCapabilities,
+  hasBigInt: () => hasBigInt,
+  hasBlob: () => hasBlob,
+  hasFileApi: () => hasFileApi,
+  hasModuleWorkers: () => hasModuleWorkers,
+  hasSharedArrayBuffer: () => hasSharedArrayBuffer,
+  hasWasm: () => hasWasm,
+  hasWasmStreaming: () => hasWasmStreaming,
+  hasWorkers: () => hasWorkers,
+  isBrowser: () => isBrowser,
+  isBun: () => isBun,
+  isDeno: () => isDeno,
+  isNode: () => isNode,
+  isServerEnvironment: () => isServerEnvironment,
+  isWebEnvironment: () => isWebEnvironment
+});
+module.exports = __toCommonJS(runtime_exports);
+function detectRuntime() {
+  if (typeof globalThis.Deno !== "undefined") {
+    return "deno";
+  }
+  if (typeof globalThis.Bun !== "undefined") {
+    return "bun";
+  }
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    return "node";
+  }
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    return "browser";
+  }
+  return "unknown";
+}
+function isBrowser() {
+  return detectRuntime() === "browser";
+}
+function isNode() {
+  return detectRuntime() === "node";
+}
+function isDeno() {
+  return detectRuntime() === "deno";
+}
+function isBun() {
+  return detectRuntime() === "bun";
+}
+function isWebEnvironment() {
+  const runtime = detectRuntime();
+  return runtime === "browser";
+}
+function isServerEnvironment() {
+  const runtime = detectRuntime();
+  return runtime === "node" || runtime === "deno" || runtime === "bun";
+}
+function hasFileApi() {
+  return typeof window !== "undefined" && typeof File !== "undefined" && typeof Blob !== "undefined";
+}
+function hasBlob() {
+  return typeof Blob !== "undefined";
+}
+function hasWorkers() {
+  return typeof Worker !== "undefined";
+}
+function hasSharedArrayBuffer() {
+  return typeof SharedArrayBuffer !== "undefined";
+}
+function hasModuleWorkers() {
+  if (!hasWorkers()) {
+    return false;
+  }
+  try {
+    const blob = new Blob(['console.log("test")'], {
+      type: "application/javascript"
+    });
+    const workerUrl = URL.createObjectURL(blob);
+    try {
+      return true;
+    } finally {
+      URL.revokeObjectURL(workerUrl);
+    }
+  } catch {
+    return false;
+  }
+}
+function hasWasm() {
+  return typeof WebAssembly !== "undefined" && WebAssembly.instantiate !== void 0;
+}
+function hasWasmStreaming() {
+  return typeof WebAssembly !== "undefined" && WebAssembly.instantiateStreaming !== void 0;
+}
+function hasBigInt() {
+  try {
+    const test = BigInt("1");
+    return typeof test === "bigint";
+  } catch {
+    return false;
+  }
+}
+function getRuntimeVersion() {
+  const runtime = detectRuntime();
+  switch (runtime) {
+    case "node":
+      return process.version?.substring(1);
+    // Remove 'v' prefix
+    case "deno": {
+      const deno = globalThis.Deno;
+      const version = deno?.version;
+      return version?.deno;
+    }
+    case "bun": {
+      const bun = globalThis.Bun;
+      return bun?.version;
+    }
+    default:
+      return void 0;
+  }
+}
+function getWasmCapabilities() {
+  const runtime = detectRuntime();
+  const version = getRuntimeVersion();
+  const capabilities = {
+    runtime,
+    hasWasm: hasWasm(),
+    hasWasmStreaming: hasWasmStreaming(),
+    hasFileApi: hasFileApi(),
+    hasBlob: hasBlob(),
+    hasWorkers: hasWorkers(),
+    hasSharedArrayBuffer: hasSharedArrayBuffer(),
+    hasModuleWorkers: hasModuleWorkers(),
+    hasBigInt: hasBigInt(),
+    ...version !== void 0 ? { runtimeVersion: version } : {}
+  };
+  return capabilities;
+}
+function getRuntimeInfo() {
+  const runtime = detectRuntime();
+  const capabilities = getWasmCapabilities();
+  return {
+    runtime,
+    isBrowser: isBrowser(),
+    isNode: isNode(),
+    isDeno: isDeno(),
+    isBun: isBun(),
+    isWeb: isWebEnvironment(),
+    isServer: isServerEnvironment(),
+    runtimeVersion: getRuntimeVersion(),
+    userAgent: typeof navigator !== "undefined" ? navigator.userAgent : "N/A",
+    capabilities
+  };
+}
+//# sourceMappingURL=runtime.js.map