@xylabs/threads 3.0.4

package/index.mjs

@@ -0,0 +1,11 @@
+/* eslint-disable import/no-internal-modules */
+import * as Threads from './dist/index.js'
+
+export const registerSerializer = Threads.registerSerializer
+export const spawn = Threads.spawn
+export const BlobWorker = Threads.BlobWorker
+export const DefaultSerializer = Threads.DefaultSerializer
+export const Pool = Threads.Pool
+export const Thread = Threads.Thread
+export const Transfer = Threads.Transfer
+export const Worker = Threads.Worker

package/observable.d.ts

@@ -0,0 +1,2 @@
+/* eslint-disable import/no-internal-modules */
+export * from './dist/observable'

package/observable.js

@@ -0,0 +1,3 @@
+/* eslint-disable import/no-internal-modules */
+/* eslint-disable no-undef */
+module.exports = require('./dist/observable')

package/observable.mjs

@@ -0,0 +1,5 @@
+/* eslint-disable import/no-internal-modules */
+import * as Observables from './dist/observable.js'
+
+export const Observable = Observables.Observable
+export const Subject = Observables.Subject

package/package.json

@@ -0,0 +1,141 @@
+{
+  "name": "@xylabs/threads",
+  "version": "3.0.4",
+  "description": "Web workers & worker threads as simple as a function call",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "module": "dist-esm/index.js",
+  "scripts": {
+    "package-compile": "yarn build",
+    "clean": "rimraf dist/ dist-esm/",
+    "dev": "npm run clean && tsc -p tsconfig.json --watch",
+    "build": "npm run clean && npm run build:cjs && npm run build:es",
+    "build:cjs": "tsc -p tsconfig.json",
+    "build:es": "tsc -p tsconfig-esm.json",
+    "postbuild": "npm run bundle",
+    "bundle": "rollup -c -f umd --file=bundle/worker.js --name=threads --silent -- dist-esm/worker/bundle-entry.js",
+    "test": "npm run test:library && npm run test:tooling && npm run test:puppeteer:basic && npm run test:puppeteer:webpack",
+    "test:library": "cross-env TS_NODE_FILES=true ava ./test/**/*.test.ts",
+    "test:tooling": "cross-env TS_NODE_FILES=true ava ./test-tooling/**/*.test.ts",
+    "test:puppeteer:basic": "puppet-run --plugin=mocha --bundle=./test/workers/:workers/ --serve=./bundle/worker.js:/worker.js ./test/*.chromium*.ts",
+    "test:puppeteer:webpack": "puppet-run --serve ./test-tooling/webpack/dist/app.web/0.worker.js --serve ./test-tooling/webpack/dist/app.web/1.worker.js --plugin=mocha ./test-tooling/webpack/webpack.chromium.mocha.ts",
+    "prepare": "npm run build"
+  },
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "default": "./index.mjs"
+    },
+    "./observable": {
+      "require": "./observable.js",
+      "default": "./observable.mjs"
+    },
+    "./register": {
+      "require": "./register.js",
+      "default": "./register.mjs"
+    },
+    "./worker": {
+      "require": "./worker.js",
+      "default": "./worker.mjs"
+    }
+  },
+  "sideEffects": [
+    "./dist*/master/register.js",
+    "./dist*/worker/index.js",
+    "./register.*js",
+    "./worker.*js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/andywer/threads.js.git"
+  },
+  "author": "Andy Wermke (https://github.com/andywer)",
+  "bugs": {
+    "url": "https://github.com/andywer/threads.js/issues"
+  },
+  "funding": "https://github.com/andywer/threads.js?sponsor=1",
+  "homepage": "https://threads.js.org",
+  "keywords": [
+    "thread",
+    "worker",
+    "pool",
+    "spawn",
+    "isomorphic",
+    "parallel",
+    "observable",
+    "worker_threads"
+  ],
+  "dependencies": {
+    "callsites": "^3.1.0",
+    "debug": "^4.2.0",
+    "is-observable": "^2.1.0",
+    "observable-fns": "^0.6.1"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^16.0.0",
+    "@rollup/plugin-node-resolve": "^10.0.0",
+    "@types/chai": "^4.2.14",
+    "@types/debug": "^4.1.5",
+    "@types/execa": "^2.0.0",
+    "@types/node": "^20",
+    "@types/webpack": "^4.41.23",
+    "ava": "^3.13.0",
+    "chai": "^4.2.0",
+    "cross-env": "^7.0.2",
+    "execa": "^4.0.3",
+    "mocha": "^8.2.0",
+    "puppet-run": "^0.11.3",
+    "puppet-run-plugin-mocha": "^0.10.0-alpha",
+    "raw-loader": "^4.0.2",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.32.1",
+    "threads-plugin": "^1.3.3",
+    "tiny-worker": "^2.2.0",
+    "ts-loader": "^8.0.7",
+    "ts-node": "^9.0.0",
+    "typescript": "^4.2.3",
+    "wavy": "^1.0.4",
+    "webpack": "^4.44.2",
+    "worker-plugin": "^5.0.0"
+  },
+  "optionalDependencies": {
+    "tiny-worker": ">= 2"
+  },
+  "ava": {
+    "extensions": [
+      "ts"
+    ],
+    "files": [
+      "./test/**/*.test.ts",
+      "./test-tooling/**/*.test.ts"
+    ],
+    "require": [
+      "ts-node/register"
+    ],
+    "serial": true
+  },
+  "browser": {
+    "./dist-esm/master/implementation.js": "./dist-esm/master/implementation.browser.js",
+    "./dist-esm/master/implementation.node.js": false,
+    "./dist-esm/worker/implementation.js": "./dist-esm/worker/implementation.browser.js",
+    "./dist-esm/worker/implementation.tiny-worker.js": false,
+    "./dist-esm/worker/implementation.worker_threads.js": false,
+    "./dist/master/implementation.js": "./dist/master/implementation.browser.js",
+    "./dist/master/implementation.node.js": false,
+    "./dist/worker/implementation.js": "./dist/worker/implementation.browser.js",
+    "./dist/worker/implementation.tiny-worker.js": false,
+    "./dist/worker/implementation.worker_threads.js": false,
+    "callsites": false,
+    "tiny-worker": false,
+    "ts-node": false,
+    "ts-node/register": false,
+    "worker_threads": false
+  },
+  "files": [
+    "dist/**",
+    "dist-esm/**",
+    "*.js",
+    "*.mjs",
+    "*.ts"
+  ]
+}

