@vitest/web-worker 0.25.8 → 0.26.0

package/README.md

@@ -2,7 +2,14 @@
 
 > Web Worker support for Vitest testing. Doesn't require JSDom.
 
-Simulates Web Worker, but in the same thread. Supports both `new Worker(url)` and `import from './worker?worker`.
+Simulates Web Worker, but in the same thread.
+
+Supported:
+
+- `new Worker(path)`
+- `new SharedWorker(path)`
+- `import MyWorker from './worker?worker'`
+- `import MySharedWorker from './worker?sharedworker'`
 
 ## Installing
 
@@ -33,18 +40,36 @@ export default defineConfig({
 })
 ```
 
+You can also import `defineWebWorkers` from `@vitest/web-worker/pure` to define workers, whenever you need:
+
+```js
+import { defineWebWorkers } from '@vitest/web-worker/pure'
+
+if (process.env.SUPPORT_WORKERS)
+  defineWebWorkers({ clone: 'none' })
+```
+
+It accepts options:
+
+- `clone`: `'native' | 'ponyfill' | 'none'`. Defines how should `Worker` clone message, when transferring data. Applies only to `Worker` communication. `SharedWorker` uses `MessageChannel` from Node's `worker_threads` module, and is not configurable.
+
+> **Note**
+> Requires Node 17, if you want to use native `structuredClone`. Otherwise, it fallbacks to [polyfill](https://github.com/ungap/structured-clone), if not specified as `none`. You can also configure this option with `VITEST_WEB_WORKER_CLONE` environmental variable.
+
 ## Examples
 
 ```ts
 // worker.ts
-import '@vitest/web-worker'
-import MyWorker from '../worker?worker'
-
 self.onmessage = (e) => {
   self.postMessage(`${e.data} world`)
 }
+```
 
+```ts
 // worker.test.ts
+import '@vitest/web-worker'
+import MyWorker from '../worker?worker'
+
 let worker = new MyWorker()
 // new Worker is also supported
 worker = new Worker(new URL('../src/worker.ts', import.meta.url))
