threadsx 2.0.0

package/dist/master/spawn.js

@@ -0,0 +1,159 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawn = spawn;
+const debug_1 = __importDefault(require("debug"));
+const observable_fns_1 = require("observable-fns");
+const common_1 = require("../common");
+const promise_1 = require("../promise");
+const symbols_1 = require("../symbols");
+const master_1 = require("../types/master");
+const invocation_proxy_1 = require("./invocation-proxy");
+const debugMessages = (0, debug_1.default)("threads:master:messages");
+const debugSpawn = (0, debug_1.default)("threads:master:spawn");
+const debugThreadUtils = (0, debug_1.default)("threads:master:thread-utils");
+const isInitMessage = (data) => data && data.type === "init";
+const isUncaughtErrorMessage = (data) => data && data.type === "uncaughtError";
+const initMessageTimeout = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.THREADS_WORKER_INIT_TIMEOUT
+    ? Number.parseInt(process.env.THREADS_WORKER_INIT_TIMEOUT, 10)
+    : 10000;
+function withTimeout(promise, timeoutInMs, errorMessage) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let timeoutHandle;
+        const timeout = new Promise((resolve, reject) => {
+            timeoutHandle = setTimeout(() => reject(Error(errorMessage)), timeoutInMs);
+        });
+        try {
+            return yield Promise.race([
+                promise,
+                timeout
+            ]);
+        }
+        finally {
+            // Always clear the timer, even when `promise` rejects. Otherwise a pending
+            // timeout keeps the event loop alive until it fires (which on a failed
+            // spawn showed up as ava "failed to exit" on slower runners).
+            clearTimeout(timeoutHandle);
+        }
+    });
+}
+function receiveInitMessage(worker) {
+    return new Promise((resolve, reject) => {
+        const messageHandler = ((event) => {
+            debugMessages("Message from worker before finishing initialization:", event.data);
+            if (isInitMessage(event.data)) {
+                worker.removeEventListener("message", messageHandler);
+                resolve(event.data);
+            }
+            else if (isUncaughtErrorMessage(event.data)) {
+                worker.removeEventListener("message", messageHandler);
+                reject((0, common_1.deserialize)(event.data.error));
+            }
+        });
+        worker.addEventListener("message", messageHandler);
+    });
+}
+function createEventObservable(worker, workerTermination) {
+    return new observable_fns_1.Observable(observer => {
+        const messageHandler = ((messageEvent) => {
+            const workerEvent = {
+                type: master_1.WorkerEventType.message,
+                data: messageEvent.data
+            };
+            observer.next(workerEvent);
+        });
+        const rejectionHandler = ((errorEvent) => {
+            debugThreadUtils("Unhandled promise rejection event in thread:", errorEvent);
+            const workerEvent = {
+                type: master_1.WorkerEventType.internalError,
+                error: Error(errorEvent.reason)
+            };
+            observer.next(workerEvent);
+        });
+        worker.addEventListener("message", messageHandler);
+        worker.addEventListener("unhandledrejection", rejectionHandler);
+        workerTermination.then(() => {
+            const terminationEvent = {
+                type: master_1.WorkerEventType.termination
+            };
+            worker.removeEventListener("message", messageHandler);
+            worker.removeEventListener("unhandledrejection", rejectionHandler);
+            observer.next(terminationEvent);
+            observer.complete();
+        });
+    });
+}
+function createTerminator(worker) {
+    const [termination, resolver] = (0, promise_1.createPromiseWithResolver)();
+    const terminate = () => __awaiter(this, void 0, void 0, function* () {
+        debugThreadUtils("Terminating worker");
+        // Newer versions of worker_threads workers return a promise
+        yield worker.terminate();
+        resolver();
+    });
+    return { terminate, termination };
+}
+function setPrivateThreadProps(raw, worker, workerEvents, terminate) {
+    const workerErrors = workerEvents
+        .filter(event => event.type === master_1.WorkerEventType.internalError)
+        .map(errorEvent => errorEvent.error);
+    return Object.assign(raw, {
+        [symbols_1.$errors]: workerErrors,
+        [symbols_1.$events]: workerEvents,
+        [symbols_1.$terminate]: terminate,
+        [symbols_1.$worker]: worker
+    });
+}
+/**
+ * Spawn a new thread. Takes a fresh worker instance, wraps it in a thin
+ * abstraction layer to provide the transparent API and verifies that
+ * the worker has initialized successfully.
+ *
+ * @param worker Instance of `Worker`. Either a web worker or a `worker_threads` worker.
+ * @param [options]
+ * @param [options.timeout] Init message timeout. Default: 10000 or set by environment variable.
+ */
+function spawn(worker, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        debugSpawn("Initializing new thread");
+        const timeout = options && options.timeout ? options.timeout : initMessageTimeout;
+        let initMessage;
+        try {
+            initMessage = yield withTimeout(receiveInitMessage(worker), timeout, `Timeout: Did not receive an init message from worker after ${timeout}ms. Make sure the worker calls expose().`);
+        }
+        catch (error) {
+            // The worker failed to initialise (e.g. it threw before calling expose(),
+            // or never sent an init message). Tear it down so it does not leak a live
+            // worker handle and keep the process from exiting.
+            yield Promise.resolve((_b = (_a = worker).terminate) === null || _b === void 0 ? void 0 : _b.call(_a)).catch(() => undefined);
+            throw error;
+        }
+        const exposed = initMessage.exposed;
+        const { termination, terminate } = createTerminator(worker);
+        const events = createEventObservable(worker, termination);
+        if (exposed.type === "function") {
+            const proxy = (0, invocation_proxy_1.createProxyFunction)(worker);
+            return setPrivateThreadProps(proxy, worker, events, terminate);
+        }
+        else if (exposed.type === "module") {
+            const proxy = (0, invocation_proxy_1.createProxyModule)(worker, exposed.methods);
+            return setPrivateThreadProps(proxy, worker, events, terminate);
+        }
+        else {
+            const type = exposed.type;
+            throw Error(`Worker init message states unexpected type of expose(): ${type}`);
+        }
+    });
+}

