convert-buddy-js 0.9.7 → 0.9.8

package/dist/src/nodejs-thread-pool.d.ts

@@ -0,0 +1,32 @@
+interface NodejsThreadPoolConfig {
+    maxWorkers: number;
+    wasmPath: string;
+}
+interface WorkerTask {
+    id: string;
+    method: string;
+    data: Uint8Array;
+    options: any;
+}
+interface WorkerResult {
+    id: string;
+    result?: Uint8Array;
+    error?: string;
+}
+declare class NodejsThreadPool {
+    private config;
+    private workers;
+    private pendingTasks;
+    private nextTaskId;
+    private isInitialized;
+    private roundRobinIndex;
+    constructor(config: NodejsThreadPoolConfig);
+    initialize(): Promise<void>;
+    private handleWorkerMessage;
+    processChunks(method: string, chunks: Uint8Array[], options: any): Promise<Uint8Array[]>;
+    destroy(): void;
+}
+declare function chunkDataNodejs(data: Uint8Array, numChunks: number): Uint8Array[];
+declare function mergeResultsNodejs(results: Uint8Array[], format: string): Uint8Array;
+
+export { NodejsThreadPool, type NodejsThreadPoolConfig, type WorkerResult, type WorkerTask, chunkDataNodejs, mergeResultsNodejs };

package/dist/src/nodejs-thread-pool.js

@@ -0,0 +1,215 @@
+import { Worker } from "worker_threads";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+class NodejsThreadPool {
+  constructor(config) {
+    this.config = config;
+  }
+  workers = [];
+  pendingTasks = /* @__PURE__ */ new Map();
+  nextTaskId = 0;
+  isInitialized = false;
+  roundRobinIndex = 0;
+  async initialize() {
+    if (this.isInitialized) return;
+    const workerScript = `
+      import { parentPort, workerData } from 'worker_threads';
+      import { createRequire } from 'node:module';
+      
+      const require = createRequire(import.meta.url);
+      
+      let wasmModule = null;
+      
+      async function initWasm() {
+        if (!wasmModule) {
+          // Import the Node.js WASM module
+          wasmModule = require('${this.config.wasmPath}');
+          wasmModule.init(false); // Initialize without debug logs in workers
+        }
+        return wasmModule;
+      }
+      
+      parentPort.on('message', async (task) => {
+        try {
+          const { id, method, data, options } = task;
+          
+          if (!wasmModule) {
+            await initWasm();
+          }
+          
+          const converter = new wasmModule.Converter(false);
+          
+          // Configure converter based on options
+          if (options.outputFormat) {
+            converter.set_output_format(options.outputFormat);
+          }
+          if (options.inputFormat) {
+            converter.set_input_format(options.inputFormat);
+          }
+          
+          // Process the data
+          const output = converter.push(data);
+          const final = converter.finish();
+          
+          // Combine outputs
+          const result = new Uint8Array(output.length + final.length);
+          result.set(output, 0);
+          result.set(final, output.length);
+          
+          parentPort.postMessage({ id, result });
+        } catch (error) {
+          parentPort.postMessage({ id, error: error.message });
+        }
+      });
+      
+      // Initialize WASM when worker starts
+      initWasm().catch(console.error);
+    `;
+    const workerPath = join(__dirname, `worker-${Date.now()}.mjs`);
+    await import("fs").then((fs) => {
+      fs.writeFileSync(workerPath, workerScript);
+    });
+    try {
+      for (let i = 0; i < this.config.maxWorkers; i++) {
+        const worker = new Worker(workerPath, { type: "module" });
+        worker.on("message", (response) => {
+          this.handleWorkerMessage(response);
+        });
+        worker.on("error", (error) => {
+          console.error("Worker error:", error);
+        });
+        this.workers.push(worker);
+      }
+      this.isInitialized = true;
+    } finally {
+      setTimeout(() => {
+        import("fs").then((fs) => {
+          try {
+            fs.unlinkSync(workerPath);
+          } catch {
+          }
+        });
+      }, 1e3);
+    }
+  }
+  handleWorkerMessage(response) {
+    const pending = this.pendingTasks.get(response.id);
+    if (pending) {
+      this.pendingTasks.delete(response.id);
+      if (response.error) {
+        pending.reject(new Error(response.error));
+      } else {
+        pending.resolve(response.result);
+      }
+    }
+  }
+  async processChunks(method, chunks, options) {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+    const promises = chunks.map((chunk, index) => {
+      const taskId = `${this.nextTaskId++}`;
+      const workerIndex = this.roundRobinIndex++ % this.workers.length;
+      return new Promise((resolve, reject) => {
+        this.pendingTasks.set(taskId, { resolve, reject });
+        const task = {
+          id: taskId,
+          method,
+          data: chunk,
+          options
+        };
+        this.workers[workerIndex].postMessage(task);
+      });
+    });
+    return Promise.all(promises);
+  }
+  destroy() {
+    this.workers.forEach((worker) => worker.terminate());
+    this.workers = [];
+    this.pendingTasks.clear();
+    this.isInitialized = false;
+  }
+}
+function chunkDataNodejs(data, numChunks) {
+  if (numChunks <= 1 || data.length < 1024) {
+    return [data];
+  }
+  const chunkSize = Math.ceil(data.length / numChunks);
+  const chunks = [];
+  let start = 0;
+  while (start < data.length) {
+    let end = Math.min(start + chunkSize, data.length);
+    if (end < data.length) {
+      const searchStart = Math.max(start + chunkSize - 2048, start);
+      const searchEnd = Math.min(end + 2048, data.length);
+      let foundNewline = false;
+      for (let i = searchEnd - 1; i >= searchStart; i--) {
+        if (data[i] === 10) {
+          end = i + 1;
+          foundNewline = true;
+          break;
+        }
+      }
+      if (!foundNewline) {
+        for (let i = end - 1; i >= searchStart; i--) {
+          if (data[i] === 44) {
+            end = i + 1;
+            break;
+          }
+        }
+      }
+    }
+    chunks.push(data.slice(start, end));
+    start = end;
+  }
+  return chunks;
+}
+function mergeResultsNodejs(results, format) {
+  if (results.length === 1) {
+    return results[0];
+  }
+  const totalLength = results.reduce((sum, chunk) => sum + chunk.length, 0);
+  const merged = new Uint8Array(totalLength);
+  let offset = 0;
+  switch (format) {
+    case "ndjson":
+      for (const chunk of results) {
+        merged.set(chunk, offset);
+        offset += chunk.length;
+      }
+      break;
+    case "csv":
+      const [first, ...rest] = results;
+      merged.set(first, offset);
+      offset += first.length;
+      for (const chunk of rest) {
+        let headerEnd = 0;
+        for (let i = 0; i < chunk.length; i++) {
+          if (chunk[i] === 10) {
+            headerEnd = i + 1;
+            break;
+          }
+        }
+        const dataWithoutHeader = chunk.slice(headerEnd);
+        merged.set(dataWithoutHeader, offset);
+        offset += dataWithoutHeader.length;
+      }
+      break;
+    case "json":
+    default:
+      for (const chunk of results) {
+        merged.set(chunk, offset);
+        offset += chunk.length;
+      }
+      break;
+  }
+  return merged.slice(0, offset);
+}
+export {
+  NodejsThreadPool,
+  chunkDataNodejs,
+  mergeResultsNodejs
+};
+//# sourceMappingURL=nodejs-thread-pool.js.map