@@ -55,6 +80,10 @@ worker.onmessage = (e) => {
 }
 ```
 
-## Notice
+## Notes
 
-- Does not support `onmessage = () => {}`. Please, use `self.onmessage = () => {}`.
+- Worker does not support `onmessage = () => {}`. Please, use `self.onmessage = () => {}`.
+- Shared worker does not support `onconnect = () => {}`. Please, use `self.onconnect = () => {}`.
+- Transferring Buffer will not change its `byteLength`.
+- You have access to shared global space as your tests.
+- You can debug your worker, using `DEBUG=vitest:web-worker` environmental variable.

package/dist/index.js

@@ -1,5 +1,6 @@
-import { defineWebWorker } from './pure.js';
+import { defineWebWorkers } from './pure.js';
 import 'vitest/node';
-import 'vite-node/utils';
+import 'debug';
+import 'worker_threads';
 
-defineWebWorker();
+defineWebWorkers();

package/dist/pure.js

@@ -1,32 +1,7 @@
 import { VitestRunner } from 'vitest/node';
-import { toFilePath } from 'vite-node/utils';
+import createDebug from 'debug';
+import { MessageChannel } from 'worker_threads';
 
-function getWorkerState() {
-  return globalThis.__vitest_worker__;
-}
-class Bridge {
-  constructor() {
-    this.callbacks = {};
-  }
-  on(event, fn) {
-    var _a;
-    (_a = this.callbacks)[event] ?? (_a[event] = []);
-    this.callbacks[event].push(fn);
-  }
-  off(event, fn) {
-    if (this.callbacks[event])
-      this.callbacks[event] = this.callbacks[event].filter((f) => f !== fn);
-  }
-  removeEvents(event) {
-    this.callbacks[event] = [];
-  }
-  clear() {
-    this.callbacks = {};
-  }
-  emit(event, ...data) {
-    return (this.callbacks[event] || []).map((fn) => fn(...data));
-  }
-}
 class InlineWorkerRunner extends VitestRunner {
   constructor(options, context) {
     super(options);
@@ -34,19 +9,322 @@ class InlineWorkerRunner extends VitestRunner {
   }
   prepareContext(context) {
     const ctx = super.prepareContext(context);
-    this.context.self.importScripts = () => {
+    const importScripts = () => {
+      throw new Error("[vitest] `importScripts` is not supported in Vite workers. Please, consider using `import` instead.");
     };
     return Object.assign(ctx, this.context, {
-      importScripts: () => {
+      importScripts
+    });
+  }
+}
+
+const VOID       = -1;
+const PRIMITIVE  = 0;
+const ARRAY      = 1;
+const OBJECT     = 2;
+const DATE       = 3;
+const REGEXP     = 4;
+const MAP        = 5;
+const SET        = 6;
+const ERROR      = 7;
+const BIGINT     = 8;
+// export const SYMBOL = 9;
+
+const env = typeof self === 'object' ? self : globalThis;
+
+const deserializer = ($, _) => {
+  const as = (out, index) => {
+    $.set(index, out);
+    return out;
+  };
+
+  const unpair = index => {
+    if ($.has(index))
+      return $.get(index);
+
+    const [type, value] = _[index];
+    switch (type) {
+      case PRIMITIVE:
+      case VOID:
+        return as(value, index);
+      case ARRAY: {
+        const arr = as([], index);
+        for (const index of value)
+          arr.push(unpair(index));
+        return arr;
+      }
+      case OBJECT: {
+        const object = as({}, index);
+        for (const [key, index] of value)
+          object[unpair(key)] = unpair(index);
+        return object;
+      }
+      case DATE:
+        return as(new Date(value), index);
+      case REGEXP: {
+        const {source, flags} = value;
+        return as(new RegExp(source, flags), index);
+      }
+      case MAP: {
+        const map = as(new Map, index);
+        for (const [key, index] of value)
+          map.set(unpair(key), unpair(index));
+        return map;
       }
+      case SET: {
+        const set = as(new Set, index);
+        for (const index of value)
+          set.add(unpair(index));
+        return set;
+      }
+      case ERROR: {
+        const {name, message} = value;
+        return as(new env[name](message), index);
+      }
+      case BIGINT:
+        return as(BigInt(value), index);
+      case 'BigInt':
+        return as(Object(BigInt(value)), index);
+    }
+    return as(new env[type](value), index);
+  };
+
+  return unpair;
+};
+
+/**
+ * @typedef {Array<string,any>} Record a type representation
+ */
+
+/**
+ * Returns a deserialized value from a serialized array of Records.
+ * @param {Record[]} serialized a previously serialized value.
+ * @returns {any}
+ */
+const deserialize = serialized => deserializer(new Map, serialized)(0);
+
+const EMPTY = '';
+
+const {toString} = {};
+const {keys} = Object;
+
+const typeOf = value => {
+  const type = typeof value;
+  if (type !== 'object' || !value)
+    return [PRIMITIVE, type];
+
+  const asString = toString.call(value).slice(8, -1);
+  switch (asString) {
+    case 'Array':
+      return [ARRAY, EMPTY];
+    case 'Object':
+      return [OBJECT, EMPTY];
+    case 'Date':
+      return [DATE, EMPTY];
+    case 'RegExp':
+      return [REGEXP, EMPTY];
+    case 'Map':
+      return [MAP, EMPTY];
+    case 'Set':
+      return [SET, EMPTY];
+  }
+
+  if (asString.includes('Array'))
+    return [ARRAY, asString];
+
+  if (asString.includes('Error'))
+    return [ERROR, asString];
+
+  return [OBJECT, asString];
+};
+
+const shouldSkip = ([TYPE, type]) => (
+  TYPE === PRIMITIVE &&
+  (type === 'function' || type === 'symbol')
+);
+
+const serializer = (strict, json, $, _) => {
+
+  const as = (out, value) => {
+    const index = _.push(out) - 1;
+    $.set(value, index);
+    return index;
+  };
+
+  const pair = value => {
+    if ($.has(value))
+      return $.get(value);
+
+    let [TYPE, type] = typeOf(value);
+    switch (TYPE) {
+      case PRIMITIVE: {
+        let entry = value;
+        switch (type) {
+          case 'bigint':
+            TYPE = BIGINT;
+            entry = value.toString();
+            break;
+          case 'function':
+          case 'symbol':
+            if (strict)
+              throw new TypeError('unable to serialize ' + type);
+            entry = null;
+            break;
+          case 'undefined':
+            return as([VOID], value);
+        }
+        return as([TYPE, entry], value);
+      }
+      case ARRAY: {
+        if (type)
+          return as([type, [...value]], value);
+  
+        const arr = [];
+        const index = as([TYPE, arr], value);
+        for (const entry of value)
+          arr.push(pair(entry));
+        return index;
+      }
+      case OBJECT: {
+        if (type) {
+          switch (type) {
+            case 'BigInt':
+              return as([type, value.toString()], value);
+            case 'Boolean':
+            case 'Number':
+            case 'String':
+              return as([type, value.valueOf()], value);
+          }
+        }
+
+        if (json && ('toJSON' in value))
+          return pair(value.toJSON());
+
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const key of keys(value)) {
+          if (strict || !shouldSkip(typeOf(value[key])))
+            entries.push([pair(key), pair(value[key])]);
+        }
+        return index;
+      }
+      case DATE:
+        return as([TYPE, value.toISOString()], value);
+      case REGEXP: {
+        const {source, flags} = value;
+        return as([TYPE, {source, flags}], value);
+      }
+      case MAP: {
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const [key, entry] of value) {
+          if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))
+            entries.push([pair(key), pair(entry)]);
+        }
+        return index;
+      }
+      case SET: {
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const entry of value) {
+          if (strict || !shouldSkip(typeOf(entry)))
+            entries.push(pair(entry));
+        }
+        return index;
+      }
+    }
+
+    const {message} = value;
+    return as([TYPE, {name: type, message}], value);
+  };
+
+  return pair;
+};
+
+/**
+ * @typedef {Array<string,any>} Record a type representation
+ */
+
+/**
+ * Returns an array of serialized Records.
+ * @param {any} value a serializable value.
+ * @param {{lossy?: boolean}?} options an object with a `lossy` property that,
+ *  if `true`, will not throw errors on incompatible types, and behave more
+ *  like JSON stringify would behave. Symbol and Function will be discarded.
+ * @returns {Record[]}
+ */
+ const serialize = (value, {json, lossy} = {}) => {
+  const _ = [];
+  return serializer(!(json || lossy), !!json, new Map, _)(value), _;
+};
+
+/**
+ * @typedef {Array<string,any>} Record a type representation
+ */
+
+/**
+ * Returns an array of serialized Records.
+ * @param {any} any a serializable value.
+ * @param {{transfer: any[]}?} options an object with a transfoer property.
+ *  This is currently not supported, all values are always cloned.
+ * @returns {Record[]}
+ */
+var ponyfillStructuredClone = typeof structuredClone === "function" ?
+  /* c8 ignore start */
+  (any, options) => (
+    options && ('json' in options || 'lossy' in options) ?
+      deserialize(serialize(any, options)) : structuredClone(any)
+  ) :
+  (any, options) => deserialize(serialize(any, options));
+
+const debug = createDebug("vitest:web-worker");
+function getWorkerState() {
+  return globalThis.__vitest_worker__;
+}
+function assertGlobalExists(name) {
+  if (!(name in globalThis))
+    throw new Error(`[@vitest/web-worker] Cannot initiate a custom Web Worker. "${name}" is not supported in this environment. Please, consider using jsdom or happy-dom environment.`);
+}
+function createClonedMessageEvent(data, transferOrOptions, clone) {
+  const transfer = Array.isArray(transferOrOptions) ? transferOrOptions : transferOrOptions == null ? void 0 : transferOrOptions.transfer;
+  debug("clone worker message %o", data);
+  const origin = typeof location === "undefined" ? void 0 : location.origin;
+  if (typeof structuredClone === "function" && clone === "native") {
+    debug("create message event, using native structured clone");
+    return new MessageEvent("message", {
+      data: structuredClone(data, { transfer }),
+      origin
+    });
+  }
+  if (clone !== "none") {
+    debug("create message event, using polifylled structured clone");
+    (transfer == null ? void 0 : transfer.length) && console.warn(
+      '[@vitest/web-worker] `structuredClone` is not supported in this environment. Falling back to polyfill, your transferable options will be lost. Set `VITEST_WEB_WORKER_CLONE` environmental variable to "none", if you don\'t want to loose it,or update to Node 17+.'
+    );
+    return new MessageEvent("message", {
+      data: ponyfillStructuredClone(data, { lossy: true }),
+      origin
     });
   }
+  debug("create message event without cloning an object");
+  return new MessageEvent("message", {
+    data,
+    origin
+  });
 }
-function defineWebWorker() {
-  if ("Worker" in globalThis)
-    return;
+function createMessageEvent(data, transferOrOptions, clone) {
+  try {
+    return createClonedMessageEvent(data, transferOrOptions, clone);
+  } catch (error) {
+    debug('failed to clone message, dispatch "messageerror" event: %o', error);
+    return new MessageEvent("messageerror", {
+      data: error
+    });
+  }
+}
+function getRunnerOptions() {
   const { config, rpc, mockMap, moduleCache } = getWorkerState();
-  const options = {
+  return {
     fetchModule(id) {
       return rpc.fetch(id);
     },
@@ -59,24 +337,41 @@ function defineWebWorker() {
     root: config.root,
     base: config.base
   };
-  globalThis.Worker = class Worker {
-    constructor(url) {
-      this.inside = new Bridge();
-      this.outside = new Bridge();
-      this.messageQueue = [];
+}
+
+function createWorkerConstructor(options) {
+  var _a;
+  const runnerOptions = getRunnerOptions();
+  const cloneType = () => (options == null ? void 0 : options.clone) ?? process.env.VITEST_WEB_WORKER_CLONE ?? "native";
+  return _a = class extends EventTarget {
+    constructor(url, options2) {
+      super();
+      this._vw_workerTarget = new EventTarget();
+      this._vw_insideListeners = /* @__PURE__ */ new Map();
+      this._vw_outsideListeners = /* @__PURE__ */ new Map();
+      this._vw_messageQueue = [];
       this.onmessage = null;
       this.onmessageerror = null;
       this.onerror = null;
       const context = {
         onmessage: null,
+        name: options2 == null ? void 0 : options2.name,
+        close: () => this.terminate(),
         dispatchEvent: (event) => {
-          this.inside.emit(event.type, event);
-          return true;
+          return this._vw_workerTarget.dispatchEvent(event);
+        },
+        addEventListener: (...args) => {
+          if (args[1])
+            this._vw_insideListeners.set(args[0], args[1]);
+          return this._vw_workerTarget.addEventListener(...args);
         },
-        addEventListener: this.inside.on.bind(this.inside),
-        removeEventListener: this.inside.off.bind(this.inside),
-        postMessage: (data) => {
-          this.outside.emit("message", { data });
+        removeEventListener: this._vw_workerTarget.removeEventListener,
+        postMessage: (...args) => {
+          if (!args.length)
+            throw new SyntaxError('"postMessage" requires at least one argument.');
+          debug("posting message %o from the worker %s to the main thread", args[0], this._vw_name);
+          const event = createMessageEvent(args[0], args[1], cloneType());
+          this.dispatchEvent(event);
         },
         get self() {
           return context;
@@ -85,51 +380,196 @@ function defineWebWorker() {
           return context;
         }
       };
-      this.inside.on("message", (e) => {
-        var _a;
-        (_a = context.onmessage) == null ? void 0 : _a.call(context, e);
+      this._vw_workerTarget.addEventListener("message", (e) => {
+        var _a2;
+        (_a2 = context.onmessage) == null ? void 0 : _a2.call(context, e);
+      });
+      this.addEventListener("message", (e) => {
+        var _a2;
+        (_a2 = this.onmessage) == null ? void 0 : _a2.call(this, e);
       });
-      this.outside.on("message", (e) => {
-        var _a;
-        (_a = this.onmessage) == null ? void 0 : _a.call(this, e);
+      this.addEventListener("messageerror", (e) => {
+        var _a2;
+        (_a2 = this.onmessageerror) == null ? void 0 : _a2.call(this, e);
       });
-      const runner = new InlineWorkerRunner(options, context);
+      const runner = new InlineWorkerRunner(runnerOptions, context);
       const id = (url instanceof URL ? url.toString() : url).replace(/^file:\/+/, "/");
-      const fsPath = toFilePath(id, config.root);
-      runner.executeFile(fsPath).then(() => {
-        moduleCache.invalidateSubDepTree([fsPath, `mock:${fsPath}`]);
-        const q = this.messageQueue;
-        this.messageQueue = null;
-        if (q)
-          q.forEach(this.postMessage, this);
-      }).catch((e) => {
-        var _a;
-        this.outside.emit("error", e);
-        (_a = this.onerror) == null ? void 0 : _a.call(this, e);
-        console.error(e);
+      this._vw_name = id;
+      runner.resolveUrl(id).then(([, fsPath]) => {
+        this._vw_name = (options2 == null ? void 0 : options2.name) ?? fsPath;
+        debug("initialize worker %s", this._vw_name);
+        runner.executeFile(fsPath).then(() => {
+          runnerOptions.moduleCache.invalidateSubDepTree([fsPath, runner.mocker.getMockPath(fsPath)]);
+          const q = this._vw_messageQueue;
+          this._vw_messageQueue = null;
+          if (q)
+            q.forEach(([data, transfer]) => this.postMessage(data, transfer), this);
+          debug("worker %s successfully initialized", this._vw_name);
+        }).catch((e) => {
+          var _a2;
+          debug("worker %s failed to initialize: %o", this._vw_name, e);
+          const EventConstructor = globalThis.ErrorEvent || globalThis.Event;
+          const error = new EventConstructor("error", {
+            error: e,
+            message: e.message
+          });
+          this.dispatchEvent(error);
+          (_a2 = this.onerror) == null ? void 0 : _a2.call(this, error);
+          console.error(e);
+        });
       });
     }
-    dispatchEvent(event) {
-      this.outside.emit(event.type, event);
-      return true;
+    addEventListener(type, callback, options2) {
+      if (callback)
+        this._vw_outsideListeners.set(type, callback);
+      return super.addEventListener(type, callback, options2);
     }
-    addEventListener(event, fn) {
-      this.outside.on(event, fn);
-    }
-    removeEventListener(event, fn) {
-      this.outside.off(event, fn);
-    }
-    postMessage(data) {
-      if (this.messageQueue != null)
-        this.messageQueue.push(data);
+    postMessage(...args) {
+      if (!args.length)
+        throw new SyntaxError('"postMessage" requires at least one argument.');
+      const [data, transferOrOptions] = args;
+      if (this._vw_messageQueue != null) {
+        debug("worker %s is not yet initialized, queue message %s", this._vw_name, data);
+        this._vw_messageQueue.push([data, transferOrOptions]);
+        return;
+      }
+      debug("posting message %o from the main thread to the worker %s", data, this._vw_name);
+      const event = createMessageEvent(data, transferOrOptions, cloneType());
+      if (event.type === "messageerror")
+        this.dispatchEvent(event);
       else
-        this.inside.emit("message", { data });
+        this._vw_workerTarget.dispatchEvent(event);
     }
     terminate() {
-      this.outside.clear();
-      this.inside.clear();
+      debug("terminating worker %s", this._vw_name);
+      this._vw_outsideListeners.forEach((fn, type) => {
+        this.removeEventListener(type, fn);
+      });
+      this._vw_insideListeners.forEach((fn, type) => {
+        this._vw_workerTarget.removeEventListener(type, fn);
+      });
     }
-  };
+  }, _a.__VITEST_WEB_WORKER__ = true, _a;
+}
+
+const convertNodePortToWebPort = (port) => {
+  if (!("addEventListener" in port)) {
+    Object.defineProperty(port, "addEventListener", {
+      value(...args) {
+        return this.addListener(...args);
+      },
+      configurable: true,
+      enumerable: true
+    });
+  }
+  if (!("removeEventListener" in port)) {
+    Object.defineProperty(port, "removeEventListener", {
+      value(...args) {
+        return this.removeListener(...args);
+      },
+      configurable: true,
+      enumerable: true
+    });
+  }
+  if (!("dispatchEvent" in port)) {
+    const emit = port.emit.bind(port);
+    Object.defineProperty(port, "emit", {
+      value(event) {
+        var _a, _b;
+        if (event.name === "message")
+          (_a = port.onmessage) == null ? void 0 : _a.call(port, event);
+        if (event.name === "messageerror")
+          (_b = port.onmessageerror) == null ? void 0 : _b.call(port, event);
+        return emit(event);
+      },
+      configurable: true,
+      enumerable: true
+    });
+    Object.defineProperty(port, "dispatchEvent", {
+      value(event) {
+        return this.emit(event);
+      },
+      configurable: true,
+      enumerable: true
+    });
+  }
+  return port;
+};
+function createSharedWorkerConstructor() {
+  var _a;
+  const runnerOptions = getRunnerOptions();
+  return _a = class extends EventTarget {
+    constructor(url, options) {
+      super();
+      this._vw_workerTarget = new EventTarget();
+      this.onerror = null;
+      const name = typeof options === "string" ? options : options == null ? void 0 : options.name;
+      const context = {
+        onconnect: null,
+        name,
+        close: () => this.port.close(),
+        dispatchEvent: (event) => {
+          return this._vw_workerTarget.dispatchEvent(event);
+        },
+        addEventListener: (...args) => {
+          return this._vw_workerTarget.addEventListener(...args);
+        },
+        removeEventListener: this._vw_workerTarget.removeEventListener,
+        get self() {
+          return context;
+        },
+        get global() {
+          return context;
+        }
+      };
+      const channel = new MessageChannel();
+      this.port = convertNodePortToWebPort(channel.port1);
+      this._vw_workerPort = convertNodePortToWebPort(channel.port2);
+      this._vw_workerTarget.addEventListener("connect", (e) => {
+        var _a2;
+        (_a2 = context.onconnect) == null ? void 0 : _a2.call(context, e);
+      });
+      const runner = new InlineWorkerRunner(runnerOptions, context);
+      const id = (url instanceof URL ? url.toString() : url).replace(/^file:\/+/, "/");
+      this._vw_name = id;
+      runner.resolveUrl(id).then(([, fsPath]) => {
+        this._vw_name = name ?? fsPath;
+        debug("initialize shared worker %s", this._vw_name);
+        runner.executeFile(fsPath).then(() => {
+          runnerOptions.moduleCache.invalidateSubDepTree([fsPath, runner.mocker.getMockPath(fsPath)]);
+          this._vw_workerTarget.dispatchEvent(
+            new MessageEvent("connect", {
+              ports: [this._vw_workerPort]
+            })
+          );
+          debug("shared worker %s successfully initialized", this._vw_name);
+        }).catch((e) => {
+          var _a2;
+          debug("shared worker %s failed to initialize: %o", this._vw_name, e);
+          const EventConstructor = globalThis.ErrorEvent || globalThis.Event;
+          const error = new EventConstructor("error", {
+            error: e,
+            message: e.message
+          });
+          this.dispatchEvent(error);
+          (_a2 = this.onerror) == null ? void 0 : _a2.call(this, error);
+          console.error(e);
+        });
+      });
+    }
+  }, _a.__VITEST_WEB_WORKER__ = true, _a;
+}
+
+function defineWebWorkers(options) {
+  if (typeof Worker === "undefined" || !("__VITEST_WEB_WORKER__" in globalThis.Worker)) {
+    assertGlobalExists("EventTarget");
+    assertGlobalExists("MessageEvent");
+    globalThis.Worker = createWorkerConstructor(options);
+  }
+  if (typeof SharedWorker === "undefined" || !("__VITEST_WEB_WORKER__" in globalThis.SharedWorker)) {
+    assertGlobalExists("EventTarget");
+    globalThis.SharedWorker = createSharedWorkerConstructor();
+  }
 }
 
-export { defineWebWorker };
+export { defineWebWorkers };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/web-worker",
   "type": "module",
-  "version": "0.25.8",
+  "version": "0.26.0",
   "description": "Web Worker support for testing in Vitest",
   "repository": {
     "type": "git",
@@ -31,9 +31,13 @@
     "vitest": "*"
   },
   "dependencies": {
-    "vite-node": "0.25.8"
+    "debug": "^4.3.4",
+    "vite-node": "0.26.0"
   },
   "devDependencies": {
+    "@types/debug": "^4.1.7",
+    "@types/ungap__structured-clone": "^0.3.0",
+    "@ungap/structured-clone": "^1.0.1",
     "rollup": "^2.79.1"
   },
   "scripts": {

package/pure.d.ts

@@ -1,3 +1,8 @@
-declare function defineWebWorker(): void;
+type CloneOption = 'native' | 'ponyfill' | 'none';
+interface DefineWorkerOptions {
+    clone: CloneOption;
+}
 
-export { defineWebWorker };
+declare function defineWebWorkers(options?: DefineWorkerOptions): void;
+
+export { defineWebWorkers };