@cartanova/qgrid-cli 1.0.1 → 1.0.3

package/bundle/dist/dist/node_modules/.pnpm/@vitest_spy@4.1.2/node_modules/@vitest/spy/dist/index.js

@@ -0,0 +1,386 @@
+//#region ../../node_modules/.pnpm/@vitest+spy@4.1.2/node_modules/@vitest/spy/dist/index.js
+function isMockFunction(fn) {
+	return typeof fn === "function" && "_isMockFunction" in fn && fn._isMockFunction === true;
+}
+const MOCK_RESTORE = /* @__PURE__ */ new Set();
+const REGISTERED_MOCKS = /* @__PURE__ */ new Set();
+const MOCK_CONFIGS = /* @__PURE__ */ new WeakMap();
+function createMockInstance(options = {}) {
+	const { originalImplementation, restore, mockImplementation, resetToMockImplementation, resetToMockName } = options;
+	if (restore) MOCK_RESTORE.add(restore);
+	const config = getDefaultConfig(originalImplementation);
+	const state = getDefaultState();
+	const mock = createMock({
+		config,
+		state,
+		...options
+	});
+	const mockLength = (mockImplementation || originalImplementation)?.length ?? 0;
+	Object.defineProperty(mock, "length", {
+		writable: true,
+		enumerable: false,
+		value: mockLength,
+		configurable: true
+	});
+	if (resetToMockName) config.mockName = mock.name || "vi.fn()";
+	MOCK_CONFIGS.set(mock, config);
+	REGISTERED_MOCKS.add(mock);
+	mock._isMockFunction = true;
+	mock.getMockImplementation = () => {
+		return config.onceMockImplementations[0] || config.mockImplementation;
+	};
+	Object.defineProperty(mock, "mock", {
+		configurable: false,
+		enumerable: true,
+		writable: false,
+		value: state
+	});
+	mock.mockImplementation = function mockImplementation(implementation) {
+		config.mockImplementation = implementation;
+		return mock;
+	};
+	mock.mockImplementationOnce = function mockImplementationOnce(implementation) {
+		config.onceMockImplementations.push(implementation);
+		return mock;
+	};
+	mock.withImplementation = function withImplementation(implementation, callback) {
+		const previousImplementation = config.mockImplementation;
+		const previousOnceImplementations = config.onceMockImplementations;
+		const reset = () => {
+			config.mockImplementation = previousImplementation;
+			config.onceMockImplementations = previousOnceImplementations;
+		};
+		config.mockImplementation = implementation;
+		config.onceMockImplementations = [];
+		const returnValue = callback();
+		if (typeof returnValue === "object" && typeof returnValue?.then === "function") return returnValue.then(() => {
+			reset();
+			return mock;
+		});
+		else reset();
+		return mock;
+	};
+	mock.mockReturnThis = function mockReturnThis() {
+		return mock.mockImplementation(function() {
+			return this;
+		});
+	};
+	mock.mockReturnValue = function mockReturnValue(value) {
+		return mock.mockImplementation(function() {
+			if (new.target) throwConstructorError("mockReturnValue");
+			return value;
+		});
+	};
+	mock.mockReturnValueOnce = function mockReturnValueOnce(value) {
+		return mock.mockImplementationOnce(function() {
+			if (new.target) throwConstructorError("mockReturnValueOnce");
+			return value;
+		});
+	};
+	mock.mockThrow = function mockThrow(value) {
+		return mock.mockImplementation(function() {
+			throw value;
+		});
+	};
+	mock.mockThrowOnce = function mockThrowOnce(value) {
+		return mock.mockImplementationOnce(function() {
+			throw value;
+		});
+	};
+	mock.mockResolvedValue = function mockResolvedValue(value) {
+		return mock.mockImplementation(function() {
+			if (new.target) throwConstructorError("mockResolvedValue");
+			return Promise.resolve(value);
+		});
+	};
+	mock.mockResolvedValueOnce = function mockResolvedValueOnce(value) {
+		return mock.mockImplementationOnce(function() {
+			if (new.target) throwConstructorError("mockResolvedValueOnce");
+			return Promise.resolve(value);
+		});
+	};
+	mock.mockRejectedValue = function mockRejectedValue(value) {
+		return mock.mockImplementation(function() {
+			if (new.target) throwConstructorError("mockRejectedValue");
+			return Promise.reject(value);
+		});
+	};
+	mock.mockRejectedValueOnce = function mockRejectedValueOnce(value) {
+		return mock.mockImplementationOnce(function() {
+			if (new.target) throwConstructorError("mockRejectedValueOnce");
+			return Promise.reject(value);
+		});
+	};
+	mock.mockClear = function mockClear() {
+		state.calls = [];
+		state.contexts = [];
+		state.instances = [];
+		state.invocationCallOrder = [];
+		state.results = [];
+		state.settledResults = [];
+		return mock;
+	};
+	mock.mockReset = function mockReset() {
+		mock.mockClear();
+		config.mockImplementation = resetToMockImplementation ? mockImplementation : void 0;
+		config.mockName = resetToMockName ? mock.name || "vi.fn()" : "vi.fn()";
+		config.onceMockImplementations = [];
+		return mock;
+	};
+	mock.mockRestore = function mockRestore() {
+		mock.mockReset();
+		return restore?.();
+	};
+	mock.mockName = function mockName(name) {
+		if (typeof name === "string") config.mockName = name;
+		return mock;
+	};
+	mock.getMockName = function getMockName() {
+		return config.mockName || "vi.fn()";
+	};
+	if (Symbol.dispose) mock[Symbol.dispose] = () => mock.mockRestore();
+	if (mockImplementation) mock.mockImplementation(mockImplementation);
+	return mock;
+}
+function fn(originalImplementation) {
+	if (originalImplementation != null && isMockFunction(originalImplementation)) return originalImplementation;
+	return createMockInstance({
+		mockImplementation: originalImplementation,
+		resetToMockImplementation: true
+	});
+}
+function spyOn(object, key, accessor) {
+	assert(object != null, "The vi.spyOn() function could not find an object to spy upon. The first argument must be defined.");
+	assert(typeof object === "object" || typeof object === "function", "Vitest cannot spy on a primitive value.");
+	const [originalDescriptorObject, originalDescriptor] = getDescriptor(object, key) || [];
+	assert(originalDescriptor || key in object, `The property "${String(key)}" is not defined on the ${typeof object}.`);
+	let accessType = accessor || "value";
+	let ssr = false;
+	if (accessType === "value" && originalDescriptor && originalDescriptor.value == null && originalDescriptor.get) {
+		accessType = "get";
+		ssr = true;
+	}
+	let original;
+	if (originalDescriptor) {
+		original = originalDescriptor[accessType];
+		if (original == null && accessType === "value") original = object[key];
+	} else if (accessType !== "value") original = () => object[key];
+	else original = object[key];
+	const originalImplementation = ssr && original ? original() : original;
+	const originalType = typeof originalImplementation;
+	assert(originalType === "function" || accessType !== "value" && original == null, `vi.spyOn() can only spy on a function. Received ${originalType}.`);
+	if (isMockFunction(originalImplementation)) return originalImplementation;
+	const reassign = (cb) => {
+		const { value, ...desc } = originalDescriptor || {
+			configurable: true,
+			writable: true
+		};
+		if (accessType !== "value") delete desc.writable;
+		desc[accessType] = cb;
+		Object.defineProperty(object, key, desc);
+	};
+	const restore = () => {
+		if (originalDescriptorObject !== object) Reflect.deleteProperty(object, key);
+		else if (originalDescriptor && !original) Object.defineProperty(object, key, originalDescriptor);
+		else reassign(original);
+	};
+	const mock = createMockInstance({
+		restore,
+		originalImplementation,
+		resetToMockName: true
+	});
+	try {
+		reassign(ssr ? () => mock : mock);
+	} catch (error) {
+		if (error instanceof TypeError && Symbol.toStringTag && object[Symbol.toStringTag] === "Module" && (error.message.includes("Cannot redefine property") || error.message.includes("Cannot replace module namespace") || error.message.includes("can't redefine non-configurable property"))) throw new TypeError(`Cannot spy on export "${String(key)}". Module namespace is not configurable in ESM. See: https://vitest.dev/guide/browser/#limitations`, { cause: error });
+		throw error;
+	}
+	return mock;
+}
+function getDescriptor(obj, method) {
+	const objDescriptor = Object.getOwnPropertyDescriptor(obj, method);
+	if (objDescriptor) return [obj, objDescriptor];
+	let currentProto = Object.getPrototypeOf(obj);
+	while (currentProto !== null) {
+		const descriptor = Object.getOwnPropertyDescriptor(currentProto, method);
+		if (descriptor) return [currentProto, descriptor];
+		currentProto = Object.getPrototypeOf(currentProto);
+	}
+}
+function assert(condition, message) {
+	if (!condition) throw new Error(message);
+}
+let invocationCallCounter = 1;
+function createMock({ state, config, name: mockName, prototypeState, prototypeConfig, keepMembersImplementation, mockImplementation, prototypeMembers = [] }) {
+	const original = config.mockOriginal;
+	const pseudoOriginal = mockImplementation;
+	const name = mockName || original?.name || "Mock";
+	const namedObject = { [name]: (function(...args) {
+		registerCalls(args, state, prototypeState);
+		registerInvocationOrder(invocationCallCounter++, state, prototypeState);
+		const result = {
+			type: "incomplete",
+			value: void 0
+		};
+		const settledResult = {
+			type: "incomplete",
+			value: void 0
+		};
+		registerResult(result, state, prototypeState);
+		registerSettledResult(settledResult, state, prototypeState);
+		const context = new.target ? void 0 : this;
+		const [instanceIndex, instancePrototypeIndex] = registerInstance(context, state, prototypeState);
+		const [contextIndex, contextPrototypeIndex] = registerContext(context, state, prototypeState);
+		const implementation = config.onceMockImplementations.shift() || config.mockImplementation || prototypeConfig?.onceMockImplementations.shift() || prototypeConfig?.mockImplementation || original || function() {};
+		let returnValue;
+		let thrownValue;
+		let didThrow = false;
+		try {
+			if (new.target) {
+				returnValue = Reflect.construct(implementation, args, new.target);
+				for (const prop of prototypeMembers) {
+					const prototypeMock = returnValue[prop];
+					if (prototypeMock !== mock.prototype[prop]) continue;
+					const isMock = isMockFunction(prototypeMock);
+					const prototypeState = isMock ? prototypeMock.mock : void 0;
+					const prototypeConfig = isMock ? MOCK_CONFIGS.get(prototypeMock) : void 0;
+					returnValue[prop] = createMockInstance({
+						originalImplementation: keepMembersImplementation ? prototypeConfig?.mockOriginal : void 0,
+						prototypeState,
+						prototypeConfig,
+						keepMembersImplementation
+					});
+				}
+			} else returnValue = implementation.apply(this, args);
+		} catch (error) {
+			thrownValue = error;
+			didThrow = true;
+			if (error instanceof TypeError && error.message.includes("is not a constructor")) console.warn(`[vitest] The ${namedObject[name].getMockName()} mock did not use 'function' or 'class' in its implementation, see https://vitest.dev/api/vi#vi-spyon for examples.`);
+			throw error;
+		} finally {
+			if (didThrow) {
+				result.type = "throw";
+				result.value = thrownValue;
+				settledResult.type = "rejected";
+				settledResult.value = thrownValue;
+			} else {
+				result.type = "return";
+				result.value = returnValue;
+				if (new.target) {
+					state.contexts[contextIndex - 1] = returnValue;
+					state.instances[instanceIndex - 1] = returnValue;
+					if (contextPrototypeIndex != null && prototypeState) prototypeState.contexts[contextPrototypeIndex - 1] = returnValue;
+					if (instancePrototypeIndex != null && prototypeState) prototypeState.instances[instancePrototypeIndex - 1] = returnValue;
+				}
+				if (returnValue instanceof Promise) returnValue.then((settledValue) => {
+					settledResult.type = "fulfilled";
+					settledResult.value = settledValue;
+				}, (rejectedValue) => {
+					settledResult.type = "rejected";
+					settledResult.value = rejectedValue;
+				});
+				else {
+					settledResult.type = "fulfilled";
+					settledResult.value = returnValue;
+				}
+			}
+		}
+		return returnValue;
+	}) };
+	const mock = namedObject[name];
+	const copyPropertiesFrom = original || pseudoOriginal;
+	if (copyPropertiesFrom) copyOriginalStaticProperties(mock, copyPropertiesFrom);
+	return mock;
+}
+function registerCalls(args, state, prototypeState) {
+	state.calls.push(args);
+	prototypeState?.calls.push(args);
+}
+function registerInvocationOrder(order, state, prototypeState) {
+	state.invocationCallOrder.push(order);
+	prototypeState?.invocationCallOrder.push(order);
+}
+function registerResult(result, state, prototypeState) {
+	state.results.push(result);
+	prototypeState?.results.push(result);
+}
+function registerSettledResult(result, state, prototypeState) {
+	state.settledResults.push(result);
+	prototypeState?.settledResults.push(result);
+}
+function registerInstance(instance, state, prototypeState) {
+	return [state.instances.push(instance), prototypeState?.instances.push(instance)];
+}
+function registerContext(context, state, prototypeState) {
+	return [state.contexts.push(context), prototypeState?.contexts.push(context)];
+}
+function copyOriginalStaticProperties(mock, original) {
+	const { properties, descriptors } = getAllProperties(original);
+	for (const key of properties) {
+		const descriptor = descriptors[key];
+		if (getDescriptor(mock, key)) continue;
+		Object.defineProperty(mock, key, descriptor);
+	}
+}
+const ignoreProperties = new Set([
+	"length",
+	"name",
+	"prototype",
+	Symbol.for("nodejs.util.promisify.custom")
+]);
+function getAllProperties(original) {
+	const properties = /* @__PURE__ */ new Set();
+	const descriptors = {};
+	while (original && original !== Object.prototype && original !== Function.prototype) {
+		const ownProperties = [...Object.getOwnPropertyNames(original), ...Object.getOwnPropertySymbols(original)];
+		for (const prop of ownProperties) {
+			if (descriptors[prop] || ignoreProperties.has(prop)) continue;
+			properties.add(prop);
+			descriptors[prop] = Object.getOwnPropertyDescriptor(original, prop);
+		}
+		original = Object.getPrototypeOf(original);
+	}
+	return {
+		properties,
+		descriptors
+	};
+}
+function getDefaultConfig(original) {
+	return {
+		mockImplementation: void 0,
+		mockOriginal: original,
+		mockName: "vi.fn()",
+		onceMockImplementations: []
+	};
+}
+function getDefaultState() {
+	const state = {
+		calls: [],
+		contexts: [],
+		instances: [],
+		invocationCallOrder: [],
+		settledResults: [],
+		results: [],
+		get lastCall() {
+			return state.calls.at(-1);
+		}
+	};
+	return state;
+}
+function restoreAllMocks() {
+	for (const restore of MOCK_RESTORE) restore();
+	MOCK_RESTORE.clear();
+}
+function clearAllMocks() {
+	REGISTERED_MOCKS.forEach((mock) => mock.mockClear());
+}
+function resetAllMocks() {
+	REGISTERED_MOCKS.forEach((mock) => mock.mockReset());
+}
+function throwConstructorError(shorthand) {
+	throw new TypeError(`Cannot use \`${shorthand}\` when called with \`new\`. Use \`mockImplementation\` with a \`class\` keyword instead. See https://vitest.dev/api/mock#class-support for more information.`);
+}
+//#endregion
+export { clearAllMocks, fn, isMockFunction, resetAllMocks, restoreAllMocks, spyOn };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/@vitest+spy@4.1.2/node_modules/@vitest/spy/dist/index.js"],"sourcesContent":["function isMockFunction(fn) {\n\treturn typeof fn === \"function\" && \"_isMockFunction\" in fn && fn._isMockFunction === true;\n}\nconst MOCK_RESTORE = new Set();\n// Jest keeps the state in a separate WeakMap which is good for memory,\n// but it makes the state slower to access and return different values\n// if you stored it before calling `mockClear` where it will be recreated\nconst REGISTERED_MOCKS = new Set();\nconst MOCK_CONFIGS = new WeakMap();\nfunction createMockInstance(options = {}) {\n\tconst { originalImplementation, restore, mockImplementation, resetToMockImplementation, resetToMockName } = options;\n\tif (restore) {\n\t\tMOCK_RESTORE.add(restore);\n\t}\n\tconst config = getDefaultConfig(originalImplementation);\n\tconst state = getDefaultState();\n\tconst mock = createMock({\n\t\tconfig,\n\t\tstate,\n\t\t...options\n\t});\n\tconst mockLength = (mockImplementation || originalImplementation)?.length ?? 0;\n\tObject.defineProperty(mock, \"length\", {\n\t\twritable: true,\n\t\tenumerable: false,\n\t\tvalue: mockLength,\n\t\tconfigurable: true\n\t});\n\t// inherit the default name so it appears in snapshots and logs\n\t// this is used by `vi.spyOn()` for better debugging.\n\t// when `vi.fn()` is called, we just use the default string\n\tif (resetToMockName) {\n\t\tconfig.mockName = mock.name || \"vi.fn()\";\n\t}\n\tMOCK_CONFIGS.set(mock, config);\n\tREGISTERED_MOCKS.add(mock);\n\tmock._isMockFunction = true;\n\tmock.getMockImplementation = () => {\n\t\t// Jest only returns `config.mockImplementation` here,\n\t\t// but we think it makes sense to return what the next function will be called\n\t\treturn config.onceMockImplementations[0] || config.mockImplementation;\n\t};\n\tObject.defineProperty(mock, \"mock\", {\n\t\tconfigurable: false,\n\t\tenumerable: true,\n\t\twritable: false,\n\t\tvalue: state\n\t});\n\tmock.mockImplementation = function mockImplementation(implementation) {\n\t\tconfig.mockImplementation = implementation;\n\t\treturn mock;\n\t};\n\tmock.mockImplementationOnce = function mockImplementationOnce(implementation) {\n\t\tconfig.onceMockImplementations.push(implementation);\n\t\treturn mock;\n\t};\n\tmock.withImplementation = function withImplementation(implementation, callback) {\n\t\tconst previousImplementation = config.mockImplementation;\n\t\tconst previousOnceImplementations = config.onceMockImplementations;\n\t\tconst reset = () => {\n\t\t\tconfig.mockImplementation = previousImplementation;\n\t\t\tconfig.onceMockImplementations = previousOnceImplementations;\n\t\t};\n\t\tconfig.mockImplementation = implementation;\n\t\tconfig.onceMockImplementations = [];\n\t\tconst returnValue = callback();\n\t\tif (typeof returnValue === \"object\" && typeof returnValue?.then === \"function\") {\n\t\t\treturn returnValue.then(() => {\n\t\t\t\treset();\n\t\t\t\treturn mock;\n\t\t\t});\n\t\t} else {\n\t\t\treset();\n\t\t}\n\t\treturn mock;\n\t};\n\tmock.mockReturnThis = function mockReturnThis() {\n\t\treturn mock.mockImplementation(function() {\n\t\t\treturn this;\n\t\t});\n\t};\n\tmock.mockReturnValue = function mockReturnValue(value) {\n\t\treturn mock.mockImplementation(function() {\n\t\t\tif (new.target) {\n\t\t\t\tthrowConstructorError(\"mockReturnValue\");\n\t\t\t}\n\t\t\treturn value;\n\t\t});\n\t};\n\tmock.mockReturnValueOnce = function mockReturnValueOnce(value) {\n\t\treturn mock.mockImplementationOnce(function() {\n\t\t\tif (new.target) {\n\t\t\t\tthrowConstructorError(\"mockReturnValueOnce\");\n\t\t\t}\n\t\t\treturn value;\n\t\t});\n\t};\n\tmock.mockThrow = function mockThrow(value) {\n\t\t// eslint-disable-next-line prefer-arrow-callback\n\t\treturn mock.mockImplementation(function() {\n\t\t\tthrow value;\n\t\t});\n\t};\n\tmock.mockThrowOnce = function mockThrowOnce(value) {\n\t\t// eslint-disable-next-line prefer-arrow-callback\n\t\treturn mock.mockImplementationOnce(function() {\n\t\t\tthrow value;\n\t\t});\n\t};\n\tmock.mockResolvedValue = function mockResolvedValue(value) {\n\t\treturn mock.mockImplementation(function() {\n\t\t\tif (new.target) {\n\t\t\t\tthrowConstructorError(\"mockResolvedValue\");\n\t\t\t}\n\t\t\treturn Promise.resolve(value);\n\t\t});\n\t};\n\tmock.mockResolvedValueOnce = function mockResolvedValueOnce(value) {\n\t\treturn mock.mockImplementationOnce(function() {\n\t\t\tif (new.target) {\n\t\t\t\tthrowConstructorError(\"mockResolvedValueOnce\");\n\t\t\t}\n\t\t\treturn Promise.resolve(value);\n\t\t});\n\t};\n\tmock.mockRejectedValue = function mockRejectedValue(value) {\n\t\treturn mock.mockImplementation(function() {\n\t\t\tif (new.target) {\n\t\t\t\tthrowConstructorError(\"mockRejectedValue\");\n\t\t\t}\n\t\t\treturn Promise.reject(value);\n\t\t});\n\t};\n\tmock.mockRejectedValueOnce = function mockRejectedValueOnce(value) {\n\t\treturn mock.mockImplementationOnce(function() {\n\t\t\tif (new.target) {\n\t\t\t\tthrowConstructorError(\"mockRejectedValueOnce\");\n\t\t\t}\n\t\t\treturn Promise.reject(value);\n\t\t});\n\t};\n\tmock.mockClear = function mockClear() {\n\t\tstate.calls = [];\n\t\tstate.contexts = [];\n\t\tstate.instances = [];\n\t\tstate.invocationCallOrder = [];\n\t\tstate.results = [];\n\t\tstate.settledResults = [];\n\t\treturn mock;\n\t};\n\tmock.mockReset = function mockReset() {\n\t\tmock.mockClear();\n\t\tconfig.mockImplementation = resetToMockImplementation ? mockImplementation : undefined;\n\t\tconfig.mockName = resetToMockName ? mock.name || \"vi.fn()\" : \"vi.fn()\";\n\t\tconfig.onceMockImplementations = [];\n\t\treturn mock;\n\t};\n\tmock.mockRestore = function mockRestore() {\n\t\tmock.mockReset();\n\t\treturn restore?.();\n\t};\n\tmock.mockName = function mockName(name) {\n\t\tif (typeof name === \"string\") {\n\t\t\tconfig.mockName = name;\n\t\t}\n\t\treturn mock;\n\t};\n\tmock.getMockName = function getMockName() {\n\t\treturn config.mockName || \"vi.fn()\";\n\t};\n\tif (Symbol.dispose) {\n\t\tmock[Symbol.dispose] = () => mock.mockRestore();\n\t}\n\tif (mockImplementation) {\n\t\tmock.mockImplementation(mockImplementation);\n\t}\n\treturn mock;\n}\nfunction fn(originalImplementation) {\n\t// if the function is already a mock, just return the same function,\n\t// similarly to how vi.spyOn() works\n\tif (originalImplementation != null && isMockFunction(originalImplementation)) {\n\t\treturn originalImplementation;\n\t}\n\treturn createMockInstance({\n\t\tmockImplementation: originalImplementation,\n\t\tresetToMockImplementation: true\n\t});\n}\nfunction spyOn(object, key, accessor) {\n\tassert(object != null, \"The vi.spyOn() function could not find an object to spy upon. The first argument must be defined.\");\n\tassert(typeof object === \"object\" || typeof object === \"function\", \"Vitest cannot spy on a primitive value.\");\n\tconst [originalDescriptorObject, originalDescriptor] = getDescriptor(object, key) || [];\n\tassert(originalDescriptor || key in object, `The property \"${String(key)}\" is not defined on the ${typeof object}.`);\n\tlet accessType = accessor || \"value\";\n\tlet ssr = false;\n\t// vite ssr support - actual function is stored inside a getter\n\tif (accessType === \"value\" && originalDescriptor && originalDescriptor.value == null && originalDescriptor.get) {\n\t\taccessType = \"get\";\n\t\tssr = true;\n\t}\n\tlet original;\n\tif (originalDescriptor) {\n\t\toriginal = originalDescriptor[accessType];\n\t\t// weird Proxy edge case where descriptor's value is undefined,\n\t\t// but there's still a value on the object when called\n\t\t// https://github.com/vitest-dev/vitest/issues/9439\n\t\tif (original == null && accessType === \"value\") {\n\t\t\toriginal = object[key];\n\t\t}\n\t} else if (accessType !== \"value\") {\n\t\toriginal = () => object[key];\n\t} else {\n\t\toriginal = object[key];\n\t}\n\tconst originalImplementation = ssr && original ? original() : original;\n\tconst originalType = typeof originalImplementation;\n\tassert(\n\t\t// allow only functions\n\t\toriginalType === \"function\" || accessType !== \"value\" && original == null,\n\t\t`vi.spyOn() can only spy on a function. Received ${originalType}.`\n\t);\n\tif (isMockFunction(originalImplementation)) {\n\t\treturn originalImplementation;\n\t}\n\tconst reassign = (cb) => {\n\t\tconst { value, ...desc } = originalDescriptor || {\n\t\t\tconfigurable: true,\n\t\t\twritable: true\n\t\t};\n\t\tif (accessType !== \"value\") {\n\t\t\tdelete desc.writable;\n\t\t}\n\t\tdesc[accessType] = cb;\n\t\tObject.defineProperty(object, key, desc);\n\t};\n\tconst restore = () => {\n\t\t// if method is defined on the prototype, we can just remove it from\n\t\t// the current object instead of redefining a copy of it\n\t\tif (originalDescriptorObject !== object) {\n\t\t\tReflect.deleteProperty(object, key);\n\t\t} else if (originalDescriptor && !original) {\n\t\t\tObject.defineProperty(object, key, originalDescriptor);\n\t\t} else {\n\t\t\treassign(original);\n\t\t}\n\t};\n\tconst mock = createMockInstance({\n\t\trestore,\n\t\toriginalImplementation,\n\t\tresetToMockName: true\n\t});\n\ttry {\n\t\treassign(ssr ? () => mock : mock);\n\t} catch (error) {\n\t\tif (error instanceof TypeError && Symbol.toStringTag && object[Symbol.toStringTag] === \"Module\" && (error.message.includes(\"Cannot redefine property\") || error.message.includes(\"Cannot replace module namespace\") || error.message.includes(\"can't redefine non-configurable property\"))) {\n\t\t\tthrow new TypeError(`Cannot spy on export \"${String(key)}\". Module namespace is not configurable in ESM. See: https://vitest.dev/guide/browser/#limitations`, { cause: error });\n\t\t}\n\t\tthrow error;\n\t}\n\treturn mock;\n}\nfunction getDescriptor(obj, method) {\n\tconst objDescriptor = Object.getOwnPropertyDescriptor(obj, method);\n\tif (objDescriptor) {\n\t\treturn [obj, objDescriptor];\n\t}\n\tlet currentProto = Object.getPrototypeOf(obj);\n\twhile (currentProto !== null) {\n\t\tconst descriptor = Object.getOwnPropertyDescriptor(currentProto, method);\n\t\tif (descriptor) {\n\t\t\treturn [currentProto, descriptor];\n\t\t}\n\t\tcurrentProto = Object.getPrototypeOf(currentProto);\n\t}\n}\nfunction assert(condition, message) {\n\tif (!condition) {\n\t\tthrow new Error(message);\n\t}\n}\nlet invocationCallCounter = 1;\nfunction createMock({ state, config, name: mockName, prototypeState, prototypeConfig, keepMembersImplementation, mockImplementation, prototypeMembers = [] }) {\n\tconst original = config.mockOriginal;\n\tconst pseudoOriginal = mockImplementation;\n\tconst name = mockName || original?.name || \"Mock\";\n\tconst namedObject = { [name]: (function(...args) {\n\t\tregisterCalls(args, state, prototypeState);\n\t\tregisterInvocationOrder(invocationCallCounter++, state, prototypeState);\n\t\tconst result = {\n\t\t\ttype: \"incomplete\",\n\t\t\tvalue: undefined\n\t\t};\n\t\tconst settledResult = {\n\t\t\ttype: \"incomplete\",\n\t\t\tvalue: undefined\n\t\t};\n\t\tregisterResult(result, state, prototypeState);\n\t\tregisterSettledResult(settledResult, state, prototypeState);\n\t\tconst context = new.target ? undefined : this;\n\t\tconst [instanceIndex, instancePrototypeIndex] = registerInstance(context, state, prototypeState);\n\t\tconst [contextIndex, contextPrototypeIndex] = registerContext(context, state, prototypeState);\n\t\tconst implementation = config.onceMockImplementations.shift() || config.mockImplementation || prototypeConfig?.onceMockImplementations.shift() || prototypeConfig?.mockImplementation || original || function() {};\n\t\tlet returnValue;\n\t\tlet thrownValue;\n\t\tlet didThrow = false;\n\t\ttry {\n\t\t\tif (new.target) {\n\t\t\t\treturnValue = Reflect.construct(implementation, args, new.target);\n\t\t\t\t// jest calls this before the implementation, but we have to resolve this _after_\n\t\t\t\t// because we cannot do it before the `Reflect.construct` called the custom implementation.\n\t\t\t\t// fortunately, the constructor is always an empty function because `prototypeMethods`\n\t\t\t\t// are only used by the automocker, so this doesn't matter\n\t\t\t\tfor (const prop of prototypeMembers) {\n\t\t\t\t\tconst prototypeMock = returnValue[prop];\n\t\t\t\t\t// the method was overridden because of inheritance, ignore it\n\t\t\t\t\t// eslint-disable-next-line ts/no-use-before-define\n\t\t\t\t\tif (prototypeMock !== mock.prototype[prop]) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tconst isMock = isMockFunction(prototypeMock);\n\t\t\t\t\tconst prototypeState = isMock ? prototypeMock.mock : undefined;\n\t\t\t\t\tconst prototypeConfig = isMock ? MOCK_CONFIGS.get(prototypeMock) : undefined;\n\t\t\t\t\treturnValue[prop] = createMockInstance({\n\t\t\t\t\t\toriginalImplementation: keepMembersImplementation ? prototypeConfig?.mockOriginal : undefined,\n\t\t\t\t\t\tprototypeState,\n\t\t\t\t\t\tprototypeConfig,\n\t\t\t\t\t\tkeepMembersImplementation\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\treturnValue = implementation.apply(this, args);\n\t\t\t}\n\t\t} catch (error) {\n\t\t\tthrownValue = error;\n\t\t\tdidThrow = true;\n\t\t\tif (error instanceof TypeError && error.message.includes(\"is not a constructor\")) {\n\t\t\t\tconsole.warn(`[vitest] The ${namedObject[name].getMockName()} mock did not use 'function' or 'class' in its implementation, see https://vitest.dev/api/vi#vi-spyon for examples.`);\n\t\t\t}\n\t\t\tthrow error;\n\t\t} finally {\n\t\t\tif (didThrow) {\n\t\t\t\tresult.type = \"throw\";\n\t\t\t\tresult.value = thrownValue;\n\t\t\t\tsettledResult.type = \"rejected\";\n\t\t\t\tsettledResult.value = thrownValue;\n\t\t\t} else {\n\t\t\t\tresult.type = \"return\";\n\t\t\t\tresult.value = returnValue;\n\t\t\t\tif (new.target) {\n\t\t\t\t\tstate.contexts[contextIndex - 1] = returnValue;\n\t\t\t\t\tstate.instances[instanceIndex - 1] = returnValue;\n\t\t\t\t\tif (contextPrototypeIndex != null && prototypeState) {\n\t\t\t\t\t\tprototypeState.contexts[contextPrototypeIndex - 1] = returnValue;\n\t\t\t\t\t}\n\t\t\t\t\tif (instancePrototypeIndex != null && prototypeState) {\n\t\t\t\t\t\tprototypeState.instances[instancePrototypeIndex - 1] = returnValue;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (returnValue instanceof Promise) {\n\t\t\t\t\treturnValue.then((settledValue) => {\n\t\t\t\t\t\tsettledResult.type = \"fulfilled\";\n\t\t\t\t\t\tsettledResult.value = settledValue;\n\t\t\t\t\t}, (rejectedValue) => {\n\t\t\t\t\t\tsettledResult.type = \"rejected\";\n\t\t\t\t\t\tsettledResult.value = rejectedValue;\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\tsettledResult.type = \"fulfilled\";\n\t\t\t\t\tsettledResult.value = returnValue;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn returnValue;\n\t}) };\n\tconst mock = namedObject[name];\n\tconst copyPropertiesFrom = original || pseudoOriginal;\n\tif (copyPropertiesFrom) {\n\t\tcopyOriginalStaticProperties(mock, copyPropertiesFrom);\n\t}\n\treturn mock;\n}\nfunction registerCalls(args, state, prototypeState) {\n\tstate.calls.push(args);\n\tprototypeState?.calls.push(args);\n}\nfunction registerInvocationOrder(order, state, prototypeState) {\n\tstate.invocationCallOrder.push(order);\n\tprototypeState?.invocationCallOrder.push(order);\n}\nfunction registerResult(result, state, prototypeState) {\n\tstate.results.push(result);\n\tprototypeState?.results.push(result);\n}\nfunction registerSettledResult(result, state, prototypeState) {\n\tstate.settledResults.push(result);\n\tprototypeState?.settledResults.push(result);\n}\nfunction registerInstance(instance, state, prototypeState) {\n\tconst instanceIndex = state.instances.push(instance);\n\tconst instancePrototypeIndex = prototypeState?.instances.push(instance);\n\treturn [instanceIndex, instancePrototypeIndex];\n}\nfunction registerContext(context, state, prototypeState) {\n\tconst contextIndex = state.contexts.push(context);\n\tconst contextPrototypeIndex = prototypeState?.contexts.push(context);\n\treturn [contextIndex, contextPrototypeIndex];\n}\nfunction copyOriginalStaticProperties(mock, original) {\n\tconst { properties, descriptors } = getAllProperties(original);\n\tfor (const key of properties) {\n\t\tconst descriptor = descriptors[key];\n\t\tconst mockDescriptor = getDescriptor(mock, key);\n\t\tif (mockDescriptor) {\n\t\t\tcontinue;\n\t\t}\n\t\tObject.defineProperty(mock, key, descriptor);\n\t}\n}\nconst ignoreProperties = new Set([\n\t\"length\",\n\t\"name\",\n\t\"prototype\",\n\tSymbol.for(\"nodejs.util.promisify.custom\")\n]);\nfunction getAllProperties(original) {\n\tconst properties = new Set();\n\tconst descriptors = {};\n\twhile (original && original !== Object.prototype && original !== Function.prototype) {\n\t\tconst ownProperties = [...Object.getOwnPropertyNames(original), ...Object.getOwnPropertySymbols(original)];\n\t\tfor (const prop of ownProperties) {\n\t\t\tif (descriptors[prop] || ignoreProperties.has(prop)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tproperties.add(prop);\n\t\t\tdescriptors[prop] = Object.getOwnPropertyDescriptor(original, prop);\n\t\t}\n\t\toriginal = Object.getPrototypeOf(original);\n\t}\n\treturn {\n\t\tproperties,\n\t\tdescriptors\n\t};\n}\nfunction getDefaultConfig(original) {\n\treturn {\n\t\tmockImplementation: undefined,\n\t\tmockOriginal: original,\n\t\tmockName: \"vi.fn()\",\n\t\tonceMockImplementations: []\n\t};\n}\nfunction getDefaultState() {\n\tconst state = {\n\t\tcalls: [],\n\t\tcontexts: [],\n\t\tinstances: [],\n\t\tinvocationCallOrder: [],\n\t\tsettledResults: [],\n\t\tresults: [],\n\t\tget lastCall() {\n\t\t\treturn state.calls.at(-1);\n\t\t}\n\t};\n\treturn state;\n}\nfunction restoreAllMocks() {\n\tfor (const restore of MOCK_RESTORE) {\n\t\trestore();\n\t}\n\tMOCK_RESTORE.clear();\n}\nfunction clearAllMocks() {\n\tREGISTERED_MOCKS.forEach((mock) => mock.mockClear());\n}\nfunction resetAllMocks() {\n\tREGISTERED_MOCKS.forEach((mock) => mock.mockReset());\n}\nfunction throwConstructorError(shorthand) {\n\tthrow new TypeError(`Cannot use \\`${shorthand}\\` when called with \\`new\\`. Use \\`mockImplementation\\` with a \\`class\\` keyword instead. See https://vitest.dev/api/mock#class-support for more information.`);\n}\n\nexport { clearAllMocks, createMockInstance, fn, isMockFunction, resetAllMocks, restoreAllMocks, spyOn };\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/bundle/dist/dist/node_modules/.pnpm/@vitest_utils@4.1.2/node_modules/@vitest/utils/dist/chunk-pathe.M-eThtNZ.js

@@ -0,0 +1,82 @@
+//#region ../../node_modules/.pnpm/@vitest+utils@4.1.2/node_modules/@vitest/utils/dist/chunk-pathe.M-eThtNZ.js
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+function cwd() {
+	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
+	return "/";
+}
+const resolve = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd();
+		if (!path || path.length === 0) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+//#endregion
+export { resolve };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"chunk-pathe.M-eThtNZ.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/@vitest+utils@4.1.2/node_modules/@vitest/utils/dist/chunk-pathe.M-eThtNZ.js"],"sourcesContent":["const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\\//;\nfunction normalizeWindowsPath(input = \"\") {\n  if (!input) {\n    return input;\n  }\n  return input.replace(/\\\\/g, \"/\").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());\n}\n\nconst _UNC_REGEX = /^[/\\\\]{2}/;\nconst _IS_ABSOLUTE_RE = /^[/\\\\](?![/\\\\])|^[/\\\\]{2}(?!\\.)|^[A-Za-z]:[/\\\\]/;\nconst _DRIVE_LETTER_RE = /^[A-Za-z]:$/;\nconst normalize = function(path) {\n  if (path.length === 0) {\n    return \".\";\n  }\n  path = normalizeWindowsPath(path);\n  const isUNCPath = path.match(_UNC_REGEX);\n  const isPathAbsolute = isAbsolute(path);\n  const trailingSeparator = path[path.length - 1] === \"/\";\n  path = normalizeString(path, !isPathAbsolute);\n  if (path.length === 0) {\n    if (isPathAbsolute) {\n      return \"/\";\n    }\n    return trailingSeparator ? \"./\" : \".\";\n  }\n  if (trailingSeparator) {\n    path += \"/\";\n  }\n  if (_DRIVE_LETTER_RE.test(path)) {\n    path += \"/\";\n  }\n  if (isUNCPath) {\n    if (!isPathAbsolute) {\n      return `//./${path}`;\n    }\n    return `//${path}`;\n  }\n  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;\n};\nconst join = function(...segments) {\n  let path = \"\";\n  for (const seg of segments) {\n    if (!seg) {\n      continue;\n    }\n    if (path.length > 0) {\n      const pathTrailing = path[path.length - 1] === \"/\";\n      const segLeading = seg[0] === \"/\";\n      const both = pathTrailing && segLeading;\n      if (both) {\n        path += seg.slice(1);\n      } else {\n        path += pathTrailing || segLeading ? seg : `/${seg}`;\n      }\n    } else {\n      path += seg;\n    }\n  }\n  return normalize(path);\n};\nfunction cwd() {\n  if (typeof process !== \"undefined\" && typeof process.cwd === \"function\") {\n    return process.cwd().replace(/\\\\/g, \"/\");\n  }\n  return \"/\";\n}\nconst resolve = function(...arguments_) {\n  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));\n  let resolvedPath = \"\";\n  let resolvedAbsolute = false;\n  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {\n    const path = index >= 0 ? arguments_[index] : cwd();\n    if (!path || path.length === 0) {\n      continue;\n    }\n    resolvedPath = `${path}/${resolvedPath}`;\n    resolvedAbsolute = isAbsolute(path);\n  }\n  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);\n  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {\n    return `/${resolvedPath}`;\n  }\n  return resolvedPath.length > 0 ? resolvedPath : \".\";\n};\nfunction normalizeString(path, allowAboveRoot) {\n  let res = \"\";\n  let lastSegmentLength = 0;\n  let lastSlash = -1;\n  let dots = 0;\n  let char = null;\n  for (let index = 0; index <= path.length; ++index) {\n    if (index < path.length) {\n      char = path[index];\n    } else if (char === \"/\") {\n      break;\n    } else {\n      char = \"/\";\n    }\n    if (char === \"/\") {\n      if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) {\n        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== \".\" || res[res.length - 2] !== \".\") {\n          if (res.length > 2) {\n            const lastSlashIndex = res.lastIndexOf(\"/\");\n            if (lastSlashIndex === -1) {\n              res = \"\";\n              lastSegmentLength = 0;\n            } else {\n              res = res.slice(0, lastSlashIndex);\n              lastSegmentLength = res.length - 1 - res.lastIndexOf(\"/\");\n            }\n            lastSlash = index;\n            dots = 0;\n            continue;\n          } else if (res.length > 0) {\n            res = \"\";\n            lastSegmentLength = 0;\n            lastSlash = index;\n            dots = 0;\n            continue;\n          }\n        }\n        if (allowAboveRoot) {\n          res += res.length > 0 ? \"/..\" : \"..\";\n          lastSegmentLength = 2;\n        }\n      } else {\n        if (res.length > 0) {\n          res += `/${path.slice(lastSlash + 1, index)}`;\n        } else {\n          res = path.slice(lastSlash + 1, index);\n        }\n        lastSegmentLength = index - lastSlash - 1;\n      }\n      lastSlash = index;\n      dots = 0;\n    } else if (char === \".\" && dots !== -1) {\n      ++dots;\n    } else {\n      dots = -1;\n    }\n  }\n  return res;\n}\nconst isAbsolute = function(p) {\n  return _IS_ABSOLUTE_RE.test(p);\n};\nconst dirname = function(p) {\n  const segments = normalizeWindowsPath(p).replace(/\\/$/, \"\").split(\"/\").slice(0, -1);\n  if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {\n    segments[0] += \"/\";\n  }\n  return segments.join(\"/\") || (isAbsolute(p) ? \"/\" : \".\");\n};\n\nexport { dirname as d, join as j, resolve as r };\n"],"x_google_ignoreList":[0],"mappings":";AAAA,MAAM,yBAAyB;AAC/B,SAAS,qBAAqB,QAAQ,IAAI;AACxC,KAAI,CAAC,MACH,QAAO;AAET,QAAO,MAAM,QAAQ,OAAO,IAAI,CAAC,QAAQ,yBAAyB,MAAM,EAAE,aAAa,CAAC;;AAI1F,MAAM,kBAAkB;AAoDxB,SAAS,MAAM;AACb,KAAI,OAAO,YAAY,eAAe,OAAO,QAAQ,QAAQ,WAC3D,QAAO,QAAQ,KAAK,CAAC,QAAQ,OAAO,IAAI;AAE1C,QAAO;;AAET,MAAM,UAAU,SAAS,GAAG,YAAY;AACtC,cAAa,WAAW,KAAK,aAAa,qBAAqB,SAAS,CAAC;CACzE,IAAI,eAAe;CACnB,IAAI,mBAAmB;AACvB,MAAK,IAAI,QAAQ,WAAW,SAAS,GAAG,SAAS,MAAM,CAAC,kBAAkB,SAAS;EACjF,MAAM,OAAO,SAAS,IAAI,WAAW,SAAS,KAAK;AACnD,MAAI,CAAC,QAAQ,KAAK,WAAW,EAC3B;AAEF,iBAAe,GAAG,KAAK,GAAG;AAC1B,qBAAmB,WAAW,KAAK;;AAErC,gBAAe,gBAAgB,cAAc,CAAC,iBAAiB;AAC/D,KAAI,oBAAoB,CAAC,WAAW,aAAa,CAC/C,QAAO,IAAI;AAEb,QAAO,aAAa,SAAS,IAAI,eAAe;;AAElD,SAAS,gBAAgB,MAAM,gBAAgB;CAC7C,IAAI,MAAM;CACV,IAAI,oBAAoB;CACxB,IAAI,YAAY;CAChB,IAAI,OAAO;CACX,IAAI,OAAO;AACX,MAAK,IAAI,QAAQ,GAAG,SAAS,KAAK,QAAQ,EAAE,OAAO;AACjD,MAAI,QAAQ,KAAK,OACf,QAAO,KAAK;WACH,SAAS,IAClB;MAEA,QAAO;AAET,MAAI,SAAS,KAAK;AAChB,OAAI,cAAc,QAAQ,KAAK,SAAS;YAAc,SAAS,GAAG;AAChE,QAAI,IAAI,SAAS,KAAK,sBAAsB,KAAK,IAAI,IAAI,SAAS,OAAO,OAAO,IAAI,IAAI,SAAS,OAAO,KACtG;SAAI,IAAI,SAAS,GAAG;MAClB,MAAM,iBAAiB,IAAI,YAAY,IAAI;AAC3C,UAAI,mBAAmB,IAAI;AACzB,aAAM;AACN,2BAAoB;aACf;AACL,aAAM,IAAI,MAAM,GAAG,eAAe;AAClC,2BAAoB,IAAI,SAAS,IAAI,IAAI,YAAY,IAAI;;AAE3D,kBAAY;AACZ,aAAO;AACP;gBACS,IAAI,SAAS,GAAG;AACzB,YAAM;AACN,0BAAoB;AACpB,kBAAY;AACZ,aAAO;AACP;;;AAGJ,QAAI,gBAAgB;AAClB,YAAO,IAAI,SAAS,IAAI,QAAQ;AAChC,yBAAoB;;UAEjB;AACL,QAAI,IAAI,SAAS,EACf,QAAO,IAAI,KAAK,MAAM,YAAY,GAAG,MAAM;QAE3C,OAAM,KAAK,MAAM,YAAY,GAAG,MAAM;AAExC,wBAAoB,QAAQ,YAAY;;AAE1C,eAAY;AACZ,UAAO;aACE,SAAS,OAAO,SAAS,GAClC,GAAE;MAEF,QAAO;;AAGX,QAAO;;AAET,MAAM,aAAa,SAAS,GAAG;AAC7B,QAAO,gBAAgB,KAAK,EAAE"}

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