package/dist/src/nodejs-thread-pool.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/nodejs-thread-pool.ts"],"sourcesContent":["// Node.js specific threading implementation using Worker Threads\r\n// This provides better performance than the browser web worker approach\r\n\r\nimport { Worker, isMainThread, parentPort, workerData } from 'worker_threads';\r\nimport { fileURLToPath } from 'url';\r\nimport { dirname, join } from 'path';\r\n\r\nconst __filename = fileURLToPath(import.meta.url);\r\nconst __dirname = dirname(__filename);\r\n\r\nexport interface NodejsThreadPoolConfig {\r\n  maxWorkers: number;\r\n  wasmPath: string;\r\n}\r\n\r\nexport interface WorkerTask {\r\n  id: string;\r\n  method: string;\r\n  data: Uint8Array;\r\n  options: any;\r\n}\r\n\r\nexport interface WorkerResult {\r\n  id: string;\r\n  result?: Uint8Array;\r\n  error?: string;\r\n}\r\n\r\nexport class NodejsThreadPool {\r\n  private workers: Worker[] = [];\r\n  private pendingTasks = new Map<string, { resolve: Function; reject: Function }>();\r\n  private nextTaskId = 0;\r\n  private isInitialized = false;\r\n  private roundRobinIndex = 0;\r\n\r\n  constructor(private config: NodejsThreadPoolConfig) {}\r\n\r\n  async initialize(): Promise<void> {\r\n    if (this.isInitialized) return;\r\n\r\n    // Create the worker script inline\r\n    const workerScript = `\r\n      import { parentPort, workerData } from 'worker_threads';\r\n      import { createRequire } from 'node:module';\r\n      \r\n      const require = createRequire(import.meta.url);\r\n      \r\n      let wasmModule = null;\r\n      \r\n      async function initWasm() {\r\n        if (!wasmModule) {\r\n          // Import the Node.js WASM module\r\n          wasmModule = require('${this.config.wasmPath}');\r\n          wasmModule.init(false); // Initialize without debug logs in workers\r\n        }\r\n        return wasmModule;\r\n      }\r\n      \r\n      parentPort.on('message', async (task) => {\r\n        try {\r\n          const { id, method, data, options } = task;\r\n          \r\n          if (!wasmModule) {\r\n            await initWasm();\r\n          }\r\n          \r\n          const converter = new wasmModule.Converter(false);\r\n          \r\n          // Configure converter based on options\r\n          if (options.outputFormat) {\r\n            converter.set_output_format(options.outputFormat);\r\n          }\r\n          if (options.inputFormat) {\r\n            converter.set_input_format(options.inputFormat);\r\n          }\r\n          \r\n          // Process the data\r\n          const output = converter.push(data);\r\n          const final = converter.finish();\r\n          \r\n          // Combine outputs\r\n          const result = new Uint8Array(output.length + final.length);\r\n          result.set(output, 0);\r\n          result.set(final, output.length);\r\n          \r\n          parentPort.postMessage({ id, result });\r\n        } catch (error) {\r\n          parentPort.postMessage({ id, error: error.message });\r\n        }\r\n      });\r\n      \r\n      // Initialize WASM when worker starts\r\n      initWasm().catch(console.error);\r\n    `;\r\n\r\n    // Write worker script to a temporary file\r\n    const workerPath = join(__dirname, `worker-${Date.now()}.mjs`);\r\n    await import('fs').then(fs => {\r\n      fs.writeFileSync(workerPath, workerScript);\r\n    });\r\n\r\n    try {\r\n      for (let i = 0; i < this.config.maxWorkers; i++) {\r\n        const worker = new Worker(workerPath, { type: 'module' } as any);\r\n        \r\n        worker.on('message', (response: WorkerResult) => {\r\n          this.handleWorkerMessage(response);\r\n        });\r\n        \r\n        worker.on('error', (error) => {\r\n          console.error('Worker error:', error);\r\n        });\r\n        \r\n        this.workers.push(worker);\r\n      }\r\n      \r\n      this.isInitialized = true;\r\n    } finally {\r\n      // Clean up the temporary worker file\r\n      setTimeout(() => {\r\n        import('fs').then(fs => {\r\n          try {\r\n            fs.unlinkSync(workerPath);\r\n          } catch {}\r\n        });\r\n      }, 1000);\r\n    }\r\n  }\r\n\r\n  private handleWorkerMessage(response: WorkerResult): void {\r\n    const pending = this.pendingTasks.get(response.id);\r\n    if (pending) {\r\n      this.pendingTasks.delete(response.id);\r\n      if (response.error) {\r\n        pending.reject(new Error(response.error));\r\n      } else {\r\n        pending.resolve(response.result);\r\n      }\r\n    }\r\n  }\r\n\r\n  async processChunks(method: string, chunks: Uint8Array[], options: any): Promise<Uint8Array[]> {\r\n    if (!this.isInitialized) {\r\n      await this.initialize();\r\n    }\r\n\r\n    const promises = chunks.map((chunk, index) => {\r\n      const taskId = `${this.nextTaskId++}`;\r\n      const workerIndex = this.roundRobinIndex++ % this.workers.length;\r\n      \r\n      return new Promise<Uint8Array>((resolve, reject) => {\r\n        this.pendingTasks.set(taskId, { resolve, reject });\r\n        \r\n        const task: WorkerTask = {\r\n          id: taskId,\r\n          method,\r\n          data: chunk,\r\n          options\r\n        };\r\n        \r\n        this.workers[workerIndex].postMessage(task);\r\n      });\r\n    });\r\n\r\n    return Promise.all(promises);\r\n  }\r\n\r\n  destroy(): void {\r\n    this.workers.forEach(worker => worker.terminate());\r\n    this.workers = [];\r\n    this.pendingTasks.clear();\r\n    this.isInitialized = false;\r\n  }\r\n}\r\n\r\n// Utility functions for chunking data at byte boundaries (optimized for Node.js)\r\nexport function chunkDataNodejs(data: Uint8Array, numChunks: number): Uint8Array[] {\r\n  if (numChunks <= 1 || data.length < 1024) {\r\n    return [data];\r\n  }\r\n\r\n  const chunkSize = Math.ceil(data.length / numChunks);\r\n  const chunks: Uint8Array[] = [];\r\n  \r\n  let start = 0;\r\n  while (start < data.length) {\r\n    let end = Math.min(start + chunkSize, data.length);\r\n    \r\n    // For CSV/NDJSON, align to line boundaries (more aggressive search)\r\n    if (end < data.length) {\r\n      const searchStart = Math.max(start + chunkSize - 2048, start); // Search back up to 2KB\r\n      const searchEnd = Math.min(end + 2048, data.length); // Search forward up to 2KB\r\n      \r\n      // Look for newline\r\n      let foundNewline = false;\r\n      for (let i = searchEnd - 1; i >= searchStart; i--) {\r\n        if (data[i] === 0x0A) { // '\\n'\r\n          end = i + 1;\r\n          foundNewline = true;\r\n          break;\r\n        }\r\n      }\r\n      \r\n      // If no newline found, search for comma (CSV field boundary)\r\n      if (!foundNewline) {\r\n        for (let i = end - 1; i >= searchStart; i--) {\r\n          if (data[i] === 0x2C) { // ','\r\n            end = i + 1;\r\n            break;\r\n          }\r\n        }\r\n      }\r\n    }\r\n    \r\n    chunks.push(data.slice(start, end));\r\n    start = end;\r\n  }\r\n  \r\n  return chunks;\r\n}\r\n\r\n// Smart result merging optimized for Node.js Buffer operations\r\nexport function mergeResultsNodejs(results: Uint8Array[], format: string): Uint8Array {\r\n  if (results.length === 1) {\r\n    return results[0];\r\n  }\r\n\r\n  // Calculate total size for efficient allocation\r\n  const totalLength = results.reduce((sum, chunk) => sum + chunk.length, 0);\r\n  const merged = new Uint8Array(totalLength);\r\n  \r\n  let offset = 0;\r\n  \r\n  switch (format) {\r\n    case 'ndjson':\r\n      // Simple concatenation for NDJSON\r\n      for (const chunk of results) {\r\n        merged.set(chunk, offset);\r\n        offset += chunk.length;\r\n      }\r\n      break;\r\n      \r\n    case 'csv':\r\n      // Merge CSV: keep header from first chunk only\r\n      const [first, ...rest] = results;\r\n      merged.set(first, offset);\r\n      offset += first.length;\r\n      \r\n      for (const chunk of rest) {\r\n        // Find first newline (skip header)\r\n        let headerEnd = 0;\r\n        for (let i = 0; i < chunk.length; i++) {\r\n          if (chunk[i] === 0x0A) {\r\n            headerEnd = i + 1;\r\n            break;\r\n          }\r\n        }\r\n        \r\n        const dataWithoutHeader = chunk.slice(headerEnd);\r\n        merged.set(dataWithoutHeader, offset);\r\n        offset += dataWithoutHeader.length;\r\n      }\r\n      break;\r\n      \r\n    case 'json':\r\n    default:\r\n      // Default concatenation\r\n      for (const chunk of results) {\r\n        merged.set(chunk, offset);\r\n        offset += chunk.length;\r\n      }\r\n      break;\r\n  }\r\n  \r\n  return merged.slice(0, offset);\r\n}"],"mappings":"AAGA,SAAS,cAAoD;AAC7D,SAAS,qBAAqB;AAC9B,SAAS,SAAS,YAAY;AAE9B,MAAM,aAAa,cAAc,YAAY,GAAG;AAChD,MAAM,YAAY,QAAQ,UAAU;AAoB7B,MAAM,iBAAiB;AAAA,EAO5B,YAAoB,QAAgC;AAAhC;AAAA,EAAiC;AAAA,EAN7C,UAAoB,CAAC;AAAA,EACrB,eAAe,oBAAI,IAAqD;AAAA,EACxE,aAAa;AAAA,EACb,gBAAgB;AAAA,EAChB,kBAAkB;AAAA,EAI1B,MAAM,aAA4B;AAChC,QAAI,KAAK,cAAe;AAGxB,UAAM,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kCAWS,KAAK,OAAO,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA4ClD,UAAM,aAAa,KAAK,WAAW,UAAU,KAAK,IAAI,CAAC,MAAM;AAC7D,UAAM,OAAO,IAAI,EAAE,KAAK,QAAM;AAC5B,SAAG,cAAc,YAAY,YAAY;AAAA,IAC3C,CAAC;AAED,QAAI;AACF,eAAS,IAAI,GAAG,IAAI,KAAK,OAAO,YAAY,KAAK;AAC/C,cAAM,SAAS,IAAI,OAAO,YAAY,EAAE,MAAM,SAAS,CAAQ;AAE/D,eAAO,GAAG,WAAW,CAAC,aAA2B;AAC/C,eAAK,oBAAoB,QAAQ;AAAA,QACnC,CAAC;AAED,eAAO,GAAG,SAAS,CAAC,UAAU;AAC5B,kBAAQ,MAAM,iBAAiB,KAAK;AAAA,QACtC,CAAC;AAED,aAAK,QAAQ,KAAK,MAAM;AAAA,MAC1B;AAEA,WAAK,gBAAgB;AAAA,IACvB,UAAE;AAEA,iBAAW,MAAM;AACf,eAAO,IAAI,EAAE,KAAK,QAAM;AACtB,cAAI;AACF,eAAG,WAAW,UAAU;AAAA,UAC1B,QAAQ;AAAA,UAAC;AAAA,QACX,CAAC;AAAA,MACH,GAAG,GAAI;AAAA,IACT;AAAA,EACF;AAAA,EAEQ,oBAAoB,UAA8B;AACxD,UAAM,UAAU,KAAK,aAAa,IAAI,SAAS,EAAE;AACjD,QAAI,SAAS;AACX,WAAK,aAAa,OAAO,SAAS,EAAE;AACpC,UAAI,SAAS,OAAO;AAClB,gBAAQ,OAAO,IAAI,MAAM,SAAS,KAAK,CAAC;AAAA,MAC1C,OAAO;AACL,gBAAQ,QAAQ,SAAS,MAAM;AAAA,MACjC;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAM,cAAc,QAAgB,QAAsB,SAAqC;AAC7F,QAAI,CAAC,KAAK,eAAe;AACvB,YAAM,KAAK,WAAW;AAAA,IACxB;AAEA,UAAM,WAAW,OAAO,IAAI,CAAC,OAAO,UAAU;AAC5C,YAAM,SAAS,GAAG,KAAK,YAAY;AACnC,YAAM,cAAc,KAAK,oBAAoB,KAAK,QAAQ;AAE1D,aAAO,IAAI,QAAoB,CAAC,SAAS,WAAW;AAClD,aAAK,aAAa,IAAI,QAAQ,EAAE,SAAS,OAAO,CAAC;AAEjD,cAAM,OAAmB;AAAA,UACvB,IAAI;AAAA,UACJ;AAAA,UACA,MAAM;AAAA,UACN;AAAA,QACF;AAEA,aAAK,QAAQ,WAAW,EAAE,YAAY,IAAI;AAAA,MAC5C,CAAC;AAAA,IACH,CAAC;AAED,WAAO,QAAQ,IAAI,QAAQ;AAAA,EAC7B;AAAA,EAEA,UAAgB;AACd,SAAK,QAAQ,QAAQ,YAAU,OAAO,UAAU,CAAC;AACjD,SAAK,UAAU,CAAC;AAChB,SAAK,aAAa,MAAM;AACxB,SAAK,gBAAgB;AAAA,EACvB;AACF;AAGO,SAAS,gBAAgB,MAAkB,WAAiC;AACjF,MAAI,aAAa,KAAK,KAAK,SAAS,MAAM;AACxC,WAAO,CAAC,IAAI;AAAA,EACd;AAEA,QAAM,YAAY,KAAK,KAAK,KAAK,SAAS,SAAS;AACnD,QAAM,SAAuB,CAAC;AAE9B,MAAI,QAAQ;AACZ,SAAO,QAAQ,KAAK,QAAQ;AAC1B,QAAI,MAAM,KAAK,IAAI,QAAQ,WAAW,KAAK,MAAM;AAGjD,QAAI,MAAM,KAAK,QAAQ;AACrB,YAAM,cAAc,KAAK,IAAI,QAAQ,YAAY,MAAM,KAAK;AAC5D,YAAM,YAAY,KAAK,IAAI,MAAM,MAAM,KAAK,MAAM;AAGlD,UAAI,eAAe;AACnB,eAAS,IAAI,YAAY,GAAG,KAAK,aAAa,KAAK;AACjD,YAAI,KAAK,CAAC,MAAM,IAAM;AACpB,gBAAM,IAAI;AACV,yBAAe;AACf;AAAA,QACF;AAAA,MACF;AAGA,UAAI,CAAC,cAAc;AACjB,iBAAS,IAAI,MAAM,GAAG,KAAK,aAAa,KAAK;AAC3C,cAAI,KAAK,CAAC,MAAM,IAAM;AACpB,kBAAM,IAAI;AACV;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,WAAO,KAAK,KAAK,MAAM,OAAO,GAAG,CAAC;AAClC,YAAQ;AAAA,EACV;AAEA,SAAO;AACT;AAGO,SAAS,mBAAmB,SAAuB,QAA4B;AACpF,MAAI,QAAQ,WAAW,GAAG;AACxB,WAAO,QAAQ,CAAC;AAAA,EAClB;AAGA,QAAM,cAAc,QAAQ,OAAO,CAAC,KAAK,UAAU,MAAM,MAAM,QAAQ,CAAC;AACxE,QAAM,SAAS,IAAI,WAAW,WAAW;AAEzC,MAAI,SAAS;AAEb,UAAQ,QAAQ;AAAA,IACd,KAAK;AAEH,iBAAW,SAAS,SAAS;AAC3B,eAAO,IAAI,OAAO,MAAM;AACxB,kBAAU,MAAM;AAAA,MAClB;AACA;AAAA,IAEF,KAAK;AAEH,YAAM,CAAC,OAAO,GAAG,IAAI,IAAI;AACzB,aAAO,IAAI,OAAO,MAAM;AACxB,gBAAU,MAAM;AAEhB,iBAAW,SAAS,MAAM;AAExB,YAAI,YAAY;AAChB,iBAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,cAAI,MAAM,CAAC,MAAM,IAAM;AACrB,wBAAY,IAAI;AAChB;AAAA,UACF;AAAA,QACF;AAEA,cAAM,oBAAoB,MAAM,MAAM,SAAS;AAC/C,eAAO,IAAI,mBAAmB,MAAM;AACpC,kBAAU,kBAAkB;AAAA,MAC9B;AACA;AAAA,IAEF,KAAK;AAAA,IACL;AAEE,iBAAW,SAAS,SAAS;AAC3B,eAAO,IAAI,OAAO,MAAM;AACxB,kBAAU,MAAM;AAAA,MAClB;AACA;AAAA,EACJ;AAEA,SAAO,OAAO,MAAM,GAAG,MAAM;AAC/B;","names":[]}

