threadsx 2.0.0

package/dist/types/master.d.ts

@@ -0,0 +1,98 @@
+import { Observable } from "observable-fns";
+import { ObservablePromise } from "../observable-promise";
+import { $errors, $events, $terminate, $worker } from "../symbols";
+import { TransferDescriptor } from "../transferable";
+interface ObservableLikeSubscription {
+    unsubscribe(): any;
+}
+interface ObservableLike<T> {
+    subscribe(onNext: (value: T) => any, onError?: (error: any) => any, onComplete?: () => any): ObservableLikeSubscription;
+    subscribe(listeners: {
+        next?(value: T): any;
+        error?(error: any): any;
+        complete?(): any;
+    }): ObservableLikeSubscription;
+}
+export type StripAsync<Type> = Type extends Promise<infer PromiseBaseType> ? PromiseBaseType : Type extends ObservableLike<infer ObservableBaseType> ? ObservableBaseType : Type;
+export type StripTransfer<Type> = Type extends TransferDescriptor<infer BaseType> ? BaseType : Type;
+export type ModuleMethods = {
+    [methodName: string]: (...args: any) => any;
+};
+export type ProxyableArgs<Args extends any[]> = Args extends [arg0: infer Arg0, ...rest: infer RestArgs] ? [Arg0 extends Transferable ? Arg0 | TransferDescriptor<Arg0> : Arg0, ...RestArgs] : Args;
+export type ProxyableFunction<Args extends any[], ReturnType> = Args extends [] ? () => ObservablePromise<StripTransfer<StripAsync<ReturnType>>> : (...args: ProxyableArgs<Args>) => ObservablePromise<StripTransfer<StripAsync<ReturnType>>>;
+export type ModuleProxy<Methods extends ModuleMethods> = {
+    [method in keyof Methods]: ProxyableFunction<Parameters<Methods[method]>, ReturnType<Methods[method]>>;
+};
+export interface PrivateThreadProps {
+    [$errors]: Observable<Error>;
+    [$events]: Observable<WorkerEvent>;
+    [$terminate]: () => Promise<void>;
+    [$worker]: Worker;
+}
+export type FunctionThread<Args extends any[] = any[], ReturnType = any> = ProxyableFunction<Args, ReturnType> & PrivateThreadProps;
+export type ModuleThread<Methods extends ModuleMethods = any> = ModuleProxy<Methods> & PrivateThreadProps;
+interface AnyFunctionThread extends PrivateThreadProps {
+    (...args: any[]): ObservablePromise<any>;
+}
+interface AnyModuleThread extends PrivateThreadProps {
+}
+/** Worker thread. Either a `FunctionThread` or a `ModuleThread`. */
+export type Thread = AnyFunctionThread | AnyModuleThread;
+export type TransferList = Transferable[];
+/** Worker instance. Either a web worker or a node.js Worker provided by `worker_threads`. */
+export interface Worker extends EventTarget {
+    postMessage(value: any, transferList?: TransferList): void;
+    /** In node.js the return type is a Promise, while in the browser it is void */
+    terminate(callback?: (error?: Error, exitCode?: number) => void): void | Promise<number>;
+}
+export interface ThreadsWorkerOptions extends WorkerOptions {
+    /** Prefix for the path passed to the Worker constructor. Web worker only. */
+    _baseURL?: string;
+    /** Resource limits passed on to Node worker_threads */
+    resourceLimits?: {
+        /** The maximum size of the main heap in MB. */
+        maxOldGenerationSizeMb?: number;
+        /** The maximum size of a heap space for recently created objects. */
+        maxYoungGenerationSizeMb?: number;
+        /** The size of a pre-allocated memory range used for generated code. */
+        codeRangeSizeMb?: number;
+    };
+    /** Data passed on to node.js worker_threads. */
+    workerData?: any;
+    /** Whether to apply CORS protection workaround. Defaults to true. */
+    CORSWorkaround?: boolean;
+}
+/** Worker implementation. Either web worker or a node.js Worker class. */
+export declare class WorkerImplementation extends EventTarget implements Worker {
+    constructor(path: string | URL, options?: ThreadsWorkerOptions);
+    postMessage(value: any, transferList?: TransferList): void;
+    terminate(): void | Promise<number>;
+}
+/** Class to spawn workers from a blob or source string. */
+export declare class BlobWorker extends WorkerImplementation {
+    constructor(blob: Blob, options?: ThreadsWorkerOptions);
+    static fromText(source: string, options?: ThreadsWorkerOptions): WorkerImplementation;
+}
+export interface ImplementationExport {
+    blob: typeof BlobWorker;
+    default: typeof WorkerImplementation;
+}
+/** Event as emitted by worker thread. Subscribe to using `Thread.events(thread)`. */
+export declare enum WorkerEventType {
+    internalError = "internalError",
+    message = "message",
+    termination = "termination"
+}
+export interface WorkerInternalErrorEvent {
+    type: WorkerEventType.internalError;
+    error: Error;
+}
+export interface WorkerMessageEvent<Data> {
+    type: WorkerEventType.message;
+    data: Data;
+}
+export interface WorkerTerminationEvent {
+    type: WorkerEventType.termination;
+}
+export type WorkerEvent = WorkerInternalErrorEvent | WorkerMessageEvent<any> | WorkerTerminationEvent;
+export {};

