opnet 1.7.21 → 1.7.22

package/browser/providers/JSONRpcProvider.d.ts

@@ -7,11 +7,14 @@ export declare class JSONRpcProvider extends AbstractRpcProvider {
     private readonly timeout;
     private readonly fetcherConfigurations;
     private useRESTAPI;
+    private readonly useThreadedParsing;
     readonly url: string;
-    constructor(url: string, network: Network, timeout?: number, fetcherConfigurations?: Agent.Options, useRESTAPI?: boolean);
-    private _fetcher;
+    private _fetcherWithCleanup;
+    constructor(url: string, network: Network, timeout?: number, fetcherConfigurations?: Agent.Options, useRESTAPI?: boolean, useThreadedParsing?: boolean);
     private get fetcher();
+    close(): Promise<void>;
     setFetchMode(useRESTAPI: boolean): void;
     _send(payload: JsonRpcPayload | JsonRpcPayload[]): Promise<JsonRpcCallResult>;
     protected providerUrl(url: string): string;
+    private parseResponse;
 }

package/browser/threading/JSONThreader.d.ts

@@ -0,0 +1,20 @@
+import { ThreaderOptions, WorkerScript } from './interfaces/IThread.js';
+import { BaseThreader } from './SharedThreader.js';
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type JsonOp = 'parse' | 'stringify';
+type JsonInput = string | JsonValue | ArrayBuffer;
+type JsonOutput = string | JsonValue;
+export declare class JsonThreader extends BaseThreader<JsonOp, JsonInput, JsonOutput> {
+    protected readonly workerScript: WorkerScript;
+    private readonly threadingThreshold;
+    constructor(options?: ThreaderOptions & {
+        threadingThreshold?: number;
+    });
+    parse<T = JsonValue>(json: string): Promise<T>;
+    parseBuffer<T = JsonValue>(buffer: ArrayBuffer): Promise<T>;
+    stringify(data: JsonValue): Promise<string>;
+}
+export declare const jsonThreader: JsonThreader;
+export {};

package/browser/threading/SharedThreader.d.ts

@@ -0,0 +1,36 @@
+import { Logger } from '@btc-vision/logger';
+import { ThreaderOptions, WorkerScript } from './interfaces/IThread.js';
+export declare abstract class BaseThreader<TOp extends string, TData, TResult> extends Logger {
+    readonly logColor: string;
+    protected abstract readonly workerScript: WorkerScript;
+    private workers;
+    private available;
+    private pending;
+    private queue;
+    private idCounter;
+    private readonly poolSize;
+    private initialized;
+    private initializing;
+    private tasksProcessed;
+    private tasksFailed;
+    private lastStatsLog;
+    private readonly statsInterval;
+    private cleanupBound;
+    protected constructor(options?: ThreaderOptions);
+    get stats(): {
+        pending: number;
+        queued: number;
+        available: number;
+        total: number;
+        processed: number;
+        failed: number;
+    };
+    terminate(): Promise<void>;
+    drain(): Promise<void>;
+    protected runWithTransfer(op: TOp, data: TData, transferables: ArrayBuffer[]): Promise<TResult>;
+    protected run(op: TOp, data: TData): Promise<TResult>;
+    private bindCleanupHandlers;
+    private init;
+    private logStatsIfNeeded;
+    private processQueue;
+}

package/browser/threading/WorkerCreator.d.ts

@@ -0,0 +1,3 @@
+import { UniversalWorker, WorkerScript } from './interfaces/IThread.js';
+export declare const isNode: boolean;
+export declare function createWorker<TOp extends string, TData, TResult>(workerScript: WorkerScript): Promise<UniversalWorker<TOp, TData, TResult>>;

package/browser/threading/interfaces/IThread.d.ts