package/dist/src/thread-pool.d.ts

@@ -0,0 +1,31 @@
+interface ThreadPoolConfig {
+    maxWorkers: number;
+    wasmPath: string;
+}
+interface WorkerMessage {
+    id: string;
+    method: string;
+    data: string;
+    options: any;
+}
+interface WorkerResponse {
+    id: string;
+    result?: string;
+    error?: string;
+}
+declare class WasmThreadPool {
+    private config;
+    private workers;
+    private pendingTasks;
+    private nextTaskId;
+    private isInitialized;
+    constructor(config: ThreadPoolConfig);
+    initialize(): Promise<void>;
+    private handleWorkerMessage;
+    processChunks(method: string, chunks: string[], options: any): Promise<string[]>;
+    destroy(): void;
+}
+declare function chunkData(data: string, numChunks: number): string[];
+declare function mergeResults(results: string[], format: string): string;
+
+export { type ThreadPoolConfig, WasmThreadPool, type WorkerMessage, type WorkerResponse, chunkData, mergeResults };

package/dist/src/thread-pool.js

@@ -0,0 +1,154 @@
+class WasmThreadPool {
+  constructor(config) {
+    this.config = config;
+  }
+  workers = [];
+  pendingTasks = /* @__PURE__ */ new Map();
+  nextTaskId = 0;
+  isInitialized = false;
+  async initialize() {
+    if (this.isInitialized) return;
+    const workerCode = `
+      let wasmModule = null;
+      
+      async function initWasm() {
+        if (!wasmModule) {
+          const wasmImport = await import('${this.config.wasmPath}');
+          wasmModule = wasmImport;
+        }
+        return wasmModule;
+      }
+      
+      self.onmessage = async function(e) {
+        try {
+          const { id, method, data, options } = e.data;
+          
+          if (!wasmModule) {
+            await initWasm();
+          }
+          
+          let result;
+          switch (method) {
+            case 'parseCSV':
+              result = wasmModule.csv_to_ndjson(data, options);
+              break;
+            case 'parseJSON':
+              result = wasmModule.json_to_csv(data, options);
+              break;
+            case 'parseNDJSON':
+              result = wasmModule.ndjson_to_csv(data, options);
+              break;
+            case 'parseXML':
+              result = wasmModule.xml_to_json(data, options);
+              break;
+            default:
+              throw new Error('Unknown method: ' + method);
+          }
+          
+          self.postMessage({ id, result });
+        } catch (error) {
+          self.postMessage({ id, error: error.message });
+        }
+      };
+    `;
+    const workerBlob = new Blob([workerCode], { type: "application/javascript" });
+    const workerUrl = URL.createObjectURL(workerBlob);
+    for (let i = 0; i < this.config.maxWorkers; i++) {
+      const worker = new Worker(workerUrl, { type: "module" });
+      worker.onmessage = (e) => {
+        this.handleWorkerMessage(e.data);
+      };
+      this.workers.push(worker);
+    }
+    URL.revokeObjectURL(workerUrl);
+    this.isInitialized = true;
+  }
+  handleWorkerMessage(response) {
+    const pending = this.pendingTasks.get(response.id);
+    if (pending) {
+      this.pendingTasks.delete(response.id);
+      if (response.error) {
+        pending.reject(new Error(response.error));
+      } else {
+        pending.resolve(response.result);
+      }
+    }
+  }
+  async processChunks(method, chunks, options) {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+    const promises = chunks.map((chunk, index) => {
+      const taskId = `${this.nextTaskId++}`;
+      const workerIndex = index % this.workers.length;
+      return new Promise((resolve, reject) => {
+        this.pendingTasks.set(taskId, { resolve, reject });
+        const message = {
+          id: taskId,
+          method,
+          data: chunk,
+          options
+        };
+        this.workers[workerIndex].postMessage(message);
+      });
+    });
+    return Promise.all(promises);
+  }
+  destroy() {
+    this.workers.forEach((worker) => worker.terminate());
+    this.workers = [];
+    this.pendingTasks.clear();
+    this.isInitialized = false;
+  }
+}
+function chunkData(data, numChunks) {
+  if (numChunks <= 1 || data.length < 1e3) {
+    return [data];
+  }
+  const chunkSize = Math.ceil(data.length / numChunks);
+  const chunks = [];
+  let start = 0;
+  while (start < data.length) {
+    let end = Math.min(start + chunkSize, data.length);
+    if (end < data.length) {
+      const nextNewline = data.indexOf("\n", end);
+      if (nextNewline !== -1 && nextNewline < end + 500) {
+        end = nextNewline + 1;
+      }
+    }
+    chunks.push(data.slice(start, end));
+    start = end;
+  }
+  return chunks;
+}
+function mergeResults(results, format) {
+  if (results.length === 1) {
+    return results[0];
+  }
+  switch (format) {
+    case "ndjson":
+      return results.join("");
+    case "csv":
+      const [first, ...rest] = results;
+      const restWithoutHeaders = rest.map((chunk) => {
+        const lines = chunk.split("\n");
+        return lines.slice(1).join("\n");
+      });
+      return [first, ...restWithoutHeaders].join("");
+    case "json":
+      try {
+        const arrays = results.map((r) => JSON.parse(r));
+        return JSON.stringify(arrays.flat());
+      } catch {
+        return results.join("\n");
+      }
+    default:
+      return results.join("");
+  }
+}
+export {
+  WasmThreadPool,
+  chunkData,
+  mergeResults
+};
+//# sourceMappingURL=thread-pool.js.map