package/dist/types/master.js

@@ -0,0 +1,12 @@
+"use strict";
+/// <reference lib="dom" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerEventType = void 0;
+const symbols_1 = require("../symbols");
+/** Event as emitted by worker thread. Subscribe to using `Thread.events(thread)`. */
+var WorkerEventType;
+(function (WorkerEventType) {
+    WorkerEventType["internalError"] = "internalError";
+    WorkerEventType["message"] = "message";
+    WorkerEventType["termination"] = "termination";
+})(WorkerEventType || (exports.WorkerEventType = WorkerEventType = {}));

package/dist/types/messages.d.ts

@@ -0,0 +1,62 @@
+export interface SerializedError {
+    __error_marker: "$$error";
+    message: string;
+    name: string;
+    stack?: string;
+}
+export declare enum MasterMessageType {
+    cancel = "cancel",
+    run = "run"
+}
+export type MasterJobCancelMessage = {
+    type: MasterMessageType.cancel;
+    uid: number;
+};
+export type MasterJobRunMessage = {
+    type: MasterMessageType.run;
+    uid: number;
+    method?: string;
+    args: any[];
+};
+export type MasterSentMessage = MasterJobCancelMessage | MasterJobRunMessage;
+export declare enum WorkerMessageType {
+    error = "error",
+    init = "init",
+    result = "result",
+    running = "running",
+    uncaughtError = "uncaughtError"
+}
+export type WorkerUncaughtErrorMessage = {
+    type: WorkerMessageType.uncaughtError;
+    error: {
+        message: string;
+        name: string;
+        stack?: string;
+    };
+};
+export type WorkerInitMessage = {
+    type: WorkerMessageType.init;
+    exposed: {
+        type: "function";
+    } | {
+        type: "module";
+        methods: string[];
+    };
+};
+export type WorkerJobErrorMessage = {
+    type: WorkerMessageType.error;
+    uid: number;
+    error: SerializedError;
+};
+export type WorkerJobResultMessage = {
+    type: WorkerMessageType.result;
+    uid: number;
+    complete?: true;
+    payload?: any;
+};
+export type WorkerJobStartMessage = {
+    type: WorkerMessageType.running;
+    uid: number;
+    resultType: "observable" | "promise";
+};
+export type WorkerSentMessage = WorkerInitMessage | WorkerJobErrorMessage | WorkerJobResultMessage | WorkerJobStartMessage | WorkerUncaughtErrorMessage;

package/dist/types/messages.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerMessageType = exports.MasterMessageType = void 0;
+/////////////////////////////
+// Messages sent by master:
+var MasterMessageType;
+(function (MasterMessageType) {
+    MasterMessageType["cancel"] = "cancel";
+    MasterMessageType["run"] = "run";
+})(MasterMessageType || (exports.MasterMessageType = MasterMessageType = {}));
+////////////////////////////
+// Messages sent by worker:
+var WorkerMessageType;
+(function (WorkerMessageType) {
+    WorkerMessageType["error"] = "error";
+    WorkerMessageType["init"] = "init";
+    WorkerMessageType["result"] = "result";
+    WorkerMessageType["running"] = "running";
+    WorkerMessageType["uncaughtError"] = "uncaughtError";
+})(WorkerMessageType || (exports.WorkerMessageType = WorkerMessageType = {}));