@@ -0,0 +1,28 @@
+export interface TaskMessage<TOp extends string = string, TData = unknown> {
+    id: number;
+    op: TOp;
+    data: TData;
+}
+export interface ResultMessage<TResult = unknown> {
+    id: number;
+    result?: TResult;
+    error?: string;
+}
+export interface PendingTask<TResult = unknown> {
+    resolve: (value: TResult) => void;
+    reject: (error: Error) => void;
+}
+export interface QueuedTask<TOp extends string = string, TData = unknown, TResult = unknown> extends PendingTask<TResult> {
+    op: TOp;
+    data: TData;
+    transferables?: ArrayBuffer[];
+}
+export interface ThreaderOptions {
+    poolSize?: number;
+}
+export interface UniversalWorker<TOp extends string = string, TData = unknown, TResult = unknown> {
+    postMessage(msg: TaskMessage<TOp, TData>, transferables?: readonly Transferable[]): void;
+    onMessage(callback: (msg: ResultMessage<TResult>) => void): void;
+    terminate(): void | Promise<void>;
+}
+export type WorkerScript = string;

package/browser/threading/worker-scripts/JSONWorker.d.ts

@@ -0,0 +1,2 @@
+import { WorkerScript } from '../interfaces/IThread.js';
+export declare const jsonWorkerScript: WorkerScript;

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.7.21";
+export declare const version = "1.7.22";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.7.21';
+export const version = '1.7.22';

package/build/block/Block.d.ts

@@ -2,6 +2,7 @@ import { Network } from '@btc-vision/bitcoin';
 import { Address } from '@btc-vision/transaction';
 import { BigNumberish } from '../common/CommonTypes.js';
 import { OPNetTransactionTypes } from '../interfaces/opnet/OPNetTransactionTypes.js';
+import { ITransaction } from '../transactions/interfaces/ITransaction.js';
 import { TransactionBase } from '../transactions/Transaction.js';
 import { BlockHeaderChecksumProof, IBlock } from './interfaces/IBlock.js';
 export declare class Block implements Omit<IBlock, 'gasUsed' | 'ema' | 'baseGas' | 'deployments'> {
@@ -26,7 +27,12 @@ export declare class Block implements Omit<IBlock, 'gasUsed' | 'ema' | 'baseGas'
     readonly baseGas: bigint;
     readonly gasUsed: bigint;
     readonly checksumProofs: BlockHeaderChecksumProof;
-    readonly transactions: TransactionBase<OPNetTransactionTypes>[];
-    readonly deployments: Address[];
+    private readonly _rawBlock;
+    private readonly _network;
     constructor(block: IBlock, network: Network);
+    private _transactions?;
+    get transactions(): TransactionBase<OPNetTransactionTypes>[];
+    private _deployments?;
+    get deployments(): Address[];
+    get rawTransactions(): ITransaction[];
 }

package/build/block/Block.js

@@ -22,12 +22,13 @@ export class Block {
     baseGas;
     gasUsed;
     checksumProofs;
-    transactions = [];
-    deployments = [];
+    _rawBlock;
+    _network;
     constructor(block, network) {
-        if (!block) {
+        if (!block)
             throw new Error('Invalid block.');
-        }
+        this._rawBlock = block;
+        this._network = network;
         this.height = BigInt(block.height.toString());
         this.hash = block.hash;
         this.previousBlockHash = block.previousBlockHash;
@@ -49,11 +50,24 @@ export class Block {
         this.storageRoot = block.storageRoot;
         this.receiptRoot = block.receiptRoot;
         this.checksumProofs = block.checksumProofs;
-        this.transactions = TransactionParser.parseTransactions(block.transactions, network);
-        this.deployments = block.deployments
-            ? block.deployments.map((address) => {
-                return Address.fromString(address);
-            })
-            : [];
+    }
+    _transactions;
+    get transactions() {
+        if (!this._transactions) {
+            this._transactions = TransactionParser.parseTransactions(this._rawBlock.transactions, this._network);
+        }
+        return this._transactions;
+    }
+    _deployments;
+    get deployments() {
+        if (!this._deployments) {
+            this._deployments = this._rawBlock.deployments
+                ? this._rawBlock.deployments.map((address) => Address.fromString(address))
+                : [];
+        }
+        return this._deployments;
+    }
+    get rawTransactions() {
+        return this._rawBlock.transactions;
     }
 }

package/build/cache/LRUCaching.d.ts

@@ -0,0 +1,7 @@
+export declare class LRUCache<K, V> {
+    private readonly cache;
+    private readonly maxSize;
+    constructor(maxSize: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+}

package/build/cache/LRUCaching.js

@@ -0,0 +1,28 @@
+export class LRUCache {
+    cache;
+    maxSize;
+    constructor(maxSize) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+    }
+    get(key) {
+        const value = this.cache.get(key);
+        if (value !== undefined) {
+            this.cache.delete(key);
+            this.cache.set(key, value);
+        }
+        return value;
+    }
+    set(key, value) {
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        else if (this.cache.size >= this.maxSize) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, value);
+    }
+}

