@xylabs/threads 4.6.4 → 4.7.0

package/src/observable-promise.ts

@@ -132,7 +132,8 @@ export class ObservablePromise<T> extends Observable<T> implements Promise<T> {
       const fulfillmentCallback = (value: T) => {
         try {
           resolve(onFulfilled(value))
-        } catch (error) {
+        } catch (ex) {
+          const error = ex as Error
           rejectionCallback(error)
         }
       }
@@ -166,7 +167,7 @@ export class ObservablePromise<T> extends Observable<T> implements Promise<T> {
     ) as Promise<T>
   }
 
-  static from<T>(thing: Observable<T> | ObservableLike<T> | ArrayLike<T> | Thenable<T>): ObservablePromise<T> {
+  static override from<T>(thing: Observable<T> | ObservableLike<T> | ArrayLike<T> | Thenable<T>): ObservablePromise<T> {
     return isThenable(thing)
       ? new ObservablePromise((observer) => {
         const onFulfilled = (value: T) => {

package/src/serializers.ts

@@ -1,6 +1,6 @@
 /* eslint-disable import-x/no-internal-modules */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type { SerializedError } from './types/messages'
+import type { SerializedError } from './types/messages.ts'
 
 export interface Serializer<Msg = JsonSerializable, Input = any> {
   deserialize(message: Msg): Input

package/src/transferable.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { $transferable } from './symbols'
+import { $transferable } from './symbols.ts'
 
 export interface TransferDescriptor<T = any> {
   [$transferable]: true
@@ -55,6 +55,7 @@ export function Transfer(transferable: Transferable): TransferDescriptor
 export function Transfer<T>(payload: T, transferables: Transferable[]): TransferDescriptor
 
 export function Transfer<T>(payload: T, transferables?: Transferable[]): TransferDescriptor {
+  console.log('Transfer')
   if (!transferables) {
     if (!isTransferable(payload)) throw new Error('Not transferable')
     transferables = [payload]

package/src/types/master.ts

@@ -6,11 +6,11 @@
 // See <https://github.com/microsoft/TypeScript/issues/28009>
 import type { Observable } from 'observable-fns'
 
-import type { ObservablePromise } from '../observable-promise'
+import type { ObservablePromise } from '../observable-promise.ts'
 import type {
   $errors, $events, $terminate, $worker,
-} from '../symbols'
-import type { TransferDescriptor } from '../transferable'
+} from '../symbols.ts'
+import type { TransferDescriptor } from '../transferable.ts'
 
 interface ObservableLikeSubscription {
   unsubscribe(): any

package/src/worker/WorkerGlobalScope.ts

@@ -0,0 +1,5 @@
+export interface WorkerGlobalScope {
+  addEventListener(eventName: string, listener: (event: Event) => void): void
+  postMessage(message: unknown, transferList?: Readonly<Transferable[]>): void
+  removeEventListener(eventName: string, listener: (event: Event) => void): void
+}

package/src/worker/expose.ts

@@ -0,0 +1,234 @@
+/* eslint-disable import-x/no-internal-modules */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-floating-promises */
+
+import isSomeObservable from 'is-observable-2-1-0'
+import type { Observable, Subscription } from 'observable-fns'
+
+import { deserialize, serialize } from '../common.ts'
+import type { TransferDescriptor } from '../transferable.ts'
+import { isTransferDescriptor } from '../transferable.ts'
+import type {
+  MasterJobCancelMessage,
+  MasterJobRunMessage,
+  SerializedError,
+  WorkerInitMessage,
+  WorkerJobErrorMessage,
+  WorkerJobResultMessage,
+  WorkerJobStartMessage,
+  WorkerUncaughtErrorMessage,
+} from '../types/messages.ts'
+import {
+  MasterMessageType,
+  WorkerMessageType,
+} from '../types/messages.ts'
+import type {
+  AbstractedWorkerAPI, WorkerFunction, WorkerModule,
+} from '../types/worker.ts'
+import type { WorkerGlobalScope } from './WorkerGlobalScope.ts'
+
+const isErrorEvent = (value: Event): value is ErrorEvent => value && (value as ErrorEvent).error
+
+export function createExpose(implementation: AbstractedWorkerAPI, self: WorkerGlobalScope) {
+  let exposeCalled = false
+
+  const activeSubscriptions = new Map<number, Subscription<any>>()
+
+  const isMasterJobCancelMessage = (thing: any): thing is MasterJobCancelMessage => thing && thing.type === MasterMessageType.cancel
+  const isMasterJobRunMessage = (thing: any): thing is MasterJobRunMessage => thing && thing.type === MasterMessageType.run
+
+  /**
+ * There are issues with `is-observable` not recognizing zen-observable's instances.
+ * We are using `observable-fns`, but it's based on zen-observable, too.
+ */
+  const isObservable = (thing: any): thing is Observable<any> => isSomeObservable(thing) || isZenObservable(thing)
+
+  function isZenObservable(thing: any): thing is Observable<any> {
+    return thing && typeof thing === 'object' && typeof thing.subscribe === 'function'
+  }
+
+  function deconstructTransfer(thing: any) {
+    return isTransferDescriptor(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: undefined }
+  }
+
+  function postFunctionInitMessage() {
+    const initMessage: WorkerInitMessage = {
+      exposed: { type: 'function' },
+      type: WorkerMessageType.init,
+    }
+    implementation.postMessageToMaster(initMessage)
+  }
+
+  function postModuleInitMessage(methodNames: string[]) {
+    const initMessage: WorkerInitMessage = {
+      exposed: {
+        methods: methodNames,
+        type: 'module',
+      },
+      type: WorkerMessageType.init,
+    }
+    implementation.postMessageToMaster(initMessage)
+  }
+
+  function postJobErrorMessage(uid: number, rawError: Error | TransferDescriptor<Error>) {
+    const { payload: error, transferables } = deconstructTransfer(rawError)
+    const errorMessage: WorkerJobErrorMessage = {
+      error: serialize(error) as any as SerializedError,
+      type: WorkerMessageType.error,
+      uid,
+    }
+    implementation.postMessageToMaster(errorMessage, transferables)
+  }
+
+  function postJobResultMessage(uid: number, completed: boolean, resultValue?: any) {
+    const { payload, transferables } = deconstructTransfer(resultValue)
+    const resultMessage: WorkerJobResultMessage = {
+      complete: completed ? true : undefined,
+      payload,
+      type: WorkerMessageType.result,
+      uid,
+    }
+    implementation.postMessageToMaster(resultMessage, transferables)
+  }
+
+  function postJobStartMessage(uid: number, resultType: WorkerJobStartMessage['resultType']) {
+    const startMessage: WorkerJobStartMessage = {
+      resultType,
+      type: WorkerMessageType.running,
+      uid,
+    }
+    implementation.postMessageToMaster(startMessage)
+  }
+
+  function postUncaughtErrorMessage(error: Error) {
+    try {
+      const errorMessage: WorkerUncaughtErrorMessage = {
+        error: serialize(error) as any as SerializedError,
+        type: WorkerMessageType.uncaughtError,
+      }
+      implementation.postMessageToMaster(errorMessage)
+    } catch (subError) {
+    // tslint:disable-next-line no-console
+      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,
+      )
+    }
+  }
+
+  async function runFunction(jobUID: number, fn: WorkerFunction, args: any[]) {
+    let syncResult: any
+
+    try {
+      syncResult = fn(...args)
+    } catch (ex) {
+      const error = ex as 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, serialize(value)),
+        (error) => {
+          postJobErrorMessage(jobUID, serialize(error) as any)
+          activeSubscriptions.delete(jobUID)
+        },
+        () => {
+          postJobResultMessage(jobUID, true)
+          activeSubscriptions.delete(jobUID)
+        },
+      )
+      activeSubscriptions.set(jobUID, subscription)
+    } else {
+      try {
+        const result = await syncResult
+        postJobResultMessage(jobUID, true, serialize(result))
+      } catch (error) {
+        postJobErrorMessage(jobUID, serialize(error) as any)
+      }
+    }
+  }
+
+  /**
+ * 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
+ */
+  const expose = (exposed: WorkerFunction | WorkerModule<any>) => {
+    if (!implementation.isWorkerRuntime()) {
+      throw new Error('expose() called in the master thread.')
+    }
+    if (exposeCalled) {
+      throw new 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.subscribeToMasterMessages((messageData: unknown) => {
+        if (isMasterJobRunMessage(messageData) && !messageData.method) {
+          runFunction(messageData.uid, exposed, messageData.args.map(deserialize))
+        }
+      })
+      postFunctionInitMessage()
+    } else if (typeof exposed === 'object' && exposed) {
+      implementation.subscribeToMasterMessages((messageData: unknown) => {
+        if (isMasterJobRunMessage(messageData) && messageData.method) {
+          runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(deserialize))
+        }
+      })
+
+      const methodNames = Object.keys(exposed).filter(key => typeof exposed[key] === 'function')
+      postModuleInitMessage(methodNames)
+    } else {
+      throw new Error(`Invalid argument passed to expose(). Expected a function or an object, got: ${exposed}`)
+    }
+
+    implementation.subscribeToMasterMessages((messageData: unknown) => {
+      if (isMasterJobCancelMessage(messageData)) {
+        const jobUID = messageData.uid
+        const subscription = activeSubscriptions.get(jobUID)
+
+        if (subscription) {
+          subscription.unsubscribe()
+          activeSubscriptions.delete(jobUID)
+        }
+      }
+    })
+  }
+
+  if (typeof globalThis !== 'undefined' && typeof self.addEventListener === 'function' && implementation.isWorkerRuntime()) {
+    self.addEventListener('error', (event) => {
+    // Post with some delay, so the master had some time to subscribe to messages
+      setTimeout(() => postUncaughtErrorMessage(isErrorEvent(event) ? event.error : event), 250)
+    })
+    self.addEventListener('unhandledrejection', (event) => {
+      const error = (event as any).reason
+      if (error && typeof (error as any).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.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 as any).message === 'string') {
+      // Post with some delay, so the master had some time to subscribe to messages
+        setTimeout(() => postUncaughtErrorMessage(error as any), 250)
+      }
+    })
+  }
+
+  return expose
+}

package/src/worker/is-observable.d.ts

@@ -0,0 +1,7 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+declare module 'is-observable-2-1-0' {
+  import type { Observable } from 'observable-fns'
+
+  function isObservable(thing: any): thing is Observable<any>
+  export = isObservable
+}

package/src/worker/{implementation.browser.ts → worker.browser.ts}

@@ -1,15 +1,11 @@
 /* eslint-disable import-x/no-internal-modules */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/// <reference lib="dom" />
-// tslint:disable no-shadowed-variable
 
-import type { AbstractedWorkerAPI } from '../types/worker'
+/// <reference lib="webworker" />
+// tslint:disable no-shadowed-variable
 
-interface WorkerGlobalScope {
-  addEventListener(eventName: string, listener: (event: Event) => void): void
-  postMessage(message: any, transferables?: any[]): void
-  removeEventListener(eventName: string, listener: (event: Event) => void): void
-}
+import type { AbstractedWorkerAPI } from '../types/worker.ts'
+import { createExpose } from './expose.ts'
+import type { WorkerGlobalScope } from './WorkerGlobalScope.ts'
 
 declare const self: WorkerGlobalScope
 
@@ -33,8 +29,28 @@ const subscribeToMasterMessages: AbstractedWorkerAPI['subscribeToMasterMessages'
   return unsubscribe
 }
 
-export default {
+const addEventListener = self.addEventListener
+const postMessage = self.postMessage
+const removeEventListener = self.removeEventListener
+
+export {
+  addEventListener,
+  postMessage,
+  removeEventListener,
+}
+
+const expose = createExpose({
+  isWorkerRuntime, postMessageToMaster, subscribeToMasterMessages,
+}, {
+  addEventListener, postMessage, removeEventListener,
+})
+
+export {
   isWorkerRuntime,
   postMessageToMaster,
   subscribeToMasterMessages,
 }
+
+export { registerSerializer } from '../common.ts'
+export { Transfer } from '../transferable.ts'
+export { expose }

package/src/worker/{implementation.worker_threads.ts → worker.node.ts}

@@ -1,10 +1,16 @@
 /* eslint-disable import-x/no-internal-modules */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 // tslint:disable no-shadowed-variable
-import type { MessagePort } from 'node:worker_threads'
 
-import type { AbstractedWorkerAPI } from '../types/worker'
-import WorkerThreads from '../worker_threads'
+import type { MessagePort, TransferListItem } from 'node:worker_threads'
+import { parentPort as optionalParentPort } from 'node:worker_threads'
+
+import { assertEx } from '@xylabs/assert'
+
+import type { AbstractedWorkerAPI } from '../types/worker.ts'
+import { createExpose } from './expose.ts'
+
+const parentPort = assertEx(optionalParentPort, () => 'Invariant violation: MessagePort to parent is not available.')
 
 function assertMessagePort(port: MessagePort | null | undefined): MessagePort {
   if (!port) {
@@ -14,16 +20,14 @@ function assertMessagePort(port: MessagePort | null | undefined): MessagePort {
 }
 
 const isWorkerRuntime: AbstractedWorkerAPI['isWorkerRuntime'] = function isWorkerRuntime() {
-  return !WorkerThreads().isMainThread
+  return true // isMainThread
 }
 
 const postMessageToMaster: AbstractedWorkerAPI['postMessageToMaster'] = function postMessageToMaster(data, transferList) {
-  assertMessagePort(WorkerThreads().parentPort).postMessage(data, transferList as any)
+  assertMessagePort(parentPort).postMessage(data, transferList as TransferListItem[])
 }
 
 const subscribeToMasterMessages: AbstractedWorkerAPI['subscribeToMasterMessages'] = function subscribeToMasterMessages(onMessage) {
-  const parentPort = WorkerThreads().parentPort
-
   if (!parentPort) {
     throw new Error('Invariant violation: MessagePort to parent is not available.')
   }
@@ -37,14 +41,28 @@ const subscribeToMasterMessages: AbstractedWorkerAPI['subscribeToMasterMessages'
   return unsubscribe
 }
 
-function testImplementation() {
-  // Will throw if `worker_threads` are not available
-  WorkerThreads()
+const addEventListener = parentPort?.on.bind(parentPort)
+const postMessage = parentPort?.postMessage.bind(parentPort)
+const removeEventListener = parentPort?.off.bind(parentPort)
+
+export {
+  addEventListener,
+  postMessage,
+  removeEventListener,
 }
 
-export default {
+const expose = createExpose({
+  isWorkerRuntime, postMessageToMaster, subscribeToMasterMessages,
+}, {
+  addEventListener, postMessage, removeEventListener,
+})
+
+export {
   isWorkerRuntime,
   postMessageToMaster,
   subscribeToMasterMessages,
-  testImplementation,
 }
+
+export { registerSerializer } from '../common.ts'
+export { Transfer } from '../transferable.ts'
+export { expose }

package/types/is-observable.d.ts

@@ -4,4 +4,4 @@ declare module 'is-observable-2-1-0' {
 
   function isObservable(thing: any): thing is Observable<any>
   export = isObservable
-}
+}

package/xy.config.ts

@@ -0,0 +1,24 @@
+import type { XyTsupConfig } from '@xylabs/ts-scripts-yarn3'
+const config: XyTsupConfig = {
+  compile: {
+    browser: { src: { entry: ['./src/master/implementation.browser.ts', './src/worker/worker.browser.ts'] } },
+    neutral: {
+      src: {
+        entry: [
+          './src/index.ts',
+          './src/master/index.ts',
+          './src/master/pool.ts',
+          './src/observable.ts',
+          './src/observable-promise.ts',
+          './src/master/implementation.ts',
+          './src/master/register.ts',
+          './src/master/spawn.ts',
+          './src/master/thread.ts',
+        ],
+      },
+    },
+    node: { src: { entry: ['./src/master/implementation.node.ts', './src/worker/worker.node.ts'] } },
+  },
+}
+
+export default config

package/dist/common.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerSerializer = registerSerializer;
-exports.deserialize = deserialize;
-exports.serialize = serialize;
-const serializers_1 = require("./serializers");
-let registeredSerializer = serializers_1.DefaultSerializer;
-function registerSerializer(serializer) {
-    registeredSerializer = (0, serializers_1.extendSerializer)(registeredSerializer, serializer);
-}
-function deserialize(message) {
-    return registeredSerializer.deserialize(message);
-}
-function serialize(input) {
-    return registeredSerializer.serialize(input);
-}

package/dist/esm/common.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerSerializer = registerSerializer;
-exports.deserialize = deserialize;
-exports.serialize = serialize;
-const serializers_1 = require("./serializers");
-let registeredSerializer = serializers_1.DefaultSerializer;
-function registerSerializer(serializer) {
-    registeredSerializer = (0, serializers_1.extendSerializer)(registeredSerializer, serializer);
-}
-function deserialize(message) {
-    return registeredSerializer.deserialize(message);
-}
-function serialize(input) {
-    return registeredSerializer.serialize(input);
-}

package/dist/esm/index.js

@@ -1,26 +0,0 @@
-"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 });
-exports.expose = exports.Transfer = exports.DefaultSerializer = exports.registerSerializer = void 0;
-var common_1 = require("./common");
-Object.defineProperty(exports, "registerSerializer", { enumerable: true, get: function () { return common_1.registerSerializer; } });
-__exportStar(require("./master/index"), exports);
-var serializers_1 = require("./serializers");
-Object.defineProperty(exports, "DefaultSerializer", { enumerable: true, get: function () { return serializers_1.DefaultSerializer; } });
-var transferable_1 = require("./transferable");
-Object.defineProperty(exports, "Transfer", { enumerable: true, get: function () { return transferable_1.Transfer; } });
-var index_1 = require("./worker/index");
-Object.defineProperty(exports, "expose", { enumerable: true, get: function () { return index_1.expose; } });

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

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBundleURL = getBundleURLCached;
-let bundleURL;
-function getBundleURLCached() {
-    if (!bundleURL) {
-        bundleURL = getBundleURL();
-    }
-    return bundleURL;
-}
-function getBundleURL() {
-    try {
-        throw new Error('getBundleURL failed');
-    }
-    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') + '/';
-}

package/dist/esm/master/implementation.browser.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultPoolSize = void 0;
-exports.getWorkerImplementation = getWorkerImplementation;
-exports.isWorkerRuntime = isWorkerRuntime;
-const get_bundle_url_browser_1 = require("./get-bundle-url.browser");
-exports.defaultPoolSize = typeof navigator !== 'undefined' && navigator.hardwareConcurrency ? navigator.hardwareConcurrency : 4;
-const isAbsoluteURL = (value) => /^[A-Za-z][\d+.A-Za-z\-]*:/.test(value);
-function createSourceBlobURL(code) {
-    const blob = new Blob([code], { type: 'application/javascript' });
-    return URL.createObjectURL(blob);
-}
-function selectWorkerImplementation() {
-    if (typeof Worker === 'undefined') {
-        return class NoWebWorker {
-            constructor() {
-                throw new Error("No web worker implementation available. You might have tried to spawn a worker within a worker in a browser that doesn't support workers in workers.");
-            }
-        };
-    }
-    class WebWorker extends Worker {
-        constructor(url, options) {
-            if (typeof url === 'string' && options && options._baseURL) {
-                url = new URL(url, options._baseURL);
-            }
-            else if (typeof url === 'string' && !isAbsoluteURL(url) && /^file:\/\//i.test((0, get_bundle_url_browser_1.getBundleURL)())) {
-                url = new URL(url, (0, get_bundle_url_browser_1.getBundleURL)().replace(/\/[^/]+$/, '/'));
-                if (options?.CORSWorkaround ?? true) {
-                    url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
-                }
-            }
-            if (typeof url === 'string'
-                && isAbsoluteURL(url)
-                && (options?.CORSWorkaround ?? true)) {
-                url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
-            }
-            super(url, options);
-        }
-    }
-    class BlobWorker extends WebWorker {
-        constructor(blob, options) {
-            const url = globalThis.URL.createObjectURL(blob);
-            super(url, options);
-        }
-        static fromText(source, options) {
-            const blob = new globalThis.Blob([source], { type: 'text/javascript' });
-            return new BlobWorker(blob, options);
-        }
-    }
-    return {
-        blob: BlobWorker,
-        default: WebWorker,
-    };
-}
-let implementation;
-function getWorkerImplementation() {
-    if (!implementation) {
-        implementation = selectWorkerImplementation();
-    }
-    return implementation;
-}
-function isWorkerRuntime() {
-    const isWindowContext = typeof globalThis !== 'undefined' && typeof Window !== 'undefined' && globalThis instanceof Window;
-    return typeof globalThis !== 'undefined' && self['postMessage'] && !isWindowContext ? true : false;
-}

package/dist/esm/master/implementation.js

@@ -1,43 +0,0 @@
-"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isWorkerRuntime = exports.getWorkerImplementation = exports.defaultPoolSize = void 0;
-const BrowserImplementation = __importStar(require("./implementation.browser"));
-const NodeImplementation = __importStar(require("./implementation.node"));
-const runningInNode = typeof process !== 'undefined' && process.arch !== 'browser' && 'pid' in process;
-const implementation = runningInNode ? NodeImplementation : BrowserImplementation;
-exports.defaultPoolSize = implementation.defaultPoolSize;
-exports.getWorkerImplementation = implementation.getWorkerImplementation;
-exports.isWorkerRuntime = implementation.isWorkerRuntime;