@@ -0,0 +1,48 @@
+new RegExp(`\\.(${[
+	"apng",
+	"bmp",
+	"png",
+	"jpe?g",
+	"jfif",
+	"pjpeg",
+	"pjp",
+	"gif",
+	"svg",
+	"ico",
+	"webp",
+	"avif",
+	"mp4",
+	"webm",
+	"ogg",
+	"mp3",
+	"wav",
+	"flac",
+	"aac",
+	"woff2?",
+	"eot",
+	"ttf",
+	"otf",
+	"webmanifest",
+	"pdf",
+	"txt"
+].join("|")})$`);
+/**
+* Prefix for resolved Ids that are not valid browser import specifiers
+*/
+const VALID_ID_PREFIX = `/@id/`;
+/**
+* Plugins that use 'virtual modules' (e.g. for helper functions), prefix the
+* module ID with `\0`, a convention from the rollup ecosystem.
+* This prevents other plugins from trying to process the id (like node resolution),
+* and core features like sourcemaps can use this info to differentiate between
+* virtual modules and regular files.
+* `\0` is not a permitted char in import URLs so we have to replace them during
+* import analysis. The id will be decoded back before entering the plugins pipeline.
+* These encoded virtual ids are also prefixed by the VALID_ID_PREFIX, so virtual
+* modules in the browser end up encoded as `/@id/__x00__{id}`
+*/
+const NULL_BYTE_PLACEHOLDER = `__x00__`;
+//#endregion
+export { NULL_BYTE_PLACEHOLDER, VALID_ID_PREFIX };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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