@eggjs/mock 6.0.6 → 6.1.0-beta.10

package/dist/node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/WorkerHandler.js

@@ -0,0 +1,419 @@
+import { __commonJS, __require } from "../../../../../../_virtual/rolldown_runtime.js";
+import { require_environment } from "./environment.js";
+import { require_Promise } from "./Promise.js";
+import { require_validateOptions } from "./validateOptions.js";
+import { require_embeddedWorker } from "./generated/embeddedWorker.js";
+
+//#region ../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/WorkerHandler.js
+var require_WorkerHandler = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/WorkerHandler.js": ((exports, module) => {
+	var { Promise: Promise$1 } = require_Promise();
+	var environment = require_environment();
+	const { validateOptions, forkOptsNames, workerThreadOptsNames, workerOptsNames } = require_validateOptions();
+	/**
+	* Special message sent by parent which causes a child process worker to terminate itself.
+	* Not a "message object"; this string is the entire message.
+	*/
+	var TERMINATE_METHOD_ID = "__workerpool-terminate__";
+	/**
+	* Special message by parent which causes a child process worker to perform cleaup
+	* steps before determining if the child process worker should be terminated.
+	*/
+	var CLEANUP_METHOD_ID = "__workerpool-cleanup__";
+	function ensureWorkerThreads() {
+		var WorkerThreads = tryRequireWorkerThreads();
+		if (!WorkerThreads) throw new Error("WorkerPool: workerType = 'thread' is not supported, Node >= 11.7.0 required");
+		return WorkerThreads;
+	}
+	function ensureWebWorker() {
+		if (typeof Worker !== "function" && (typeof Worker !== "object" || typeof Worker.prototype.constructor !== "function")) throw new Error("WorkerPool: Web Workers not supported");
+	}
+	function tryRequireWorkerThreads() {
+		try {
+			return __require("worker_threads");
+		} catch (error) {
+			if (typeof error === "object" && error !== null && error.code === "MODULE_NOT_FOUND") return null;
+			else throw error;
+		}
+	}
+	function getDefaultWorker() {
+		if (environment.platform === "browser") {
+			if (typeof Blob === "undefined") throw new Error("Blob not supported by the browser");
+			if (!window.URL || typeof window.URL.createObjectURL !== "function") throw new Error("URL.createObjectURL not supported by the browser");
+			var blob = new Blob([require_embeddedWorker()], { type: "text/javascript" });
+			return window.URL.createObjectURL(blob);
+		} else return __dirname + "/worker.js";
+	}
+	function setupWorker(script, options) {
+		if (options.workerType === "web") {
+			ensureWebWorker();
+			return setupBrowserWorker(script, options.workerOpts, Worker);
+		} else if (options.workerType === "thread") {
+			WorkerThreads = ensureWorkerThreads();
+			return setupWorkerThreadWorker(script, WorkerThreads, options);
+		} else if (options.workerType === "process" || !options.workerType) return setupProcessWorker(script, resolveForkOptions(options), __require("child_process"));
+		else if (environment.platform === "browser") {
+			ensureWebWorker();
+			return setupBrowserWorker(script, options.workerOpts, Worker);
+		} else {
+			var WorkerThreads = tryRequireWorkerThreads();
+			if (WorkerThreads) return setupWorkerThreadWorker(script, WorkerThreads, options);
+			else return setupProcessWorker(script, resolveForkOptions(options), __require("child_process"));
+		}
+	}
+	function setupBrowserWorker(script, workerOpts, Worker$1) {
+		validateOptions(workerOpts, workerOptsNames, "workerOpts");
+		var worker = new Worker$1(script, workerOpts);
+		worker.isBrowserWorker = true;
+		worker.on = function(event, callback) {
+			this.addEventListener(event, function(message) {
+				callback(message.data);
+			});
+		};
+		worker.send = function(message, transfer) {
+			this.postMessage(message, transfer);
+		};
+		return worker;
+	}
+	function setupWorkerThreadWorker(script, WorkerThreads, options) {
+		validateOptions(options?.workerThreadOpts, workerThreadOptsNames, "workerThreadOpts");
+		var worker = new WorkerThreads.Worker(script, {
+			stdout: options?.emitStdStreams ?? false,
+			stderr: options?.emitStdStreams ?? false,
+			...options?.workerThreadOpts
+		});
+		worker.isWorkerThread = true;
+		worker.send = function(message, transfer) {
+			this.postMessage(message, transfer);
+		};
+		worker.kill = function() {
+			this.terminate();
+			return true;
+		};
+		worker.disconnect = function() {
+			this.terminate();
+		};
+		if (options?.emitStdStreams) {
+			worker.stdout.on("data", (data) => worker.emit("stdout", data));
+			worker.stderr.on("data", (data) => worker.emit("stderr", data));
+		}
+		return worker;
+	}
+	function setupProcessWorker(script, options, child_process) {
+		validateOptions(options.forkOpts, forkOptsNames, "forkOpts");
+		var worker = child_process.fork(script, options.forkArgs, options.forkOpts);
+		var send = worker.send;
+		worker.send = function(message) {
+			return send.call(worker, message);
+		};
+		if (options.emitStdStreams) {
+			worker.stdout.on("data", (data) => worker.emit("stdout", data));
+			worker.stderr.on("data", (data) => worker.emit("stderr", data));
+		}
+		worker.isChildProcess = true;
+		return worker;
+	}
+	function resolveForkOptions(opts) {
+		opts = opts || {};
+		var processExecArgv = process.execArgv.join(" ");
+		var inspectorActive = processExecArgv.indexOf("--inspect") !== -1;
+		var debugBrk = processExecArgv.indexOf("--debug-brk") !== -1;
+		var execArgv = [];
+		if (inspectorActive) {
+			execArgv.push("--inspect=" + opts.debugPort);
+			if (debugBrk) execArgv.push("--debug-brk");
+		}
+		process.execArgv.forEach(function(arg) {
+			if (arg.indexOf("--max-old-space-size") > -1) execArgv.push(arg);
+		});
+		return Object.assign({}, opts, {
+			forkArgs: opts.forkArgs,
+			forkOpts: Object.assign({}, opts.forkOpts, {
+				execArgv: (opts.forkOpts && opts.forkOpts.execArgv || []).concat(execArgv),
+				stdio: opts.emitStdStreams ? "pipe" : void 0
+			})
+		});
+	}
+	/**
+	* Converts a serialized error to Error
+	* @param {Object} obj Error that has been serialized and parsed to object
+	* @return {Error} The equivalent Error.
+	*/
+	function objectToError(obj) {
+		var temp = /* @__PURE__ */ new Error("");
+		var props = Object.keys(obj);
+		for (var i = 0; i < props.length; i++) temp[props[i]] = obj[props[i]];
+		return temp;
+	}
+	function handleEmittedStdPayload(handler, payload) {
+		Object.values(handler.processing).forEach((task) => task?.options?.on(payload));
+		Object.values(handler.tracking).forEach((task) => task?.options?.on(payload));
+	}
+	/**
+	* A WorkerHandler controls a single worker. This worker can be a child process
+	* on node.js or a WebWorker in a browser environment.
+	* @param {String} [script] If no script is provided, a default worker with a
+	*                          function run will be created.
+	* @param {import('./types.js').WorkerPoolOptions} [_options] See docs
+	* @constructor
+	*/
+	function WorkerHandler(script, _options) {
+		var me = this;
+		var options = _options || {};
+		this.script = script || getDefaultWorker();
+		this.worker = setupWorker(this.script, options);
+		this.debugPort = options.debugPort;
+		this.forkOpts = options.forkOpts;
+		this.forkArgs = options.forkArgs;
+		this.workerOpts = options.workerOpts;
+		this.workerThreadOpts = options.workerThreadOpts;
+		this.workerTerminateTimeout = options.workerTerminateTimeout;
+		if (!script) this.worker.ready = true;
+		this.requestQueue = [];
+		this.worker.on("stdout", function(data) {
+			handleEmittedStdPayload(me, { "stdout": data.toString() });
+		});
+		this.worker.on("stderr", function(data) {
+			handleEmittedStdPayload(me, { "stderr": data.toString() });
+		});
+		this.worker.on("message", function(response) {
+			if (me.terminated) return;
+			if (typeof response === "string" && response === "ready") {
+				me.worker.ready = true;
+				dispatchQueuedRequests();
+			} else {
+				var id = response.id;
+				var task = me.processing[id];
+				if (task !== void 0) if (response.isEvent) {
+					if (task.options && typeof task.options.on === "function") task.options.on(response.payload);
+				} else {
+					delete me.processing[id];
+					if (me.terminating === true) me.terminate();
+					if (response.error) task.resolver.reject(objectToError(response.error));
+					else task.resolver.resolve(response.result);
+				}
+				else {
+					var task = me.tracking[id];
+					if (task !== void 0) {
+						if (response.isEvent) {
+							if (task.options && typeof task.options.on === "function") task.options.on(response.payload);
+						}
+					}
+				}
+				if (response.method === CLEANUP_METHOD_ID) {
+					var trackedTask = me.tracking[response.id];
+					if (trackedTask !== void 0) if (response.error) {
+						clearTimeout(trackedTask.timeoutId);
+						trackedTask.resolver.reject(objectToError(response.error));
+					} else {
+						me.tracking && clearTimeout(trackedTask.timeoutId);
+						trackedTask.resolver.reject(new WrappedTimeoutError(trackedTask.error));
+					}
+					delete me.tracking[id];
+				}
+			}
+		});
+		function onError(error) {
+			me.terminated = true;
+			for (var id in me.processing) if (me.processing[id] !== void 0) me.processing[id].resolver.reject(error);
+			me.processing = Object.create(null);
+		}
+		function dispatchQueuedRequests() {
+			for (const request of me.requestQueue.splice(0)) me.worker.send(request.message, request.transfer);
+		}
+		var worker = this.worker;
+		this.worker.on("error", onError);
+		this.worker.on("exit", function(exitCode, signalCode) {
+			var message = "Workerpool Worker terminated Unexpectedly\n";
+			message += "    exitCode: `" + exitCode + "`\n";
+			message += "    signalCode: `" + signalCode + "`\n";
+			message += "    workerpool.script: `" + me.script + "`\n";
+			message += "    spawnArgs: `" + worker.spawnargs + "`\n";
+			message += "    spawnfile: `" + worker.spawnfile + "`\n";
+			message += "    stdout: `" + worker.stdout + "`\n";
+			message += "    stderr: `" + worker.stderr + "`\n";
+			onError(new Error(message));
+		});
+		this.processing = Object.create(null);
+		this.tracking = Object.create(null);
+		this.terminating = false;
+		this.terminated = false;
+		this.cleaning = false;
+		this.terminationHandler = null;
+		this.lastId = 0;
+	}
+	/**
+	* Get a list with methods available on the worker.
+	* @return {Promise.<String[], Error>} methods
+	*/
+	WorkerHandler.prototype.methods = function() {
+		return this.exec("methods");
+	};
+	/**
+	* Execute a method with given parameters on the worker
+	* @param {String} method
+	* @param {Array} [params]
+	* @param {{resolve: Function, reject: Function}} [resolver]
+	* @param {import('./types.js').ExecOptions}  [options]
+	* @return {Promise.<*, Error>} result
+	*/
+	WorkerHandler.prototype.exec = function(method, params, resolver, options) {
+		if (!resolver) resolver = Promise$1.defer();
+		var id = ++this.lastId;
+		this.processing[id] = {
+			id,
+			resolver,
+			options
+		};
+		var request = {
+			message: {
+				id,
+				method,
+				params
+			},
+			transfer: options && options.transfer
+		};
+		if (this.terminated) resolver.reject(/* @__PURE__ */ new Error("Worker is terminated"));
+		else if (this.worker.ready) this.worker.send(request.message, request.transfer);
+		else this.requestQueue.push(request);
+		var me = this;
+		return resolver.promise.catch(function(error) {
+			if (error instanceof Promise$1.CancellationError || error instanceof Promise$1.TimeoutError) {
+				me.tracking[id] = {
+					id,
+					resolver: Promise$1.defer(),
+					options,
+					error
+				};
+				delete me.processing[id];
+				me.tracking[id].resolver.promise = me.tracking[id].resolver.promise.catch(function(err) {
+					delete me.tracking[id];
+					if (err instanceof WrappedTimeoutError) throw err.error;
+					return me.terminateAndNotify(true).then(function() {
+						throw err;
+					}, function(err$1) {
+						throw err$1;
+					});
+				});
+				me.worker.send({
+					id,
+					method: CLEANUP_METHOD_ID
+				});
+				/**
+				* Sets a timeout to reject the cleanup operation if the message sent to the worker
+				* does not receive a response. see worker.tryCleanup for worker cleanup operations.
+				* Here we use the workerTerminateTimeout as the worker will be terminated if the timeout does invoke.
+				* 
+				* We need this timeout in either case of a Timeout or Cancellation Error as if
+				* the worker does not send a message we still need to give a window of time for a response.
+				* 
+				* The workerTermniateTimeout is used here if this promise is rejected the worker cleanup
+				* operations will occure.
+				*/
+				me.tracking[id].timeoutId = setTimeout(function() {
+					me.tracking[id].resolver.reject(error);
+				}, me.workerTerminateTimeout);
+				return me.tracking[id].resolver.promise;
+			} else throw error;
+		});
+	};
+	/**
+	* Test whether the worker is processing any tasks or cleaning up before termination.
+	* @return {boolean} Returns true if the worker is busy
+	*/
+	WorkerHandler.prototype.busy = function() {
+		return this.cleaning || Object.keys(this.processing).length > 0;
+	};
+	/**
+	* Terminate the worker.
+	* @param {boolean} [force=false]   If false (default), the worker is terminated
+	*                                  after finishing all tasks currently in
+	*                                  progress. If true, the worker will be
+	*                                  terminated immediately.
+	* @param {function} [callback=null] If provided, will be called when process terminates.
+	*/
+	WorkerHandler.prototype.terminate = function(force, callback) {
+		var me = this;
+		if (force) {
+			for (var id in this.processing) if (this.processing[id] !== void 0) this.processing[id].resolver.reject(/* @__PURE__ */ new Error("Worker terminated"));
+			this.processing = Object.create(null);
+		}
+		for (var task of Object.values(me.tracking)) {
+			clearTimeout(task.timeoutId);
+			task.resolver.reject(/* @__PURE__ */ new Error("Worker Terminating"));
+		}
+		me.tracking = Object.create(null);
+		if (typeof callback === "function") this.terminationHandler = callback;
+		if (!this.busy()) {
+			var cleanup = function(err) {
+				me.terminated = true;
+				me.cleaning = false;
+				if (me.worker != null && me.worker.removeAllListeners) me.worker.removeAllListeners("message");
+				me.worker = null;
+				me.terminating = false;
+				if (me.terminationHandler) me.terminationHandler(err, me);
+				else if (err) throw err;
+			};
+			if (this.worker) if (typeof this.worker.kill === "function") {
+				if (this.worker.killed) {
+					cleanup(/* @__PURE__ */ new Error("worker already killed!"));
+					return;
+				}
+				var cleanExitTimeout = setTimeout(function() {
+					if (me.worker) me.worker.kill();
+				}, this.workerTerminateTimeout);
+				this.worker.once("exit", function() {
+					clearTimeout(cleanExitTimeout);
+					if (me.worker) me.worker.killed = true;
+					cleanup();
+				});
+				if (this.worker.ready) this.worker.send(TERMINATE_METHOD_ID);
+				else this.requestQueue.push({ message: TERMINATE_METHOD_ID });
+				this.cleaning = true;
+				return;
+			} else if (typeof this.worker.terminate === "function") {
+				this.worker.terminate();
+				this.worker.killed = true;
+			} else throw new Error("Failed to terminate worker");
+			cleanup();
+		} else this.terminating = true;
+	};
+	/**
+	* Terminate the worker, returning a Promise that resolves when the termination has been done.
+	* @param {boolean} [force=false]   If false (default), the worker is terminated
+	*                                  after finishing all tasks currently in
+	*                                  progress. If true, the worker will be
+	*                                  terminated immediately.
+	* @param {number} [timeout]        If provided and non-zero, worker termination promise will be rejected
+	*                                  after timeout if worker process has not been terminated.
+	* @return {Promise.<WorkerHandler, Error>}
+	*/
+	WorkerHandler.prototype.terminateAndNotify = function(force, timeout) {
+		var resolver = Promise$1.defer();
+		if (timeout) resolver.promise.timeout(timeout);
+		this.terminate(force, function(err, worker) {
+			if (err) resolver.reject(err);
+			else resolver.resolve(worker);
+		});
+		return resolver.promise;
+	};
+	/**
+	* Wrapper error type to denote that a TimeoutError has already been proceesed
+	* and we should skip cleanup operations
+	* @param {Promise.TimeoutError} timeoutError
+	*/
+	function WrappedTimeoutError(timeoutError) {
+		this.error = timeoutError;
+		this.stack = (/* @__PURE__ */ new Error()).stack;
+	}
+	module.exports = WorkerHandler;
+	module.exports._tryRequireWorkerThreads = tryRequireWorkerThreads;
+	module.exports._setupProcessWorker = setupProcessWorker;
+	module.exports._setupBrowserWorker = setupBrowserWorker;
+	module.exports._setupWorkerThreadWorker = setupWorkerThreadWorker;
+	module.exports.ensureWorkerThreads = ensureWorkerThreads;
+}) });
+
+//#endregion
+export default require_WorkerHandler();
+
+export { require_WorkerHandler };

