npm - @cartanova/qgrid-cli - Versions diffs - 2.7.0 → 2.7.2 - Mend

@cartanova/qgrid-cli 2.7.0 → 2.7.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1337) hide show

package/bundle/dist/node_modules/.pnpm/vitest@4.1.10_@opentelemetry_api@1.9.0_@types_node@25.0.7_@vitest_coverage-v8@4.1.10_vi_3892b4338df694f79f7d384fad23d930/node_modules/vitest/dist/chunks/benchmark.CX_oY03V.js ADDED Viewed

@@ -0,0 +1,41 @@
+import { noop } from "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/helpers.js";
+import { i as getCurrentSuite, y as createChainable } from "../../../../../@vitest_runner@4.1.10/node_modules/@vitest/runner/dist/chunk-artifact.js";
+import "../../../../../@vitest_runner@4.1.10/node_modules/@vitest/runner/dist/index.js";
+import "../../../../../@vitest_runner@4.1.10/node_modules/@vitest/runner/dist/utils.js";
+import { g as getWorkerState } from "./utils.BX5Fg8C4.js";
+//#region ../../node_modules/.pnpm/vitest@4.1.10_@opentelemetry+api@1.9.0_@types+node@25.0.7_@vitest+coverage-v8@4.1.10_vi_3892b4338df694f79f7d384fad23d930/node_modules/vitest/dist/chunks/benchmark.CX_oY03V.js
+const benchFns = /* @__PURE__ */ new WeakMap();
+const benchOptsMap = /* @__PURE__ */ new WeakMap();
+function getBenchOptions(key) {
+	return benchOptsMap.get(key);
+}
+function getBenchFn(key) {
+	return benchFns.get(key);
+}
+const bench = createBenchmark(function(name, fn = noop, options = {}) {
+	if (getWorkerState().config.mode !== "benchmark") throw new Error("`bench()` is only available in benchmark mode.");
+	const task = getCurrentSuite().task(formatName(name), {
+		...this,
+		meta: { benchmark: true }
+	});
+	benchFns.set(task, fn);
+	benchOptsMap.set(task, options);
+	if (!this.todo && task.mode === "todo") task.mode = "run";
+});
+function createBenchmark(fn) {
+	const benchmark = createChainable([
+		"skip",
+		"only",
+		"todo"
+	], fn);
+	benchmark.skipIf = (condition) => condition ? benchmark.skip : benchmark;
+	benchmark.runIf = (condition) => condition ? benchmark : benchmark.skip;
+	return benchmark;
+}
+function formatName(name) {
+	return typeof name === "string" ? name : typeof name === "function" ? name.name || "<anonymous>" : String(name);
+}
+//#endregion
+export { getBenchOptions as a, bench as b, getBenchFn as g };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