package/dist/types/worker.d.ts

@@ -0,0 +1,11 @@
+type UnsubscribeFn = () => void;
+export interface AbstractedWorkerAPI {
+    isWorkerRuntime(): boolean;
+    postMessageToMaster(message: any, transferList?: Transferable[]): void;
+    subscribeToMasterMessages(onMessage: (data: any) => void): UnsubscribeFn;
+}
+export type WorkerFunction = ((...args: any[]) => any) | (() => any);
+export type WorkerModule<Keys extends string> = {
+    [key in Keys]: WorkerFunction;
+};
+export {};

package/dist/types/worker.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/worker/bundle-entry.d.ts

@@ -0,0 +1 @@
+export * from "./index";

package/dist/worker/bundle-entry.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+__exportStar(require("./index"), exports);
+if (typeof global !== "undefined") {
+    global.expose = index_1.expose;
+}
+if (typeof self !== "undefined") {
+    self.expose = index_1.expose;
+}

package/dist/worker/implementation.browser.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    isWorkerRuntime: () => boolean;
+    postMessageToMaster: (message: any, transferList?: Transferable[]) => void;
+    subscribeToMasterMessages: (onMessage: (data: any) => void) => () => void;
+};
+export default _default;

package/dist/worker/implementation.browser.js

@@ -0,0 +1,25 @@
+"use strict";
+/// <reference lib="dom" />
+Object.defineProperty(exports, "__esModule", { value: true });
+const isWorkerRuntime = function isWorkerRuntime() {
+    const isWindowContext = typeof self !== "undefined" && typeof Window !== "undefined" && self instanceof Window;
+    return typeof self !== "undefined" && typeof self.postMessage === "function" && !isWindowContext;
+};
+const postMessageToMaster = function postMessageToMaster(data, transferList) {
+    self.postMessage(data, transferList);
+};
+const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage) {
+    const messageHandler = (messageEvent) => {
+        onMessage(messageEvent.data);
+    };
+    const unsubscribe = () => {
+        self.removeEventListener("message", messageHandler);
+    };
+    self.addEventListener("message", messageHandler);
+    return unsubscribe;
+};
+exports.default = {
+    isWorkerRuntime,
+    postMessageToMaster,
+    subscribeToMasterMessages
+};

package/dist/worker/implementation.d.ts

@@ -0,0 +1,3 @@
+import { AbstractedWorkerAPI } from "../types/worker";
+declare const _default: AbstractedWorkerAPI;
+export default _default;

package/dist/worker/implementation.js

@@ -0,0 +1,18 @@
+"use strict";
+/*
+ * This file is only a stub to make './implementation' resolve to the right module.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const implementation_browser_1 = __importDefault(require("./implementation.browser"));
+const implementation_worker_threads_1 = __importDefault(require("./implementation.worker_threads"));
+const runningInNode = typeof process !== 'undefined' && process.arch !== 'browser' && 'pid' in process;
+function selectNodeImplementation() {
+    implementation_worker_threads_1.default.testImplementation();
+    return implementation_worker_threads_1.default;
+}
+exports.default = runningInNode
+    ? selectNodeImplementation()
+    : implementation_browser_1.default;

package/dist/worker/implementation.worker_threads.d.ts

@@ -0,0 +1,8 @@
+declare function testImplementation(): void;
+declare const _default: {
+    isWorkerRuntime: () => boolean;
+    postMessageToMaster: (message: any, transferList?: Transferable[]) => void;
+    subscribeToMasterMessages: (onMessage: (data: any) => void) => () => void;
+    testImplementation: typeof testImplementation;
+};
+export default _default;

package/dist/worker/implementation.worker_threads.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_threads_1 = __importDefault(require("../worker_threads"));
+function assertMessagePort(port) {
+    if (!port) {
+        throw Error("Invariant violation: MessagePort to parent is not available.");
+    }
+    return port;
+}
+const isWorkerRuntime = function isWorkerRuntime() {
+    return !(0, worker_threads_1.default)().isMainThread;
+};
+const postMessageToMaster = function postMessageToMaster(data, transferList) {
+    assertMessagePort((0, worker_threads_1.default)().parentPort).postMessage(data, transferList);
+};
+const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage) {
+    const parentPort = (0, worker_threads_1.default)().parentPort;
+    if (!parentPort) {
+        throw Error("Invariant violation: MessagePort to parent is not available.");
+    }
+    const messageHandler = (message) => {
+        onMessage(message);
+    };
+    const unsubscribe = () => {
+        assertMessagePort(parentPort).off("message", messageHandler);
+    };
+    assertMessagePort(parentPort).on("message", messageHandler);
+    return unsubscribe;
+};
+function testImplementation() {
+    // Will throw if `worker_threads` are not available
+    (0, worker_threads_1.default)();
+}
+exports.default = {
+    isWorkerRuntime,
+    postMessageToMaster,
+    subscribeToMasterMessages,
+    testImplementation
+};

package/dist/worker/index.d.ts

@@ -0,0 +1,13 @@
+import { WorkerFunction, WorkerModule } from "../types/worker";
+export { registerSerializer } from "../common";
+export { Transfer } from "../transferable";
+/** Returns `true` if this code is currently running in a worker. */
+export declare const isWorkerRuntime: () => boolean;
+/**
+ * Expose a function or a module (an object whose values are functions)
+ * to the main thread. Must be called exactly once in every worker thread
+ * to signal its API to the main thread.
+ *
+ * @param exposed Function or object whose values are functions
+ */
+export declare function expose(exposed: WorkerFunction | WorkerModule<any>): void;