package/dist/master/thread.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from "observable-fns";
+import { Thread as ThreadType, WorkerEvent } from "../types/master";
+export type Thread = ThreadType;
+/** Thread utility functions. Use them to manage or inspect a `spawn()`-ed thread. */
+export declare const Thread: {
+    /** Return an observable that can be used to subscribe to all errors happening in the thread. */
+    errors<ThreadT extends ThreadType>(thread: ThreadT): Observable<Error>;
+    /** Return an observable that can be used to subscribe to internal events happening in the thread. Useful for debugging. */
+    events<ThreadT extends ThreadType>(thread: ThreadT): Observable<WorkerEvent>;
+    /** Terminate a thread. Remember to terminate every thread when you are done using it. */
+    terminate<ThreadT extends ThreadType>(thread: ThreadT): Promise<void>;
+};

package/dist/master/thread.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Thread = void 0;
+const symbols_1 = require("../symbols");
+function fail(message) {
+    throw Error(message);
+}
+/** Thread utility functions. Use them to manage or inspect a `spawn()`-ed thread. */
+exports.Thread = {
+    /** Return an observable that can be used to subscribe to all errors happening in the thread. */
+    errors(thread) {
+        return thread[symbols_1.$errors] || fail("Error observable not found. Make sure to pass a thread instance as returned by the spawn() promise.");
+    },
+    /** Return an observable that can be used to subscribe to internal events happening in the thread. Useful for debugging. */
+    events(thread) {
+        return thread[symbols_1.$events] || fail("Events observable not found. Make sure to pass a thread instance as returned by the spawn() promise.");
+    },
+    /** Terminate a thread. Remember to terminate every thread when you are done using it. */
+    terminate(thread) {
+        return thread[symbols_1.$terminate]();
+    }
+};

package/dist/observable-promise.d.ts