package/dist/src/thread-pool.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/thread-pool.ts"],"sourcesContent":["// Custom WASM threading implementation using web workers\r\n// This bypasses wasm-bindgen-rayon issues by implementing parallelism at the JS level\r\n\r\nexport interface ThreadPoolConfig {\r\n  maxWorkers: number;\r\n  wasmPath: string;\r\n}\r\n\r\nexport interface WorkerMessage {\r\n  id: string;\r\n  method: string;\r\n  data: string;\r\n  options: any;\r\n}\r\n\r\nexport interface WorkerResponse {\r\n  id: string;\r\n  result?: string;\r\n  error?: string;\r\n}\r\n\r\nexport class WasmThreadPool {\r\n  private workers: Worker[] = [];\r\n  private pendingTasks = new Map<string, { resolve: Function; reject: Function }>();\r\n  private nextTaskId = 0;\r\n  private isInitialized = false;\r\n\r\n  constructor(private config: ThreadPoolConfig) {}\r\n\r\n  async initialize(): Promise<void> {\r\n    if (this.isInitialized) return;\r\n\r\n    // Create worker code inline to avoid external file dependencies\r\n    const workerCode = `\r\n      let wasmModule = null;\r\n      \r\n      async function initWasm() {\r\n        if (!wasmModule) {\r\n          const wasmImport = await import('${this.config.wasmPath}');\r\n          wasmModule = wasmImport;\r\n        }\r\n        return wasmModule;\r\n      }\r\n      \r\n      self.onmessage = async function(e) {\r\n        try {\r\n          const { id, method, data, options } = e.data;\r\n          \r\n          if (!wasmModule) {\r\n            await initWasm();\r\n          }\r\n          \r\n          let result;\r\n          switch (method) {\r\n            case 'parseCSV':\r\n              result = wasmModule.csv_to_ndjson(data, options);\r\n              break;\r\n            case 'parseJSON':\r\n              result = wasmModule.json_to_csv(data, options);\r\n              break;\r\n            case 'parseNDJSON':\r\n              result = wasmModule.ndjson_to_csv(data, options);\r\n              break;\r\n            case 'parseXML':\r\n              result = wasmModule.xml_to_json(data, options);\r\n              break;\r\n            default:\r\n              throw new Error('Unknown method: ' + method);\r\n          }\r\n          \r\n          self.postMessage({ id, result });\r\n        } catch (error) {\r\n          self.postMessage({ id, error: error.message });\r\n        }\r\n      };\r\n    `;\r\n\r\n    const workerBlob = new Blob([workerCode], { type: 'application/javascript' });\r\n    const workerUrl = URL.createObjectURL(workerBlob);\r\n\r\n    for (let i = 0; i < this.config.maxWorkers; i++) {\r\n      const worker = new Worker(workerUrl, { type: 'module' });\r\n      worker.onmessage = (e: MessageEvent<WorkerResponse>) => {\r\n        this.handleWorkerMessage(e.data);\r\n      };\r\n      this.workers.push(worker);\r\n    }\r\n\r\n    URL.revokeObjectURL(workerUrl);\r\n    this.isInitialized = true;\r\n  }\r\n\r\n  private handleWorkerMessage(response: WorkerResponse): void {\r\n    const pending = this.pendingTasks.get(response.id);\r\n    if (pending) {\r\n      this.pendingTasks.delete(response.id);\r\n      if (response.error) {\r\n        pending.reject(new Error(response.error));\r\n      } else {\r\n        pending.resolve(response.result);\r\n      }\r\n    }\r\n  }\r\n\r\n  async processChunks(method: string, chunks: string[], options: any): Promise<string[]> {\r\n    if (!this.isInitialized) {\r\n      await this.initialize();\r\n    }\r\n\r\n    const promises = chunks.map((chunk, index) => {\r\n      const taskId = `${this.nextTaskId++}`;\r\n      const workerIndex = index % this.workers.length;\r\n      \r\n      return new Promise<string>((resolve, reject) => {\r\n        this.pendingTasks.set(taskId, { resolve, reject });\r\n        \r\n        const message: WorkerMessage = {\r\n          id: taskId,\r\n          method,\r\n          data: chunk,\r\n          options\r\n        };\r\n        \r\n        this.workers[workerIndex].postMessage(message);\r\n      });\r\n    });\r\n\r\n    return Promise.all(promises);\r\n  }\r\n\r\n  destroy(): void {\r\n    this.workers.forEach(worker => worker.terminate());\r\n    this.workers = [];\r\n    this.pendingTasks.clear();\r\n    this.isInitialized = false;\r\n  }\r\n}\r\n\r\n// Utility functions for chunking data intelligently\r\nexport function chunkData(data: string, numChunks: number): string[] {\r\n  if (numChunks <= 1 || data.length < 1000) {\r\n    return [data];\r\n  }\r\n\r\n  const chunkSize = Math.ceil(data.length / numChunks);\r\n  const chunks: string[] = [];\r\n  \r\n  let start = 0;\r\n  while (start < data.length) {\r\n    let end = Math.min(start + chunkSize, data.length);\r\n    \r\n    // For CSV/NDJSON, align to line boundaries\r\n    if (end < data.length) {\r\n      const nextNewline = data.indexOf('\\n', end);\r\n      if (nextNewline !== -1 && nextNewline < end + 500) {\r\n        end = nextNewline + 1;\r\n      }\r\n    }\r\n    \r\n    chunks.push(data.slice(start, end));\r\n    start = end;\r\n  }\r\n  \r\n  return chunks;\r\n}\r\n\r\n// Smart chunk merging that preserves data structure\r\nexport function mergeResults(results: string[], format: string): string {\r\n  if (results.length === 1) {\r\n    return results[0];\r\n  }\r\n\r\n  switch (format) {\r\n    case 'ndjson':\r\n      return results.join('');\r\n    case 'csv':\r\n      // Merge CSV: keep header from first chunk only\r\n      const [first, ...rest] = results;\r\n      const restWithoutHeaders = rest.map(chunk => {\r\n        const lines = chunk.split('\\n');\r\n        return lines.slice(1).join('\\n');\r\n      });\r\n      return [first, ...restWithoutHeaders].join('');\r\n    case 'json':\r\n      // Merge JSON arrays\r\n      try {\r\n        const arrays = results.map(r => JSON.parse(r));\r\n        return JSON.stringify(arrays.flat());\r\n      } catch {\r\n        return results.join('\\n');\r\n      }\r\n    default:\r\n      return results.join('');\r\n  }\r\n}"],"mappings":"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","names":[]}