package/dist/worker/index.js

@@ -0,0 +1,224 @@
+"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.isWorkerRuntime = exports.Transfer = exports.registerSerializer = void 0;
+exports.expose = expose;
+const common_1 = require("../common");
+const transferable_1 = require("../transferable");
+const messages_1 = require("../types/messages");
+const implementation_1 = __importDefault(require("./implementation"));
+var common_2 = require("../common");
+Object.defineProperty(exports, "registerSerializer", { enumerable: true, get: function () { return common_2.registerSerializer; } });
+var transferable_2 = require("../transferable");
+Object.defineProperty(exports, "Transfer", { enumerable: true, get: function () { return transferable_2.Transfer; } });
+/** Returns `true` if this code is currently running in a worker. */
+exports.isWorkerRuntime = implementation_1.default.isWorkerRuntime;
+let exposeCalled = false;
+const activeSubscriptions = new Map();
+const isMasterJobCancelMessage = (thing) => thing && thing.type === messages_1.MasterMessageType.cancel;
+const isMasterJobRunMessage = (thing) => thing && thing.type === messages_1.MasterMessageType.run;
+/**
+ * Detects observables via the `Symbol.observable` / `@@observable` interop protocol.
+ * Inlined from the `is-observable` package (which is now ESM-only) to keep the
+ * CommonJS build working without an extra dependency.
+ */
+function isInteropObservable(thing) {
+    if (!thing) {
+        return false;
+    }
+    const observableSymbol = Symbol.observable;
+    if (typeof observableSymbol === "symbol" && typeof thing[observableSymbol] === "function") {
+        return thing === thing[observableSymbol]();
+    }
+    if (typeof thing["@@observable"] === "function") {
+        return thing === thing["@@observable"]();
+    }
+    return false;
+}
+/**
+ * There are issues with interop observable detection not recognizing zen-observable's instances.
+ * We are using `observable-fns`, but it's based on zen-observable, too.
+ */
+const isObservable = (thing) => isInteropObservable(thing) || isZenObservable(thing);
+function isZenObservable(thing) {
+    return thing && typeof thing === "object" && typeof thing.subscribe === "function";
+}
+function deconstructTransfer(thing) {
+    return (0, transferable_1.isTransferDescriptor)(thing)
+        ? { payload: thing.send, transferables: thing.transferables }
+        : { payload: thing, transferables: undefined };
+}
+function postFunctionInitMessage() {
+    const initMessage = {
+        type: messages_1.WorkerMessageType.init,
+        exposed: {
+            type: "function"
+        }
+    };
+    implementation_1.default.postMessageToMaster(initMessage);
+}
+function postModuleInitMessage(methodNames) {
+    const initMessage = {
+        type: messages_1.WorkerMessageType.init,
+        exposed: {
+            type: "module",
+            methods: methodNames
+        }
+    };
+    implementation_1.default.postMessageToMaster(initMessage);
+}
+function postJobErrorMessage(uid, rawError) {
+    const { payload: error, transferables } = deconstructTransfer(rawError);
+    const errorMessage = {
+        type: messages_1.WorkerMessageType.error,
+        uid,
+        error: (0, common_1.serialize)(error)
+    };
+    implementation_1.default.postMessageToMaster(errorMessage, transferables);
+}
+function postJobResultMessage(uid, completed, resultValue) {
+    const { payload, transferables } = deconstructTransfer(resultValue);
+    const resultMessage = {
+        type: messages_1.WorkerMessageType.result,
+        uid,
+        complete: completed ? true : undefined,
+        payload
+    };
+    implementation_1.default.postMessageToMaster(resultMessage, transferables);
+}
+function postJobStartMessage(uid, resultType) {
+    const startMessage = {
+        type: messages_1.WorkerMessageType.running,
+        uid,
+        resultType
+    };
+    implementation_1.default.postMessageToMaster(startMessage);
+}
+function postUncaughtErrorMessage(error) {
+    try {
+        const errorMessage = {
+            type: messages_1.WorkerMessageType.uncaughtError,
+            error: (0, common_1.serialize)(error)
+        };
+        implementation_1.default.postMessageToMaster(errorMessage);
+    }
+    catch (subError) {
+        console.error("Not reporting uncaught error back to master thread as it " +
+            "occured while reporting an uncaught error already." +
+            "\nLatest error:", subError, "\nOriginal error:", error);
+    }
+}
+function runFunction(jobUID, fn, args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let syncResult;
+        try {
+            syncResult = fn(...args);
+        }
+        catch (error) {
+            return postJobErrorMessage(jobUID, error);
+        }
+        const resultType = isObservable(syncResult) ? "observable" : "promise";
+        postJobStartMessage(jobUID, resultType);
+        if (isObservable(syncResult)) {
+            const subscription = syncResult.subscribe(value => postJobResultMessage(jobUID, false, (0, common_1.serialize)(value)), error => {
+                postJobErrorMessage(jobUID, (0, common_1.serialize)(error));
+                activeSubscriptions.delete(jobUID);
+            }, () => {
+                postJobResultMessage(jobUID, true);
+                activeSubscriptions.delete(jobUID);
+            });
+            activeSubscriptions.set(jobUID, subscription);
+        }
+        else {
+            try {
+                const result = yield syncResult;
+                postJobResultMessage(jobUID, true, (0, common_1.serialize)(result));
+            }
+            catch (error) {
+                postJobErrorMessage(jobUID, (0, common_1.serialize)(error));
+            }
+        }
+    });
+}
+/**
+ * Expose a function or a module (an object whose values are functions)
+ * to the main thread. Must be called exactly once in every worker thread
+ * to signal its API to the main thread.
+ *
+ * @param exposed Function or object whose values are functions
+ */
+function expose(exposed) {
+    if (!implementation_1.default.isWorkerRuntime()) {
+        throw Error("expose() called in the master thread.");
+    }
+    if (exposeCalled) {
+        throw Error("expose() called more than once. This is not possible. Pass an object to expose() if you want to expose multiple functions.");
+    }
+    exposeCalled = true;
+    if (typeof exposed === "function") {
+        implementation_1.default.subscribeToMasterMessages(messageData => {
+            if (isMasterJobRunMessage(messageData) && !messageData.method) {
+                runFunction(messageData.uid, exposed, messageData.args.map(common_1.deserialize));
+            }
+        });
+        postFunctionInitMessage();
+    }
+    else if (typeof exposed === "object" && exposed) {
+        implementation_1.default.subscribeToMasterMessages(messageData => {
+            if (isMasterJobRunMessage(messageData) && messageData.method) {
+                runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(common_1.deserialize));
+            }
+        });
+        const methodNames = Object.keys(exposed).filter(key => typeof exposed[key] === "function");
+        postModuleInitMessage(methodNames);
+    }
+    else {
+        throw Error(`Invalid argument passed to expose(). Expected a function or an object, got: ${exposed}`);
+    }
+    implementation_1.default.subscribeToMasterMessages(messageData => {
+        if (isMasterJobCancelMessage(messageData)) {
+            const jobUID = messageData.uid;
+            const subscription = activeSubscriptions.get(jobUID);
+            if (subscription) {
+                subscription.unsubscribe();
+                activeSubscriptions.delete(jobUID);
+            }
+        }
+    });
+}
+if (typeof self !== "undefined" && typeof self.addEventListener === "function" && implementation_1.default.isWorkerRuntime()) {
+    self.addEventListener("error", event => {
+        // Post with some delay, so the master had some time to subscribe to messages
+        setTimeout(() => postUncaughtErrorMessage(event.error || event), 250);
+    });
+    self.addEventListener("unhandledrejection", event => {
+        const error = event.reason;
+        if (error && typeof error.message === "string") {
+            // Post with some delay, so the master had some time to subscribe to messages
+            setTimeout(() => postUncaughtErrorMessage(error), 250);
+        }
+    });
+}
+if (typeof process !== "undefined" && typeof process.on === "function" && implementation_1.default.isWorkerRuntime()) {
+    process.on("uncaughtException", (error) => {
+        // Post with some delay, so the master had some time to subscribe to messages
+        setTimeout(() => postUncaughtErrorMessage(error), 250);
+    });
+    process.on("unhandledRejection", (error) => {
+        if (error && typeof error.message === "string") {
+            // Post with some delay, so the master had some time to subscribe to messages
+            setTimeout(() => postUncaughtErrorMessage(error), 250);
+        }
+    });
+}

