@jcheesepkg/nanobot 0.8.7 → 0.8.9

package/dist/node_modules/@vitest/runner/dist/index.mjs

@@ -0,0 +1,563 @@
+import { format, objDisplay } from "../../utils/dist/chunk-_commonjsHelpers.mjs";
+import { assertTypes, createDefer, isNegativeNaN, isObject, objectAttr, toArray } from "../../utils/dist/helpers.mjs";
+import { getSafeTimers } from "../../utils/dist/index.mjs";
+import { processError } from "../../utils/dist/error.mjs";
+import { parseSingleStack } from "../../utils/dist/source-map.mjs";
+import { createChainable } from "./chunk-tasks.mjs";
+
+//#region node_modules/@vitest/runner/dist/index.js
+var PendingError = class extends Error {
+	constructor(message, task) {
+		super(message);
+		this.message = message;
+		this.taskId = task.id;
+	}
+	code = "VITEST_PENDING";
+	taskId;
+};
+const collectorContext = {
+	tasks: [],
+	currentSuite: null
+};
+function collectTask(task) {
+	var _a;
+	(_a = collectorContext.currentSuite) == null || _a.tasks.push(task);
+}
+async function runWithSuite(suite, fn) {
+	const prev = collectorContext.currentSuite;
+	collectorContext.currentSuite = suite;
+	await fn();
+	collectorContext.currentSuite = prev;
+}
+function withTimeout(fn, timeout, isHook = false) {
+	if (timeout <= 0 || timeout === Number.POSITIVE_INFINITY) return fn;
+	const { setTimeout, clearTimeout } = getSafeTimers();
+	return function runWithTimeout(...args) {
+		return Promise.race([fn(...args), new Promise((resolve, reject) => {
+			var _a;
+			const timer = setTimeout(() => {
+				clearTimeout(timer);
+				reject(new Error(makeTimeoutMsg(isHook, timeout)));
+			}, timeout);
+			(_a = timer.unref) == null || _a.call(timer);
+		})]);
+	};
+}
+function createTestContext(test, runner) {
+	var _a;
+	const context = function() {
+		throw new Error("done() callback is deprecated, use promise instead");
+	};
+	context.task = test;
+	context.skip = () => {
+		test.pending = true;
+		throw new PendingError("test is skipped; abort execution", test);
+	};
+	context.onTestFailed = (fn) => {
+		test.onFailed || (test.onFailed = []);
+		test.onFailed.push(fn);
+	};
+	context.onTestFinished = (fn) => {
+		test.onFinished || (test.onFinished = []);
+		test.onFinished.push(fn);
+	};
+	return ((_a = runner.extendTaskContext) == null ? void 0 : _a.call(runner, context)) || context;
+}
+function makeTimeoutMsg(isHook, timeout) {
+	return `${isHook ? "Hook" : "Test"} timed out in ${timeout}ms.
+If this is a long-running ${isHook ? "hook" : "test"}, pass a timeout value as the last argument or configure it globally with "${isHook ? "hookTimeout" : "testTimeout"}".`;
+}
+const fnMap = /* @__PURE__ */ new WeakMap();
+const fixtureMap = /* @__PURE__ */ new WeakMap();
+const hooksMap = /* @__PURE__ */ new WeakMap();
+function setFn(key, fn) {
+	fnMap.set(key, fn);
+}
+function setFixture(key, fixture) {
+	fixtureMap.set(key, fixture);
+}
+function getFixture(key) {
+	return fixtureMap.get(key);
+}
+function setHooks(key, hooks) {
+	hooksMap.set(key, hooks);
+}
+function getHooks(key) {
+	return hooksMap.get(key);
+}
+function mergeContextFixtures(fixtures, context = {}) {
+	const fixtureOptionKeys = ["auto"];
+	const fixtureArray = Object.entries(fixtures).map(([prop, value]) => {
+		const fixtureItem = { value };
+		if (Array.isArray(value) && value.length >= 2 && isObject(value[1]) && Object.keys(value[1]).some((key) => fixtureOptionKeys.includes(key))) {
+			Object.assign(fixtureItem, value[1]);
+			fixtureItem.value = value[0];
+		}
+		fixtureItem.prop = prop;
+		fixtureItem.isFn = typeof fixtureItem.value === "function";
+		return fixtureItem;
+	});
+	if (Array.isArray(context.fixtures)) context.fixtures = context.fixtures.concat(fixtureArray);
+	else context.fixtures = fixtureArray;
+	fixtureArray.forEach((fixture) => {
+		if (fixture.isFn) {
+			const usedProps = getUsedProps(fixture.value);
+			if (usedProps.length) fixture.deps = context.fixtures.filter(({ prop }) => prop !== fixture.prop && usedProps.includes(prop));
+		}
+	});
+	return context;
+}
+const fixtureValueMaps = /* @__PURE__ */ new Map();
+const cleanupFnArrayMap = /* @__PURE__ */ new Map();
+function withFixtures(fn, testContext) {
+	return (hookContext) => {
+		const context = hookContext || testContext;
+		if (!context) return fn({});
+		const fixtures = getFixture(context);
+		if (!(fixtures == null ? void 0 : fixtures.length)) return fn(context);
+		const usedProps = getUsedProps(fn);
+		const hasAutoFixture = fixtures.some(({ auto }) => auto);
+		if (!usedProps.length && !hasAutoFixture) return fn(context);
+		if (!fixtureValueMaps.get(context)) fixtureValueMaps.set(context, /* @__PURE__ */ new Map());
+		const fixtureValueMap = fixtureValueMaps.get(context);
+		if (!cleanupFnArrayMap.has(context)) cleanupFnArrayMap.set(context, []);
+		const cleanupFnArray = cleanupFnArrayMap.get(context);
+		const pendingFixtures = resolveDeps(fixtures.filter(({ prop, auto }) => auto || usedProps.includes(prop)));
+		if (!pendingFixtures.length) return fn(context);
+		async function resolveFixtures() {
+			for (const fixture of pendingFixtures) {
+				if (fixtureValueMap.has(fixture)) continue;
+				const resolvedValue = fixture.isFn ? await resolveFixtureFunction(fixture.value, context, cleanupFnArray) : fixture.value;
+				context[fixture.prop] = resolvedValue;
+				fixtureValueMap.set(fixture, resolvedValue);
+				cleanupFnArray.unshift(() => {
+					fixtureValueMap.delete(fixture);
+				});
+			}
+		}
+		return resolveFixtures().then(() => fn(context));
+	};
+}
+async function resolveFixtureFunction(fixtureFn, context, cleanupFnArray) {
+	const useFnArgPromise = createDefer();
+	let isUseFnArgResolved = false;
+	const fixtureReturn = fixtureFn(context, async (useFnArg) => {
+		isUseFnArgResolved = true;
+		useFnArgPromise.resolve(useFnArg);
+		const useReturnPromise = createDefer();
+		cleanupFnArray.push(async () => {
+			useReturnPromise.resolve();
+			await fixtureReturn;
+		});
+		await useReturnPromise;
+	}).catch((e) => {
+		if (!isUseFnArgResolved) {
+			useFnArgPromise.reject(e);
+			return;
+		}
+		throw e;
+	});
+	return useFnArgPromise;
+}
+function resolveDeps(fixtures, depSet = /* @__PURE__ */ new Set(), pendingFixtures = []) {
+	fixtures.forEach((fixture) => {
+		if (pendingFixtures.includes(fixture)) return;
+		if (!fixture.isFn || !fixture.deps) {
+			pendingFixtures.push(fixture);
+			return;
+		}
+		if (depSet.has(fixture)) throw new Error(`Circular fixture dependency detected: ${fixture.prop} <- ${[...depSet].reverse().map((d) => d.prop).join(" <- ")}`);
+		depSet.add(fixture);
+		resolveDeps(fixture.deps, depSet, pendingFixtures);
+		pendingFixtures.push(fixture);
+		depSet.clear();
+	});
+	return pendingFixtures;
+}
+function getUsedProps(fn) {
+	let fnString = fn.toString();
+	if (/__async\(this, (?:null|arguments|\[[_0-9, ]*\]), function\*/.test(fnString)) fnString = fnString.split("__async(this,")[1];
+	const match = fnString.match(/[^(]*\(([^)]*)/);
+	if (!match) return [];
+	const args = splitByComma(match[1]);
+	if (!args.length) return [];
+	let first = args[0];
+	if ("__VITEST_FIXTURE_INDEX__" in fn) {
+		first = args[fn.__VITEST_FIXTURE_INDEX__];
+		if (!first) return [];
+	}
+	if (!(first.startsWith("{") && first.endsWith("}"))) throw new Error(`The first argument inside a fixture must use object destructuring pattern, e.g. ({ test } => {}). Instead, received "${first}".`);
+	const props = splitByComma(first.slice(1, -1).replace(/\s/g, "")).map((prop) => {
+		return prop.replace(/:.*|=.*/g, "");
+	});
+	const last = props.at(-1);
+	if (last && last.startsWith("...")) throw new Error(`Rest parameters are not supported in fixtures, received "${last}".`);
+	return props;
+}
+function splitByComma(s) {
+	const result = [];
+	const stack = [];
+	let start = 0;
+	for (let i = 0; i < s.length; i++) if (s[i] === "{" || s[i] === "[") stack.push(s[i] === "{" ? "}" : "]");
+	else if (s[i] === stack[stack.length - 1]) stack.pop();
+	else if (!stack.length && s[i] === ",") {
+		const token = s.substring(start, i).trim();
+		if (token) result.push(token);
+		start = i + 1;
+	}
+	const lastToken = s.substring(start).trim();
+	if (lastToken) result.push(lastToken);
+	return result;
+}
+let _test;
+function getCurrentTest() {
+	return _test;
+}
+const suite = createSuite();
+const test = createTest(function(name, optionsOrFn, optionsOrTest) {
+	if (getCurrentTest()) throw new Error("Calling the test function inside another test function is not allowed. Please put it inside \"describe\" or \"suite\" so it can be properly collected.");
+	getCurrentSuite().test.fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
+});
+const describe = suite;
+const it = test;
+let runner;
+let defaultSuite;
+let currentTestFilepath;
+function assert(condition, message) {
+	if (!condition) throw new Error(`Vitest failed to find ${message}. This is a bug in Vitest. Please, open an issue with reproduction.`);
+}
+function getTestFilepath() {
+	return currentTestFilepath;
+}
+function getRunner() {
+	assert(runner, "the runner");
+	return runner;
+}
+function getCurrentSuite() {
+	const currentSuite = collectorContext.currentSuite || defaultSuite;
+	assert(currentSuite, "the current suite");
+	return currentSuite;
+}
+function createSuiteHooks() {
+	return {
+		beforeAll: [],
+		afterAll: [],
+		beforeEach: [],
+		afterEach: []
+	};
+}
+function parseArguments(optionsOrFn, optionsOrTest) {
+	let options = {};
+	let fn = () => {};
+	if (typeof optionsOrTest === "object") {
+		if (typeof optionsOrFn === "object") throw new TypeError("Cannot use two objects as arguments. Please provide options and a function callback in that order.");
+		options = optionsOrTest;
+	} else if (typeof optionsOrTest === "number") options = { timeout: optionsOrTest };
+	else if (typeof optionsOrFn === "object") options = optionsOrFn;
+	if (typeof optionsOrFn === "function") {
+		if (typeof optionsOrTest === "function") throw new TypeError("Cannot use two functions as arguments. Please use the second argument for options.");
+		fn = optionsOrFn;
+	} else if (typeof optionsOrTest === "function") fn = optionsOrTest;
+	return {
+		options,
+		handler: fn
+	};
+}
+function createSuiteCollector(name, factory = () => {}, mode, shuffle, each, suiteOptions) {
+	const tasks = [];
+	const factoryQueue = [];
+	let suite2;
+	initSuite(true);
+	const task = function(name2 = "", options = {}) {
+		const task2 = {
+			id: "",
+			name: name2,
+			suite: void 0,
+			each: options.each,
+			fails: options.fails,
+			context: void 0,
+			type: "custom",
+			file: void 0,
+			retry: options.retry ?? runner.config.retry,
+			repeats: options.repeats,
+			mode: options.only ? "only" : options.skip ? "skip" : options.todo ? "todo" : "run",
+			meta: options.meta ?? /* @__PURE__ */ Object.create(null)
+		};
+		const handler = options.handler;
+		if (options.concurrent || !options.sequential && runner.config.sequence.concurrent) task2.concurrent = true;
+		if (shuffle) task2.shuffle = true;
+		const context = createTestContext(task2, runner);
+		Object.defineProperty(task2, "context", {
+			value: context,
+			enumerable: false
+		});
+		setFixture(context, options.fixtures);
+		if (handler) setFn(task2, withTimeout(withAwaitAsyncAssetions(withFixtures(handler, context), task2), (options == null ? void 0 : options.timeout) ?? runner.config.testTimeout));
+		if (runner.config.includeTaskLocation) {
+			const limit = Error.stackTraceLimit;
+			Error.stackTraceLimit = 15;
+			const error = (/* @__PURE__ */ new Error("stacktrace")).stack;
+			Error.stackTraceLimit = limit;
+			const stack = findTestFileStackTrace(error, task2.each ?? false);
+			if (stack) task2.location = stack;
+		}
+		tasks.push(task2);
+		return task2;
+	};
+	const test2 = createTest(function(name2, optionsOrFn, optionsOrTest) {
+		let { options, handler } = parseArguments(optionsOrFn, optionsOrTest);
+		if (typeof suiteOptions === "object") options = Object.assign({}, suiteOptions, options);
+		options.concurrent = this.concurrent || !this.sequential && (options == null ? void 0 : options.concurrent);
+		options.sequential = this.sequential || !this.concurrent && (options == null ? void 0 : options.sequential);
+		const test3 = task(formatName(name2), {
+			...this,
+			...options,
+			handler
+		});
+		test3.type = "test";
+	});
+	const collector = {
+		type: "collector",
+		name,
+		mode,
+		options: suiteOptions,
+		test: test2,
+		tasks,
+		collect,
+		task,
+		clear,
+		on: addHook
+	};
+	function addHook(name2, ...fn) {
+		getHooks(suite2)[name2].push(...fn);
+	}
+	function initSuite(includeLocation) {
+		if (typeof suiteOptions === "number") suiteOptions = { timeout: suiteOptions };
+		suite2 = {
+			id: "",
+			type: "suite",
+			name,
+			mode,
+			each,
+			file: void 0,
+			shuffle,
+			tasks: [],
+			meta: /* @__PURE__ */ Object.create(null),
+			concurrent: suiteOptions == null ? void 0 : suiteOptions.concurrent
+		};
+		if (runner && includeLocation && runner.config.includeTaskLocation) {
+			const limit = Error.stackTraceLimit;
+			Error.stackTraceLimit = 15;
+			const error = (/* @__PURE__ */ new Error("stacktrace")).stack;
+			Error.stackTraceLimit = limit;
+			const stack = findTestFileStackTrace(error, suite2.each ?? false);
+			if (stack) suite2.location = stack;
+		}
+		setHooks(suite2, createSuiteHooks());
+	}
+	function clear() {
+		tasks.length = 0;
+		factoryQueue.length = 0;
+		initSuite(false);
+	}
+	async function collect(file) {
+		if (!file) throw new TypeError("File is required to collect tasks.");
+		factoryQueue.length = 0;
+		if (factory) await runWithSuite(collector, () => factory(test2));
+		const allChildren = [];
+		for (const i of [...factoryQueue, ...tasks]) allChildren.push(i.type === "collector" ? await i.collect(file) : i);
+		suite2.file = file;
+		suite2.tasks = allChildren;
+		allChildren.forEach((task2) => {
+			task2.suite = suite2;
+			task2.file = file;
+		});
+		return suite2;
+	}
+	collectTask(collector);
+	return collector;
+}
+function withAwaitAsyncAssetions(fn, task) {
+	return async (...args) => {
+		await fn(...args);
+		if (task.promises) {
+			const errors = (await Promise.allSettled(task.promises)).map((r) => r.status === "rejected" ? r.reason : void 0).filter(Boolean);
+			if (errors.length) throw errors;
+		}
+	};
+}
+function createSuite() {
+	function suiteFn(name, factoryOrOptions, optionsOrFactory = {}) {
+		const mode = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
+		const currentSuite = collectorContext.currentSuite || defaultSuite;
+		let { options, handler: factory } = parseArguments(factoryOrOptions, optionsOrFactory);
+		const isConcurrentSpecified = options.concurrent || this.concurrent || options.sequential === false;
+		const isSequentialSpecified = options.sequential || this.sequential || options.concurrent === false;
+		if (currentSuite == null ? void 0 : currentSuite.options) options = {
+			...currentSuite.options,
+			...options
+		};
+		const isConcurrent = isConcurrentSpecified || options.concurrent && !isSequentialSpecified;
+		const isSequential = isSequentialSpecified || options.sequential && !isConcurrentSpecified;
+		options.concurrent = isConcurrent && !isSequential;
+		options.sequential = isSequential && !isConcurrent;
+		return createSuiteCollector(formatName(name), factory, mode, this.shuffle, this.each, options);
+	}
+	suiteFn.each = function(cases, ...args) {
+		const suite2 = this.withContext();
+		this.setContext("each", true);
+		if (Array.isArray(cases) && args.length) cases = formatTemplateString(cases, args);
+		return (name, optionsOrFn, fnOrOptions) => {
+			const _name = formatName(name);
+			const arrayOnlyCases = cases.every(Array.isArray);
+			const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+			const fnFirst = typeof optionsOrFn === "function";
+			cases.forEach((i, idx) => {
+				const items = Array.isArray(i) ? i : [i];
+				if (fnFirst) if (arrayOnlyCases) suite2(formatTitle(_name, items, idx), () => handler(...items), options);
+				else suite2(formatTitle(_name, items, idx), () => handler(i), options);
+				else if (arrayOnlyCases) suite2(formatTitle(_name, items, idx), options, () => handler(...items));
+				else suite2(formatTitle(_name, items, idx), options, () => handler(i));
+			});
+			this.setContext("each", void 0);
+		};
+	};
+	suiteFn.skipIf = (condition) => condition ? suite.skip : suite;
+	suiteFn.runIf = (condition) => condition ? suite : suite.skip;
+	return createChainable([
+		"concurrent",
+		"sequential",
+		"shuffle",
+		"skip",
+		"only",
+		"todo"
+	], suiteFn);
+}
+function createTaskCollector(fn, context) {
+	const taskFn = fn;
+	taskFn.each = function(cases, ...args) {
+		const test2 = this.withContext();
+		this.setContext("each", true);
+		if (Array.isArray(cases) && args.length) cases = formatTemplateString(cases, args);
+		return (name, optionsOrFn, fnOrOptions) => {
+			const _name = formatName(name);
+			const arrayOnlyCases = cases.every(Array.isArray);
+			const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+			const fnFirst = typeof optionsOrFn === "function";
+			cases.forEach((i, idx) => {
+				const items = Array.isArray(i) ? i : [i];
+				if (fnFirst) if (arrayOnlyCases) test2(formatTitle(_name, items, idx), () => handler(...items), options);
+				else test2(formatTitle(_name, items, idx), () => handler(i), options);
+				else if (arrayOnlyCases) test2(formatTitle(_name, items, idx), options, () => handler(...items));
+				else test2(formatTitle(_name, items, idx), options, () => handler(i));
+			});
+			this.setContext("each", void 0);
+		};
+	};
+	taskFn.for = function(cases, ...args) {
+		const test2 = this.withContext();
+		if (Array.isArray(cases) && args.length) cases = formatTemplateString(cases, args);
+		return (name, optionsOrFn, fnOrOptions) => {
+			const _name = formatName(name);
+			const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+			cases.forEach((item, idx) => {
+				const handlerWrapper = (ctx) => handler(item, ctx);
+				handlerWrapper.__VITEST_FIXTURE_INDEX__ = 1;
+				handlerWrapper.toString = () => handler.toString();
+				test2(formatTitle(_name, toArray(item), idx), options, handlerWrapper);
+			});
+		};
+	};
+	taskFn.skipIf = function(condition) {
+		return condition ? this.skip : this;
+	};
+	taskFn.runIf = function(condition) {
+		return condition ? this : this.skip;
+	};
+	taskFn.extend = function(fixtures) {
+		return createTest(function fn2(name, optionsOrFn, optionsOrTest) {
+			getCurrentSuite().test.fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
+		}, mergeContextFixtures(fixtures, context));
+	};
+	const _test = createChainable([
+		"concurrent",
+		"sequential",
+		"skip",
+		"only",
+		"todo",
+		"fails"
+	], taskFn);
+	if (context) _test.mergeContext(context);
+	return _test;
+}
+function createTest(fn, context) {
+	return createTaskCollector(fn, context);
+}
+function formatName(name) {
+	return typeof name === "string" ? name : name instanceof Function ? name.name || "<anonymous>" : String(name);
+}
+function formatTitle(template, items, idx) {
+	if (template.includes("%#")) template = template.replace(/%%/g, "__vitest_escaped_%__").replace(/%#/g, `${idx}`).replace(/__vitest_escaped_%__/g, "%%");
+	const count = template.split("%").length - 1;
+	if (template.includes("%f")) (template.match(/%f/g) || []).forEach((_, i) => {
+		if (isNegativeNaN(items[i]) || Object.is(items[i], -0)) {
+			let occurrence = 0;
+			template = template.replace(/%f/g, (match) => {
+				occurrence++;
+				return occurrence === i + 1 ? "-%f" : match;
+			});
+		}
+	});
+	let formatted = format(template, ...items.slice(0, count));
+	if (isObject(items[0])) formatted = formatted.replace(/\$([$\w.]+)/g, (_, key) => {
+		var _a, _b;
+		return objDisplay(objectAttr(items[0], key), { truncate: (_b = (_a = runner == null ? void 0 : runner.config) == null ? void 0 : _a.chaiConfig) == null ? void 0 : _b.truncateThreshold });
+	});
+	return formatted;
+}
+function formatTemplateString(cases, args) {
+	const header = cases.join("").trim().replace(/ /g, "").split("\n").map((i) => i.split("|"))[0];
+	const res = [];
+	for (let i = 0; i < Math.floor(args.length / header.length); i++) {
+		const oneCase = {};
+		for (let j = 0; j < header.length; j++) oneCase[header[j]] = args[i * header.length + j];
+		res.push(oneCase);
+	}
+	return res;
+}
+function findTestFileStackTrace(error, each) {
+	const lines = error.split("\n").slice(1);
+	for (const line of lines) {
+		const stack = parseSingleStack(line);
+		if (stack && stack.file === getTestFilepath()) return {
+			line: stack.line,
+			column: each ? stack.column + 1 : stack.column
+		};
+	}
+}
+function getDefaultHookTimeout() {
+	return getRunner().config.hookTimeout;
+}
+const onTestFailed = createTestHook("onTestFailed", (test, handler, timeout) => {
+	test.onFailed || (test.onFailed = []);
+	test.onFailed.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true));
+});
+const onTestFinished = createTestHook("onTestFinished", (test, handler, timeout) => {
+	test.onFinished || (test.onFinished = []);
+	test.onFinished.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true));
+});
+function createTestHook(name, handler) {
+	return (fn, timeout) => {
+		assertTypes(fn, `"${name}" callback`, ["function"]);
+		const current = getCurrentTest();
+		if (!current) throw new Error(`Hook ${name}() can only be called inside a test`);
+		return handler(current, fn, timeout);
+	};
+}
+const now$1 = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+const unixNow = Date.now;
+
+//#endregion
+export { describe, getCurrentTest, it };
+//# sourceMappingURL=index.mjs.map