package/build/cache/P2OPCache.d.ts

@@ -0,0 +1,2 @@
+import { Network } from '@btc-vision/bitcoin';
+export declare const getP2op: (rawAddress: string, network: Network) => string;

package/build/cache/P2OPCache.js

@@ -0,0 +1,19 @@
+import { Address } from '@btc-vision/transaction';
+import { LRUCache } from './LRUCaching.js';
+const P2OP_CACHE_MAX_SIZE = 5_000;
+const p2opCache = new LRUCache(P2OP_CACHE_MAX_SIZE);
+const addressCache = new LRUCache(P2OP_CACHE_MAX_SIZE);
+export const getP2op = (rawAddress, network) => {
+    const cacheKey = `${network.bip32}:${network.pubKeyHash}:${network.bech32}:${rawAddress}`;
+    let cached = p2opCache.get(cacheKey);
+    if (cached === undefined) {
+        let addr = addressCache.get(rawAddress);
+        if (addr === undefined) {
+            addr = Address.fromString(rawAddress);
+            addressCache.set(rawAddress, addr);
+        }
+        cached = addr.p2op(network);
+        p2opCache.set(cacheKey, cached);
+    }
+    return cached;
+};

package/build/fetch/fetch.d.ts

@@ -1,4 +1,4 @@
 import { Agent } from 'undici';
-import { Fetcher } from './fetcher-type.js';
-export declare function getFetcher(configs: Agent.Options): Fetcher;
+import { FetcherWithCleanup } from './fetcher-type.js';
+export declare function getFetcher(configs: Agent.Options): FetcherWithCleanup;
 export default getFetcher;

package/build/fetch/fetch.js

@@ -1,12 +1,16 @@
 import pLimit from 'p-limit';