package/dist/node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/debug-port-allocator.js

@@ -0,0 +1,27 @@
+import { __commonJS } from "../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/debug-port-allocator.js
+var require_debug_port_allocator = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/debug-port-allocator.js": ((exports, module) => {
+	var MAX_PORTS = 65535;
+	module.exports = DebugPortAllocator;
+	function DebugPortAllocator() {
+		this.ports = Object.create(null);
+		this.length = 0;
+	}
+	DebugPortAllocator.prototype.nextAvailableStartingAt = function(starting) {
+		while (this.ports[starting] === true) starting++;
+		if (starting >= MAX_PORTS) throw new Error("WorkerPool debug port limit reached: " + starting + ">= " + MAX_PORTS);
+		this.ports[starting] = true;
+		this.length++;
+		return starting;
+	};
+	DebugPortAllocator.prototype.releasePort = function(port) {
+		delete this.ports[port];
+		this.length--;
+	};
+}) });
+
+//#endregion
+export default require_debug_port_allocator();
+
+export { require_debug_port_allocator };

package/dist/node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/environment.js

@@ -0,0 +1,18 @@
+import { __commonJS, __require } from "../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/environment.js
+var require_environment = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/environment.js": ((exports, module) => {
+	var isNode = function(nodeProcess) {
+		return typeof nodeProcess !== "undefined" && nodeProcess.versions != null && nodeProcess.versions.node != null && nodeProcess + "" === "[object process]";
+	};
+	module.exports.isNode = isNode;
+	module.exports.platform = typeof process !== "undefined" && isNode(process) ? "node" : "browser";
+	var worker_threads = module.exports.platform === "node" && __require("worker_threads");
+	module.exports.isMainThread = module.exports.platform === "node" ? (!worker_threads || worker_threads.isMainThread) && !process.connected : typeof Window !== "undefined";
+	module.exports.cpus = module.exports.platform === "browser" ? self.navigator.hardwareConcurrency : __require("os").cpus().length;
+}) });
+
+//#endregion
+export default require_environment();
+
+export { require_environment };

