@cartanova/qgrid-cli 0.1.1 → 1.0.0

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

@@ -0,0 +1,33 @@
+import "../../../../../tinyrainbow@3.1.0/node_modules/tinyrainbow/dist/index.js";
+import "../../../../../@vitest_pretty-format@4.1.2/node_modules/@vitest/pretty-format/dist/index.js";
+import { stringify } from "./display.js";
+import "./constants.js";
+import "./helpers.js";
+import { printDiffOrStringify } from "./diff.js";
+import { serializeValue } from "./serialize.js";
+//#region ../../node_modules/.pnpm/@vitest+utils@4.1.2/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) err.diff = printDiffOrStringify(err.actual, err.expected, {
+		...diffOptions,
+		...err.diffOptions
+	});
+	if ("expected" in err && typeof err.expected !== "string") err.expected = stringify(err.expected, 10);
+	if ("actual" in err && typeof err.actual !== "string") err.actual = stringify(err.actual, 10);
+	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}`));
+	}
+}
+//#endregion
+export { processError };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,226 @@
+import "./constants.js";
+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 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("");
+}
+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 = 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, createDefer, createSimpleStackTrace, deepClone, filterOutComments, getCallLastIndex, getOwnProperties, getType, isNegativeNaN, isObject, isPrimitive, noop, notNullish, objectAttr, ordinal, shuffle, toArray, unique };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"helpers.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/@vitest+utils@4.1.2/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}\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, 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.2/node_modules/@vitest/utils/dist/offset.js

@@ -0,0 +1,27 @@
+//#region ../../node_modules/.pnpm/@vitest+utils@4.1.2/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.2/node_modules/@vitest/utils/dist/serialize.js

@@ -0,0 +1,77 @@
+//#region ../../node_modules/.pnpm/@vitest+utils@4.1.2/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.2/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":";AAAA,MAAM,mBAAmB;AACzB,MAAM,uBAAuB;AAC7B,SAAS,YAAY,GAAG;AACvB,QAAO,MAAM,EAAE,yBAAyB,EAAE;;AAE3C,MAAM,eAAe,OAAO,eAAe,EAAE,CAAC;AAC9C,SAAS,yBAAyB,KAAK;AACtC,KAAI,eAAe,MAClB,QAAO,qBAAqB,IAAI;AAEjC,KAAI,OAAO,QAAQ,SAClB,QAAO,qBAAqB;AAE7B,QAAO;;AAGR,SAAS,eAAe,KAAK,uBAAO,IAAI,SAAS,EAAE;AAClD,KAAI,CAAC,OAAO,OAAO,QAAQ,SAC1B,QAAO;AAER,KAAI,eAAe,SAAS,YAAY,OAAO,OAAO,IAAI,WAAW,YAAY;EAChF,MAAM,YAAY,IAAI,QAAQ;AAC9B,MAAI,aAAa,cAAc,OAAO,OAAO,cAAc,UAAU;AACpE,OAAI,OAAO,IAAI,YAAY,SAC1B,YAAW,UAAU,YAAY,sBAAsB,IAAI,QAAQ,CAAC;AAErE,OAAI,OAAO,IAAI,UAAU,SACxB,YAAW,UAAU,UAAU,IAAI,MAAM;AAE1C,OAAI,OAAO,IAAI,SAAS,SACvB,YAAW,UAAU,SAAS,IAAI,KAAK;AAExC,OAAI,IAAI,SAAS,KAChB,YAAW,UAAU,UAAU,eAAe,IAAI,OAAO,KAAK,CAAC;;AAGjE,SAAO,eAAe,WAAW,KAAK;;AAEvC,KAAI,OAAO,QAAQ,WAClB,QAAO,YAAY,IAAI,QAAQ,YAAY;AAE5C,KAAI,OAAO,QAAQ,SAClB,QAAO,IAAI,UAAU;AAEtB,KAAI,OAAO,QAAQ,SAClB,QAAO;AAER,KAAI,OAAO,WAAW,eAAe,eAAe,OACnD,QAAO,WAAW,IAAI,OAAO;AAE9B,KAAI,OAAO,eAAe,eAAe,eAAe,WACvD,QAAO,eAAe,IAAI,OAAO;AAGlC,KAAI,YAAY,IAAI,CACnB,QAAO,eAAe,IAAI,QAAQ,EAAE,KAAK;AAE1C,KAAI,eAAe,WAAW,IAAI,eAAe,IAAI,YAAY,cAAc,gBAC9E,QAAO;AAER,KAAI,OAAO,YAAY,eAAe,eAAe,QACpD,QAAO,IAAI;AAEZ,KAAI,OAAO,IAAI,WAAW,WACzB,QAAO,eAAe,IAAI,QAAQ,EAAE,KAAK;AAE1C,KAAI,KAAK,IAAI,IAAI,CAChB,QAAO,KAAK,IAAI,IAAI;AAErB,KAAI,MAAM,QAAQ,IAAI,EAAE;EAEvB,MAAM,QAAQ,IAAI,MAAM,IAAI,OAAO;AACnC,OAAK,IAAI,KAAK,MAAM;AACpB,MAAI,SAAS,GAAG,MAAM;AACrB,OAAI;AACH,UAAM,KAAK,eAAe,GAAG,KAAK;YAC1B,KAAK;AACb,UAAM,KAAK,yBAAyB,IAAI;;IAExC;AACF,SAAO;QACD;EAGN,MAAM,QAAQ,OAAO,OAAO,KAAK;AACjC,OAAK,IAAI,KAAK,MAAM;EACpB,IAAI,MAAM;AACV,SAAO,OAAO,QAAQ,cAAc;AACnC,UAAO,oBAAoB,IAAI,CAAC,SAAS,QAAQ;AAChD,QAAI,OAAO,MACV;AAED,QAAI;AACH,WAAM,OAAO,eAAe,IAAI,MAAM,KAAK;aACnC,KAAK;AAEb,YAAO,MAAM;AACb,WAAM,OAAO,yBAAyB,IAAI;;KAE1C;AACF,SAAM,OAAO,eAAe,IAAI;;AAEjC,MAAI,eAAe,MAClB,YAAW,MAAM,UAAU,sBAAsB,IAAI,QAAQ,CAAC;AAE/D,SAAO;;;AAGT,SAAS,KAAK,IAAI;AACjB,KAAI;AACH,SAAO,IAAI;SACJ;;AAET,SAAS,sBAAsB,SAAS;AACvC,QAAO,QAAQ,QAAQ,8CAA8C,KAAK,CAAC,QAAQ,0CAA0C,GAAG,CAAC,QAAQ,kCAAkC,OAAO"}