-import { Agent, fetch as undiciFetch, setGlobalDispatcher } from 'undici';
+import { Agent, fetch as undiciFetch } from 'undici';
 export function getFetcher(configs) {
     const agent = new Agent(configs);
-    setGlobalDispatcher(agent);
     const limit = pLimit(500);
-    async function limitedFetch(...args) {
-        return limit(() => undiciFetch(...args));
+    async function limitedFetch(input, init) {
+        return limit(() => undiciFetch(input, { ...init, dispatcher: agent }));
     }
-    return limitedFetch;
+    return {
+        fetch: limitedFetch,
+        close: async () => {
+            await agent.close();
+        },
+    };
 }
 export default getFetcher;

package/build/fetch/fetcher-type.d.ts

@@ -1,2 +1,6 @@
 import { RequestInfo, RequestInit, Response } from 'undici';
 export type Fetcher = (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+export interface FetcherWithCleanup {
+    fetch: Fetcher;
+    close: () => Promise<void>;
+}

package/build/providers/JSONRpcProvider.d.ts

@@ -7,11 +7,14 @@ export declare class JSONRpcProvider extends AbstractRpcProvider {
     private readonly timeout;
     private readonly fetcherConfigurations;
     private useRESTAPI;
+    private readonly useThreadedParsing;
     readonly url: string;
-    constructor(url: string, network: Network, timeout?: number, fetcherConfigurations?: Agent.Options, useRESTAPI?: boolean);
-    private _fetcher;
+    private _fetcherWithCleanup;
+    constructor(url: string, network: Network, timeout?: number, fetcherConfigurations?: Agent.Options, useRESTAPI?: boolean, useThreadedParsing?: boolean);
     private get fetcher();
+    close(): Promise<void>;
     setFetchMode(useRESTAPI: boolean): void;
     _send(payload: JsonRpcPayload | JsonRpcPayload[]): Promise<JsonRpcCallResult>;
     protected providerUrl(url: string): string;
+    private parseResponse;
 }

package/build/providers/JSONRpcProvider.js

@@ -1,28 +1,37 @@
 import getFetcher from '../fetch/fetch.js';
+import { jsonThreader } from '../threading/JSONThreader.js';
 import { AbstractRpcProvider } from './AbstractRpcProvider.js';
 export class JSONRpcProvider extends AbstractRpcProvider {
     timeout;
     fetcherConfigurations;
     useRESTAPI;
+    useThreadedParsing;
     url;
+    _fetcherWithCleanup;
     constructor(url, network, timeout = 20_000, fetcherConfigurations = {
         keepAliveTimeout: 30_000,
         keepAliveTimeoutThreshold: 30_000,
         connections: 128,
         pipelining: 2,
-    }, useRESTAPI = true) {
+    }, useRESTAPI = true, useThreadedParsing = true) {
         super(network);
         this.timeout = timeout;
         this.fetcherConfigurations = fetcherConfigurations;
         this.useRESTAPI = useRESTAPI;
+        this.useThreadedParsing = useThreadedParsing;
         this.url = this.providerUrl(url);
     }
-    _fetcher;
     get fetcher() {
-        if (!this._fetcher) {
-            this._fetcher = getFetcher(this.fetcherConfigurations);
+        if (!this._fetcherWithCleanup) {
+            this._fetcherWithCleanup = getFetcher(this.fetcherConfigurations);
+        }
+        return this._fetcherWithCleanup.fetch;
+    }
+    async close() {
+        if (this._fetcherWithCleanup) {
+            await this._fetcherWithCleanup.close();
+            this._fetcherWithCleanup = undefined;
         }
-        return this._fetcher;
     }
     setFetchMode(useRESTAPI) {
         this.useRESTAPI = useRESTAPI;
@@ -50,7 +59,7 @@ export class JSONRpcProvider extends AbstractRpcProvider {
             if (!resp.ok) {
                 throw new Error(`Failed to fetch: ${resp.statusText}`);
             }
-            const fetchedData = (await resp.json());
+            const fetchedData = await this.parseResponse(resp);
             if (!fetchedData) {
                 throw new Error('No data fetched');
             }
@@ -79,4 +88,11 @@ export class JSONRpcProvider extends AbstractRpcProvider {
             return `${url}/api/v1/json-rpc`;
         }
     }
+    async parseResponse(resp) {
+        if (this.useThreadedParsing) {
+            const buffer = await resp.arrayBuffer();
+            return jsonThreader.parseBuffer(buffer);
+        }
+        return (await resp.json());
+    }
 }

package/build/threading/JSONThreader.d.ts

@@ -0,0 +1,20 @@
+import { ThreaderOptions, WorkerScript } from './interfaces/IThread.js';
+import { BaseThreader } from './SharedThreader.js';
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type JsonOp = 'parse' | 'stringify';
+type JsonInput = string | JsonValue | ArrayBuffer;
+type JsonOutput = string | JsonValue;
+export declare class JsonThreader extends BaseThreader<JsonOp, JsonInput, JsonOutput> {
+    protected readonly workerScript: WorkerScript;
+    private readonly threadingThreshold;
+    constructor(options?: ThreaderOptions & {
+        threadingThreshold?: number;
+    });
+    parse<T = JsonValue>(json: string): Promise<T>;
+    parseBuffer<T = JsonValue>(buffer: ArrayBuffer): Promise<T>;
+    stringify(data: JsonValue): Promise<string>;
+}
+export declare const jsonThreader: JsonThreader;
+export {};

package/build/threading/JSONThreader.js

@@ -0,0 +1,38 @@
+import { BaseThreader } from './SharedThreader.js';
+import { jsonWorkerScript } from './worker-scripts/JSONWorker.js';
+export class JsonThreader extends BaseThreader {
+    workerScript = jsonWorkerScript;
+    threadingThreshold;
+    constructor(options = {}) {
+        super(options);
+        this.threadingThreshold = options.threadingThreshold ?? 16_384;
+    }
+    async parse(json) {
+        if (json.length < this.threadingThreshold) {
+            return JSON.parse(json);
+        }
+        const result = await this.run('parse', json);
+        return result;
+    }
+    async parseBuffer(buffer) {
+        if (buffer.byteLength < this.threadingThreshold) {
+            const text = new TextDecoder().decode(buffer);
+            return JSON.parse(text);
+        }
+        const result = await this.runWithTransfer('parse', buffer, [buffer]);
+        return result;
+    }
+    async stringify(data) {
+        const result = JSON.stringify(data);
+        if (result.length < this.threadingThreshold) {
+            return result;
+        }
+        return (await this.run('stringify', data));
+    }
+}
+const GLOBAL_KEY = Symbol.for('opnet.jsonThreader');
+const globalObj = (typeof globalThis !== 'undefined' ? globalThis : global);
+if (!globalObj[GLOBAL_KEY]) {
+    globalObj[GLOBAL_KEY] = new JsonThreader();
+}
+export const jsonThreader = globalObj[GLOBAL_KEY];

package/build/threading/SharedThreader.d.ts

@@ -0,0 +1,36 @@
+import { Logger } from '@btc-vision/logger';
+import { ThreaderOptions, WorkerScript } from './interfaces/IThread.js';
+export declare abstract class BaseThreader<TOp extends string, TData, TResult> extends Logger {
+    readonly logColor: string;
+    protected abstract readonly workerScript: WorkerScript;
+    private workers;
+    private available;
+    private pending;
+    private queue;
+    private idCounter;
+    private readonly poolSize;
+    private initialized;
+    private initializing;
+    private tasksProcessed;
+    private tasksFailed;
+    private lastStatsLog;
+    private readonly statsInterval;
+    private cleanupBound;
+    protected constructor(options?: ThreaderOptions);
+    get stats(): {
+        pending: number;
+        queued: number;
+        available: number;
+        total: number;
+        processed: number;
+        failed: number;
+    };
+    terminate(): Promise<void>;
+    drain(): Promise<void>;
+    protected runWithTransfer(op: TOp, data: TData, transferables: ArrayBuffer[]): Promise<TResult>;
+    protected run(op: TOp, data: TData): Promise<TResult>;
+    private bindCleanupHandlers;
+    private init;
+    private logStatsIfNeeded;
+    private processQueue;
+}

package/build/threading/SharedThreader.js

@@ -0,0 +1,184 @@
+import { Logger } from '@btc-vision/logger';
+import { createWorker, isNode } from './WorkerCreator.js';
+export class BaseThreader extends Logger {
+    logColor = '#FF5733';
+    workers = [];
+    available = [];
+    pending = new Map();
+    queue = [];
+    idCounter = 0;
+    poolSize;
+    initialized = false;
+    initializing = null;
+    tasksProcessed = 0;
+    tasksFailed = 0;
+    lastStatsLog = 0;
+    statsInterval = 30_000;
+    cleanupBound = false;
+    constructor(options = {}) {
+        super();
+        this.poolSize = options.poolSize ?? (isNode ? 6 : (navigator?.hardwareConcurrency ?? 4));
+    }
+    get stats() {
+        return {
+            pending: this.pending.size,
+            queued: this.queue.length,
+            available: this.available.length,
+            total: this.workers.length,
+            processed: this.tasksProcessed,
+            failed: this.tasksFailed,
+        };
+    }
+    async terminate() {
+        if (!this.initialized && !this.initializing)
+            return;
+        const queuedCount = this.queue.length;
+        const pendingCount = this.pending.size;
+        for (const task of this.queue) {
+            task.reject(new Error('Threader terminated'));
+        }
+        for (const [, handler] of this.pending) {
+            handler.reject(new Error('Threader terminated'));
+        }
+        for (const worker of this.workers) {
+            await worker.terminate();
+        }
+        this.queue = [];
+        this.pending.clear();
+        this.workers = [];
+        this.available = [];
+        this.initialized = false;
+        this.initializing = null;
+        if (queuedCount > 0 || pendingCount > 0) {
+            this.info(`Terminated. Rejected ${queuedCount} queued and ${pendingCount} pending tasks. Total processed: ${this.tasksProcessed}, failed: ${this.tasksFailed}`);
+        }
+    }
+    async drain() {
+        if (!this.initialized)
+            return;
+        const queuedCount = this.queue.length;
+        const pendingCount = this.pending.size;
+        this.info(`Draining. Rejecting ${queuedCount} queued, waiting for ${pendingCount} pending...`);
+        for (const task of this.queue) {
+            task.reject(new Error('Threader draining'));
+        }
+        this.queue = [];
+        if (this.pending.size > 0) {
+            await new Promise((resolve) => {
+                const checkDone = () => {
+                    if (this.pending.size === 0) {
+                        resolve();
+                    }
+                };
+                const originalPending = new Map(this.pending);
+                for (const [id, handler] of originalPending) {
+                    const origResolve = handler.resolve;
+                    const origReject = handler.reject;
+                    handler.resolve = (v) => {
+                        origResolve(v);
+                        checkDone();
+                    };
+                    handler.reject = (e) => {
+                        origReject(e);
+                        checkDone();
+                    };
+                    this.pending.set(id, handler);
+                }
+                checkDone();
+            });
+        }
+        await this.terminate();
+    }
+    runWithTransfer(op, data, transferables) {
+        return new Promise(async (resolve, reject) => {
+            await this.init();
+            this.queue.push({ resolve, reject, op, data, transferables });
+            this.processQueue();
+        });
+    }
+    run(op, data) {
+        return new Promise(async (resolve, reject) => {
+            await this.init();
+            this.queue.push({ resolve, reject, op, data });
+            this.processQueue();
+        });
+    }
+    bindCleanupHandlers() {
+        if (this.cleanupBound)
+            return;
+        this.cleanupBound = true;
+        const cleanup = () => {
+            this.terminate().catch(() => { });
+        };
+        if (isNode) {
+            process.once('beforeExit', cleanup);
+            process.once('SIGINT', cleanup);
+            process.once('SIGTERM', cleanup);
+        }
+        else if (typeof window !== 'undefined') {
+            window.addEventListener('beforeunload', cleanup);
+            window.addEventListener('unload', cleanup);
+        }
+        else if (typeof self !== 'undefined') {
+            self.addEventListener('beforeunload', cleanup);
+        }
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        if (this.initializing)
+            return this.initializing;
+        this.bindCleanupHandlers();
+        this.initializing = (async () => {
+            const startTime = Date.now();
+            const workers = await Promise.all(Array.from({ length: this.poolSize }, () => createWorker(this.workerScript)));
+            for (const worker of workers) {
+                worker.onMessage((msg) => {
+                    const handler = this.pending.get(msg.id);
+                    if (handler) {
+                        this.pending.delete(msg.id);
+                        if (msg.error) {
+                            this.tasksFailed++;
+                            handler.reject(new Error(msg.error));
+                        }
+                        else {
+                            this.tasksProcessed++;
+                            handler.resolve(msg.result);
+                        }
+                    }
+                    this.available.push(worker);
+                    this.logStatsIfNeeded();
+                    this.processQueue();
+                });
+                this.workers.push(worker);
+                this.available.push(worker);
+            }
+            this.initialized = true;
+        })();
+        return this.initializing;
+    }
+    logStatsIfNeeded() {
+        const now = Date.now();
+        if (now - this.lastStatsLog < this.statsInterval)
+            return;
+        this.lastStatsLog = now;
+        const s = this.stats;
+        this.debug(`Stats: ${s.processed} processed, ${s.failed} failed, ${s.pending} pending, ${s.queued} queued, ${s.available}/${s.total} workers available`);
+    }
+    processQueue() {
+        if (this.queue.length > 100 && this.available.length === 0) {
+            this.warn(`Queue backing up: ${this.queue.length} tasks waiting, no workers available`);
+        }
+        while (this.queue.length > 0 && this.available.length > 0) {
+            const task = this.queue.shift();
+            if (!task)
+                break;
+            const worker = this.available.pop();
+            if (!worker)
+                break;
+            const id = this.idCounter++;
+            this.pending.set(id, task);
+            worker.postMessage({ id, op: task.op, data: task.data }, task.transferables);
+        }
+    }
+}

package/build/threading/WorkerCreator.d.ts

@@ -0,0 +1,3 @@
+import { UniversalWorker, WorkerScript } from './interfaces/IThread.js';
+export declare const isNode: boolean;
+export declare function createWorker<TOp extends string, TData, TResult>(workerScript: WorkerScript): Promise<UniversalWorker<TOp, TData, TResult>>;