@assistant-ui/react
Version:
Typescript/React library for AI Chat
1,408 lines (1,400 loc) • 102 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
// ../../node_modules/.pnpm/vitest@3.1.1_@types+debug@4.1.12_@types+node@22.14.0_jiti@2.4.2_lightningcss@1.29.2_terser@5.39.0_tsx@4.19.3_yaml@2.7.1/node_modules/vitest/dist/chunks/vi.B-PuvDzu.js
var import_expect = require("@vitest/expect.js");
var import_runner = require("@vitest/runner.js");
var import_utils2 = require("@vitest/runner/utils.js");
var chai$1 = __toESM(require("chai.js"), 1);
// ../../node_modules/.pnpm/vitest@3.1.1_@types+debug@4.1.12_@types+node@22.14.0_jiti@2.4.2_lightningcss@1.29.2_terser@5.39.0_tsx@4.19.3_yaml@2.7.1/node_modules/vitest/dist/chunks/utils.CtocqOoE.js
var import_utils = require("@vitest/utils.js");
var NAME_WORKER_STATE = "__vitest_worker__";
function getWorkerState() {
const workerState = globalThis[NAME_WORKER_STATE];
if (!workerState) {
const errorMsg = 'Vitest failed to access its internal state.\n\nOne of the following is possible:\n- "vitest" is imported directly without running "vitest" command\n- "vitest" is imported inside "globalSetup" (to fix this, use "setupFiles" instead, because "globalSetup" runs in a different context)\n- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues\n';
throw new Error(errorMsg);
}
return workerState;
}
function getCurrentEnvironment() {
const state = getWorkerState();
return state?.environment.name;
}
function isChildProcess() {
return typeof process !== "undefined" && !!process.send;
}
function resetModules(modules, resetMocks = false) {
const skipPaths = [
/\/vitest\/dist\//,
/\/vite-node\/dist\//,
/vitest-virtual-\w+\/dist/,
/@vitest\/dist/,
...!resetMocks ? [/^mock:/] : []
];
modules.forEach((mod, path) => {
if (skipPaths.some((re) => re.test(path))) {
return;
}
modules.invalidateModule(mod);
});
}
function waitNextTick() {
const { setTimeout } = (0, import_utils.getSafeTimers)();
return new Promise((resolve) => setTimeout(resolve, 0));
}
async function waitForImportsToResolve() {
await waitNextTick();
const state = getWorkerState();
const promises = [];
let resolvingCount = 0;
for (const mod of state.moduleCache.values()) {
if (mod.promise && !mod.evaluated) {
promises.push(mod.promise);
}
if (mod.resolving) {
resolvingCount++;
}
}
if (!promises.length && !resolvingCount) {
return;
}
await Promise.allSettled(promises);
await waitForImportsToResolve();
}
// ../../node_modules/.pnpm/vitest@3.1.1_@types+debug@4.1.12_@types+node@22.14.0_jiti@2.4.2_lightningcss@1.29.2_terser@5.39.0_tsx@4.19.3_yaml@2.7.1/node_modules/vitest/dist/chunks/vi.B-PuvDzu.js
var import_utils3 = require("@vitest/utils.js");
// ../../node_modules/.pnpm/vitest@3.1.1_@types+debug@4.1.12_@types+node@22.14.0_jiti@2.4.2_lightningcss@1.29.2_terser@5.39.0_tsx@4.19.3_yaml@2.7.1/node_modules/vitest/dist/chunks/_commonjsHelpers.BFTU3MAI.js
var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
function getDefaultExportFromCjs(x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
}
// ../../node_modules/.pnpm/vitest@3.1.1_@types+debug@4.1.12_@types+node@22.14.0_jiti@2.4.2_lightningcss@1.29.2_terser@5.39.0_tsx@4.19.3_yaml@2.7.1/node_modules/vitest/dist/chunks/vi.B-PuvDzu.js
var import_snapshot = require("@vitest/snapshot.js");
var import_error = require("@vitest/utils/error.js");
var import_spy = require("@vitest/spy.js");
var import_source_map = require("@vitest/utils/source-map.js");
// ../../node_modules/.pnpm/vitest@3.1.1_@types+debug@4.1.12_@types+node@22.14.0_jiti@2.4.2_lightningcss@1.29.2_terser@5.39.0_tsx@4.19.3_yaml@2.7.1/node_modules/vitest/dist/chunks/date.CDOsz-HY.js
var RealDate = Date;
var now = null;
var MockDate = class _MockDate extends RealDate {
constructor(y, m, d, h, M, s, ms) {
super();
let date;
switch (arguments.length) {
case 0:
if (now !== null) {
date = new RealDate(now.valueOf());
} else {
date = new RealDate();
}
break;
case 1:
date = new RealDate(y);
break;
default:
d = typeof d === "undefined" ? 1 : d;
h = h || 0;
M = M || 0;
s = s || 0;
ms = ms || 0;
date = new RealDate(y, m, d, h, M, s, ms);
break;
}
Object.setPrototypeOf(date, _MockDate.prototype);
return date;
}
};
MockDate.UTC = RealDate.UTC;
MockDate.now = function() {
return new MockDate().valueOf();
};
MockDate.parse = function(dateString) {
return RealDate.parse(dateString);
};
MockDate.toString = function() {
return RealDate.toString();
};
function mockDate(date) {
const dateObj = new RealDate(date.valueOf());
if (Number.isNaN(dateObj.getTime())) {
throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);
}
globalThis.Date = MockDate;
now = dateObj.valueOf();
}
function resetDate() {
globalThis.Date = RealDate;
}
// ../../node_modules/.pnpm/vitest@3.1.1_@types+debug@4.1.12_@types+node@22.14.0_jiti@2.4.2_lightningcss@1.29.2_terser@5.39.0_tsx@4.19.3_yaml@2.7.1/node_modules/vitest/dist/chunks/vi.B-PuvDzu.js
var unsupported = [
"matchSnapshot",
"toMatchSnapshot",
"toMatchInlineSnapshot",
"toThrowErrorMatchingSnapshot",
"toThrowErrorMatchingInlineSnapshot",
"throws",
"Throw",
"throw",
"toThrow",
"toThrowError"
];
function createExpectPoll(expect2) {
return function poll(fn2, options = {}) {
const state = getWorkerState();
const defaults = state.config.expect?.poll ?? {};
const { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options;
const assertion = expect2(null, message).withContext({ poll: true });
fn2 = fn2.bind(assertion);
const test2 = chai$1.util.flag(assertion, "vitest-test");
if (!test2) {
throw new Error("expect.poll() must be called inside a test");
}
const proxy = new Proxy(assertion, { get(target, key, receiver) {
const assertionFunction = Reflect.get(target, key, receiver);
if (typeof assertionFunction !== "function") {
return assertionFunction instanceof chai$1.Assertion ? proxy : assertionFunction;
}
if (key === "assert") {
return assertionFunction;
}
if (typeof key === "string" && unsupported.includes(key)) {
throw new SyntaxError(`expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`);
}
return function(...args) {
const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
const promise = () => new Promise((resolve, reject) => {
let intervalId;
let timeoutId;
let lastError;
const { setTimeout, clearTimeout } = (0, import_utils3.getSafeTimers)();
const check = async () => {
try {
chai$1.util.flag(assertion, "_name", key);
const obj = await fn2();
chai$1.util.flag(assertion, "object", obj);
resolve(await assertionFunction.call(assertion, ...args));
clearTimeout(intervalId);
clearTimeout(timeoutId);
} catch (err) {
lastError = err;
if (!chai$1.util.flag(assertion, "_isLastPollAttempt")) {
intervalId = setTimeout(check, interval);
}
}
};
timeoutId = setTimeout(() => {
clearTimeout(intervalId);
chai$1.util.flag(assertion, "_isLastPollAttempt", true);
const rejectWithCause = (cause) => {
reject(copyStackTrace$1(new Error("Matcher did not succeed in time.", { cause }), STACK_TRACE_ERROR));
};
check().then(() => rejectWithCause(lastError)).catch((e) => rejectWithCause(e));
}, timeout);
check();
});
let awaited = false;
test2.onFinished ??= [];
test2.onFinished.push(() => {
if (!awaited) {
const negated = chai$1.util.flag(assertion, "negate") ? "not." : "";
const name = chai$1.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)";
const assertionString = `expect.${name}.${negated}${String(key)}()`;
const error = new Error(`${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:
await ${assertionString}
`);
throw copyStackTrace$1(error, STACK_TRACE_ERROR);
}
});
let resultPromise;
return {
then(onFulfilled, onRejected) {
awaited = true;
return (resultPromise ||= promise()).then(onFulfilled, onRejected);
},
catch(onRejected) {
return (resultPromise ||= promise()).catch(onRejected);
},
finally(onFinally) {
return (resultPromise ||= promise()).finally(onFinally);
},
[Symbol.toStringTag]: "Promise"
};
};
} });
return proxy;
};
}
function copyStackTrace$1(target, source) {
if (source.stack !== void 0) {
target.stack = source.stack.replace(source.message, target.message);
}
return target;
}
function commonjsRequire(path) {
throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
}
var chaiSubset$1 = { exports: {} };
var chaiSubset = chaiSubset$1.exports;
var hasRequiredChaiSubset;
function requireChaiSubset() {
if (hasRequiredChaiSubset) return chaiSubset$1.exports;
hasRequiredChaiSubset = 1;
(function(module2, exports2) {
(function() {
(function(chaiSubset2) {
if (typeof commonjsRequire === "function" && true && true) {
return module2.exports = chaiSubset2;
} else {
return chai.use(chaiSubset2);
}
})(function(chai3, utils) {
var Assertion2 = chai3.Assertion;
var assertionPrototype = Assertion2.prototype;
Assertion2.addMethod("containSubset", function(expected) {
var actual = utils.flag(this, "object");
var showDiff = chai3.config.showDiff;
assertionPrototype.assert.call(
this,
compare(expected, actual),
"expected #{act} to contain subset #{exp}",
"expected #{act} to not contain subset #{exp}",
expected,
actual,
showDiff
);
});
chai3.assert.containSubset = function(val, exp, msg) {
new chai3.Assertion(val, msg).to.be.containSubset(exp);
};
function compare(expected, actual) {
if (expected === actual) {
return true;
}
if (typeof actual !== typeof expected) {
return false;
}
if (typeof expected !== "object" || expected === null) {
return expected === actual;
}
if (!!expected && !actual) {
return false;
}
if (Array.isArray(expected)) {
if (typeof actual.length !== "number") {
return false;
}
var aa = Array.prototype.slice.call(actual);
return expected.every(function(exp) {
return aa.some(function(act) {
return compare(exp, act);
});
});
}
if (expected instanceof Date) {
if (actual instanceof Date) {
return expected.getTime() === actual.getTime();
} else {
return false;
}
}
return Object.keys(expected).every(function(key) {
var eo = expected[key];
var ao = actual[key];
if (typeof eo === "object" && eo !== null && ao !== null) {
return compare(eo, ao);
}
if (typeof eo === "function") {
return eo(ao);
}
return ao === eo;
});
}
});
}).call(chaiSubset);
})(chaiSubset$1);
return chaiSubset$1.exports;
}
var chaiSubsetExports = requireChaiSubset();
var Subset = /* @__PURE__ */ getDefaultExportFromCjs(chaiSubsetExports);
function createAssertionMessage(util2, assertion, hasArgs) {
const not = util2.flag(assertion, "negate") ? "not." : "";
const name = `${util2.flag(assertion, "_name")}(${"expected"})`;
const promiseName = util2.flag(assertion, "promise");
const promise = promiseName ? `.${promiseName}` : "";
return `expect(actual)${promise}.${not}${name}`;
}
function recordAsyncExpect(_test, promise, assertion, error) {
const test2 = _test;
if (test2 && promise instanceof Promise) {
promise = promise.finally(() => {
if (!test2.promises) {
return;
}
const index = test2.promises.indexOf(promise);
if (index !== -1) {
test2.promises.splice(index, 1);
}
});
if (!test2.promises) {
test2.promises = [];
}
test2.promises.push(promise);
let resolved = false;
test2.onFinished ??= [];
test2.onFinished.push(() => {
if (!resolved) {
const processor = globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || "");
const stack = processor(error.stack);
console.warn([
`Promise returned by \`${assertion}\` was not awaited. `,
"Vitest currently auto-awaits hanging assertions at the end of the test, but this will cause the test to fail in Vitest 3. ",
"Please remember to await the assertion.\n",
stack
].join(""));
}
});
return {
then(onFulfilled, onRejected) {
resolved = true;
return promise.then(onFulfilled, onRejected);
},
catch(onRejected) {
return promise.catch(onRejected);
},
finally(onFinally) {
return promise.finally(onFinally);
},
[Symbol.toStringTag]: "Promise"
};
}
return promise;
}
var _client;
function getSnapshotClient() {
if (!_client) {
_client = new import_snapshot.SnapshotClient({ isEqual: (received, expected) => {
return (0, import_expect.equals)(received, expected, [import_expect.iterableEquality, import_expect.subsetEquality]);
} });
}
return _client;
}
function getError(expected, promise) {
if (typeof expected !== "function") {
if (!promise) {
throw new Error(`expected must be a function, received ${typeof expected}`);
}
return expected;
}
try {
expected();
} catch (e) {
return e;
}
throw new Error("snapshot function didn't throw");
}
function getTestNames(test2) {
return {
filepath: test2.file.filepath,
name: (0, import_utils2.getNames)(test2).slice(1).join(" > "),
testId: test2.id
};
}
var SnapshotPlugin = (chai3, utils) => {
function getTest(assertionName, obj) {
const test2 = utils.flag(obj, "vitest-test");
if (!test2) {
throw new Error(`'${assertionName}' cannot be used without test context`);
}
return test2;
}
for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
utils.addMethod(chai3.Assertion.prototype, key, function(properties, message) {
utils.flag(this, "_name", key);
const isNot = utils.flag(this, "negate");
if (isNot) {
throw new Error(`${key} cannot be used with "not"`);
}
const expected = utils.flag(this, "object");
const test2 = getTest(key, this);
if (typeof properties === "string" && typeof message === "undefined") {
message = properties;
properties = void 0;
}
const errorMessage = utils.flag(this, "message");
getSnapshotClient().assert({
received: expected,
message,
isInline: false,
properties,
errorMessage,
...getTestNames(test2)
});
});
}
utils.addMethod(chai3.Assertion.prototype, "toMatchFileSnapshot", function(file, message) {
utils.flag(this, "_name", "toMatchFileSnapshot");
const isNot = utils.flag(this, "negate");
if (isNot) {
throw new Error('toMatchFileSnapshot cannot be used with "not"');
}
const error = new Error("resolves");
const expected = utils.flag(this, "object");
const test2 = getTest("toMatchFileSnapshot", this);
const errorMessage = utils.flag(this, "message");
const promise = getSnapshotClient().assertRaw({
received: expected,
message,
isInline: false,
rawSnapshot: { file },
errorMessage,
...getTestNames(test2)
});
return recordAsyncExpect(test2, promise, createAssertionMessage(utils, this), error);
});
utils.addMethod(chai3.Assertion.prototype, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
utils.flag(this, "_name", "toMatchInlineSnapshot");
const isNot = utils.flag(this, "negate");
if (isNot) {
throw new Error('toMatchInlineSnapshot cannot be used with "not"');
}
const test2 = getTest("toMatchInlineSnapshot", this);
const isInsideEach = test2.each || test2.suite?.each;
if (isInsideEach) {
throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
}
const expected = utils.flag(this, "object");
const error = utils.flag(this, "error");
if (typeof properties === "string") {
message = inlineSnapshot;
inlineSnapshot = properties;
properties = void 0;
}
if (inlineSnapshot) {
inlineSnapshot = (0, import_snapshot.stripSnapshotIndentation)(inlineSnapshot);
}
const errorMessage = utils.flag(this, "message");
getSnapshotClient().assert({
received: expected,
message,
isInline: true,
properties,
inlineSnapshot,
error,
errorMessage,
...getTestNames(test2)
});
});
utils.addMethod(chai3.Assertion.prototype, "toThrowErrorMatchingSnapshot", function(message) {
utils.flag(this, "_name", "toThrowErrorMatchingSnapshot");
const isNot = utils.flag(this, "negate");
if (isNot) {
throw new Error('toThrowErrorMatchingSnapshot cannot be used with "not"');
}
const expected = utils.flag(this, "object");
const test2 = getTest("toThrowErrorMatchingSnapshot", this);
const promise = utils.flag(this, "promise");
const errorMessage = utils.flag(this, "message");
getSnapshotClient().assert({
received: getError(expected, promise),
message,
errorMessage,
...getTestNames(test2)
});
});
utils.addMethod(chai3.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
const isNot = utils.flag(this, "negate");
if (isNot) {
throw new Error('toThrowErrorMatchingInlineSnapshot cannot be used with "not"');
}
const test2 = getTest("toThrowErrorMatchingInlineSnapshot", this);
const isInsideEach = test2.each || test2.suite?.each;
if (isInsideEach) {
throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
}
const expected = utils.flag(this, "object");
const error = utils.flag(this, "error");
const promise = utils.flag(this, "promise");
const errorMessage = utils.flag(this, "message");
if (inlineSnapshot) {
inlineSnapshot = (0, import_snapshot.stripSnapshotIndentation)(inlineSnapshot);
}
getSnapshotClient().assert({
received: getError(expected, promise),
message,
inlineSnapshot,
isInline: true,
error,
errorMessage,
...getTestNames(test2)
});
});
utils.addMethod(chai3.expect, "addSnapshotSerializer", import_snapshot.addSerializer);
};
chai$1.use(import_expect.JestExtend);
chai$1.use(import_expect.JestChaiExpect);
chai$1.use(Subset);
chai$1.use(SnapshotPlugin);
chai$1.use(import_expect.JestAsymmetricMatchers);
function createExpect(test2) {
const expect2 = (value, message) => {
const { assertionCalls } = (0, import_expect.getState)(expect2);
(0, import_expect.setState)({ assertionCalls: assertionCalls + 1 }, expect2);
const assert3 = chai$1.expect(value, message);
const _test = test2 || (0, import_runner.getCurrentTest)();
if (_test) {
return assert3.withTest(_test);
} else {
return assert3;
}
};
Object.assign(expect2, chai$1.expect);
Object.assign(expect2, globalThis[import_expect.ASYMMETRIC_MATCHERS_OBJECT]);
expect2.getState = () => (0, import_expect.getState)(expect2);
expect2.setState = (state) => (0, import_expect.setState)(state, expect2);
const globalState = (0, import_expect.getState)(globalThis[import_expect.GLOBAL_EXPECT]) || {};
(0, import_expect.setState)({
...globalState,
assertionCalls: 0,
isExpectingAssertions: false,
isExpectingAssertionsError: null,
expectedAssertionsNumber: null,
expectedAssertionsNumberErrorGen: null,
environment: getCurrentEnvironment(),
get testPath() {
return getWorkerState().filepath;
},
currentTestName: test2 ? (0, import_utils2.getTestName)(test2) : globalState.currentTestName
}, expect2);
expect2.extend = (matchers) => chai$1.expect.extend(expect2, matchers);
expect2.addEqualityTesters = (customTesters) => (0, import_expect.addCustomEqualityTesters)(customTesters);
expect2.soft = (...args) => {
return expect2(...args).withContext({ soft: true });
};
expect2.poll = createExpectPoll(expect2);
expect2.unreachable = (message) => {
chai$1.assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
};
function assertions(expected) {
const errorGen = () => new Error(`expected number of assertions to be ${expected}, but got ${expect2.getState().assertionCalls}`);
if (Error.captureStackTrace) {
Error.captureStackTrace(errorGen(), assertions);
}
expect2.setState({
expectedAssertionsNumber: expected,
expectedAssertionsNumberErrorGen: errorGen
});
}
function hasAssertions() {
const error = new Error("expected any number of assertion, but got none");
if (Error.captureStackTrace) {
Error.captureStackTrace(error, hasAssertions);
}
expect2.setState({
isExpectingAssertions: true,
isExpectingAssertionsError: error
});
}
chai$1.util.addMethod(expect2, "assertions", assertions);
chai$1.util.addMethod(expect2, "hasAssertions", hasAssertions);
expect2.extend(import_expect.customMatchers);
return expect2;
}
var globalExpect = createExpect();
Object.defineProperty(globalThis, import_expect.GLOBAL_EXPECT, {
value: globalExpect,
writable: true,
configurable: true
});
var fakeTimersSrc = {};
var global2;
var hasRequiredGlobal;
function requireGlobal() {
if (hasRequiredGlobal) return global2;
hasRequiredGlobal = 1;
var globalObject;
if (typeof commonjsGlobal !== "undefined") {
globalObject = commonjsGlobal;
} else if (typeof window !== "undefined") {
globalObject = window;
} else {
globalObject = self;
}
global2 = globalObject;
return global2;
}
var throwsOnProto_1;
var hasRequiredThrowsOnProto;
function requireThrowsOnProto() {
if (hasRequiredThrowsOnProto) return throwsOnProto_1;
hasRequiredThrowsOnProto = 1;
let throwsOnProto;
try {
const object2 = {};
object2.__proto__;
throwsOnProto = false;
} catch (_) {
throwsOnProto = true;
}
throwsOnProto_1 = throwsOnProto;
return throwsOnProto_1;
}
var copyPrototypeMethods;
var hasRequiredCopyPrototypeMethods;
function requireCopyPrototypeMethods() {
if (hasRequiredCopyPrototypeMethods) return copyPrototypeMethods;
hasRequiredCopyPrototypeMethods = 1;
var call = Function.call;
var throwsOnProto = requireThrowsOnProto();
var disallowedProperties = [
// ignore size because it throws from Map
"size",
"caller",
"callee",
"arguments"
];
if (throwsOnProto) {
disallowedProperties.push("__proto__");
}
copyPrototypeMethods = function copyPrototypeMethods2(prototype) {
return Object.getOwnPropertyNames(prototype).reduce(
function(result, name) {
if (disallowedProperties.includes(name)) {
return result;
}
if (typeof prototype[name] !== "function") {
return result;
}
result[name] = call.bind(prototype[name]);
return result;
},
/* @__PURE__ */ Object.create(null)
);
};
return copyPrototypeMethods;
}
var array;
var hasRequiredArray;
function requireArray() {
if (hasRequiredArray) return array;
hasRequiredArray = 1;
var copyPrototype = requireCopyPrototypeMethods();
array = copyPrototype(Array.prototype);
return array;
}
var calledInOrder_1;
var hasRequiredCalledInOrder;
function requireCalledInOrder() {
if (hasRequiredCalledInOrder) return calledInOrder_1;
hasRequiredCalledInOrder = 1;
var every2 = requireArray().every;
function hasCallsLeft(callMap, spy) {
if (callMap[spy.id] === void 0) {
callMap[spy.id] = 0;
}
return callMap[spy.id] < spy.callCount;
}
function checkAdjacentCalls(callMap, spy, index, spies) {
var calledBeforeNext = true;
if (index !== spies.length - 1) {
calledBeforeNext = spy.calledBefore(spies[index + 1]);
}
if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
callMap[spy.id] += 1;
return true;
}
return false;
}
function calledInOrder(spies) {
var callMap = {};
var _spies = arguments.length > 1 ? arguments : spies;
return every2(_spies, checkAdjacentCalls.bind(null, callMap));
}
calledInOrder_1 = calledInOrder;
return calledInOrder_1;
}
var className_1;
var hasRequiredClassName;
function requireClassName() {
if (hasRequiredClassName) return className_1;
hasRequiredClassName = 1;
function className(value) {
const name = value.constructor && value.constructor.name;
return name || null;
}
className_1 = className;
return className_1;
}
var deprecated = {};
var hasRequiredDeprecated;
function requireDeprecated() {
if (hasRequiredDeprecated) return deprecated;
hasRequiredDeprecated = 1;
(function(exports2) {
exports2.wrap = function(func, msg) {
var wrapped = function() {
exports2.printWarning(msg);
return func.apply(this, arguments);
};
if (func.prototype) {
wrapped.prototype = func.prototype;
}
return wrapped;
};
exports2.defaultMsg = function(packageName, funcName) {
return `${packageName}.${funcName} is deprecated and will be removed from the public API in a future version of ${packageName}.`;
};
exports2.printWarning = function(msg) {
if (typeof process === "object" && process.emitWarning) {
process.emitWarning(msg);
} else if (console.info) {
console.info(msg);
} else {
console.log(msg);
}
};
})(deprecated);
return deprecated;
}
var every;
var hasRequiredEvery;
function requireEvery() {
if (hasRequiredEvery) return every;
hasRequiredEvery = 1;
every = function every2(obj, fn2) {
var pass = true;
try {
obj.forEach(function() {
if (!fn2.apply(this, arguments)) {
throw new Error();
}
});
} catch (e) {
pass = false;
}
return pass;
};
return every;
}
var functionName;
var hasRequiredFunctionName;
function requireFunctionName() {
if (hasRequiredFunctionName) return functionName;
hasRequiredFunctionName = 1;
functionName = function functionName2(func) {
if (!func) {
return "";
}
try {
return func.displayName || func.name || // Use function decomposition as a last resort to get function
// name. Does not rely on function decomposition to work - if it
// doesn't debugging will be slightly less informative
// (i.e. toString will say 'spy' rather than 'myFunc').
(String(func).match(/function ([^\s(]+)/) || [])[1];
} catch (e) {
return "";
}
};
return functionName;
}
var orderByFirstCall_1;
var hasRequiredOrderByFirstCall;
function requireOrderByFirstCall() {
if (hasRequiredOrderByFirstCall) return orderByFirstCall_1;
hasRequiredOrderByFirstCall = 1;
var sort = requireArray().sort;
var slice = requireArray().slice;
function comparator(a, b) {
var aCall = a.getCall(0);
var bCall = b.getCall(0);
var aId = aCall && aCall.callId || -1;
var bId = bCall && bCall.callId || -1;
return aId < bId ? -1 : 1;
}
function orderByFirstCall(spies) {
return sort(slice(spies), comparator);
}
orderByFirstCall_1 = orderByFirstCall;
return orderByFirstCall_1;
}
var _function;
var hasRequired_function;
function require_function() {
if (hasRequired_function) return _function;
hasRequired_function = 1;
var copyPrototype = requireCopyPrototypeMethods();
_function = copyPrototype(Function.prototype);
return _function;
}
var map;
var hasRequiredMap;
function requireMap() {
if (hasRequiredMap) return map;
hasRequiredMap = 1;
var copyPrototype = requireCopyPrototypeMethods();
map = copyPrototype(Map.prototype);
return map;
}
var object;
var hasRequiredObject;
function requireObject() {
if (hasRequiredObject) return object;
hasRequiredObject = 1;
var copyPrototype = requireCopyPrototypeMethods();
object = copyPrototype(Object.prototype);
return object;
}
var set;
var hasRequiredSet;
function requireSet() {
if (hasRequiredSet) return set;
hasRequiredSet = 1;
var copyPrototype = requireCopyPrototypeMethods();
set = copyPrototype(Set.prototype);
return set;
}
var string;
var hasRequiredString;
function requireString() {
if (hasRequiredString) return string;
hasRequiredString = 1;
var copyPrototype = requireCopyPrototypeMethods();
string = copyPrototype(String.prototype);
return string;
}
var prototypes;
var hasRequiredPrototypes;
function requirePrototypes() {
if (hasRequiredPrototypes) return prototypes;
hasRequiredPrototypes = 1;
prototypes = {
array: requireArray(),
function: require_function(),
map: requireMap(),
object: requireObject(),
set: requireSet(),
string: requireString()
};
return prototypes;
}
var typeDetect$1 = { exports: {} };
var typeDetect = typeDetect$1.exports;
var hasRequiredTypeDetect;
function requireTypeDetect() {
if (hasRequiredTypeDetect) return typeDetect$1.exports;
hasRequiredTypeDetect = 1;
(function(module2, exports2) {
(function(global3, factory) {
module2.exports = factory();
})(typeDetect, function() {
var promiseExists = typeof Promise === "function";
var globalObject = typeof self === "object" ? self : commonjsGlobal;
var symbolExists = typeof Symbol !== "undefined";
var mapExists = typeof Map !== "undefined";
var setExists = typeof Set !== "undefined";
var weakMapExists = typeof WeakMap !== "undefined";
var weakSetExists = typeof WeakSet !== "undefined";
var dataViewExists = typeof DataView !== "undefined";
var symbolIteratorExists = symbolExists && typeof Symbol.iterator !== "undefined";
var symbolToStringTagExists = symbolExists && typeof Symbol.toStringTag !== "undefined";
var setEntriesExists = setExists && typeof Set.prototype.entries === "function";
var mapEntriesExists = mapExists && typeof Map.prototype.entries === "function";
var setIteratorPrototype = setEntriesExists && Object.getPrototypeOf((/* @__PURE__ */ new Set()).entries());
var mapIteratorPrototype = mapEntriesExists && Object.getPrototypeOf((/* @__PURE__ */ new Map()).entries());
var arrayIteratorExists = symbolIteratorExists && typeof Array.prototype[Symbol.iterator] === "function";
var arrayIteratorPrototype = arrayIteratorExists && Object.getPrototypeOf([][Symbol.iterator]());
var stringIteratorExists = symbolIteratorExists && typeof String.prototype[Symbol.iterator] === "function";
var stringIteratorPrototype = stringIteratorExists && Object.getPrototypeOf(""[Symbol.iterator]());
var toStringLeftSliceLength = 8;
var toStringRightSliceLength = -1;
function typeDetect2(obj) {
var typeofObj = typeof obj;
if (typeofObj !== "object") {
return typeofObj;
}
if (obj === null) {
return "null";
}
if (obj === globalObject) {
return "global";
}
if (Array.isArray(obj) && (symbolToStringTagExists === false || !(Symbol.toStringTag in obj))) {
return "Array";
}
if (typeof window === "object" && window !== null) {
if (typeof window.location === "object" && obj === window.location) {
return "Location";
}
if (typeof window.document === "object" && obj === window.document) {
return "Document";
}
if (typeof window.navigator === "object") {
if (typeof window.navigator.mimeTypes === "object" && obj === window.navigator.mimeTypes) {
return "MimeTypeArray";
}
if (typeof window.navigator.plugins === "object" && obj === window.navigator.plugins) {
return "PluginArray";
}
}
if ((typeof window.HTMLElement === "function" || typeof window.HTMLElement === "object") && obj instanceof window.HTMLElement) {
if (obj.tagName === "BLOCKQUOTE") {
return "HTMLQuoteElement";
}
if (obj.tagName === "TD") {
return "HTMLTableDataCellElement";
}
if (obj.tagName === "TH") {
return "HTMLTableHeaderCellElement";
}
}
}
var stringTag = symbolToStringTagExists && obj[Symbol.toStringTag];
if (typeof stringTag === "string") {
return stringTag;
}
var objPrototype = Object.getPrototypeOf(obj);
if (objPrototype === RegExp.prototype) {
return "RegExp";
}
if (objPrototype === Date.prototype) {
return "Date";
}
if (promiseExists && objPrototype === Promise.prototype) {
return "Promise";
}
if (setExists && objPrototype === Set.prototype) {
return "Set";
}
if (mapExists && objPrototype === Map.prototype) {
return "Map";
}
if (weakSetExists && objPrototype === WeakSet.prototype) {
return "WeakSet";
}
if (weakMapExists && objPrototype === WeakMap.prototype) {
return "WeakMap";
}
if (dataViewExists && objPrototype === DataView.prototype) {
return "DataView";
}
if (mapExists && objPrototype === mapIteratorPrototype) {
return "Map Iterator";
}
if (setExists && objPrototype === setIteratorPrototype) {
return "Set Iterator";
}
if (arrayIteratorExists && objPrototype === arrayIteratorPrototype) {
return "Array Iterator";
}
if (stringIteratorExists && objPrototype === stringIteratorPrototype) {
return "String Iterator";
}
if (objPrototype === null) {
return "Object";
}
return Object.prototype.toString.call(obj).slice(toStringLeftSliceLength, toStringRightSliceLength);
}
return typeDetect2;
});
})(typeDetect$1);
return typeDetect$1.exports;
}
var typeOf;
var hasRequiredTypeOf;
function requireTypeOf() {
if (hasRequiredTypeOf) return typeOf;
hasRequiredTypeOf = 1;
var type = requireTypeDetect();
typeOf = function typeOf2(value) {
return type(value).toLowerCase();
};
return typeOf;
}
var valueToString_1;
var hasRequiredValueToString;
function requireValueToString() {
if (hasRequiredValueToString) return valueToString_1;
hasRequiredValueToString = 1;
function valueToString(value) {
if (value && value.toString) {
return value.toString();
}
return String(value);
}
valueToString_1 = valueToString;
return valueToString_1;
}
var lib;
var hasRequiredLib;
function requireLib() {
if (hasRequiredLib) return lib;
hasRequiredLib = 1;
lib = {
global: requireGlobal(),
calledInOrder: requireCalledInOrder(),
className: requireClassName(),
deprecated: requireDeprecated(),
every: requireEvery(),
functionName: requireFunctionName(),
orderByFirstCall: requireOrderByFirstCall(),
prototypes: requirePrototypes(),
typeOf: requireTypeOf(),
valueToString: requireValueToString()
};
return lib;
}
var hasRequiredFakeTimersSrc;
function requireFakeTimersSrc() {
if (hasRequiredFakeTimersSrc) return fakeTimersSrc;
hasRequiredFakeTimersSrc = 1;
const globalObject = requireLib().global;
let timersModule, timersPromisesModule;
if (typeof __vitest_required__ !== "undefined") {
try {
timersModule = __vitest_required__.timers;
} catch (e) {
}
try {
timersPromisesModule = __vitest_required__.timersPromises;
} catch (e) {
}
}
function withGlobal(_global) {
const maxTimeout = Math.pow(2, 31) - 1;
const idCounterStart = 1e12;
const NOOP = function() {
return void 0;
};
const NOOP_ARRAY = function() {
return [];
};
const isPresent = {};
let timeoutResult, addTimerReturnsObject = false;
if (_global.setTimeout) {
isPresent.setTimeout = true;
timeoutResult = _global.setTimeout(NOOP, 0);
addTimerReturnsObject = typeof timeoutResult === "object";
}
isPresent.clearTimeout = Boolean(_global.clearTimeout);
isPresent.setInterval = Boolean(_global.setInterval);
isPresent.clearInterval = Boolean(_global.clearInterval);
isPresent.hrtime = _global.process && typeof _global.process.hrtime === "function";
isPresent.hrtimeBigint = isPresent.hrtime && typeof _global.process.hrtime.bigint === "function";
isPresent.nextTick = _global.process && typeof _global.process.nextTick === "function";
const utilPromisify = _global.process && _global.__vitest_required__ && _global.__vitest_required__.util.promisify;
isPresent.performance = _global.performance && typeof _global.performance.now === "function";
const hasPerformancePrototype = _global.Performance && (typeof _global.Performance).match(/^(function|object)$/);
const hasPerformanceConstructorPrototype = _global.performance && _global.performance.constructor && _global.performance.constructor.prototype;
isPresent.queueMicrotask = _global.hasOwnProperty("queueMicrotask");
isPresent.requestAnimationFrame = _global.requestAnimationFrame && typeof _global.requestAnimationFrame === "function";
isPresent.cancelAnimationFrame = _global.cancelAnimationFrame && typeof _global.cancelAnimationFrame === "function";
isPresent.requestIdleCallback = _global.requestIdleCallback && typeof _global.requestIdleCallback === "function";
isPresent.cancelIdleCallbackPresent = _global.cancelIdleCallback && typeof _global.cancelIdleCallback === "function";
isPresent.setImmediate = _global.setImmediate && typeof _global.setImmediate === "function";
isPresent.clearImmediate = _global.clearImmediate && typeof _global.clearImmediate === "function";
isPresent.Intl = _global.Intl && typeof _global.Intl === "object";
if (_global.clearTimeout) {
_global.clearTimeout(timeoutResult);
}
const NativeDate = _global.Date;
const NativeIntl = isPresent.Intl ? Object.defineProperties(
/* @__PURE__ */ Object.create(null),
Object.getOwnPropertyDescriptors(_global.Intl)
) : void 0;
let uniqueTimerId = idCounterStart;
if (NativeDate === void 0) {
throw new Error(
"The global scope doesn't have a `Date` object (see https://github.com/sinonjs/sinon/issues/1852#issuecomment-419622780)"
);
}
isPresent.Date = true;
class FakePerformanceEntry {
constructor(name, entryType, startTime, duration) {
this.name = name;
this.entryType = entryType;
this.startTime = startTime;
this.duration = duration;
}
toJSON() {
return JSON.stringify({ ...this });
}
}
function isNumberFinite(num) {
if (Number.isFinite) {
return Number.isFinite(num);
}
return isFinite(num);
}
let isNearInfiniteLimit = false;
function checkIsNearInfiniteLimit(clock, i) {
if (clock.loopLimit && i === clock.loopLimit - 1) {
isNearInfiniteLimit = true;
}
}
function resetIsNearInfiniteLimit() {
isNearInfiniteLimit = false;
}
function parseTime(str) {
if (!str) {
return 0;
}
const strings = str.split(":");
const l = strings.length;
let i = l;
let ms = 0;
let parsed;
if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
throw new Error(
"tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits"
);
}
while (i--) {
parsed = parseInt(strings[i], 10);
if (parsed >= 60) {
throw new Error(`Invalid time ${str}`);
}
ms += parsed * Math.pow(60, l - i - 1);
}
return ms * 1e3;
}
function nanoRemainder(msFloat) {
const modulo = 1e6;
const remainder = msFloat * 1e6 % modulo;
const positiveRemainder = remainder < 0 ? remainder + modulo : remainder;
return Math.floor(positiveRemainder);
}
function getEpoch(epoch) {
if (!epoch) {
return 0;
}
if (typeof epoch.getTime === "function") {
return epoch.getTime();
}
if (typeof epoch === "number") {
return epoch;
}
throw new TypeError("now should be milliseconds since UNIX epoch");
}
function inRange(from, to, timer) {
return timer && timer.callAt >= from && timer.callAt <= to;
}
function getInfiniteLoopError(clock, job) {
const infiniteLoopError = new Error(
`Aborting after running ${clock.loopLimit} timers, assuming an infinite loop!`
);
if (!job.error) {
return infiniteLoopError;
}
const computedTargetPattern = /target\.*[<|(|[].*?[>|\]|)]\s*/;
let clockMethodPattern = new RegExp(
String(Object.keys(clock).join("|"))
);
if (addTimerReturnsObject) {
clockMethodPattern = new RegExp(
`\\s+at (Object\\.)?(?:${Object.keys(clock).join("|")})\\s+`
);
}
let matchedLineIndex = -1;
job.error.stack.split("\n").some(function(line, i) {
const matchedComputedTarget = line.match(computedTargetPattern);
if (matchedComputedTarget) {
matchedLineIndex = i;
return true;
}
const matchedClockMethod = line.match(clockMethodPattern);
if (matchedClockMethod) {
matchedLineIndex = i;
return false;
}
return matchedLineIndex >= 0;
});
const stack = `${infiniteLoopError}
${job.type || "Microtask"} - ${job.func.name || "anonymous"}
${job.error.stack.split("\n").slice(matchedLineIndex + 1).join("\n")}`;
try {
Object.defineProperty(infiniteLoopError, "stack", {
value: stack
});
} catch (e) {
}
return infiniteLoopError;
}
function createDate() {
class ClockDate extends NativeDate {
/**
* @param {number} year
* @param {number} month
* @param {number} date
* @param {number} hour
* @param {number} minute
* @param {number} second
* @param {number} ms
* @returns void
*/
// eslint-disable-next-line no-unused-vars
constructor(year, month, date, hour, minute, second, ms) {
if (arguments.length === 0) {
super(ClockDate.clock.now);
} else {
super(...arguments);
}
Object.defineProperty(this, "constructor", {
value: NativeDate,
enumerable: false
});
}
static [Symbol.hasInstance](instance) {
return instance instanceof NativeDate;
}
}
ClockDate.isFake = true;
if (NativeDate.now) {
ClockDate.now = function now2() {
return ClockDate.clock.now;
};
}
if (NativeDate.toSource) {
ClockDate.toSource = function toSource() {
return NativeDate.toSource();
};
}
ClockDate.toString = function toString() {
return NativeDate.toString();
};
const ClockDateProxy = new Proxy(ClockDate, {
// handler for [[Call]] invocations (i.e. not using `new`)
apply() {
if (this instanceof ClockDate) {
throw new TypeError(
"A Proxy should only capture `new` calls with the `construct` handler. This is not supposed to be possible, so check the logic."
);
}
return new NativeDate(ClockDate.clock.now).toString();
}
});
return ClockDateProxy;
}
function createIntl() {
const ClockIntl = {};
Object.getOwnPropertyNames(NativeIntl).forEach(
(property) => ClockIntl[property] = NativeIntl[property]
);
ClockIntl.DateTimeFormat = function(...args) {
const realFormatter = new NativeIntl.DateTimeFormat(...args);
const formatter = {};
["formatRange", "formatRangeToParts", "resolvedOptions"].forEach(
(method) => {
formatter[method] = realFormatter[method].bind(realFormatter);
}
);
["format", "formatToParts"].forEach((method) => {
formatter[method] = function(date) {
return realFormatter[method](date || ClockIntl.clock.now);
};
});
return formatter;
};
ClockIntl.DateTimeFormat.prototype = Object.create(
NativeIntl.DateTimeFormat.prototype
);
ClockIntl.DateTimeFormat.supportedLocalesOf = NativeIntl.DateTimeFormat.supportedLocalesOf;
return ClockIntl;
}
function enqueueJob(clock, job) {
if (!clock.jobs) {
clock.jobs = [];
}
clock.jobs.push(job);
}
function runJobs(clock) {
if (!clock.jobs) {
return;
}
for (let i = 0; i < clock.jobs.length; i++) {
const job = clock.jobs[i];
job.func.apply(null, job.args);
checkIsNearInfiniteLimit(clock, i);
if (clock.loopLimit && i > clock.loopLimit) {
throw getInfiniteLoopError(clock, job);
}
}
resetIsNearInfiniteLimit();
clock.jobs = [];
}
function addTimer(clock, timer) {
if (timer.func === void 0) {
throw new Error("Callback must be provided to timer calls");
}
if (addTimerReturnsObject) {
if (typeof timer.func !== "function") {
throw new TypeError(
`[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${timer.func} of type ${typeof timer.func}`
);
}
}
if (isNearInfiniteLimit) {
timer.error = new Error();
}
timer.type = timer.immediate ? "Immediate" : "Timeout";
if (timer.hasOwnProperty("delay")) {
if (typeof timer.delay !== "number") {
timer.delay = parseInt(timer.delay, 10);
}
if (!isNumberFinite(timer.delay)) {
timer.delay = 0;
}
timer.delay = timer.delay > maxTimeout ? 1 : timer.delay;
timer.delay = Math.max(0, timer.delay);
}
if (timer.hasOwnProperty("interval")) {
timer.type = "Interval";
timer.interval = timer.interval > maxTimeout ? 1 : timer.interval;
}
if (timer.hasOwnProperty("animation")) {
timer.type = "AnimationFrame";
timer.animation = true;
}
if (timer.hasOwnProperty("idleCallback")) {
timer.type = "IdleCallback";
timer.idleCallback = true;
}
if (!clock.timers) {
clock.timers = {};
}
timer.id = uniqueTimerId++;
timer.createdAt = clock.now;
timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
clock.timers[timer.id] = timer;
if (addTimerReturnsObject) {
const res = {
refed: true,
ref: function() {
this.refed = true;
return res;
},
unref: function() {
this.refed = false;
return res;
},
hasRef: function() {
return this.refed