planning

node_modules/web-worker/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

node_modules/web-worker/README.md

@@ -0,0 +1,134 @@
+<h1 align="center">
+  web-worker
+  <a href="https://www.npmjs.org/package/web-worker"><img src="https://img.shields.io/npm/v/web-worker.svg?style=flat-square" alt="npm"></a>
+</h1>
+<p align="center">
+  Native cross-platform Web Workers. Works in published npm modules.
+</p>
+<p align="center">
+  <img src="https://user-images.githubusercontent.com/105127/79602228-1998bf00-80b8-11ea-91e4-26b212aabaa2.png" width="1000" alt="">
+</p>
+
+**In Node**, it's a web-compatible Worker implementation atop Node's [worker_threads](https://nodejs.org/api/worker_threads.html).
+
+**In the browser** (and when bundled for the browser), it's simply an alias of `Worker`.
+
+### Features
+
+_Here's how this is different from worker_threads:_
+
+- makes Worker code compatible across browser and Node
+- supports Module Workers (`{type:'module'}`) natively in Node 12.8+
+- uses DOM-style events (`Event.data`, `Event.type`, etc)
+- supports event handler properties (`worker.onmessage=..`)
+- `Worker()` accepts a module URL, Blob URL or Data URL
+- emulates browser-style [WorkerGlobalScope] within the worker
+
+### Usage Example
+
+In its simplest form:
+
+```js
+import Worker from 'web-worker';
+
+const worker = new Worker('data:,postMessage("hello")');
+worker.onmessage = e => console.log(e.data);  // "hello"
+```
+
+<table>
+<thead><tr><th><strong>main.js</strong></th><th><strong>worker.js</strong></th></tr></thead>
+<tbody><tr><td>
+
+```js
+import Worker from 'web-worker';
+
+const url = new URL('./worker.js', import.meta.url);
+const worker = new Worker(url);
+
+worker.addEventListener('message', e => {
+  console.log(e.data)  // "hiya!"
+});
+
+worker.postMessage('hello');
+```
+
+</td><td valign="top">
+
+```js
+addEventListener('message', e => {
+  if (e.data === 'hello') {
+    postMessage('hiya!');
+  }
+});
+```
+
+</td></tr></tbody>
+</table>
+
+👉 Notice how `new URL('./worker.js', import.meta.url)` is used above to load the worker relative to the current module instead of the application base URL. Without this, Worker URLs are relative to a document's URL, which in Node.js is interpreted to be `process.cwd()`.
+
+> _Support for this pattern in build tools and test frameworks is still limited. We are [working on growing this](https://github.com/developit/web-worker/issues/4)._
+
+### Module Workers
+
+Module Workers are supported in Node 12.8+ using this plugin, leveraging Node's native ES Modules support.
+In the browser, they can be used natively in Chrome 80+, or in all browsers via [worker-plugin] or [rollup-plugin-off-main-thread]. As with classic workers, there is no difference in usage between Node and the browser:
+
+<table>
+<thead><tr><th><strong>main.mjs</strong></th><th><strong>worker.mjs</strong></th></tr></thead>
+<tbody><tr><td>
+
+```js
+import Worker from 'web-worker';
+
+const worker = new Worker(
+  new URL('./worker.mjs', import.meta.url),
+  { type: 'module' }
+);
+worker.addEventListener('message', e => {
+  console.log(e.data)  // "200 OK"
+});
+worker.postMessage('https://httpstat.us/200');
+```
+
+</td><td valign="top">
+
+```js
+import fetch from 'isomorphic-fetch';
+
+addEventListener('message', async e => {
+  const url = e.data;
+  const res = await fetch(url)
+  const text = await res.text();
+  postMessage(text);
+});
+```
+
+</td></tr></tbody>
+</table>
+
+
+### Data URLs
+
+Instantiating Worker using a Data URL is supported in both module and classic workers:
+
+```js
+import Worker from 'web-worker';
+
+const worker = new Worker(`data:application/javascript,postMessage(42)`);
+worker.addEventListener('message', e => {
+  console.log(e.data)  // 42
+});
+```
+
+### Special Thanks
+
+This module aims to provide a simple and forgettable piece of infrastructure,
+and as such it needed an obvious and descriptive name.
+[@calvinmetcalf](https://github.com/calvinmetcalf), who you may recognize as the author of [Lie](https://github.com/calvinmetcalf/lie) and other fine modules, gratiously offered up the name from his `web-worker` package.
+Thanks Calvin!
+
+
+[worker-plugin]: https://github.com/googlechromelabs/worker-plugin
+[rollup-plugin-off-main-thread]: https://github.com/surma/rollup-plugin-off-main-thread
+[WorkerGlobalScope]: https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope

node_modules/web-worker/browser.js

@@ -0,0 +1,17 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export default Worker;

node_modules/web-worker/cjs/browser.js

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+module.exports = Worker;

node_modules/web-worker/cjs/node.js

@@ -0,0 +1,219 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const URL = require('url');
+const VM = require('vm');
+const threads = require('worker_threads');
+const WORKER = Symbol.for('worker');
+const EVENTS = Symbol.for('events');
+class EventTarget {
+  constructor() {
+    Object.defineProperty(this, EVENTS, {
+      value: new Map()
+    });
+  }
+  dispatchEvent(event) {
+    event.target = event.currentTarget = this;
+    if (this['on' + event.type]) {
+      try {
+        this['on' + event.type](event);
+      } catch (err) {
+        console.error(err);
+      }
+    }
+    const list = this[EVENTS].get(event.type);
+    if (list == null) return;
+    list.forEach(handler => {
+      try {
+        handler.call(this, event);
+      } catch (err) {
+        console.error(err);
+      }
+    });
+  }
+  addEventListener(type, fn) {
+    let events = this[EVENTS].get(type);
+    if (!events) this[EVENTS].set(type, events = []);
+    events.push(fn);
+  }
+  removeEventListener(type, fn) {
+    let events = this[EVENTS].get(type);
+    if (events) {
+      const index = events.indexOf(fn);
+      if (index !== -1) events.splice(index, 1);
+    }
+  }
+}
+function Event(type, target) {
+  this.type = type;
+  this.timeStamp = Date.now();
+  this.target = this.currentTarget = this.data = null;
+}
+
+// this module is used self-referentially on both sides of the
+// thread boundary, but behaves differently in each context.
+module.exports = threads.isMainThread ? mainThread() : workerThread();
+const baseUrl = URL.pathToFileURL(process.cwd() + '/');
+function mainThread() {
+  /**
+   * A web-compatible Worker implementation atop Node's worker_threads.
+   *  - uses DOM-style events (Event.data, Event.type, etc)
+   *  - supports event handler properties (worker.onmessage)
+   *  - Worker() constructor accepts a module URL
+   *  - accepts the {type:'module'} option
+   *  - emulates WorkerGlobalScope within the worker
+   * @param {string} url  The URL or module specifier to load
+   * @param {object} [options]  Worker construction options
+   * @param {string} [options.name]  Available as `self.name` within the Worker
+   * @param {string} [options.type="classic"]  Pass "module" to create a Module Worker.
+   */
+  class Worker extends EventTarget {
+    constructor(url, options) {
+      super();
+      const {
+        name,
+        type
+      } = options || {};
+      url += '';
+      let mod;
+      if (/^data:/.test(url)) {
+        mod = url;
+      } else {
+        mod = URL.fileURLToPath(new URL.URL(url, baseUrl));
+      }
+      const worker = new threads.Worker(__filename, {
+        workerData: {
+          mod,
+          name,
+          type
+        }
+      });
+      Object.defineProperty(this, WORKER, {
+        value: worker
+      });
+      worker.on('message', data => {
+        const event = new Event('message');
+        event.data = data;
+        this.dispatchEvent(event);
+      });
+      worker.on('error', error => {
+        error.type = 'error';
+        this.dispatchEvent(error);
+      });
+      worker.on('exit', () => {
+        this.dispatchEvent(new Event('close'));
+      });
+    }
+    postMessage(data, transferList) {
+      this[WORKER].postMessage(data, transferList);
+    }
+    terminate() {
+      this[WORKER].terminate();
+    }
+  }
+  Worker.prototype.onmessage = Worker.prototype.onerror = Worker.prototype.onclose = null;
+  return Worker;
+}
+function workerThread() {
+  let {
+    mod,
+    name,
+    type
+  } = threads.workerData;
+  if (!mod) return mainThread();
+
+  // turn global into a mock WorkerGlobalScope
+  const self = global.self = global;
+
+  // enqueue messages to dispatch after modules are loaded
+  let q = [];
+  function flush() {
+    const buffered = q;
+    q = null;
+    buffered.forEach(event => {
+      self.dispatchEvent(event);
+    });
+  }
+  threads.parentPort.on('message', data => {
+    const event = new Event('message');
+    event.data = data;
+    if (q == null) self.dispatchEvent(event);else q.push(event);
+  });
+  threads.parentPort.on('error', err => {
+    err.type = 'Error';
+    self.dispatchEvent(err);
+  });
+  class WorkerGlobalScope extends EventTarget {
+    postMessage(data, transferList) {
+      threads.parentPort.postMessage(data, transferList);
+    }
+    // Emulates https://developer.mozilla.org/en-US/docs/Web/API/DedicatedWorkerGlobalScope/close
+    close() {
+      process.exit();
+    }
+  }
+  let proto = Object.getPrototypeOf(global);
+  delete proto.constructor;
+  Object.defineProperties(WorkerGlobalScope.prototype, proto);
+  proto = Object.setPrototypeOf(global, new WorkerGlobalScope());
+  ['postMessage', 'addEventListener', 'removeEventListener', 'dispatchEvent'].forEach(fn => {
+    proto[fn] = proto[fn].bind(global);
+  });
+  global.name = name;
+  const isDataUrl = /^data:/.test(mod);
+  if (type === 'module') {
+    import(mod).catch(err => {
+      if (isDataUrl && err.message === 'Not supported') {
+        console.warn('Worker(): Importing data: URLs requires Node 12.10+. Falling back to classic worker.');
+        return evaluateDataUrl(mod, name);
+      }
+      console.error(err);
+    }).then(flush);
+  } else {
+    try {
+      if (/^data:/.test(mod)) {
+        evaluateDataUrl(mod, name);
+      } else {
+        require(mod);
+      }
+    } catch (err) {
+      console.error(err);
+    }
+    Promise.resolve().then(flush);
+  }
+}
+function evaluateDataUrl(url, name) {
+  const {
+    data
+  } = parseDataUrl(url);
+  return VM.runInThisContext(data, {
+    filename: 'worker.<' + (name || 'data:') + '>'
+  });
+}
+function parseDataUrl(url) {
+  let [m, type, encoding, data] = url.match(/^data: *([^;,]*)(?: *; *([^,]*))? *,(.*)$/) || [];
+  if (!m) throw Error('Invalid Data URL.');
+  if (encoding) switch (encoding.toLowerCase()) {
+    case 'base64':
+      data = Buffer.from(data, 'base64').toString();
+      break;
+    default:
+      throw Error('Unknown Data URL encoding "' + encoding + '"');
+  }
+  return {
+    type,
+    data
+  };
+}

node_modules/web-worker/index.d.ts

@@ -0,0 +1,4 @@
+type ConstructorOf<C> = { new (...args: any[]): C }
+
+declare const _default: ConstructorOf<Worker>
+export default _default

node_modules/web-worker/node.js

@@ -0,0 +1,223 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import URL from 'url';
+import VM from 'vm';
+import threads from 'worker_threads';
+
+const WORKER = Symbol.for('worker');
+const EVENTS = Symbol.for('events');
+
+class EventTarget {
+	constructor() {
+		Object.defineProperty(this, EVENTS, {
+			value: new Map()
+		});
+	}
+	dispatchEvent(event) {
+		event.target = event.currentTarget = this;
+		if (this['on'+event.type]) {
+			try {
+				this['on'+event.type](event);
+			}
+			catch (err) {
+				console.error(err);
+			}
+		}
+		const list = this[EVENTS].get(event.type);
+		if (list == null) return;
+		list.forEach(handler => {
+			try {
+				handler.call(this, event);
+			}
+			catch (err) {
+				console.error(err);
+			}
+		});
+	}
+	addEventListener(type, fn) {
+		let events = this[EVENTS].get(type);
+		if (!events) this[EVENTS].set(type, events = []);
+		events.push(fn);
+	}
+	removeEventListener(type, fn) {
+		let events = this[EVENTS].get(type);
+		if (events) {
+			const index = events.indexOf(fn);
+			if (index !== -1) events.splice(index, 1);
+		}
+	}
+}
+
+function Event(type, target) {
+	this.type = type;
+	this.timeStamp = Date.now();
+	this.target = this.currentTarget = this.data = null;
+}
+
+// this module is used self-referentially on both sides of the
+// thread boundary, but behaves differently in each context.
+export default threads.isMainThread ? mainThread() : workerThread();
+
+const baseUrl = URL.pathToFileURL(process.cwd() + '/');
+
+function mainThread() {
+
+	/**
+	 * A web-compatible Worker implementation atop Node's worker_threads.
+	 *  - uses DOM-style events (Event.data, Event.type, etc)
+	 *  - supports event handler properties (worker.onmessage)
+	 *  - Worker() constructor accepts a module URL
+	 *  - accepts the {type:'module'} option
+	 *  - emulates WorkerGlobalScope within the worker
+	 * @param {string} url  The URL or module specifier to load
+	 * @param {object} [options]  Worker construction options
+	 * @param {string} [options.name]  Available as `self.name` within the Worker
+	 * @param {string} [options.type="classic"]  Pass "module" to create a Module Worker.
+	 */
+	class Worker extends EventTarget {
+		constructor(url, options) {
+			super();
+			const { name, type } = options || {};
+			url += '';
+			let mod;
+			if (/^data:/.test(url)) {
+				mod = url;
+			}
+			else {
+				mod = URL.fileURLToPath(new URL.URL(url, baseUrl));
+			}
+			const worker = new threads.Worker(
+				__filename,
+				{ workerData: { mod, name, type } }
+			);
+			Object.defineProperty(this, WORKER, {
+				value: worker
+			});
+			worker.on('message', data => {
+				const event = new Event('message');
+				event.data = data;
+				this.dispatchEvent(event);
+			});
+			worker.on('error', error => {
+				error.type = 'error';
+				this.dispatchEvent(error);
+			});
+			worker.on('exit', () => {
+				this.dispatchEvent(new Event('close'));
+			});
+		}
+		postMessage(data, transferList) {
+			this[WORKER].postMessage(data, transferList);
+		}
+		terminate() {
+			this[WORKER].terminate();
+		}
+	}
+	Worker.prototype.onmessage = Worker.prototype.onerror = Worker.prototype.onclose = null;
+	return Worker;
+}
+
+function workerThread() {
+	let { mod, name, type } = threads.workerData;
+	if (!mod) return mainThread();
+
+	// turn global into a mock WorkerGlobalScope
+	const self = global.self = global;
+
+	// enqueue messages to dispatch after modules are loaded
+	let q = [];
+	function flush() {
+		const buffered = q;
+		q = null;
+		buffered.forEach(event => { self.dispatchEvent(event); });
+	}
+	threads.parentPort.on('message', data => {
+		const event = new Event('message');
+		event.data = data;
+		if (q == null) self.dispatchEvent(event);
+		else q.push(event);
+	});
+	threads.parentPort.on('error', err => {
+		err.type = 'Error';
+		self.dispatchEvent(err);
+	});
+
+	class WorkerGlobalScope extends EventTarget {
+		postMessage(data, transferList) {
+			threads.parentPort.postMessage(data, transferList);
+		}
+		// Emulates https://developer.mozilla.org/en-US/docs/Web/API/DedicatedWorkerGlobalScope/close
+		close() {
+			process.exit();
+		}
+	}
+	let proto = Object.getPrototypeOf(global);
+	delete proto.constructor;
+	Object.defineProperties(WorkerGlobalScope.prototype, proto);
+	proto = Object.setPrototypeOf(global, new WorkerGlobalScope());
+	['postMessage', 'addEventListener', 'removeEventListener', 'dispatchEvent'].forEach(fn => {
+		proto[fn] = proto[fn].bind(global);
+	});
+	global.name = name;
+
+	const isDataUrl = /^data:/.test(mod);
+	if (type === 'module') {
+		import(mod)
+			.catch(err => {
+				if (isDataUrl && err.message === 'Not supported') {
+					console.warn('Worker(): Importing data: URLs requires Node 12.10+. Falling back to classic worker.');
+					return evaluateDataUrl(mod, name);
+				}
+				console.error(err);
+			})
+			.then(flush);
+	}
+	else {
+		try {
+			if (/^data:/.test(mod)) {
+				evaluateDataUrl(mod, name);
+			}
+			else {
+				require(mod);
+			}
+		}
+		catch (err) {
+			console.error(err);
+		}
+		Promise.resolve().then(flush);
+	}
+}
+
+function evaluateDataUrl(url, name) {
+	const { data } = parseDataUrl(url);
+	return VM.runInThisContext(data, {
+		filename: 'worker.<'+(name || 'data:')+'>'
+	});
+}
+
+function parseDataUrl(url) {
+	let [m, type, encoding, data] = url.match(/^data: *([^;,]*)(?: *; *([^,]*))? *,(.*)$/) || [];
+	if (!m) throw Error('Invalid Data URL.');
+	if (encoding) switch (encoding.toLowerCase()) {
+		case 'base64':
+			data = Buffer.from(data, 'base64').toString();
+			break;
+		default:
+			throw Error('Unknown Data URL encoding "' + encoding + '"');
+	}
+	return { type, data };
+}

node_modules/web-worker/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "web-worker",
+  "version": "1.3.0",
+  "description": "Consistent Web Workers in browser and Node.",
+  "main": "./cjs/node.js",
+  "browser": "./cjs/browser.js",
+  "types": "./index.d.ts",
+  "exports": {
+    "types": "./index.d.ts",
+    "import": {
+      "bun": "./browser.js",
+      "browser": "./browser.js",
+      "default": "./node.js"
+    },
+    "module": {
+      "bun": "./browser.js",
+      "browser": "./browser.js",
+      "default": "./node.js"
+    },
+    "default": {
+      "bun": "./cjs/browser.js",
+      "browser": "./cjs/browser.js",
+      "default": "./cjs/node.js"
+    }
+  },
+  "files": [
+    "cjs",
+    "browser.js",
+    "node.js",
+    "index.d.ts"
+  ],
+  "scripts": {
+    "prepare": "babel node.js browser.js -d cjs",
+    "test": "eslint '*.js' test && node --experimental-modules ./node_modules/.bin/ava"
+  },
+  "babel": {
+    "plugins": [
+      "@babel/plugin-syntax-dynamic-import",
+      "babel-plugin-commonjs-lite"
+    ]
+  },
+  "repository": "developit/web-worker",
+  "keywords": [
+    "worker",
+    "worker_threads",
+    "webworker",
+    "web worker",
+    "web-worker",
+    "threads"
+  ],
+  "authors": [],
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/developit/web-worker",
+  "eslintConfig": {
+    "extends": "developit",
+    "rules": {
+      "no-console": 0
+    }
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.21.0",
+    "@babel/core": "^7.21.0",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-transform-modules-commonjs": "7.21",
+    "ava": "2.4",
+    "babel-plugin-commonjs-lite": "gist:3e38560d5bed35da1fd708d635e4acb3",
+    "eslint": "^7.32.0",
+    "eslint-config-developit": "^1.2.0",
+    "eslint-plugin-compat": "^4.2.0"
+  }
+}