package/dist/node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/generated/embeddedWorker.js

@@ -0,0 +1,16 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/generated/embeddedWorker.js
+var require_embeddedWorker = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/generated/embeddedWorker.js": ((exports, module) => {
+	/**
+	* embeddedWorker.js contains an embedded version of worker.js.
+	* This file is automatically generated,
+	* changes made in this file will be overwritten.
+	*/
+	module.exports = "!function(e,n){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=n():\"function\"==typeof define&&define.amd?define(n):(e=\"undefined\"!=typeof globalThis?globalThis:e||self).worker=n()}(this,(function(){\"use strict\";function e(n){return e=\"function\"==typeof Symbol&&\"symbol\"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&\"function\"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?\"symbol\":typeof e},e(n)}function n(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,\"default\")?e.default:e}var t={};var r=function(e,n){this.message=e,this.transfer=n},o={};function i(e,n){var t=this;if(!(this instanceof i))throw new SyntaxError(\"Constructor must be called with the new operator\");if(\"function\"!=typeof e)throw new SyntaxError(\"Function parameter handler(resolve, reject) missing\");var r=[],o=[];this.resolved=!1,this.rejected=!1,this.pending=!0,this[Symbol.toStringTag]=\"Promise\";var a=function(e,n){r.push(e),o.push(n)};this.then=function(e,n){return new i((function(t,r){var o=e?s(e,t,r):t,i=n?s(n,t,r):r;a(o,i)}),t)};var f=function(e){return t.resolved=!0,t.rejected=!1,t.pending=!1,r.forEach((function(n){n(e)})),a=function(n,t){n(e)},f=d=function(){},t},d=function(e){return t.resolved=!1,t.rejected=!0,t.pending=!1,o.forEach((function(n){n(e)})),a=function(n,t){t(e)},f=d=function(){},t};this.cancel=function(){return n?n.cancel():d(new u),t},this.timeout=function(e){if(n)n.timeout(e);else{var r=setTimeout((function(){d(new c(\"Promise timed out after \"+e+\" ms\"))}),e);t.always((function(){clearTimeout(r)}))}return t},e((function(e){f(e)}),(function(e){d(e)}))}function s(e,n,t){return function(r){try{var o=e(r);o&&\"function\"==typeof o.then&&\"function\"==typeof o.catch?o.then(n,t):n(o)}catch(e){t(e)}}}function u(e){this.message=e||\"promise cancelled\",this.stack=(new Error).stack}function c(e){this.message=e||\"timeout exceeded\",this.stack=(new Error).stack}return i.prototype.catch=function(e){return this.then(null,e)},i.prototype.always=function(e){return this.then(e,e)},i.prototype.finally=function(e){var n=this,t=function(){return new i((function(e){return e()})).then(e).then((function(){return n}))};return this.then(t,t)},i.all=function(e){return new i((function(n,t){var r=e.length,o=[];r?e.forEach((function(e,i){e.then((function(e){o[i]=e,0==--r&&n(o)}),(function(e){r=0,t(e)}))})):n(o)}))},i.defer=function(){var e={};return e.promise=new i((function(n,t){e.resolve=n,e.reject=t})),e},u.prototype=new Error,u.prototype.constructor=Error,u.prototype.name=\"CancellationError\",i.CancellationError=u,c.prototype=new Error,c.prototype.constructor=Error,c.prototype.name=\"TimeoutError\",i.TimeoutError=c,o.Promise=i,function(n){var t=r,i=o.Promise,s=\"__workerpool-cleanup__\",u={exit:function(){}},c={addAbortListener:function(e){u.abortListeners.push(e)},emit:u.emit};if(\"undefined\"!=typeof self&&\"function\"==typeof postMessage&&\"function\"==typeof addEventListener)u.on=function(e,n){addEventListener(e,(function(e){n(e.data)}))},u.send=function(e,n){n?postMessage(e,n):postMessage(e)};else{if(\"undefined\"==typeof process)throw new Error(\"Script must be executed as a worker\");var a;try{a=require(\"worker_threads\")}catch(n){if(\"object\"!==e(n)||null===n||\"MODULE_NOT_FOUND\"!==n.code)throw n}if(a&&null!==a.parentPort){var f=a.parentPort;u.send=f.postMessage.bind(f),u.on=f.on.bind(f),u.exit=process.exit.bind(process)}else u.on=process.on.bind(process),u.send=function(e){process.send(e)},u.on(\"disconnect\",(function(){process.exit(1)})),u.exit=process.exit.bind(process)}function d(e){return e&&e.toJSON?JSON.parse(JSON.stringify(e)):JSON.parse(JSON.stringify(e,Object.getOwnPropertyNames(e)))}function l(e){return e&&\"function\"==typeof e.then&&\"function\"==typeof e.catch}u.methods={},u.methods.run=function(e,n){var t=new Function(\"return (\"+e+\").apply(this, arguments);\");return t.worker=c,t.apply(t,n)},u.methods.methods=function(){return Object.keys(u.methods)},u.terminationHandler=void 0,u.abortListenerTimeout=1e3,u.abortListeners=[],u.terminateAndExit=function(e){var n=function(){u.exit(e)};if(!u.terminationHandler)return n();var t=u.terminationHandler(e);return l(t)?(t.then(n,n),t):(n(),new i((function(e,n){n(new Error(\"Worker terminating\"))})))},u.cleanup=function(e){if(!u.abortListeners.length)return u.send({id:e,method:s,error:d(new Error(\"Worker terminating\"))}),new i((function(e){e()}));var n,t=u.abortListeners.map((function(e){return e()})),r=new i((function(e,t){n=setTimeout((function(){t(new Error(\"Timeout occured waiting for abort handler, killing worker\"))}),u.abortListenerTimeout)})),o=i.all(t).then((function(){clearTimeout(n),u.abortListeners.length||(u.abortListeners=[])}),(function(){clearTimeout(n),u.exit()}));return new i((function(e,n){o.then(e,n),r.then(e,n)})).then((function(){u.send({id:e,method:s,error:null})}),(function(n){u.send({id:e,method:s,error:n?d(n):null})}))};var p=null;u.on(\"message\",(function(e){if(\"__workerpool-terminate__\"===e)return u.terminateAndExit(0);if(e.method===s)return u.cleanup(e.id);try{var n=u.methods[e.method];if(!n)throw new Error('Unknown method \"'+e.method+'\"');p=e.id;var r=n.apply(n,e.params);l(r)?r.then((function(n){n instanceof t?u.send({id:e.id,result:n.message,error:null},n.transfer):u.send({id:e.id,result:n,error:null}),p=null})).catch((function(n){u.send({id:e.id,result:null,error:d(n)}),p=null})):(r instanceof t?u.send({id:e.id,result:r.message,error:null},r.transfer):u.send({id:e.id,result:r,error:null}),p=null)}catch(n){u.send({id:e.id,result:null,error:d(n)})}})),u.register=function(e,n){if(e)for(var t in e)e.hasOwnProperty(t)&&(u.methods[t]=e[t],u.methods[t].worker=c);n&&(u.terminationHandler=n.onTerminate,u.abortListenerTimeout=n.abortListenerTimeout||1e3),u.send(\"ready\")},u.emit=function(e){if(p){if(e instanceof t)return void u.send({id:p,isEvent:!0,payload:e.message},e.transfer);u.send({id:p,isEvent:!0,payload:e})}},n.add=u.register,n.emit=u.emit}(t),n(t)}));\n//# sourceMappingURL=worker.min.js.map\n";
+}) });
+
+//#endregion
+export default require_embeddedWorker();
+
+export { require_embeddedWorker };

