@cartanova/qgrid-cli 2.4.8 → 2.4.9

package/bundle/dist/node_modules/.pnpm/@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/error.js

@@ -0,0 +1,40 @@
+import "../../../../../tinyrainbow@3.1.0/node_modules/tinyrainbow/dist/index.js";
+import { format } from "../../../../../@vitest_pretty-format@4.1.10/node_modules/@vitest/pretty-format/dist/index.js";
+import "./display.js";
+import "./constants.js";
+import "./helpers.js";
+import { getDefaultFormatOptions, printDiffOrStringify } from "./diff.js";
+import { serializeValue } from "./serialize.js";
+//#region ../../node_modules/.pnpm/@vitest+utils@4.1.10/node_modules/@vitest/utils/dist/error.js
+function processError(_err, diffOptions, seen = /* @__PURE__ */ new WeakSet()) {
+	if (!_err || typeof _err !== "object") return { message: String(_err) };
+	const err = _err;
+	if (err.showDiff || err.showDiff === void 0 && err.expected !== void 0 && err.actual !== void 0) {
+		const options = {
+			...diffOptions,
+			...err.diffOptions
+		};
+		err.diff = printDiffOrStringify(err.actual, err.expected, options, err);
+		err.expected = prettifyValue(err.expected, options);
+		err.actual = prettifyValue(err.actual, options);
+	}
+	try {
+		if (!seen.has(err) && typeof err.cause === "object") {
+			seen.add(err);
+			err.cause = processError(err.cause, diffOptions, seen);
+		}
+	} catch {}
+	try {
+		return serializeValue(err);
+	} catch (e) {
+		return serializeValue(/* @__PURE__ */ new Error(`Failed to fully serialize error: ${e?.message}\nInner error message: ${err?.message}`));
+	}
+}
+function prettifyValue(value, options) {
+	if (typeof value !== "string") return format(value, getDefaultFormatOptions(options));
+	return value;
+}
+//#endregion
+export { processError, serializeValue as serializeError };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/node_modules/.pnpm/@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/helpers.js