package/register.d.ts

@@ -0,0 +1,3 @@
+/* eslint-disable import/export */
+/* eslint-disable import/no-internal-modules */
+export * from './dist/master/register'

package/register.js

@@ -0,0 +1,3 @@
+/* eslint-disable no-undef */
+/* eslint-disable import/no-internal-modules */
+require('./dist/master/register')

package/register.mjs

@@ -0,0 +1,2 @@
+/* eslint-disable import/no-internal-modules */
+import './dist/master/register.js'

package/rollup.config.js

@@ -0,0 +1,16 @@
+/* eslint-disable no-undef */
+/* eslint-disable @typescript-eslint/no-var-requires */
+const commonjs = require('@rollup/plugin-commonjs')
+const { nodeResolve } = require('@rollup/plugin-node-resolve')
+
+module.exports = {
+  plugins: [
+    nodeResolve({
+      browser: true,
+      mainFields: ['module', 'main'],
+      preferBuiltins: true,
+    }),
+
+    commonjs(),
+  ],
+}

package/src/common.ts

@@ -0,0 +1,16 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { DefaultSerializer, extendSerializer, JsonSerializable, Serializer, SerializerImplementation } from './serializers'
+
+let registeredSerializer: Serializer<JsonSerializable> = DefaultSerializer
+
+export function registerSerializer(serializer: SerializerImplementation<JsonSerializable>) {
+  registeredSerializer = extendSerializer(registeredSerializer, serializer)
+}
+
+export function deserialize(message: JsonSerializable): any {
+  return registeredSerializer.deserialize(message)
+}
+
+export function serialize(input: any): JsonSerializable {
+  return registeredSerializer.serialize(input)
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+/* eslint-disable import/no-internal-modules */
+export { registerSerializer } from './common'
+export * from './master/index'
+export { QueuedTask } from './master/pool'
+export { ExposedToThreadType as ExposedAs } from './master/spawn'
+export { DefaultSerializer, JsonSerializable, Serializer, SerializerImplementation } from './serializers'
+export { Transfer, TransferDescriptor } from './transferable'
+export { expose } from './worker/index'

package/src/master/get-bundle-url.browser.ts

@@ -0,0 +1,31 @@
+// Source: <https://github.com/parcel-bundler/parcel/blob/master/packages/core/parcel-bundler/src/builtins/bundle-url.js>
+
+let bundleURL: string | undefined
+
+function getBundleURLCached(): string {
+  if (!bundleURL) {
+    bundleURL = getBundleURL()
+  }
+
+  return bundleURL
+}
+
+function getBundleURL(): string {
+  // Attempt to find the URL of the current script and use that as the base URL
+  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: string): string {
+  return ('' + url).replace(/^((?:https?|file|ftp|chrome-extension|moz-extension):\/\/.+)?\/[^/]+(?:\?.*)?$/, '$1') + '/'
+}
+
+export { getBaseURL, getBundleURLCached as getBundleURL }

package/src/master/implementation.browser.ts

@@ -0,0 +1,80 @@
+// tslint:disable max-classes-per-file
+
+import { ImplementationExport, ThreadsWorkerOptions } from '../types/master'
+import { getBundleURL } from './get-bundle-url.browser'
+
+export const defaultPoolSize = typeof navigator !== 'undefined' && navigator.hardwareConcurrency ? navigator.hardwareConcurrency : 4
+
+const isAbsoluteURL = (value: string) => /^[A-Za-z][\d+.A-Za-z\-]*:/.test(value)
+
+function createSourceBlobURL(code: string): string {
+  const blob = new Blob([code], { type: 'application/javascript' })
+  return URL.createObjectURL(blob)
+}
+
+function selectWorkerImplementation(): ImplementationExport {
+  if (typeof Worker === 'undefined') {
+    // Might happen on Safari, for instance
+    // The idea is to only fail if the constructor is actually used
+    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.",
+        )
+      }
+    } as unknown as ImplementationExport
+  }
+
+  class WebWorker extends Worker {
+    constructor(url: string | URL, options?: ThreadsWorkerOptions) {
+      if (typeof url === 'string' && options && options._baseURL) {
+        url = new URL(url, options._baseURL)
+      } else if (typeof url === 'string' && !isAbsoluteURL(url) && /^file:\/\//i.test(getBundleURL())) {
+        url = new URL(url, getBundleURL().replace(/\/[^/]+$/, '/'))
+        if (options?.CORSWorkaround ?? true) {
+          url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`)
+        }
+      }
+      if (
+        typeof url === 'string' &&
+        isAbsoluteURL(url) && // Create source code blob loading JS file via `importScripts()`
+        // to circumvent worker CORS restrictions
+        (options?.CORSWorkaround ?? true)
+      ) {
+        url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`)
+      }
+      super(url, options)
+    }
+  }
+
+  class BlobWorker extends WebWorker {
+    constructor(blob: Blob, options?: ThreadsWorkerOptions) {
+      const url = window.URL.createObjectURL(blob)
+      super(url, options)
+    }
+
+    static fromText(source: string, options?: ThreadsWorkerOptions): WebWorker {
+      const blob = new window.Blob([source], { type: 'text/javascript' })
+      return new BlobWorker(blob, options)
+    }
+  }
+
+  return {
+    blob: BlobWorker,
+    default: WebWorker,
+  }
+}
+
+let implementation: ImplementationExport
+
+export function getWorkerImplementation(): ImplementationExport {
+  if (!implementation) {
+    implementation = selectWorkerImplementation()
+  }
+  return implementation
+}
+
+export function isWorkerRuntime() {
+  const isWindowContext = typeof self !== 'undefined' && typeof Window !== 'undefined' && self instanceof Window
+  return typeof self !== 'undefined' && self['postMessage'] && !isWindowContext ? true : false
+}