@@ -0,0 +1,19 @@
+import { d as dirname, r as resolve } from "../../../../../pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.js";
+import "../../../../../pathe@2.0.3/node_modules/pathe/dist/index.js";
+import { EvaluatedModules } from "../../../../../vite@8.0.3_@emnapi_core@1.11.2_@emnapi_runtime@1.11.2_@types_node@25.0.7_esbuild@0.27.4_2519c2e8d8013fcbc7b443879bc9da6d/node_modules/vite/dist/node/module-runner.js";
+//#region ../../node_modules/.pnpm/vitest@4.1.10_@opentelemetry+api@1.9.0_@types+node@25.0.7_@vitest+coverage-v8@4.1.10_vi_3892b4338df694f79f7d384fad23d930/node_modules/vitest/dist/chunks/evaluatedModules.Dg1zASAC.js
+var VitestEvaluatedModules = class extends EvaluatedModules {
+	getModuleSourceMapById(id) {
+		const map = super.getModuleSourceMapById(id);
+		if (map != null && !("_patched" in map)) {
+			map._patched = true;
+			const dir = dirname(map.url);
+			map.resolvedSources = (map.map.sources || []).map((s) => resolve(dir, s || ""));
+		}
+		return map;
+	}
+};
+//#endregion
+export { VitestEvaluatedModules as V };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZhbHVhdGVkTW9kdWxlcy5EZzF6QVNBQy5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9ub2RlX21vZHVsZXMvLnBucG0vdml0ZXN0QDQuMS4xMF9Ab3BlbnRlbGVtZXRyeSthcGlAMS45LjBfQHR5cGVzK25vZGVAMjUuMC43X0B2aXRlc3QrY292ZXJhZ2UtdjhANC4xLjEwX3ZpXzM4OTJiNDMzOGRmNjk0Zjc5ZjdkMzg0ZmFkMjNkOTMwL25vZGVfbW9kdWxlcy92aXRlc3QvZGlzdC9jaHVua3MvZXZhbHVhdGVkTW9kdWxlcy5EZzF6QVNBQy5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBkaXJuYW1lLCByZXNvbHZlIH0gZnJvbSAncGF0aGUnO1xuaW1wb3J0IHsgRXZhbHVhdGVkTW9kdWxlcyB9IGZyb20gJ3ZpdGUvbW9kdWxlLXJ1bm5lcic7XG5cbi8vIFRPRE86IHRoaXMgaXMgbm90IG5lZWRlZCBpbiBWaXRlIDcuMitcbmNsYXNzIFZpdGVzdEV2YWx1YXRlZE1vZHVsZXMgZXh0ZW5kcyBFdmFsdWF0ZWRNb2R1bGVzIHtcblx0Z2V0TW9kdWxlU291cmNlTWFwQnlJZChpZCkge1xuXHRcdGNvbnN0IG1hcCA9IHN1cGVyLmdldE1vZHVsZVNvdXJjZU1hcEJ5SWQoaWQpO1xuXHRcdGlmIChtYXAgIT0gbnVsbCAmJiAhKFwiX3BhdGNoZWRcIiBpbiBtYXApKSB7XG5cdFx0XHRtYXAuX3BhdGNoZWQgPSB0cnVlO1xuXHRcdFx0Y29uc3QgZGlyID0gZGlybmFtZShtYXAudXJsKTtcblx0XHRcdG1hcC5yZXNvbHZlZFNvdXJjZXMgPSAobWFwLm1hcC5zb3VyY2VzIHx8IFtdKS5tYXAoKHMpID0+IHJlc29sdmUoZGlyLCBzIHx8IFwiXCIpKTtcblx0XHR9XG5cdFx0cmV0dXJuIG1hcDtcblx0fVxufVxuXG5leHBvcnQgeyBWaXRlc3RFdmFsdWF0ZWRNb2R1bGVzIGFzIFYgfTtcbiJdLCJ4X2dvb2dsZV9pZ25vcmVMaXN0IjpbMF0sIm1hcHBpbmdzIjoiOzs7O0FBSUEsSUFBTSx5QkFBTixjQUFxQyxpQkFBaUI7Q0FDckQsdUJBQXVCLElBQUk7RUFDMUIsTUFBTSxNQUFNLE1BQU0sdUJBQXVCLEVBQUU7RUFDM0MsSUFBSSxPQUFPLFFBQVEsRUFBRSxjQUFjLE1BQU07R0FDeEMsSUFBSSxXQUFXO0dBQ2YsTUFBTSxNQUFNLFFBQVEsSUFBSSxHQUFHO0dBQzNCLElBQUksbUJBQW1CLElBQUksSUFBSSxXQUFXLENBQUMsRUFBQSxDQUFHLEtBQUssTUFBTSxRQUFRLEtBQUssS0FBSyxFQUFFLENBQUM7RUFDL0U7RUFDQSxPQUFPO0NBQ1I7QUFDRCJ9