package/dist/worker_threads.d.ts

@@ -0,0 +1,8 @@
+type MessagePort = any;
+interface WorkerThreadsModule {
+    MessagePort: typeof MessagePort;
+    isMainThread: boolean;
+    parentPort: MessagePort;
+}
+export default function getImplementation(): WorkerThreadsModule;
+export {};

package/dist/worker_threads.js

@@ -0,0 +1,16 @@
+"use strict";
+// Webpack hack
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getImplementation;
+let implementation;
+function selectImplementation() {
+    return typeof __non_webpack_require__ === "function"
+        ? __non_webpack_require__("worker_threads")
+        : eval("require")("worker_threads");
+}
+function getImplementation() {
+    if (!implementation) {
+        implementation = selectImplementation();
+    }
+    return implementation;
+}

package/dist-esm/common.js

@@ -0,0 +1,11 @@
+import { extendSerializer, DefaultSerializer } from "./serializers";
+let registeredSerializer = DefaultSerializer;
+export function registerSerializer(serializer) {
+    registeredSerializer = extendSerializer(registeredSerializer, serializer);
+}
+export function deserialize(message) {
+    return registeredSerializer.deserialize(message);
+}
+export function serialize(input) {
+    return registeredSerializer.serialize(input);
+}

package/dist-esm/index.js