package/dist/node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/index.js

@@ -0,0 +1,63 @@
+import { __commonJS } from "../../../../../../_virtual/rolldown_runtime.js";
+import { require_environment } from "./environment.js";
+import { require_Promise } from "./Promise.js";
+import { require_Pool } from "./Pool.js";
+import { require_transfer } from "./transfer.js";
+import { require_worker } from "./worker.js";
+
+//#region ../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/index.js
+var require_src = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/index.js": ((exports) => {
+	const { platform, isMainThread, cpus } = require_environment();
+	/** @typedef {import("./Pool")} Pool */
+	/** @typedef {import("./types.js").WorkerPoolOptions} WorkerPoolOptions */
+	/** @typedef {import("./types.js").WorkerRegisterOptions} WorkerRegisterOptions */
+	/**
+	* @template { { [k: string]: (...args: any[]) => any } } T
+	* @typedef {import('./types.js').Proxy<T>} Proxy<T>
+	*/
+	/**
+	* @overload
+	* Create a new worker pool
+	* @param {WorkerPoolOptions} [script]
+	* @returns {Pool} pool
+	*/
+	/**
+	* @overload
+	* Create a new worker pool
+	* @param {string} [script]
+	* @param {WorkerPoolOptions} [options]
+	* @returns {Pool} pool
+	*/
+	function pool(script, options) {
+		return new (require_Pool())(script, options);
+	}
+	exports.pool = pool;
+	/**
+	* Create a worker and optionally register a set of methods to the worker.
+	* @param {{ [k: string]: (...args: any[]) => any }} [methods]
+	* @param {WorkerRegisterOptions} [options]
+	*/
+	function worker(methods, options) {
+		require_worker().add(methods, options);
+	}
+	exports.worker = worker;
+	/**
+	* Sends an event to the parent worker pool.
+	* @param {any} payload 
+	*/
+	function workerEmit(payload) {
+		require_worker().emit(payload);
+	}
+	exports.workerEmit = workerEmit;
+	const { Promise: Promise$1 } = require_Promise();
+	exports.Promise = Promise$1;
+	exports.Transfer = require_transfer();
+	exports.platform = platform;
+	exports.isMainThread = isMainThread;
+	exports.cpus = cpus;
+}) });
+
+//#endregion
+export default require_src();
+
+export { require_src };

package/dist/node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/transfer.js

@@ -0,0 +1,21 @@
+import { __commonJS } from "../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/transfer.js
+var require_transfer = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/transfer.js": ((exports, module) => {
+	/**
+	* The helper class for transferring data from the worker to the main thread.
+	*
+	* @param {Object} message The object to deliver to the main thread.
+	* @param {Object[]} transfer An array of transferable Objects to transfer ownership of.
+	*/
+	function Transfer(message, transfer) {
+		this.message = message;
+		this.transfer = transfer;
+	}
+	module.exports = Transfer;
+}) });
+
+//#endregion
+export default require_transfer();
+
+export { require_transfer };

package/dist/node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/validateOptions.js

@@ -0,0 +1,9 @@
+import { __commonJS } from "../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/validateOptions.js
+var require_validateOptions = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/validateOptions.js": ((exports) => {}) });
+
+//#endregion
+export default require_validateOptions();
+
+export { require_validateOptions };