package/src/master/implementation.node.ts

@@ -0,0 +1,284 @@
+/* eslint-disable unicorn/prefer-logical-operator-over-ternary */
+/* eslint-disable unicorn/prefer-regexp-test */
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable unicorn/prefer-add-event-listener */
+/* eslint-disable unicorn/prefer-event-target */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable unicorn/text-encoding-identifier-case */
+/* eslint-disable unicorn/no-process-exit */
+/// <reference lib="dom" />
+
+import { EventEmitter } from 'node:events'
+import { cpus } from 'node:os'
+import * as path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import getCallsites, { CallSite } from 'callsites'
+
+import { ImplementationExport, ThreadsWorkerOptions, WorkerImplementation } from '../types/master'
+
+interface WorkerGlobalScope {
+  addEventListener(eventName: string, listener: (event: Event) => void): void
+  postMessage(message: any, transferables?: any[]): void
+  removeEventListener(eventName: string, listener: (event: Event) => void): void
+}
+
+declare const __non_webpack_require__: typeof require
+declare const self: WorkerGlobalScope
+
+type WorkerEventName = 'error' | 'message'
+
+let tsNodeAvailable: boolean | undefined
+
+export const defaultPoolSize = cpus().length
+
+function detectTsNode() {
+  if (typeof __non_webpack_require__ === 'function') {
+    // Webpack build: => No ts-node required or possible
+    return false
+  }
+  if (tsNodeAvailable) {
+    return tsNodeAvailable
+  }
+
+  try {
+    eval('require').resolve('ts-node')
+    tsNodeAvailable = true
+  } catch (error) {
+    if (error && error.code === 'MODULE_NOT_FOUND') {
+      tsNodeAvailable = false
+    } else {
+      // Re-throw
+      throw error
+    }
+  }
+  return tsNodeAvailable
+}
+
+function createTsNodeModule(scriptPath: string) {
+  const content = `
+    require("ts-node/register/transpile-only");
+    require(${JSON.stringify(scriptPath)});
+  `
+  return content
+}
+
+function rebaseScriptPath(scriptPath: string, ignoreRegex: RegExp) {
+  const parentCallSite = getCallsites().find((callsite: CallSite) => {
+    const filename = callsite.getFileName()
+    return Boolean(
+      filename && !filename.match(ignoreRegex) && !/[/\\]master[/\\]implementation/.test(filename) && !/^internal\/process/.test(filename),
+    )
+  })
+
+  const rawCallerPath = parentCallSite ? parentCallSite.getFileName() : null
+  let callerPath = rawCallerPath ? rawCallerPath : null
+  if (callerPath && callerPath.startsWith('file:')) {
+    callerPath = fileURLToPath(callerPath)
+  }
+  const rebasedScriptPath = callerPath ? path.join(path.dirname(callerPath), scriptPath) : scriptPath
+
+  return rebasedScriptPath
+}
+
+function resolveScriptPath(scriptPath: string, baseURL?: string | undefined) {
+  const makeRelative = (filePath: string) => {
+    // eval() hack is also webpack-related
+    return path.isAbsolute(filePath) ? filePath : path.join(baseURL || eval('__dirname'), filePath)
+  }
+
+  const workerFilePath =
+    typeof __non_webpack_require__ === 'function' ?
+      __non_webpack_require__.resolve(makeRelative(scriptPath))
+    : eval('require').resolve(makeRelative(rebaseScriptPath(scriptPath, /[/\\]worker_threads[/\\]/)))
+
+  return workerFilePath
+}
+
+function initWorkerThreadsWorker(): ImplementationExport {
+  // Webpack hack
+  const NativeWorker =
+    typeof __non_webpack_require__ === 'function' ? __non_webpack_require__('worker_threads').Worker : eval('require')('worker_threads').Worker
+
+  let allWorkers: Array<typeof NativeWorker> = []
+
+  class Worker extends NativeWorker {
+    private mappedEventListeners: WeakMap<EventListener, EventListener>
+
+    constructor(scriptPath: string, options?: ThreadsWorkerOptions & { fromSource: boolean }) {
+      const resolvedScriptPath = options && options.fromSource ? null : resolveScriptPath(scriptPath, (options || {})._baseURL)
+
+      if (!resolvedScriptPath) {
+        // `options.fromSource` is true
+        const sourceCode = scriptPath
+        super(sourceCode, { ...options, eval: true })
+      } else if (/\.tsx?$/i.test(resolvedScriptPath) && detectTsNode()) {
+        super(createTsNodeModule(resolvedScriptPath), { ...options, eval: true })
+      } else if (/\.asar[/\\]/.test(resolvedScriptPath)) {
+        // See <https://github.com/andywer/threads-plugin/issues/17>
+        super(resolvedScriptPath.replace(/\.asar([/\\])/, '.asar.unpacked$1'), options)
+      } else {
+        super(resolvedScriptPath, options)
+      }
+
+      this.mappedEventListeners = new WeakMap()
+      allWorkers.push(this)
+    }
+
+    addEventListener(eventName: string, rawListener: EventListener) {
+      const listener = (message: any) => {
+        rawListener({ data: message } as any)
+      }
+      this.mappedEventListeners.set(rawListener, listener)
+      this.on(eventName, listener)
+    }
+
+    removeEventListener(eventName: string, rawListener: EventListener) {
+      const listener = this.mappedEventListeners.get(rawListener) || rawListener
+      this.off(eventName, listener)
+    }
+  }
+
+  const terminateWorkersAndMaster = () => {
+    // we should terminate all workers and then gracefully shutdown self process
+    Promise.all(allWorkers.map((worker) => worker.terminate())).then(
+      () => process.exit(0),
+      () => process.exit(1),
+    )
+    allWorkers = []
+  }
+
+  // Take care to not leave orphaned processes behind. See #147.
+  process.on('SIGINT', () => terminateWorkersAndMaster())
+  process.on('SIGTERM', () => terminateWorkersAndMaster())
+
+  class BlobWorker extends Worker {
+    constructor(blob: Uint8Array, options?: ThreadsWorkerOptions) {
+      super(Buffer.from(blob).toString('utf-8'), { ...options, fromSource: true })
+    }
+
+    static fromText(source: string, options?: ThreadsWorkerOptions): WorkerImplementation {
+      return new Worker(source, { ...options, fromSource: true }) as any
+    }
+  }
+
+  return {
+    blob: BlobWorker as any,
+    default: Worker as any,
+  }
+}
+
+function initTinyWorker(): ImplementationExport {
+  const TinyWorker = require('tiny-worker')
+
+  let allWorkers: Array<typeof TinyWorker> = []
+
+  class Worker extends TinyWorker {
+    private emitter: EventEmitter
+
+    constructor(scriptPath: string, options?: ThreadsWorkerOptions & { fromSource?: boolean }) {
+      // Need to apply a work-around for Windows or it will choke upon the absolute path
+      // (`Error [ERR_INVALID_PROTOCOL]: Protocol 'c:' not supported`)
+      const resolvedScriptPath =
+        options && options.fromSource ? null
+        : process.platform === 'win32' ? `file:///${resolveScriptPath(scriptPath).replaceAll('\\', '/')}`
+        : resolveScriptPath(scriptPath)
+
+      if (!resolvedScriptPath) {
+        // `options.fromSource` is true
+        const sourceCode = scriptPath
+        super(new Function(sourceCode), [], { esm: true })
+      } else if (/\.tsx?$/i.test(resolvedScriptPath) && detectTsNode()) {
+        super(new Function(createTsNodeModule(resolveScriptPath(scriptPath))), [], { esm: true })
+      } else if (/\.asar[/\\]/.test(resolvedScriptPath)) {
+        // See <https://github.com/andywer/threads-plugin/issues/17>
+        super(resolvedScriptPath.replace(/\.asar([/\\])/, '.asar.unpacked$1'), [], { esm: true })
+      } else {
+        super(resolvedScriptPath, [], { esm: true })
+      }
+
+      allWorkers.push(this)
+
+      this.emitter = new EventEmitter()
+      this.onerror = (error: Error) => this.emitter.emit('error', error)
+      this.onmessage = (message: MessageEvent) => this.emitter.emit('message', message)
+    }
+
+    addEventListener(eventName: WorkerEventName, listener: EventListener) {
+      this.emitter.addListener(eventName, listener)
+    }
+
+    removeEventListener(eventName: WorkerEventName, listener: EventListener) {
+      this.emitter.removeListener(eventName, listener)
+    }
+
+    terminate() {
+      allWorkers = allWorkers.filter((worker) => worker !== this)
+      return super.terminate()
+    }
+  }
+
+  const terminateWorkersAndMaster = () => {
+    // we should terminate all workers and then gracefully shutdown self process
+    Promise.all(allWorkers.map((worker) => worker.terminate())).then(
+      () => process.exit(0),
+      () => process.exit(1),
+    )
+    allWorkers = []
+  }
+
+  // Take care to not leave orphaned processes behind
+  // See <https://github.com/avoidwork/tiny-worker#faq>
+  process.on('SIGINT', () => terminateWorkersAndMaster())
+  process.on('SIGTERM', () => terminateWorkersAndMaster())
+
+  class BlobWorker extends Worker {
+    constructor(blob: Uint8Array, options?: ThreadsWorkerOptions) {
+      super(Buffer.from(blob).toString('utf-8'), { ...options, fromSource: true })
+    }
+
+    static fromText(source: string, options?: ThreadsWorkerOptions): WorkerImplementation {
+      return new Worker(source, { ...options, fromSource: true }) as any
+    }
+  }
+
+  return {
+    blob: BlobWorker as any,
+    default: Worker as any,
+  }
+}
+
+let implementation: ImplementationExport
+let isTinyWorker: boolean
+
+function selectWorkerImplementation(): ImplementationExport {
+  try {
+    isTinyWorker = false
+    return initWorkerThreadsWorker()
+  } catch {
+    // tslint:disable-next-line no-console
+    console.debug('Node worker_threads not available. Trying to fall back to tiny-worker polyfill...')
+    isTinyWorker = true
+    return initTinyWorker()
+  }
+}
+
+export function getWorkerImplementation(): ImplementationExport {
+  if (!implementation) {
+    implementation = selectWorkerImplementation()
+  }
+  return implementation
+}
+
+export function isWorkerRuntime() {
+  if (isTinyWorker) {
+    return self !== undefined && self['postMessage'] ? true : false
+  } else {
+    // Webpack hack
+    const isMainThread =
+      typeof __non_webpack_require__ === 'function' ?
+        __non_webpack_require__('worker_threads').isMainThread
+      : eval('require')('worker_threads').isMainThread
+    return !isMainThread
+  }
+}