package/dist/wasm/nodejs/convert_buddy.cjs

@@ -0,0 +1,712 @@
+
+let imports = {};
+imports['__wbindgen_placeholder__'] = module.exports;
+let wasm;
+const { TextDecoder, TextEncoder } = require(`util`);
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_export_3.set(idx, obj);
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedTextEncoder = new TextEncoder('utf-8');
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+/**
+ * Check if threading is enabled in this build.
+ * @returns {boolean}
+ */
+module.exports.getThreadingEnabled = function() {
+    const ret = wasm.getSimdEnabled();
+    return ret !== 0;
+};
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+/**
+ * Detect XML elements from a sample of bytes.
+ * @param {Uint8Array} sample
+ * @returns {any}
+ */
+module.exports.detectXmlElements = function(sample) {
+    const ptr0 = passArray8ToWasm0(sample, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.detectXmlElements(ptr0, len0);
+    return ret;
+};
+
+/**
+ * Detect CSV fields and delimiter from a sample of bytes.
+ * @param {Uint8Array} sample
+ * @returns {any}
+ */
+module.exports.detectCsvFields = function(sample) {
+    const ptr0 = passArray8ToWasm0(sample, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.detectCsvFields(ptr0, len0);
+    return ret;
+};
+
+/**
+ * @param {boolean} debug_enabled
+ */
+module.exports.init = function(debug_enabled) {
+    wasm.init(debug_enabled);
+};
+
+/**
+ * Check if SIMD is enabled in this build.
+ * @returns {boolean}
+ */
+module.exports.getSimdEnabled = function() {
+    const ret = wasm.getSimdEnabled();
+    return ret !== 0;
+};
+
+/**
+ * @returns {any}
+ */
+module.exports.get_threading_support_info = function() {
+    const ret = wasm.get_threading_support_info();
+    return ret;
+};
+
+/**
+ * Detect the input format from a sample of bytes.
+ * @param {Uint8Array} sample
+ * @returns {string | undefined}
+ */
+module.exports.detectFormat = function(sample) {
+    const ptr0 = passArray8ToWasm0(sample, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.detectFormat(ptr0, len0);
+    let v2;
+    if (ret[0] !== 0) {
+        v2 = getStringFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v2;
+};
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_3.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+const ConverterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_converter_free(ptr >>> 0, 1));
+/**
+ * A streaming converter state machine.
+ * Converts between CSV, NDJSON, JSON, and XML formats with high performance.
+ */
+class Converter {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Converter.prototype);
+        obj.__wbg_ptr = ptr;
+        ConverterFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ConverterFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_converter_free(ptr, 0);
+    }
+    /**
+     * Create a new converter with specific configuration
+     * @param {boolean} debug
+     * @param {string} input_format
+     * @param {string} output_format
+     * @param {number} chunk_target_bytes
+     * @param {boolean} enable_stats
+     * @param {any} csv_config
+     * @param {any} xml_config
+     * @returns {Converter}
+     */
+    static withConfig(debug, input_format, output_format, chunk_target_bytes, enable_stats, csv_config, xml_config) {
+        const ptr0 = passStringToWasm0(input_format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(output_format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.converter_withConfig(debug, ptr0, len0, ptr1, len1, chunk_target_bytes, enable_stats, csv_config, xml_config);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Converter.__wrap(ret[0]);
+    }
+    /**
+     * @param {boolean} debug
+     */
+    constructor(debug) {
+        const ret = wasm.converter_new(debug);
+        this.__wbg_ptr = ret >>> 0;
+        ConverterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Push a chunk of bytes. Returns converted output bytes for that chunk.
+     * @param {Uint8Array} chunk
+     * @returns {Uint8Array}
+     */
+    push(chunk) {
+        const ptr0 = passArray8ToWasm0(chunk, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.converter_push(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v2;
+    }
+    /**
+     * Finish the stream and return any remaining buffered output.
+     * @returns {Uint8Array}
+     */
+    finish() {
+        const ret = wasm.converter_finish(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Get performance statistics
+     * @returns {Stats}
+     */
+    getStats() {
+        const ret = wasm.converter_getStats(this.__wbg_ptr);
+        return Stats.__wrap(ret);
+    }
+}
+module.exports.Converter = Converter;
+
+const StatsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_stats_free(ptr >>> 0, 1));
+/**
+ * Performance statistics for the converter
+ */
+class Stats {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Stats.prototype);
+        obj.__wbg_ptr = ptr;
+        StatsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StatsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_stats_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get parse_time_ms() {
+        const ret = wasm.stats_parse_time_ms(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get write_time_ms() {
+        const ret = wasm.stats_write_time_ms(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get max_buffer_size() {
+        const ret = wasm.stats_max_buffer_size(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get records_processed() {
+        const ret = wasm.stats_records_processed(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get transform_time_ms() {
+        const ret = wasm.stats_transform_time_ms(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get current_partial_size() {
+        const ret = wasm.stats_current_partial_size(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get throughput_mb_per_sec() {
+        const ret = wasm.stats_throughput_mb_per_sec(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get bytes_in() {
+        const ret = wasm.stats_bytes_in(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get bytes_out() {
+        const ret = wasm.stats_bytes_out(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get chunks_in() {
+        const ret = wasm.stats_chunks_in(this.__wbg_ptr);
+        return ret;
+    }
+}
+module.exports.Stats = Stats;
+
+module.exports.__wbg_buffer_61b7ce01341d7f88 = function(arg0) {
+    const ret = arg0.buffer;
+    return ret;
+};
+
+module.exports.__wbg_debug_156ca727dbc3150f = function(arg0) {
+    console.debug(arg0);
+};
+
+module.exports.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm0(arg0, arg1));
+    } finally {
+        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+    }
+};
+
+module.exports.__wbg_error_fab41a42d22bf2bc = function(arg0) {
+    console.error(arg0);
+};
+
+module.exports.__wbg_getwithrefkey_1dc361bd10053bfe = function(arg0, arg1) {
+    const ret = arg0[arg1];
+    return ret;
+};
+
+module.exports.__wbg_info_c3044c86ae29faab = function(arg0) {
+    console.info(arg0);
+};
+
+module.exports.__wbg_instanceof_ArrayBuffer_670ddde44cdb2602 = function(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof ArrayBuffer;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+module.exports.__wbg_instanceof_Uint8Array_28af5bc19d6acad8 = function(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Uint8Array;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+module.exports.__wbg_length_65d1cd11729ced11 = function(arg0) {
+    const ret = arg0.length;
+    return ret;
+};
+
+module.exports.__wbg_log_464d1b2190ca1e04 = function(arg0) {
+    console.log(arg0);
+};
+
+module.exports.__wbg_new_254fa9eac11932ae = function() {
+    const ret = new Array();
+    return ret;
+};
+
+module.exports.__wbg_new_3ff5b33b1ce712df = function(arg0) {
+    const ret = new Uint8Array(arg0);
+    return ret;
+};
+
+module.exports.__wbg_new_688846f374351c92 = function() {
+    const ret = new Object();
+    return ret;
+};
+
+module.exports.__wbg_new_8a6f238a6ece86ea = function() {
+    const ret = new Error();
+    return ret;
+};
+
+module.exports.__wbg_new_bc96c6a1c0786643 = function() {
+    const ret = new Map();
+    return ret;
+};
+
+module.exports.__wbg_now_64d0bb151e5d3889 = function() {
+    const ret = Date.now();
+    return ret;
+};
+
+module.exports.__wbg_push_6edad0df4b546b2c = function(arg0, arg1) {
+    const ret = arg0.push(arg1);
+    return ret;
+};
+
+module.exports.__wbg_set_1d80752d0d5f0b21 = function(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
+};
+
+module.exports.__wbg_set_23d69db4e5c66a6e = function(arg0, arg1, arg2) {
+    arg0.set(arg1, arg2 >>> 0);
+};
+
+module.exports.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+    arg0[arg1] = arg2;
+};
+
+module.exports.__wbg_set_4e647025551483bd = function() { return handleError(function (arg0, arg1, arg2) {
+    const ret = Reflect.set(arg0, arg1, arg2);
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_set_76818dc3c59a63d5 = function(arg0, arg1, arg2) {
+    const ret = arg0.set(arg1, arg2);
+    return ret;
+};
+
+module.exports.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
+    const ret = arg1.stack;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+module.exports.__wbg_warn_123db6aa8948382e = function(arg0) {
+    console.warn(arg0);
+};
+
+module.exports.__wbindgen_bigint_from_i64 = function(arg0) {
+    const ret = arg0;
+    return ret;
+};
+
+module.exports.__wbindgen_bigint_from_u64 = function(arg0) {
+    const ret = BigInt.asUintN(64, arg0);
+    return ret;
+};
+
+module.exports.__wbindgen_boolean_get = function(arg0) {
+    const v = arg0;
+    const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
+    return ret;
+};
+
+module.exports.__wbindgen_debug_string = function(arg0, arg1) {
+    const ret = debugString(arg1);
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+module.exports.__wbindgen_error_new = function(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+};
+
+module.exports.__wbindgen_in = function(arg0, arg1) {
+    const ret = arg0 in arg1;
+    return ret;
+};
+
+module.exports.__wbindgen_init_externref_table = function() {
+    const table = wasm.__wbindgen_export_3;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
+};
+
+module.exports.__wbindgen_is_null = function(arg0) {
+    const ret = arg0 === null;
+    return ret;
+};
+
+module.exports.__wbindgen_is_object = function(arg0) {
+    const val = arg0;
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+};
+
+module.exports.__wbindgen_is_string = function(arg0) {
+    const ret = typeof(arg0) === 'string';
+    return ret;
+};
+
+module.exports.__wbindgen_is_undefined = function(arg0) {
+    const ret = arg0 === undefined;
+    return ret;
+};
+
+module.exports.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
+    const ret = arg0 == arg1;
+    return ret;
+};
+
+module.exports.__wbindgen_memory = function() {
+    const ret = wasm.memory;
+    return ret;
+};
+
+module.exports.__wbindgen_number_get = function(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'number' ? obj : undefined;
+    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+};
+
+module.exports.__wbindgen_number_new = function(arg0) {
+    const ret = arg0;
+    return ret;
+};
+
+module.exports.__wbindgen_string_get = function(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'string' ? obj : undefined;
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+module.exports.__wbindgen_string_new = function(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+};
+
+module.exports.__wbindgen_throw = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+const path = require('path').join(__dirname, 'convert_buddy_bg.wasm');
+const bytes = require('fs').readFileSync(path);
+
+const wasmModule = new WebAssembly.Module(bytes);
+const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
+wasm = wasmInstance.exports;
+module.exports.__wasm = wasm;
+
+wasm.__wbindgen_start();
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "convert-buddy-js",
-  "version": "0.9.7",
+  "version": "0.9.8",
   "description": "TypeScript wrapper for convert-buddy (Rust/WASM core)",
   "license": "MIT",
   "type": "module",