@@ -0,0 +1,38 @@
+import { Observable, ObservableLike, SubscriptionObserver } from "observable-fns";
+type Initializer<T> = (observer: SubscriptionObserver<T>) => UnsubscribeFn | void;
+type Thenable<T> = {
+    then: (onFulfilled?: (value: T) => any, onRejected?: (error: any) => any) => any;
+};
+type UnsubscribeFn = () => void;
+/**
+ * Creates a hybrid, combining the APIs of an Observable and a Promise.
+ *
+ * It is used to proxy async process states when we are initially not sure
+ * if that async process will yield values once (-> Promise) or multiple
+ * times (-> Observable).
+ *
+ * Note that the observable promise inherits some of the observable's characteristics:
+ * The `init` function will be called *once for every time anyone subscribes to it*.
+ *
+ * If this is undesired, derive a hot observable from it using `makeHot()` and
+ * subscribe to that.
+ */
+export declare class ObservablePromise<T> extends Observable<T> implements Promise<T> {
+    private initHasRun;
+    private fulfillmentCallbacks;
+    private rejectionCallbacks;
+    private firstValue;
+    private firstValueSet;
+    private rejection;
+    private state;
+    readonly [Symbol.toStringTag]: "[object ObservablePromise]";
+    constructor(init: Initializer<T>);
+    private onNext;
+    private onError;
+    private onCompletion;
+    then<TResult1 = T, TResult2 = never>(onFulfilledRaw?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onRejectedRaw?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    catch<Result = never>(onRejected: ((error: Error) => Promise<Result> | Result) | null | undefined): Promise<Result>;
+    finally(onCompleted?: (() => void) | null | undefined): Promise<T>;
+    static from<T>(thing: Observable<T> | ObservableLike<T> | ArrayLike<T> | Thenable<T>): ObservablePromise<T>;
+}
+export {};

package/dist/observable-promise.js

@@ -0,0 +1,150 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservablePromise = void 0;
+const observable_fns_1 = require("observable-fns");
+const doNothing = () => undefined;
+const returnInput = (input) => input;
+const runDeferred = (fn) => Promise.resolve().then(fn);
+function fail(error) {
+    throw error;
+}
+function isThenable(thing) {
+    return thing && typeof thing.then === "function";
+}
+/**
+ * Creates a hybrid, combining the APIs of an Observable and a Promise.
+ *
+ * It is used to proxy async process states when we are initially not sure
+ * if that async process will yield values once (-> Promise) or multiple
+ * times (-> Observable).
+ *
+ * Note that the observable promise inherits some of the observable's characteristics:
+ * The `init` function will be called *once for every time anyone subscribes to it*.
+ *
+ * If this is undesired, derive a hot observable from it using `makeHot()` and
+ * subscribe to that.
+ */
+class ObservablePromise extends observable_fns_1.Observable {
+    constructor(init) {
+        super((originalObserver) => {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const self = this;
+            const observer = Object.assign(Object.assign({}, originalObserver), { complete() {
+                    originalObserver.complete();
+                    self.onCompletion();
+                },
+                error(error) {
+                    originalObserver.error(error);
+                    self.onError(error);
+                },
+                next(value) {
+                    originalObserver.next(value);
+                    self.onNext(value);
+                } });
+            try {
+                this.initHasRun = true;
+                return init(observer);
+            }
+            catch (error) {
+                observer.error(error);
+            }
+        });
+        this.initHasRun = false;
+        this.fulfillmentCallbacks = [];
+        this.rejectionCallbacks = [];
+        this.firstValueSet = false;
+        this.state = "pending";
+        this[_a] = "[object ObservablePromise]";
+    }
+    onNext(value) {
+        if (!this.firstValueSet) {
+            this.firstValue = value;
+            this.firstValueSet = true;
+        }
+    }
+    onError(error) {
+        this.state = "rejected";
+        this.rejection = error;
+        for (const onRejected of this.rejectionCallbacks) {
+            // Promisifying the call to turn errors into unhandled promise rejections
+            // instead of them failing sync and cancelling the iteration
+            runDeferred(() => onRejected(error));
+        }
+    }
+    onCompletion() {
+        this.state = "fulfilled";
+        for (const onFulfilled of this.fulfillmentCallbacks) {
+            // Promisifying the call to turn errors into unhandled promise rejections
+            // instead of them failing sync and cancelling the iteration
+            runDeferred(() => onFulfilled(this.firstValue));
+        }
+    }
+    then(onFulfilledRaw, onRejectedRaw) {
+        const onFulfilled = onFulfilledRaw || returnInput;
+        const onRejected = onRejectedRaw || fail;
+        let onRejectedCalled = false;
+        return new Promise((resolve, reject) => {
+            const rejectionCallback = (error) => {
+                if (onRejectedCalled)
+                    return;
+                onRejectedCalled = true;
+                try {
+                    resolve(onRejected(error));
+                }
+                catch (anotherError) {
+                    reject(anotherError);
+                }
+            };
+            const fulfillmentCallback = (value) => {
+                try {
+                    resolve(onFulfilled(value));
+                }
+                catch (error) {
+                    rejectionCallback(error);
+                }
+            };
+            if (!this.initHasRun) {
+                this.subscribe({ error: rejectionCallback });
+            }
+            if (this.state === "fulfilled") {
+                return resolve(onFulfilled(this.firstValue));
+            }
+            if (this.state === "rejected") {
+                onRejectedCalled = true;
+                return resolve(onRejected(this.rejection));
+            }
+            this.fulfillmentCallbacks.push(fulfillmentCallback);
+            this.rejectionCallbacks.push(rejectionCallback);
+        });
+    }
+    catch(onRejected) {
+        return this.then(undefined, onRejected);
+    }
+    finally(onCompleted) {
+        const handler = onCompleted || doNothing;
+        return this.then((value) => {
+            handler();
+            return value;
+        }, () => handler());
+    }
+    static from(thing) {
+        if (isThenable(thing)) {
+            return new ObservablePromise(observer => {
+                const onFulfilled = (value) => {
+                    observer.next(value);
+                    observer.complete();
+                };
+                const onRejected = (error) => {
+                    observer.error(error);
+                };
+                thing.then(onFulfilled, onRejected);
+            });
+        }
+        else {
+            return super.from(thing);
+        }
+    }
+}
+exports.ObservablePromise = ObservablePromise;
+_a = Symbol.toStringTag;

package/dist/observable.d.ts

@@ -0,0 +1,19 @@
+import { Observable, ObservableLike } from "observable-fns";
+export { Observable };
+declare const $observers: unique symbol;
+/**
+ * Observable subject. Implements the Observable interface, but also exposes
+ * the `next()`, `error()`, `complete()` methods to initiate observable
+ * updates "from the outside".
+ *
+ * Use `Observable.from(subject)` to derive an observable that proxies all
+ * values, errors and the completion raised on this subject, but does not
+ * expose the `next()`, `error()`, `complete()` methods.
+ */
+export declare class Subject<T> extends Observable<T> implements ObservableLike<T> {
+    private [$observers];
+    constructor();
+    complete(): void;
+    error(error: any): void;
+    next(value: T): void;
+}

package/dist/observable.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subject = exports.Observable = void 0;
+const observable_fns_1 = require("observable-fns");
+Object.defineProperty(exports, "Observable", { enumerable: true, get: function () { return observable_fns_1.Observable; } });
+const $observers = Symbol("observers");
+/**
+ * Observable subject. Implements the Observable interface, but also exposes
+ * the `next()`, `error()`, `complete()` methods to initiate observable
+ * updates "from the outside".
+ *
+ * Use `Observable.from(subject)` to derive an observable that proxies all
+ * values, errors and the completion raised on this subject, but does not
+ * expose the `next()`, `error()`, `complete()` methods.
+ */
+class Subject extends observable_fns_1.Observable {
+    constructor() {
+        super(observer => {
+            this[$observers] = [
+                ...(this[$observers] || []),
+                observer
+            ];
+            const unsubscribe = () => {
+                this[$observers] = this[$observers].filter(someObserver => someObserver !== observer);
+            };
+            return unsubscribe;
+        });
+        this[$observers] = [];
+    }
+    complete() {
+        this[$observers].forEach(observer => observer.complete());
+    }
+    error(error) {
+        this[$observers].forEach(observer => observer.error(error));
+    }
+    next(value) {
+        this[$observers].forEach(observer => observer.next(value));
+    }
+}
+exports.Subject = Subject;

package/dist/ponyfills.d.ts

@@ -0,0 +1,8 @@
+export type SettlementResult<T> = {
+    status: "fulfilled";
+    value: T;
+} | {
+    status: "rejected";
+    reason: any;
+};
+export declare function allSettled<T>(values: T[]): Promise<Array<SettlementResult<T>>>;

package/dist/ponyfills.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allSettled = allSettled;
+// Based on <https://github.com/es-shims/Promise.allSettled/blob/master/implementation.js>
+function allSettled(values) {
+    return Promise.all(values.map(item => {
+        const onFulfill = (value) => {
+            return { status: 'fulfilled', value };
+        };
+        const onReject = (reason) => {
+            return { status: 'rejected', reason };
+        };
+        const itemPromise = Promise.resolve(item);
+        try {
+            return itemPromise.then(onFulfill, onReject);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }));
+}

package/dist/promise.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Creates a new promise and exposes its resolver function.
+ * Use with care!
+ */
+export declare function createPromiseWithResolver<T>(): [Promise<T>, (result: T) => void];

package/dist/promise.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPromiseWithResolver = createPromiseWithResolver;
+const doNothing = () => undefined;
+/**
+ * Creates a new promise and exposes its resolver function.
+ * Use with care!
+ */
+function createPromiseWithResolver() {
+    let alreadyResolved = false;
+    let resolvedTo;
+    let resolver = doNothing;
+    const promise = new Promise(resolve => {
+        if (alreadyResolved) {
+            resolve(resolvedTo);
+        }
+        else {
+            resolver = resolve;
+        }
+    });
+    const exposedResolver = (value) => {
+        alreadyResolved = true;
+        resolvedTo = value;
+        resolver(resolvedTo);
+    };
+    return [promise, exposedResolver];
+}

package/dist/serializers.d.ts

@@ -0,0 +1,16 @@
+export interface Serializer<Msg = JsonSerializable, Input = any> {
+    deserialize(message: Msg): Input;
+    serialize(input: Input): Msg;
+}
+export interface SerializerImplementation<Msg = JsonSerializable, Input = any> {
+    deserialize(message: Msg, defaultDeserialize: ((msg: Msg) => Input)): Input;
+    serialize(input: Input, defaultSerialize: ((inp: Input) => Msg)): Msg;
+}
+export declare function extendSerializer<MessageType, InputType = any>(extend: Serializer<MessageType, InputType>, implementation: SerializerImplementation<MessageType, InputType>): Serializer<MessageType, InputType>;
+type JsonSerializablePrimitive = string | number | boolean | null;
+type JsonSerializableObject = {
+    [key: string]: JsonSerializablePrimitive | JsonSerializablePrimitive[] | JsonSerializableObject | JsonSerializableObject[] | undefined;
+};
+export type JsonSerializable = JsonSerializablePrimitive | JsonSerializablePrimitive[] | JsonSerializableObject | JsonSerializableObject[];
+export declare const DefaultSerializer: Serializer<JsonSerializable>;
+export {};

package/dist/serializers.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSerializer = void 0;
+exports.extendSerializer = extendSerializer;
+function extendSerializer(extend, implementation) {
+    const fallbackDeserializer = extend.deserialize.bind(extend);
+    const fallbackSerializer = extend.serialize.bind(extend);
+    return {
+        deserialize(message) {
+            return implementation.deserialize(message, fallbackDeserializer);
+        },
+        serialize(input) {
+            return implementation.serialize(input, fallbackSerializer);
+        }
+    };
+}
+const DefaultErrorSerializer = {
+    deserialize(message) {
+        return Object.assign(Error(message.message), {
+            name: message.name,
+            stack: message.stack
+        });
+    },
+    serialize(error) {
+        return {
+            __error_marker: "$$error",
+            message: error.message,
+            name: error.name,
+            stack: error.stack
+        };
+    }
+};
+const isSerializedError = (thing) => thing && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error";
+exports.DefaultSerializer = {
+    deserialize(message) {
+        if (isSerializedError(message)) {
+            return DefaultErrorSerializer.deserialize(message);
+        }
+        else {
+            return message;
+        }
+    },
+    serialize(input) {
+        if (input instanceof Error) {
+            return DefaultErrorSerializer.serialize(input);
+        }
+        else {
+            return input;
+        }
+    }
+};

package/dist/symbols.d.ts

@@ -0,0 +1,5 @@
+export declare const $errors: unique symbol;
+export declare const $events: unique symbol;
+export declare const $terminate: unique symbol;
+export declare const $transferable: unique symbol;
+export declare const $worker: unique symbol;

package/dist/symbols.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$worker = exports.$transferable = exports.$terminate = exports.$events = exports.$errors = void 0;
+exports.$errors = Symbol("thread.errors");
+exports.$events = Symbol("thread.events");
+exports.$terminate = Symbol("thread.terminate");
+exports.$transferable = Symbol("thread.transferable");
+exports.$worker = Symbol("thread.worker");

package/dist/transferable.d.ts

@@ -0,0 +1,42 @@
+import { $transferable } from "./symbols";
+export interface TransferDescriptor<T = any> {
+    [$transferable]: true;
+    send: T;
+    transferables: Transferable[];
+}
+export declare function isTransferDescriptor(thing: any): thing is TransferDescriptor;
+/**
+ * Mark a transferable object as such, so it will no be serialized and
+ * deserialized on messaging with the main thread, but to transfer
+ * ownership of it to the receiving thread.
+ *
+ * Only works with array buffers, message ports and few more special
+ * types of objects, but it's much faster than serializing and
+ * deserializing them.
+ *
+ * Note:
+ * The transferable object cannot be accessed by this thread again
+ * unless the receiving thread transfers it back again!
+ *
+ * @param transferable Array buffer, message port or similar.
+ * @see <https://developers.google.com/web/updates/2011/12/Transferable-Objects-Lightning-Fast>
+ */
+export declare function Transfer(transferable: Transferable): TransferDescriptor;
+/**
+ * Mark transferable objects within an arbitrary object or array as
+ * being a transferable object. They will then not be serialized
+ * and deserialized on messaging with the main thread, but ownership
+ * of them will be tranferred to the receiving thread.
+ *
+ * Only array buffers, message ports and few more special types of
+ * objects can be transferred, but it's much faster than serializing and
+ * deserializing them.
+ *
+ * Note:
+ * The transferable object cannot be accessed by this thread again
+ * unless the receiving thread transfers it back again!
+ *
+ * @param transferable Array buffer, message port or similar.
+ * @see <https://developers.google.com/web/updates/2011/12/Transferable-Objects-Lightning-Fast>
+ */
+export declare function Transfer<T>(payload: T, transferables: Transferable[]): TransferDescriptor;

package/dist/transferable.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTransferDescriptor = isTransferDescriptor;
+exports.Transfer = Transfer;
+const symbols_1 = require("./symbols");
+function isTransferable(thing) {
+    if (!thing || typeof thing !== "object")
+        return false;
+    // Don't check too thoroughly, since the list of transferable things in JS might grow over time
+    return true;
+}
+function isTransferDescriptor(thing) {
+    return thing && typeof thing === "object" && thing[symbols_1.$transferable];
+}
+function Transfer(payload, transferables) {
+    if (!transferables) {
+        if (!isTransferable(payload))
+            throw Error();
+        transferables = [payload];
+    }
+    return {
+        [symbols_1.$transferable]: true,
+        send: payload,
+        transferables
+    };
+}