@@ -0,0 +1,202 @@
+//#region ../../node_modules/.pnpm/vitest@4.1.10_@opentelemetry+api@1.9.0_@types+node@25.0.7_@vitest+coverage-v8@4.1.10_vi_3892b4338df694f79f7d384fad23d930/node_modules/vitest/dist/chunks/index.Chj8NDwU.js
+const TYPE_REQUEST = "q";
+const TYPE_RESPONSE = "s";
+function createPromiseWithResolvers() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
+}
+const random = Math.random.bind(Math);
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+	let id = "";
+	let i = size;
+	while (i--) id += urlAlphabet[random() * 64 | 0];
+	return id;
+}
+const DEFAULT_TIMEOUT = 6e4;
+const defaultSerialize = (i) => i;
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout, setTimeout } = globalThis;
+function createBirpc($functions, options) {
+	const { post, on, off = () => {}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT, proxify = true } = options;
+	let $closed = false;
+	const _rpcPromiseMap = /* @__PURE__ */ new Map();
+	let _promiseInit;
+	let rpc;
+	async function _call(method, args, event, optional) {
+		if ($closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+		const req = {
+			m: method,
+			a: args,
+			t: TYPE_REQUEST
+		};
+		if (optional) req.o = true;
+		const send = async (_req) => post(serialize(_req));
+		if (event) {
+			await send(req);
+			return;
+		}
+		if (_promiseInit) try {
+			await _promiseInit;
+		} finally {
+			_promiseInit = void 0;
+		}
+		let { promise, resolve, reject } = createPromiseWithResolvers();
+		const id = nanoid();
+		req.i = id;
+		let timeoutId;
+		async function handler(newReq = req) {
+			if (timeout >= 0) {
+				timeoutId = setTimeout(() => {
+					try {
+						if (options.onTimeoutError?.call(rpc, method, args) !== true) throw new Error(`[birpc] timeout on calling "${method}"`);
+					} catch (e) {
+						reject(e);
+					}
+					_rpcPromiseMap.delete(id);
+				}, timeout);
+				if (typeof timeoutId === "object") timeoutId = timeoutId.unref?.();
+			}
+			_rpcPromiseMap.set(id, {
+				resolve,
+				reject,
+				timeoutId,
+				method
+			});
+			await send(newReq);
+			return promise;
+		}
+		try {
+			if (options.onRequest) await options.onRequest.call(rpc, req, handler, resolve);
+			else await handler();
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		} finally {
+			clearTimeout(timeoutId);
+			_rpcPromiseMap.delete(id);
+		}
+		return promise;
+	}
+	const builtinMethods = {
+		$call: (method, ...args) => _call(method, args, false),
+		$callOptional: (method, ...args) => _call(method, args, false, true),
+		$callEvent: (method, ...args) => _call(method, args, true),
+		$callRaw: (options$1) => _call(options$1.method, options$1.args, options$1.event, options$1.optional),
+		$rejectPendingCalls,
+		get $closed() {
+			return $closed;
+		},
+		get $meta() {
+			return options.meta;
+		},
+		$close,
+		$functions
+	};
+	if (proxify) rpc = new Proxy({}, { get(_, method) {
+		if (Object.prototype.hasOwnProperty.call(builtinMethods, method)) return builtinMethods[method];
+		if (method === "then" && !eventNames.includes("then") && !("then" in $functions)) return void 0;
+		const sendEvent = (...args) => _call(method, args, true);
+		if (eventNames.includes(method)) {
+			sendEvent.asEvent = sendEvent;
+			return sendEvent;
+		}
+		const sendCall = (...args) => _call(method, args, false);
+		sendCall.asEvent = sendEvent;
+		return sendCall;
+	} });
+	else rpc = builtinMethods;
+	function $close(customError) {
+		$closed = true;
+		_rpcPromiseMap.forEach(({ reject, method }) => {
+			const error = /* @__PURE__ */ new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+			if (customError) {
+				customError.cause ??= error;
+				return reject(customError);
+			}
+			reject(error);
+		});
+		_rpcPromiseMap.clear();
+		off(onMessage);
+	}
+	function $rejectPendingCalls(handler) {
+		const handlerResults = Array.from(_rpcPromiseMap.values()).map(({ method, reject }) => {
+			if (!handler) return reject(/* @__PURE__ */ new Error(`[birpc]: rejected pending call "${method}".`));
+			return handler({
+				method,
+				reject
+			});
+		});
+		_rpcPromiseMap.clear();
+		return handlerResults;
+	}
+	async function onMessage(data, ...extra) {
+		let msg;
+		try {
+			msg = deserialize(data);
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		}
+		if (msg.t === TYPE_REQUEST) {
+			const { m: method, a: args, o: optional } = msg;
+			let result, error;
+			let fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);
+			if (optional) fn ||= () => void 0;
+			if (!fn) error = /* @__PURE__ */ new Error(`[birpc] function "${method}" not found`);
+			else try {
+				result = await fn.apply(bind === "rpc" ? rpc : $functions, args);
+			} catch (e) {
+				error = e;
+			}
+			if (msg.i) {
+				if (error && options.onFunctionError) {
+					if (options.onFunctionError.call(rpc, error, method, args) === true) return;
+				}
+				if (!error) try {
+					await post(serialize({
+						t: TYPE_RESPONSE,
+						i: msg.i,
+						r: result
+					}), ...extra);
+					return;
+				} catch (e) {
+					error = e;
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+				try {
+					await post(serialize({
+						t: TYPE_RESPONSE,
+						i: msg.i,
+						e: error
+					}), ...extra);
+				} catch (e) {
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+			}
+		} else {
+			const { i: ack, r: result, e: error } = msg;
+			const promise = _rpcPromiseMap.get(ack);
+			if (promise) {
+				clearTimeout(promise.timeoutId);
+				if (error) promise.reject(error);
+				else promise.resolve(result);
+			}
+			_rpcPromiseMap.delete(ack);
+		}
+	}
+	_promiseInit = on(onMessage);
+	return rpc;
+}
+//#endregion
+export { createBirpc as c };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.Chj8NDwU.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/vitest@4.1.10_@opentelemetry+api@1.9.0_@types+node@25.0.7_@vitest+coverage-v8@4.1.10_vi_3892b4338df694f79f7d384fad23d930/node_modules/vitest/dist/chunks/index.Chj8NDwU.js"],"sourcesContent":["//#region src/messages.ts\nconst TYPE_REQUEST = \"q\";\nconst TYPE_RESPONSE = \"s\";\n\n//#endregion\n//#region src/utils.ts\nfunction createPromiseWithResolvers() {\n\tlet resolve;\n\tlet reject;\n\treturn {\n\t\tpromise: new Promise((res, rej) => {\n\t\t\tresolve = res;\n\t\t\treject = rej;\n\t\t}),\n\t\tresolve,\n\t\treject\n\t};\n}\nconst random = Math.random.bind(Math);\nconst urlAlphabet = \"useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict\";\nfunction nanoid(size = 21) {\n\tlet id = \"\";\n\tlet i = size;\n\twhile (i--) id += urlAlphabet[random() * 64 | 0];\n\treturn id;\n}\n\n//#endregion\n//#region src/main.ts\nconst DEFAULT_TIMEOUT = 6e4;\nconst defaultSerialize = (i) => i;\nconst defaultDeserialize = defaultSerialize;\nconst { clearTimeout, setTimeout } = globalThis;\nfunction createBirpc($functions, options) {\n\tconst { post, on, off = () => {}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = \"rpc\", timeout = DEFAULT_TIMEOUT, proxify = true } = options;\n\tlet $closed = false;\n\tconst _rpcPromiseMap = /* @__PURE__ */ new Map();\n\tlet _promiseInit;\n\tlet rpc;\n\tasync function _call(method, args, event, optional) {\n\t\tif ($closed) throw new Error(`[birpc] rpc is closed, cannot call \"${method}\"`);\n\t\tconst req = {\n\t\t\tm: method,\n\t\t\ta: args,\n\t\t\tt: TYPE_REQUEST\n\t\t};\n\t\tif (optional) req.o = true;\n\t\tconst send = async (_req) => post(serialize(_req));\n\t\tif (event) {\n\t\t\tawait send(req);\n\t\t\treturn;\n\t\t}\n\t\tif (_promiseInit) try {\n\t\t\tawait _promiseInit;\n\t\t} finally {\n\t\t\t_promiseInit = void 0;\n\t\t}\n\t\tlet { promise, resolve, reject } = createPromiseWithResolvers();\n\t\tconst id = nanoid();\n\t\treq.i = id;\n\t\tlet timeoutId;\n\t\tasync function handler(newReq = req) {\n\t\t\tif (timeout >= 0) {\n\t\t\t\ttimeoutId = setTimeout(() => {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tif (options.onTimeoutError?.call(rpc, method, args) !== true) throw new Error(`[birpc] timeout on calling \"${method}\"`);\n\t\t\t\t\t} catch (e) {\n\t\t\t\t\t\treject(e);\n\t\t\t\t\t}\n\t\t\t\t\t_rpcPromiseMap.delete(id);\n\t\t\t\t}, timeout);\n\t\t\t\tif (typeof timeoutId === \"object\") timeoutId = timeoutId.unref?.();\n\t\t\t}\n\t\t\t_rpcPromiseMap.set(id, {\n\t\t\t\tresolve,\n\t\t\t\treject,\n\t\t\t\ttimeoutId,\n\t\t\t\tmethod\n\t\t\t});\n\t\t\tawait send(newReq);\n\t\t\treturn promise;\n\t\t}\n\t\ttry {\n\t\t\tif (options.onRequest) await options.onRequest.call(rpc, req, handler, resolve);\n\t\t\telse await handler();\n\t\t} catch (e) {\n\t\t\tif (options.onGeneralError?.call(rpc, e) !== true) throw e;\n\t\t\treturn;\n\t\t} finally {\n\t\t\tclearTimeout(timeoutId);\n\t\t\t_rpcPromiseMap.delete(id);\n\t\t}\n\t\treturn promise;\n\t}\n\tconst builtinMethods = {\n\t\t$call: (method, ...args) => _call(method, args, false),\n\t\t$callOptional: (method, ...args) => _call(method, args, false, true),\n\t\t$callEvent: (method, ...args) => _call(method, args, true),\n\t\t$callRaw: (options$1) => _call(options$1.method, options$1.args, options$1.event, options$1.optional),\n\t\t$rejectPendingCalls,\n\t\tget $closed() {\n\t\t\treturn $closed;\n\t\t},\n\t\tget $meta() {\n\t\t\treturn options.meta;\n\t\t},\n\t\t$close,\n\t\t$functions\n\t};\n\tif (proxify) rpc = new Proxy({}, { get(_, method) {\n\t\tif (Object.prototype.hasOwnProperty.call(builtinMethods, method)) return builtinMethods[method];\n\t\tif (method === \"then\" && !eventNames.includes(\"then\") && !(\"then\" in $functions)) return void 0;\n\t\tconst sendEvent = (...args) => _call(method, args, true);\n\t\tif (eventNames.includes(method)) {\n\t\t\tsendEvent.asEvent = sendEvent;\n\t\t\treturn sendEvent;\n\t\t}\n\t\tconst sendCall = (...args) => _call(method, args, false);\n\t\tsendCall.asEvent = sendEvent;\n\t\treturn sendCall;\n\t} });\n\telse rpc = builtinMethods;\n\tfunction $close(customError) {\n\t\t$closed = true;\n\t\t_rpcPromiseMap.forEach(({ reject, method }) => {\n\t\t\tconst error = /* @__PURE__ */ new Error(`[birpc] rpc is closed, cannot call \"${method}\"`);\n\t\t\tif (customError) {\n\t\t\t\tcustomError.cause ??= error;\n\t\t\t\treturn reject(customError);\n\t\t\t}\n\t\t\treject(error);\n\t\t});\n\t\t_rpcPromiseMap.clear();\n\t\toff(onMessage);\n\t}\n\tfunction $rejectPendingCalls(handler) {\n\t\tconst handlerResults = Array.from(_rpcPromiseMap.values()).map(({ method, reject }) => {\n\t\t\tif (!handler) return reject(/* @__PURE__ */ new Error(`[birpc]: rejected pending call \"${method}\".`));\n\t\t\treturn handler({\n\t\t\t\tmethod,\n\t\t\t\treject\n\t\t\t});\n\t\t});\n\t\t_rpcPromiseMap.clear();\n\t\treturn handlerResults;\n\t}\n\tasync function onMessage(data, ...extra) {\n\t\tlet msg;\n\t\ttry {\n\t\t\tmsg = deserialize(data);\n\t\t} catch (e) {\n\t\t\tif (options.onGeneralError?.call(rpc, e) !== true) throw e;\n\t\t\treturn;\n\t\t}\n\t\tif (msg.t === TYPE_REQUEST) {\n\t\t\tconst { m: method, a: args, o: optional } = msg;\n\t\t\tlet result, error;\n\t\t\tlet fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);\n\t\t\tif (optional) fn ||= () => void 0;\n\t\t\tif (!fn) error = /* @__PURE__ */ new Error(`[birpc] function \"${method}\" not found`);\n\t\t\telse try {\n\t\t\t\tresult = await fn.apply(bind === \"rpc\" ? rpc : $functions, args);\n\t\t\t} catch (e) {\n\t\t\t\terror = e;\n\t\t\t}\n\t\t\tif (msg.i) {\n\t\t\t\tif (error && options.onFunctionError) {\n\t\t\t\t\tif (options.onFunctionError.call(rpc, error, method, args) === true) return;\n\t\t\t\t}\n\t\t\t\tif (!error) try {\n\t\t\t\t\tawait post(serialize({\n\t\t\t\t\t\tt: TYPE_RESPONSE,\n\t\t\t\t\t\ti: msg.i,\n\t\t\t\t\t\tr: result\n\t\t\t\t\t}), ...extra);\n\t\t\t\t\treturn;\n\t\t\t\t} catch (e) {\n\t\t\t\t\terror = e;\n\t\t\t\t\tif (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;\n\t\t\t\t}\n\t\t\t\ttry {\n\t\t\t\t\tawait post(serialize({\n\t\t\t\t\t\tt: TYPE_RESPONSE,\n\t\t\t\t\t\ti: msg.i,\n\t\t\t\t\t\te: error\n\t\t\t\t\t}), ...extra);\n\t\t\t\t} catch (e) {\n\t\t\t\t\tif (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tconst { i: ack, r: result, e: error } = msg;\n\t\t\tconst promise = _rpcPromiseMap.get(ack);\n\t\t\tif (promise) {\n\t\t\t\tclearTimeout(promise.timeoutId);\n\t\t\t\tif (error) promise.reject(error);\n\t\t\t\telse promise.resolve(result);\n\t\t\t}\n\t\t\t_rpcPromiseMap.delete(ack);\n\t\t}\n\t}\n\t_promiseInit = on(onMessage);\n\treturn rpc;\n}\n\nexport { createBirpc as c };\n"],"x_google_ignoreList":[0],"mappings":"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"}

@@ -0,0 +1,46 @@
+import { a as afterAll, b as afterEach, c as aroundAll, d as aroundEach, e as beforeAll, f as beforeEach, h as describe, m as it, n as onTestFinished, o as onTestFailed, r as recordArtifact, u as suite, v as test } from "../../../../../@vitest_runner@4.1.10/node_modules/@vitest/runner/dist/chunk-artifact.js";
+import "../../../../../@vitest_runner@4.1.10/node_modules/@vitest/runner/dist/index.js";
+import { b as bench } from "./benchmark.CX_oY03V.js";
+import { chai_exports } from "../../../../../chai@6.2.2/node_modules/chai/index.js";
+import "../../../../../@vitest_expect@4.1.10/node_modules/@vitest/expect/dist/index.js";
+import { N as NodeBenchmarkRunner, S as Snapshots, T as TestRunner, a as assert, b as vitest, c as createExpect, g as globalExpect, i as inject, s as should, v as vi } from "./test.DNmyFkvJ.js";
+import { V as VitestEvaluatedModules } from "./evaluatedModules.Dg1zASAC.js";
+import { require_dist } from "../../../../../expect-type@1.3.0/node_modules/expect-type/dist/index.js";
+//#region ../../node_modules/.pnpm/vitest@4.1.10_@opentelemetry+api@1.9.0_@types+node@25.0.7_@vitest+coverage-v8@4.1.10_vi_3892b4338df694f79f7d384fad23d930/node_modules/vitest/dist/chunks/index.DdgEv5B1.js
+var import_dist = require_dist();
+const assertType = function assertType() {};
+var index = /*#__PURE__*/ Object.freeze({
+	__proto__: null,
+	BenchmarkRunner: NodeBenchmarkRunner,
+	EvaluatedModules: VitestEvaluatedModules,
+	Snapshots,
+	TestRunner,
+	afterAll,
+	afterEach,
+	aroundAll,
+	aroundEach,
+	assert,
+	assertType,
+	beforeAll,
+	beforeEach,
+	bench,
+	chai: chai_exports,
+	createExpect,
+	describe,
+	expect: globalExpect,
+	expectTypeOf: import_dist.expectTypeOf,
+	inject,
+	it,
+	onTestFailed,
+	onTestFinished,
+	recordArtifact,
+	should,
+	suite,
+	test,
+	vi,
+	vitest
+});
+//#endregion
+export { assertType as a, index as i };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

@@ -0,0 +1,119 @@
+import { getSafeTimers } from "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/timers.js";
+import { g as getWorkerState } from "./utils.BX5Fg8C4.js";
+import { c as createBirpc } from "./index.Chj8NDwU.js";
+//#region ../../node_modules/.pnpm/vitest@4.1.10_@opentelemetry+api@1.9.0_@types+node@25.0.7_@vitest+coverage-v8@4.1.10_vi_3892b4338df694f79f7d384fad23d930/node_modules/vitest/dist/chunks/rpc.MzXet3jl.js
+const RealDate = Date;
+let now = null;
+var MockDate = class MockDate extends RealDate {
+	constructor(y, m, d, h, M, s, ms) {
+		super();
+		let date;
+		switch (arguments.length) {
+			case 0:
+				if (now !== null) date = new RealDate(now.valueOf());
+				else date = new RealDate();
+				break;
+			case 1:
+				date = new RealDate(y);
+				break;
+			default:
+				d = typeof d === "undefined" ? 1 : d;
+				h = h || 0;
+				M = M || 0;
+				s = s || 0;
+				ms = ms || 0;
+				date = new RealDate(y, m, d, h, M, s, ms);
+				break;
+		}
+		Object.setPrototypeOf(date, MockDate.prototype);
+		return date;
+	}
+};
+MockDate.UTC = RealDate.UTC;
+MockDate.now = function() {
+	return new MockDate().valueOf();
+};
+MockDate.parse = function(dateString) {
+	return RealDate.parse(dateString);
+};
+MockDate.toString = function() {
+	return RealDate.toString();
+};
+function mockDate(date) {
+	const dateObj = new RealDate(date.valueOf());
+	if (Number.isNaN(dateObj.getTime())) throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);
+	globalThis.Date = MockDate;
+	now = dateObj.valueOf();
+}
+function resetDate() {
+	globalThis.Date = RealDate;
+}
+const { get } = Reflect;
+function withSafeTimers(fn) {
+	const { setTimeout, clearTimeout, nextTick, setImmediate, clearImmediate } = getSafeTimers();
+	const currentSetTimeout = globalThis.setTimeout;
+	const currentClearTimeout = globalThis.clearTimeout;
+	const currentSetImmediate = globalThis.setImmediate;
+	const currentClearImmediate = globalThis.clearImmediate;
+	const currentNextTick = globalThis.process?.nextTick;
+	try {
+		globalThis.setTimeout = setTimeout;
+		globalThis.clearTimeout = clearTimeout;
+		if (setImmediate) globalThis.setImmediate = setImmediate;
+		if (clearImmediate) globalThis.clearImmediate = clearImmediate;
+		if (globalThis.process && nextTick) globalThis.process.nextTick = nextTick;
+		return fn();
+	} finally {
+		globalThis.setTimeout = currentSetTimeout;
+		globalThis.clearTimeout = currentClearTimeout;
+		globalThis.setImmediate = currentSetImmediate;
+		globalThis.clearImmediate = currentClearImmediate;
+		if (globalThis.process && nextTick) nextTick(() => {
+			globalThis.process.nextTick = currentNextTick;
+		});
+	}
+}
+const promises = /* @__PURE__ */ new Set();
+async function rpcDone() {
+	if (!promises.size) return;
+	const awaitable = Array.from(promises);
+	return Promise.all(awaitable);
+}
+const onCancelCallbacks = [];
+function onCancel(callback) {
+	onCancelCallbacks.push(callback);
+}
+function createRuntimeRpc(options) {
+	return createSafeRpc(createBirpc({ async onCancel(reason) {
+		await Promise.all(onCancelCallbacks.map((fn) => fn(reason)));
+	} }, {
+		eventNames: ["onCancel"],
+		timeout: -1,
+		...options
+	}));
+}
+function createSafeRpc(rpc) {
+	return new Proxy(rpc, { get(target, p, handler) {
+		if (p === "$rejectPendingCalls") return rpc.$rejectPendingCalls;
+		const sendCall = get(target, p, handler);
+		const safeSendCall = (...args) => withSafeTimers(async () => {
+			const result = sendCall(...args);
+			promises.add(result);
+			try {
+				return await result;
+			} finally {
+				promises.delete(result);
+			}
+		});
+		safeSendCall.asEvent = sendCall.asEvent;
+		return safeSendCall;
+	} });
+}
+function rpc() {
+	const { rpc } = getWorkerState();
+	return rpc;
+}
+//#endregion
+export { RealDate as R, rpcDone as a, resetDate as b, createRuntimeRpc as c, mockDate as m, onCancel as o, rpc as r };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"rpc.MzXet3jl.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/vitest@4.1.10_@opentelemetry+api@1.9.0_@types+node@25.0.7_@vitest+coverage-v8@4.1.10_vi_3892b4338df694f79f7d384fad23d930/node_modules/vitest/dist/chunks/rpc.MzXet3jl.js"],"sourcesContent":["import { getSafeTimers } from '@vitest/utils/timers';\nimport { c as createBirpc } from './index.Chj8NDwU.js';\nimport { g as getWorkerState } from './utils.BX5Fg8C4.js';\n\n/* Ported from https://github.com/boblauer/MockDate/blob/master/src/mockdate.ts */\n/*\nThe MIT License (MIT)\n\nCopyright (c) 2014 Bob Lauer\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n*/\nconst RealDate = Date;\nlet now = null;\nclass MockDate extends RealDate {\n\tconstructor(y, m, d, h, M, s, ms) {\n\t\tsuper();\n\t\tlet date;\n\t\tswitch (arguments.length) {\n\t\t\tcase 0:\n\t\t\t\tif (now !== null) date = new RealDate(now.valueOf());\n\t\t\t\telse date = new RealDate();\n\t\t\t\tbreak;\n\t\t\tcase 1:\n\t\t\t\tdate = new RealDate(y);\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\td = typeof d === \"undefined\" ? 1 : d;\n\t\t\t\th = h || 0;\n\t\t\t\tM = M || 0;\n\t\t\t\ts = s || 0;\n\t\t\t\tms = ms || 0;\n\t\t\t\tdate = new RealDate(y, m, d, h, M, s, ms);\n\t\t\t\tbreak;\n\t\t}\n\t\tObject.setPrototypeOf(date, MockDate.prototype);\n\t\treturn date;\n\t}\n}\nMockDate.UTC = RealDate.UTC;\nMockDate.now = function() {\n\treturn new MockDate().valueOf();\n};\nMockDate.parse = function(dateString) {\n\treturn RealDate.parse(dateString);\n};\nMockDate.toString = function() {\n\treturn RealDate.toString();\n};\nfunction mockDate(date) {\n\tconst dateObj = new RealDate(date.valueOf());\n\tif (Number.isNaN(dateObj.getTime())) throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);\n\t// @ts-expect-error global\n\tglobalThis.Date = MockDate;\n\tnow = dateObj.valueOf();\n}\nfunction resetDate() {\n\tglobalThis.Date = RealDate;\n}\n\nconst { get } = Reflect;\nfunction withSafeTimers(fn) {\n\tconst { setTimeout, clearTimeout, nextTick, setImmediate, clearImmediate } = getSafeTimers();\n\tconst currentSetTimeout = globalThis.setTimeout;\n\tconst currentClearTimeout = globalThis.clearTimeout;\n\tconst currentSetImmediate = globalThis.setImmediate;\n\tconst currentClearImmediate = globalThis.clearImmediate;\n\tconst currentNextTick = globalThis.process?.nextTick;\n\ttry {\n\t\tglobalThis.setTimeout = setTimeout;\n\t\tglobalThis.clearTimeout = clearTimeout;\n\t\tif (setImmediate) globalThis.setImmediate = setImmediate;\n\t\tif (clearImmediate) globalThis.clearImmediate = clearImmediate;\n\t\tif (globalThis.process && nextTick) globalThis.process.nextTick = nextTick;\n\t\treturn fn();\n\t} finally {\n\t\tglobalThis.setTimeout = currentSetTimeout;\n\t\tglobalThis.clearTimeout = currentClearTimeout;\n\t\tglobalThis.setImmediate = currentSetImmediate;\n\t\tglobalThis.clearImmediate = currentClearImmediate;\n\t\tif (globalThis.process && nextTick) nextTick(() => {\n\t\t\tglobalThis.process.nextTick = currentNextTick;\n\t\t});\n\t}\n}\nconst promises = /* @__PURE__ */ new Set();\nasync function rpcDone() {\n\tif (!promises.size) return;\n\tconst awaitable = Array.from(promises);\n\treturn Promise.all(awaitable);\n}\nconst onCancelCallbacks = [];\nfunction onCancel(callback) {\n\tonCancelCallbacks.push(callback);\n}\nfunction createRuntimeRpc(options) {\n\treturn createSafeRpc(createBirpc({ async onCancel(reason) {\n\t\tawait Promise.all(onCancelCallbacks.map((fn) => fn(reason)));\n\t} }, {\n\t\teventNames: [\"onCancel\"],\n\t\ttimeout: -1,\n\t\t...options\n\t}));\n}\nfunction createSafeRpc(rpc) {\n\treturn new Proxy(rpc, { get(target, p, handler) {\n\t\t// keep $rejectPendingCalls as sync function\n\t\tif (p === \"$rejectPendingCalls\") return rpc.$rejectPendingCalls;\n\t\tconst sendCall = get(target, p, handler);\n\t\tconst safeSendCall = (...args) => withSafeTimers(async () => {\n\t\t\tconst result = sendCall(...args);\n\t\t\tpromises.add(result);\n\t\t\ttry {\n\t\t\t\treturn await result;\n\t\t\t} finally {\n\t\t\t\tpromises.delete(result);\n\t\t\t}\n\t\t});\n\t\tsafeSendCall.asEvent = sendCall.asEvent;\n\t\treturn safeSendCall;\n\t} });\n}\nfunction rpc() {\n\tconst { rpc } = getWorkerState();\n\treturn rpc;\n}\n\nexport { RealDate as R, rpcDone as a, resetDate as b, createRuntimeRpc as c, mockDate as m, onCancel as o, rpc as r };\n"],"x_google_ignoreList":[0],"mappings":"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"}