@@ -0,0 +1,272 @@
+import { NULL_BYTE_PLACEHOLDER, VALID_ID_PREFIX } from "./constants.js";
+//#region ../../node_modules/.pnpm/@vitest+utils@4.1.10/node_modules/@vitest/utils/dist/helpers.js
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+	let id = "";
+	let i = size;
+	while (i--) id += urlAlphabet[Math.random() * 64 | 0];
+	return id;
+}
+const RealDate = Date;
+function random(seed) {
+	const x = Math.sin(seed++) * 1e4;
+	return x - Math.floor(x);
+}
+function shuffle(array, seed = RealDate.now()) {
+	let length = array.length;
+	while (length) {
+		const index = Math.floor(random(seed) * length--);
+		const previous = array[length];
+		array[length] = array[index];
+		array[index] = previous;
+		++seed;
+	}
+	return array;
+}
+/**
+* Get original stacktrace without source map support the most performant way.
+* - Create only 1 stack frame.
+* - Rewrite prepareStackTrace to bypass "support-stack-trace" (usually takes ~250ms).
+*/
+function createSimpleStackTrace(options) {
+	const { message = "$$stack trace error", stackTraceLimit = 1 } = options || {};
+	const limit = Error.stackTraceLimit;
+	const prepareStackTrace = Error.prepareStackTrace;
+	Error.stackTraceLimit = stackTraceLimit;
+	Error.prepareStackTrace = (e) => e.stack;
+	const stackTrace = new Error(message).stack || "";
+	Error.prepareStackTrace = prepareStackTrace;
+	Error.stackTraceLimit = limit;
+	return stackTrace;
+}
+function notNullish(v) {
+	return v != null;
+}
+function assertTypes(value, name, types) {
+	const receivedType = typeof value;
+	if (!types.includes(receivedType)) throw new TypeError(`${name} value must be ${types.join(" or ")}, received "${receivedType}"`);
+}
+function isPrimitive(value) {
+	return value === null || typeof value !== "function" && typeof value !== "object";
+}
+function slash(path) {
+	return path.replace(/\\/g, "/");
+}
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+	return url.replace(postfixRE, "");
+}
+function splitFileAndPostfix(path) {
+	const file = cleanUrl(path);
+	return {
+		file,
+		postfix: path.slice(file.length)
+	};
+}
+const externalRE = /^(?:[a-z]+:)?\/\//;
+const isExternalUrl = (url) => externalRE.test(url);
+/**
+* Prepend `/@id/` and replace null byte so the id is URL-safe.
+* This is prepended to resolved ids that are not valid browser
+* import specifiers by the importAnalysis plugin.
+*/
+function wrapId(id) {
+	return id.startsWith(VALID_ID_PREFIX) ? id : VALID_ID_PREFIX + id.replace("\0", NULL_BYTE_PLACEHOLDER);
+}
+/**
+* Undo {@link wrapId}'s `/@id/` and null byte replacements.
+*/
+function unwrapId(id) {
+	return id.startsWith(VALID_ID_PREFIX) ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, "\0") : id;
+}
+function withTrailingSlash(path) {
+	if (path.at(-1) !== "/") return `${path}/`;
+	return path;
+}
+function filterOutComments(s) {
+	const result = [];
+	let commentState = "none";
+	for (let i = 0; i < s.length; ++i) if (commentState === "singleline") {
+		if (s[i] === "\n") commentState = "none";
+	} else if (commentState === "multiline") {
+		if (s[i - 1] === "*" && s[i] === "/") commentState = "none";
+	} else if (commentState === "none") if (s[i] === "/" && s[i + 1] === "/") commentState = "singleline";
+	else if (s[i] === "/" && s[i + 1] === "*") {
+		commentState = "multiline";
+		i += 2;
+	} else result.push(s[i]);
+	return result.join("");
+}
+const bareImportRE = /^(?![a-z]:)[\w@](?!.*:\/\/)/i;
+function isBareImport(id) {
+	return bareImportRE.test(id);
+}
+function toArray(array) {
+	if (array === null || array === void 0) array = [];
+	if (Array.isArray(array)) return array;
+	return [array];
+}
+function isObject(item) {
+	return item != null && typeof item === "object" && !Array.isArray(item);
+}
+function isFinalObj(obj) {
+	return obj === Object.prototype || obj === Function.prototype || obj === RegExp.prototype;
+}
+function getType(value) {
+	return Object.prototype.toString.apply(value).slice(8, -1);
+}
+function collectOwnProperties(obj, collector) {
+	const collect = typeof collector === "function" ? collector : (key) => collector.add(key);
+	Object.getOwnPropertyNames(obj).forEach(collect);
+	Object.getOwnPropertySymbols(obj).forEach(collect);
+}
+function getOwnProperties(obj) {
+	const ownProps = /* @__PURE__ */ new Set();
+	if (isFinalObj(obj)) return [];
+	collectOwnProperties(obj, ownProps);
+	return Array.from(ownProps);
+}
+const defaultCloneOptions = { forceWritable: false };
+function deepClone(val, options = defaultCloneOptions) {
+	return clone(val, /* @__PURE__ */ new WeakMap(), options);
+}
+function clone(val, seen, options = defaultCloneOptions) {
+	let k, out;
+	if (seen.has(val)) return seen.get(val);
+	if (Array.isArray(val)) {
+		out = Array.from({ length: k = val.length });
+		seen.set(val, out);
+		while (k--) out[k] = clone(val[k], seen, options);
+		return out;
+	}
+	if (Object.prototype.toString.call(val) === "[object Object]") {
+		out = Object.create(Object.getPrototypeOf(val));
+		seen.set(val, out);
+		const props = getOwnProperties(val);
+		for (const k of props) {
+			const descriptor = Object.getOwnPropertyDescriptor(val, k);
+			if (!descriptor) continue;
+			const cloned = clone(val[k], seen, options);
+			if (options.forceWritable) Object.defineProperty(out, k, {
+				enumerable: descriptor.enumerable,
+				configurable: true,
+				writable: true,
+				value: cloned
+			});
+			else if ("get" in descriptor) Object.defineProperty(out, k, {
+				...descriptor,
+				get() {
+					return cloned;
+				}
+			});
+			else Object.defineProperty(out, k, {
+				...descriptor,
+				value: cloned
+			});
+		}
+		return out;
+	}
+	return val;
+}
+function noop() {}
+function objectAttr(source, path, defaultValue = void 0) {
+	const paths = path.replace(/\[(\d+)\]/g, ".$1").split(".");
+	let result = source;
+	for (const p of paths) {
+		result = new Object(result)[p];
+		if (result === void 0) return defaultValue;
+	}
+	return result;
+}
+function createDefer() {
+	let resolve = null;
+	let reject = null;
+	const p = new Promise((_resolve, _reject) => {
+		resolve = _resolve;
+		reject = _reject;
+	});
+	p.resolve = resolve;
+	p.reject = reject;
+	return p;
+}
+/**
+* If code starts with a function call, will return its last index, respecting arguments.
+* This will return 25 - last ending character of toMatch ")"
+* Also works with callbacks
+* ```
+* toMatch({ test: '123' });
+* toBeAliased('123')
+* ```
+*/
+function getCallLastIndex(code) {
+	let charIndex = -1;
+	let inString = null;
+	let startedBracers = 0;
+	let endedBracers = 0;
+	let beforeChar = null;
+	while (charIndex <= code.length) {
+		beforeChar = code[charIndex];
+		charIndex++;
+		const char = code[charIndex];
+		if ((char === "\"" || char === "'" || char === "`") && beforeChar !== "\\") {
+			if (inString === char) inString = null;
+			else if (!inString) inString = char;
+		}
+		if (!inString) {
+			if (char === "(") startedBracers++;
+			if (char === ")") endedBracers++;
+		}
+		if (startedBracers && endedBracers && startedBracers === endedBracers) return charIndex;
+	}
+	return null;
+}
+function isNegativeNaN(val) {
+	if (!Number.isNaN(val)) return false;
+	const f64 = /* @__PURE__ */ new Float64Array(1);
+	f64[0] = val;
+	return new Uint32Array(f64.buffer)[1] >>> 31 === 1;
+}
+function toString(v) {
+	return Object.prototype.toString.call(v);
+}
+function isPlainObject(val) {
+	return toString(val) === "[object Object]" && (!val.constructor || val.constructor.name === "Object");
+}
+function isMergeableObject(item) {
+	return isPlainObject(item) && !Array.isArray(item);
+}
+function ordinal(i) {
+	const j = i % 10;
+	const k = i % 100;
+	if (j === 1 && k !== 11) return `${i}st`;
+	if (j === 2 && k !== 12) return `${i}nd`;
+	if (j === 3 && k !== 13) return `${i}rd`;
+	return `${i}th`;
+}
+/**
+* Deep merge :P
+*
+* Will merge objects only if they are plain
+*
+* Do not merge types - it is very expensive and usually it's better to case a type here
+*/
+function deepMerge(target, ...sources) {
+	if (!sources.length) return target;
+	const source = sources.shift();
+	if (source === void 0) return target;
+	if (isMergeableObject(target) && isMergeableObject(source)) Object.keys(source).forEach((key) => {
+		const _source = source;
+		if (isMergeableObject(_source[key])) {
+			if (!target[key]) target[key] = {};
+			deepMerge(target[key], _source[key]);
+		} else target[key] = _source[key];
+	});
+	return deepMerge(target, ...sources);
+}
+function unique(array) {
+	return Array.from(new Set(array));
+}
+//#endregion
+export { assertTypes, cleanUrl, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, filterOutComments, getCallLastIndex, getOwnProperties, getType, isBareImport, isExternalUrl, isNegativeNaN, isObject, isPrimitive, nanoid, noop, notNullish, objectAttr, ordinal, shuffle, slash, splitFileAndPostfix, toArray, unique, unwrapId, withTrailingSlash, wrapId };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"helpers.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/@vitest+utils@4.1.10/node_modules/@vitest/utils/dist/helpers.js"],"sourcesContent":["import { VALID_ID_PREFIX, NULL_BYTE_PLACEHOLDER } from './constants.js';\n\n// port from nanoid\n// https://github.com/ai/nanoid\nconst urlAlphabet = \"useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict\";\nfunction nanoid(size = 21) {\n\tlet id = \"\";\n\tlet i = size;\n\twhile (i--) {\n\t\tid += urlAlphabet[Math.random() * 64 | 0];\n\t}\n\treturn id;\n}\n\nconst RealDate = Date;\nfunction random(seed) {\n\tconst x = Math.sin(seed++) * 1e4;\n\treturn x - Math.floor(x);\n}\nfunction shuffle(array, seed = RealDate.now()) {\n\tlet length = array.length;\n\twhile (length) {\n\t\tconst index = Math.floor(random(seed) * length--);\n\t\tconst previous = array[length];\n\t\tarray[length] = array[index];\n\t\tarray[index] = previous;\n\t\t++seed;\n\t}\n\treturn array;\n}\n\n/**\n* Get original stacktrace without source map support the most performant way.\n* - Create only 1 stack frame.\n* - Rewrite prepareStackTrace to bypass \"support-stack-trace\" (usually takes ~250ms).\n*/\nfunction createSimpleStackTrace(options) {\n\tconst { message = \"$$stack trace error\", stackTraceLimit = 1 } = options || {};\n\tconst limit = Error.stackTraceLimit;\n\tconst prepareStackTrace = Error.prepareStackTrace;\n\tError.stackTraceLimit = stackTraceLimit;\n\tError.prepareStackTrace = (e) => e.stack;\n\tconst err = new Error(message);\n\tconst stackTrace = err.stack || \"\";\n\tError.prepareStackTrace = prepareStackTrace;\n\tError.stackTraceLimit = limit;\n\treturn stackTrace;\n}\nfunction notNullish(v) {\n\treturn v != null;\n}\nfunction assertTypes(value, name, types) {\n\tconst receivedType = typeof value;\n\tconst pass = types.includes(receivedType);\n\tif (!pass) {\n\t\tthrow new TypeError(`${name} value must be ${types.join(\" or \")}, received \"${receivedType}\"`);\n\t}\n}\nfunction isPrimitive(value) {\n\treturn value === null || typeof value !== \"function\" && typeof value !== \"object\";\n}\nfunction slash(path) {\n\treturn path.replace(/\\\\/g, \"/\");\n}\nconst postfixRE = /[?#].*$/;\nfunction cleanUrl(url) {\n\treturn url.replace(postfixRE, \"\");\n}\nfunction splitFileAndPostfix(path) {\n\tconst file = cleanUrl(path);\n\treturn {\n\t\tfile,\n\t\tpostfix: path.slice(file.length)\n\t};\n}\nconst externalRE = /^(?:[a-z]+:)?\\/\\//;\nconst isExternalUrl = (url) => externalRE.test(url);\n/**\n* Prepend `/@id/` and replace null byte so the id is URL-safe.\n* This is prepended to resolved ids that are not valid browser\n* import specifiers by the importAnalysis plugin.\n*/\nfunction wrapId(id) {\n\treturn id.startsWith(VALID_ID_PREFIX) ? id : VALID_ID_PREFIX + id.replace(\"\\0\", NULL_BYTE_PLACEHOLDER);\n}\n/**\n* Undo {@link wrapId}'s `/@id/` and null byte replacements.\n*/\nfunction unwrapId(id) {\n\treturn id.startsWith(VALID_ID_PREFIX) ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, \"\\0\") : id;\n}\nfunction withTrailingSlash(path) {\n\tif (path.at(-1) !== \"/\") {\n\t\treturn `${path}/`;\n\t}\n\treturn path;\n}\nfunction filterOutComments(s) {\n\tconst result = [];\n\tlet commentState = \"none\";\n\tfor (let i = 0; i < s.length; ++i) {\n\t\tif (commentState === \"singleline\") {\n\t\t\tif (s[i] === \"\\n\") {\n\t\t\t\tcommentState = \"none\";\n\t\t\t}\n\t\t} else if (commentState === \"multiline\") {\n\t\t\tif (s[i - 1] === \"*\" && s[i] === \"/\") {\n\t\t\t\tcommentState = \"none\";\n\t\t\t}\n\t\t} else if (commentState === \"none\") {\n\t\t\tif (s[i] === \"/\" && s[i + 1] === \"/\") {\n\t\t\t\tcommentState = \"singleline\";\n\t\t\t} else if (s[i] === \"/\" && s[i + 1] === \"*\") {\n\t\t\t\tcommentState = \"multiline\";\n\t\t\t\ti += 2;\n\t\t\t} else {\n\t\t\t\tresult.push(s[i]);\n\t\t\t}\n\t\t}\n\t}\n\treturn result.join(\"\");\n}\nconst bareImportRE = /^(?![a-z]:)[\\w@](?!.*:\\/\\/)/i;\nfunction isBareImport(id) {\n\treturn bareImportRE.test(id);\n}\nfunction toArray(array) {\n\tif (array === null || array === undefined) {\n\t\tarray = [];\n\t}\n\tif (Array.isArray(array)) {\n\t\treturn array;\n\t}\n\treturn [array];\n}\nfunction isObject(item) {\n\treturn item != null && typeof item === \"object\" && !Array.isArray(item);\n}\nfunction isFinalObj(obj) {\n\treturn obj === Object.prototype || obj === Function.prototype || obj === RegExp.prototype;\n}\nfunction getType(value) {\n\treturn Object.prototype.toString.apply(value).slice(8, -1);\n}\nfunction collectOwnProperties(obj, collector) {\n\tconst collect = typeof collector === \"function\" ? collector : (key) => collector.add(key);\n\tObject.getOwnPropertyNames(obj).forEach(collect);\n\tObject.getOwnPropertySymbols(obj).forEach(collect);\n}\nfunction getOwnProperties(obj) {\n\tconst ownProps = new Set();\n\tif (isFinalObj(obj)) {\n\t\treturn [];\n\t}\n\tcollectOwnProperties(obj, ownProps);\n\treturn Array.from(ownProps);\n}\nconst defaultCloneOptions = { forceWritable: false };\nfunction deepClone(val, options = defaultCloneOptions) {\n\tconst seen = new WeakMap();\n\treturn clone(val, seen, options);\n}\nfunction clone(val, seen, options = defaultCloneOptions) {\n\tlet k, out;\n\tif (seen.has(val)) {\n\t\treturn seen.get(val);\n\t}\n\tif (Array.isArray(val)) {\n\t\tout = Array.from({ length: k = val.length });\n\t\tseen.set(val, out);\n\t\twhile (k--) {\n\t\t\tout[k] = clone(val[k], seen, options);\n\t\t}\n\t\treturn out;\n\t}\n\tif (Object.prototype.toString.call(val) === \"[object Object]\") {\n\t\tout = Object.create(Object.getPrototypeOf(val));\n\t\tseen.set(val, out);\n\t\t// we don't need properties from prototype\n\t\tconst props = getOwnProperties(val);\n\t\tfor (const k of props) {\n\t\t\tconst descriptor = Object.getOwnPropertyDescriptor(val, k);\n\t\t\tif (!descriptor) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst cloned = clone(val[k], seen, options);\n\t\t\tif (options.forceWritable) {\n\t\t\t\tObject.defineProperty(out, k, {\n\t\t\t\t\tenumerable: descriptor.enumerable,\n\t\t\t\t\tconfigurable: true,\n\t\t\t\t\twritable: true,\n\t\t\t\t\tvalue: cloned\n\t\t\t\t});\n\t\t\t} else if (\"get\" in descriptor) {\n\t\t\t\tObject.defineProperty(out, k, {\n\t\t\t\t\t...descriptor,\n\t\t\t\t\tget() {\n\t\t\t\t\t\treturn cloned;\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\tObject.defineProperty(out, k, {\n\t\t\t\t\t...descriptor,\n\t\t\t\t\tvalue: cloned\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\treturn out;\n\t}\n\treturn val;\n}\nfunction noop() {}\nfunction objectAttr(source, path, defaultValue = undefined) {\n\t// a[3].b -> a.3.b\n\tconst paths = path.replace(/\\[(\\d+)\\]/g, \".$1\").split(\".\");\n\tlet result = source;\n\tfor (const p of paths) {\n\t\tresult = new Object(result)[p];\n\t\tif (result === undefined) {\n\t\t\treturn defaultValue;\n\t\t}\n\t}\n\treturn result;\n}\nfunction createDefer() {\n\tlet resolve = null;\n\tlet reject = null;\n\tconst p = new Promise((_resolve, _reject) => {\n\t\tresolve = _resolve;\n\t\treject = _reject;\n\t});\n\tp.resolve = resolve;\n\tp.reject = reject;\n\treturn p;\n}\n/**\n* If code starts with a function call, will return its last index, respecting arguments.\n* This will return 25 - last ending character of toMatch \")\"\n* Also works with callbacks\n* ```\n* toMatch({ test: '123' });\n* toBeAliased('123')\n* ```\n*/\nfunction getCallLastIndex(code) {\n\tlet charIndex = -1;\n\tlet inString = null;\n\tlet startedBracers = 0;\n\tlet endedBracers = 0;\n\tlet beforeChar = null;\n\twhile (charIndex <= code.length) {\n\t\tbeforeChar = code[charIndex];\n\t\tcharIndex++;\n\t\tconst char = code[charIndex];\n\t\tconst isCharString = char === \"\\\"\" || char === \"'\" || char === \"`\";\n\t\tif (isCharString && beforeChar !== \"\\\\\") {\n\t\t\tif (inString === char) {\n\t\t\t\tinString = null;\n\t\t\t} else if (!inString) {\n\t\t\t\tinString = char;\n\t\t\t}\n\t\t}\n\t\tif (!inString) {\n\t\t\tif (char === \"(\") {\n\t\t\t\tstartedBracers++;\n\t\t\t}\n\t\t\tif (char === \")\") {\n\t\t\t\tendedBracers++;\n\t\t\t}\n\t\t}\n\t\tif (startedBracers && endedBracers && startedBracers === endedBracers) {\n\t\t\treturn charIndex;\n\t\t}\n\t}\n\treturn null;\n}\nfunction isNegativeNaN(val) {\n\tif (!Number.isNaN(val)) {\n\t\treturn false;\n\t}\n\tconst f64 = new Float64Array(1);\n\tf64[0] = val;\n\tconst u32 = new Uint32Array(f64.buffer);\n\tconst isNegative = u32[1] >>> 31 === 1;\n\treturn isNegative;\n}\nfunction toString(v) {\n\treturn Object.prototype.toString.call(v);\n}\nfunction isPlainObject(val) {\n\treturn toString(val) === \"[object Object]\" && (!val.constructor || val.constructor.name === \"Object\");\n}\nfunction isMergeableObject(item) {\n\treturn isPlainObject(item) && !Array.isArray(item);\n}\nfunction ordinal(i) {\n\tconst j = i % 10;\n\tconst k = i % 100;\n\tif (j === 1 && k !== 11) {\n\t\treturn `${i}st`;\n\t}\n\tif (j === 2 && k !== 12) {\n\t\treturn `${i}nd`;\n\t}\n\tif (j === 3 && k !== 13) {\n\t\treturn `${i}rd`;\n\t}\n\treturn `${i}th`;\n}\n/**\n* Deep merge :P\n*\n* Will merge objects only if they are plain\n*\n* Do not merge types - it is very expensive and usually it's better to case a type here\n*/\nfunction deepMerge(target, ...sources) {\n\tif (!sources.length) {\n\t\treturn target;\n\t}\n\tconst source = sources.shift();\n\tif (source === undefined) {\n\t\treturn target;\n\t}\n\tif (isMergeableObject(target) && isMergeableObject(source)) {\n\t\tObject.keys(source).forEach((key) => {\n\t\t\tconst _source = source;\n\t\t\tif (isMergeableObject(_source[key])) {\n\t\t\t\tif (!target[key]) {\n\t\t\t\t\ttarget[key] = {};\n\t\t\t\t}\n\t\t\t\tdeepMerge(target[key], _source[key]);\n\t\t\t} else {\n\t\t\t\ttarget[key] = _source[key];\n\t\t\t}\n\t\t});\n\t}\n\treturn deepMerge(target, ...sources);\n}\nfunction unique(array) {\n\treturn Array.from(new Set(array));\n}\n\nexport { assertTypes, cleanUrl, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, filterOutComments, getCallLastIndex, getOwnProperties, getType, isBareImport, isExternalUrl, isNegativeNaN, isObject, isPrimitive, nanoid, noop, notNullish, objectAttr, ordinal, shuffle, slash, splitFileAndPostfix, toArray, unique, unwrapId, withTrailingSlash, wrapId };\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/bundle/dist/node_modules/.pnpm/@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/offset.js

@@ -0,0 +1,27 @@
+//#region ../../node_modules/.pnpm/@vitest+utils@4.1.10/node_modules/@vitest/utils/dist/offset.js
+const lineSplitRE = /\r?\n/;
+function positionToOffset(source, lineNumber, columnNumber) {
+	const lines = source.split(lineSplitRE);
+	const nl = /\r\n/.test(source) ? 2 : 1;
+	let start = 0;
+	if (lineNumber > lines.length) return source.length;
+	for (let i = 0; i < lineNumber - 1; i++) start += lines[i].length + nl;
+	return start + columnNumber;
+}
+function offsetToLineNumber(source, offset) {
+	if (offset > source.length) throw new Error(`offset is longer than source length! offset ${offset} > length ${source.length}`);
+	const lines = source.split(lineSplitRE);
+	const nl = /\r\n/.test(source) ? 2 : 1;
+	let counted = 0;
+	let line = 0;
+	for (; line < lines.length; line++) {
+		const lineLength = lines[line].length + nl;
+		if (counted + lineLength >= offset) break;
+		counted += lineLength;
+	}
+	return line + 1;
+}
+//#endregion
+export { lineSplitRE, offsetToLineNumber, positionToOffset };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/node_modules/.pnpm/@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/serialize.js

@@ -0,0 +1,77 @@
+//#region ../../node_modules/.pnpm/@vitest+utils@4.1.10/node_modules/@vitest/utils/dist/serialize.js
+const IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
+const IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";
+function isImmutable(v) {
+	return v && (v[IS_COLLECTION_SYMBOL] || v[IS_RECORD_SYMBOL]);
+}
+const OBJECT_PROTO = Object.getPrototypeOf({});
+function getUnserializableMessage(err) {
+	if (err instanceof Error) return `<unserializable>: ${err.message}`;
+	if (typeof err === "string") return `<unserializable>: ${err}`;
+	return "<unserializable>";
+}
+function serializeValue(val, seen = /* @__PURE__ */ new WeakMap()) {
+	if (!val || typeof val === "string") return val;
+	if (val instanceof Error && "toJSON" in val && typeof val.toJSON === "function") {
+		const jsonValue = val.toJSON();
+		if (jsonValue && jsonValue !== val && typeof jsonValue === "object") {
+			if (typeof val.message === "string") safe(() => jsonValue.message ??= normalizeErrorMessage(val.message));
+			if (typeof val.stack === "string") safe(() => jsonValue.stack ??= val.stack);
+			if (typeof val.name === "string") safe(() => jsonValue.name ??= val.name);
+			if (val.cause != null) safe(() => jsonValue.cause ??= serializeValue(val.cause, seen));
+		}
+		return serializeValue(jsonValue, seen);
+	}
+	if (typeof val === "function") return `Function<${val.name || "anonymous"}>`;
+	if (typeof val === "symbol") return val.toString();
+	if (typeof val !== "object") return val;
+	if (typeof Buffer !== "undefined" && val instanceof Buffer) return `<Buffer(${val.length}) ...>`;
+	if (typeof Uint8Array !== "undefined" && val instanceof Uint8Array) return `<Uint8Array(${val.length}) ...>`;
+	if (isImmutable(val)) return serializeValue(val.toJSON(), seen);
+	if (val instanceof Promise || val.constructor && val.constructor.prototype === "AsyncFunction") return "Promise";
+	if (typeof Element !== "undefined" && val instanceof Element) return val.tagName;
+	if (typeof val.toJSON === "function") return serializeValue(val.toJSON(), seen);
+	if (seen.has(val)) return seen.get(val);
+	if (Array.isArray(val)) {
+		const clone = new Array(val.length);
+		seen.set(val, clone);
+		val.forEach((e, i) => {
+			try {
+				clone[i] = serializeValue(e, seen);
+			} catch (err) {
+				clone[i] = getUnserializableMessage(err);
+			}
+		});
+		return clone;
+	} else {
+		const clone = Object.create(null);
+		seen.set(val, clone);
+		let obj = val;
+		while (obj && obj !== OBJECT_PROTO) {
+			Object.getOwnPropertyNames(obj).forEach((key) => {
+				if (key in clone) return;
+				try {
+					clone[key] = serializeValue(val[key], seen);
+				} catch (err) {
+					delete clone[key];
+					clone[key] = getUnserializableMessage(err);
+				}
+			});
+			obj = Object.getPrototypeOf(obj);
+		}
+		if (val instanceof Error) safe(() => clone.message = normalizeErrorMessage(val.message));
+		return clone;
+	}
+}
+function safe(fn) {
+	try {
+		return fn();
+	} catch {}
+}
+function normalizeErrorMessage(message) {
+	return message.replace(/\(0\s?,\s?__vite_ssr_import_\d+__.(\w+)\)/g, "$1").replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "").replace(/getByTestId('__vitest_\d+__')/g, "page");
+}
+//#endregion
+export { serializeValue };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"serialize.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/@vitest+utils@4.1.10/node_modules/@vitest/utils/dist/serialize.js"],"sourcesContent":["const IS_RECORD_SYMBOL = \"@@__IMMUTABLE_RECORD__@@\";\nconst IS_COLLECTION_SYMBOL = \"@@__IMMUTABLE_ITERABLE__@@\";\nfunction isImmutable(v) {\n\treturn v && (v[IS_COLLECTION_SYMBOL] || v[IS_RECORD_SYMBOL]);\n}\nconst OBJECT_PROTO = Object.getPrototypeOf({});\nfunction getUnserializableMessage(err) {\n\tif (err instanceof Error) {\n\t\treturn `<unserializable>: ${err.message}`;\n\t}\n\tif (typeof err === \"string\") {\n\t\treturn `<unserializable>: ${err}`;\n\t}\n\treturn \"<unserializable>\";\n}\n// https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm\nfunction serializeValue(val, seen = new WeakMap()) {\n\tif (!val || typeof val === \"string\") {\n\t\treturn val;\n\t}\n\tif (val instanceof Error && \"toJSON\" in val && typeof val.toJSON === \"function\") {\n\t\tconst jsonValue = val.toJSON();\n\t\tif (jsonValue && jsonValue !== val && typeof jsonValue === \"object\") {\n\t\t\tif (typeof val.message === \"string\") {\n\t\t\t\tsafe(() => jsonValue.message ??= normalizeErrorMessage(val.message));\n\t\t\t}\n\t\t\tif (typeof val.stack === \"string\") {\n\t\t\t\tsafe(() => jsonValue.stack ??= val.stack);\n\t\t\t}\n\t\t\tif (typeof val.name === \"string\") {\n\t\t\t\tsafe(() => jsonValue.name ??= val.name);\n\t\t\t}\n\t\t\tif (val.cause != null) {\n\t\t\t\tsafe(() => jsonValue.cause ??= serializeValue(val.cause, seen));\n\t\t\t}\n\t\t}\n\t\treturn serializeValue(jsonValue, seen);\n\t}\n\tif (typeof val === \"function\") {\n\t\treturn `Function<${val.name || \"anonymous\"}>`;\n\t}\n\tif (typeof val === \"symbol\") {\n\t\treturn val.toString();\n\t}\n\tif (typeof val !== \"object\") {\n\t\treturn val;\n\t}\n\tif (typeof Buffer !== \"undefined\" && val instanceof Buffer) {\n\t\treturn `<Buffer(${val.length}) ...>`;\n\t}\n\tif (typeof Uint8Array !== \"undefined\" && val instanceof Uint8Array) {\n\t\treturn `<Uint8Array(${val.length}) ...>`;\n\t}\n\t// cannot serialize immutables as immutables\n\tif (isImmutable(val)) {\n\t\treturn serializeValue(val.toJSON(), seen);\n\t}\n\tif (val instanceof Promise || val.constructor && val.constructor.prototype === \"AsyncFunction\") {\n\t\treturn \"Promise\";\n\t}\n\tif (typeof Element !== \"undefined\" && val instanceof Element) {\n\t\treturn val.tagName;\n\t}\n\tif (typeof val.toJSON === \"function\") {\n\t\treturn serializeValue(val.toJSON(), seen);\n\t}\n\tif (seen.has(val)) {\n\t\treturn seen.get(val);\n\t}\n\tif (Array.isArray(val)) {\n\t\t// eslint-disable-next-line unicorn/no-new-array -- we need to keep sparse arrays ([1,,3])\n\t\tconst clone = new Array(val.length);\n\t\tseen.set(val, clone);\n\t\tval.forEach((e, i) => {\n\t\t\ttry {\n\t\t\t\tclone[i] = serializeValue(e, seen);\n\t\t\t} catch (err) {\n\t\t\t\tclone[i] = getUnserializableMessage(err);\n\t\t\t}\n\t\t});\n\t\treturn clone;\n\t} else {\n\t\t// Objects with `Error` constructors appear to cause problems during worker communication\n\t\t// using `MessagePort`, so the serialized error object is being recreated as plain object.\n\t\tconst clone = Object.create(null);\n\t\tseen.set(val, clone);\n\t\tlet obj = val;\n\t\twhile (obj && obj !== OBJECT_PROTO) {\n\t\t\tObject.getOwnPropertyNames(obj).forEach((key) => {\n\t\t\t\tif (key in clone) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\ttry {\n\t\t\t\t\tclone[key] = serializeValue(val[key], seen);\n\t\t\t\t} catch (err) {\n\t\t\t\t\t// delete in case it has a setter from prototype that might throw\n\t\t\t\t\tdelete clone[key];\n\t\t\t\t\tclone[key] = getUnserializableMessage(err);\n\t\t\t\t}\n\t\t\t});\n\t\t\tobj = Object.getPrototypeOf(obj);\n\t\t}\n\t\tif (val instanceof Error) {\n\t\t\tsafe(() => clone.message = normalizeErrorMessage(val.message));\n\t\t}\n\t\treturn clone;\n\t}\n}\nfunction safe(fn) {\n\ttry {\n\t\treturn fn();\n\t} catch {}\n}\nfunction normalizeErrorMessage(message) {\n\treturn message.replace(/\\(0\\s?,\\s?__vite_ssr_import_\\d+__.(\\w+)\\)/g, \"$1\").replace(/__(vite_ssr_import|vi_import)_\\d+__\\./g, \"\").replace(/getByTestId('__vitest_\\d+__')/g, \"page\");\n}\n\nexport { serializeValue };\n"],"x_google_ignoreList":[0],"mappings":"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"}