@@ -0,0 +1,5 @@
+export { registerSerializer } from "./common";
+export * from "./master/index";
+export { expose } from "./worker/index";
+export { DefaultSerializer } from "./serializers";
+export { Transfer } from "./transferable";

package/dist-esm/master/get-bundle-url.browser.js

@@ -0,0 +1,25 @@
+// Source: <https://github.com/parcel-bundler/parcel/blob/master/packages/core/parcel-bundler/src/builtins/bundle-url.js>
+let bundleURL;
+function getBundleURLCached() {
+    if (!bundleURL) {
+        bundleURL = getBundleURL();
+    }
+    return bundleURL;
+}
+function getBundleURL() {
+    // Attempt to find the URL of the current script and use that as the base URL
+    try {
+        throw new Error;
+    }
+    catch (err) {
+        const matches = ("" + err.stack).match(/(https?|file|ftp|chrome-extension|moz-extension):\/\/[^)\n]+/g);
+        if (matches) {
+            return getBaseURL(matches[0]);
+        }
+    }
+    return "/";
+}
+function getBaseURL(url) {
+    return ("" + url).replace(/^((?:https?|file|ftp|chrome-extension|moz-extension):\/\/.+)?\/[^/]+(?:\?.*)?$/, '$1') + '/';
+}
+export { getBaseURL, getBundleURLCached as getBundleURL };