package/src/master/implementation.ts

@@ -0,0 +1,21 @@
+/*
+ * This file is only a stub to make './implementation' resolve to the right module.
+ */
+
+// We alias `src/master/implementation` to `src/master/implementation.browser` for web
+// browsers already in the package.json, so if get here, it's safe to pass-through the
+// node implementation
+
+import * as BrowserImplementation from './implementation.browser'
+import * as NodeImplementation from './implementation.node'
+
+const runningInNode = typeof process !== 'undefined' && (process.arch as string) !== 'browser' && 'pid' in process
+const implementation = runningInNode ? NodeImplementation : BrowserImplementation
+
+/** Default size of pools. Depending on the platform the value might vary from device to device. */
+export const defaultPoolSize = implementation.defaultPoolSize
+
+export const getWorkerImplementation = implementation.getWorkerImplementation
+
+/** Returns `true` if this code is currently running in a worker. */
+export const isWorkerRuntime = implementation.isWorkerRuntime

package/src/master/index.ts

@@ -0,0 +1,20 @@
+// tslint:disable no-duplicate-imports
+import type { BlobWorker as BlobWorkerClass } from '../types/master'
+import { Worker as WorkerType } from '../types/master'
+import { getWorkerImplementation } from './implementation'
+
+export { FunctionThread, ModuleThread } from '../types/master'
+export { Pool } from './pool'
+export { spawn } from './spawn'
+export { Thread } from './thread'
+
+export type BlobWorker = typeof BlobWorkerClass
+export type Worker = WorkerType
+
+/** Separate class to spawn workers from source code blobs or strings. */
+export const BlobWorker = getWorkerImplementation().blob
+
+/** Worker implementation. Either web worker or a node.js Worker class. */
+export const Worker = getWorkerImplementation().default
+
+export { isWorkerRuntime } from './implementation'