storybook
Version:
Storybook: Develop, document, and test UI components in isolation
1,255 lines • 56.7 kB
JavaScript
// ../../node_modules/@vitest/mocker/dist/chunk-registry.js
var MockerRegistry = class {
registryByUrl = /* @__PURE__ */ new Map();
registryById = /* @__PURE__ */ new Map();
clear() {
this.registryByUrl.clear(), this.registryById.clear();
}
keys() {
return this.registryByUrl.keys();
}
add(mock) {
this.registryByUrl.set(mock.url, mock), this.registryById.set(mock.id, mock);
}
register(typeOrEvent, raw, id, url, factoryOrRedirect) {
let type = typeof typeOrEvent == "object" ? typeOrEvent.type : typeOrEvent;
if (typeof typeOrEvent == "object") {
let event = typeOrEvent;
if (event instanceof AutomockedModule || event instanceof AutospiedModule || event instanceof ManualMockedModule || event instanceof RedirectedModule)
throw new TypeError(`[vitest] Cannot register a mock that is already defined. Expected a JSON representation from \`MockedModule.toJSON\`, instead got "${event.type}". Use "registry.add()" to update a mock instead.`);
if (event.type === "automock") {
let module = AutomockedModule.fromJSON(event);
return this.add(module), module;
} else if (event.type === "autospy") {
let module = AutospiedModule.fromJSON(event);
return this.add(module), module;
} else if (event.type === "redirect") {
let module = RedirectedModule.fromJSON(event);
return this.add(module), module;
} else throw event.type === "manual" ? new Error("Cannot set serialized manual mock. Define a factory function manually with `ManualMockedModule.fromJSON()`.") : new Error(`Unknown mock type: ${event.type}`);
}
if (typeof raw != "string")
throw new TypeError("[vitest] Mocks require a raw string.");
if (typeof url != "string")
throw new TypeError("[vitest] Mocks require a url string.");
if (typeof id != "string")
throw new TypeError("[vitest] Mocks require an id string.");
if (type === "manual") {
if (typeof factoryOrRedirect != "function")
throw new TypeError("[vitest] Manual mocks require a factory function.");
let mock = new ManualMockedModule(raw, id, url, factoryOrRedirect);
return this.add(mock), mock;
} else if (type === "automock" || type === "autospy") {
let mock = type === "automock" ? new AutomockedModule(raw, id, url) : new AutospiedModule(raw, id, url);
return this.add(mock), mock;
} else if (type === "redirect") {
if (typeof factoryOrRedirect != "string")
throw new TypeError("[vitest] Redirect mocks require a redirect string.");
let mock = new RedirectedModule(raw, id, url, factoryOrRedirect);
return this.add(mock), mock;
} else
throw new Error(`[vitest] Unknown mock type: ${type}`);
}
delete(id) {
this.registryByUrl.delete(id);
}
get(id) {
return this.registryByUrl.get(id);
}
getById(id) {
return this.registryById.get(id);
}
has(id) {
return this.registryByUrl.has(id);
}
}, AutomockedModule = class {
type = "automock";
constructor(raw, id, url) {
this.raw = raw, this.id = id, this.url = url;
}
static fromJSON(data) {
return new AutospiedModule(data.raw, data.id, data.url);
}
toJSON() {
return {
type: this.type,
url: this.url,
raw: this.raw,
id: this.id
};
}
}, AutospiedModule = class _AutospiedModule {
type = "autospy";
constructor(raw, id, url) {
this.raw = raw, this.id = id, this.url = url;
}
static fromJSON(data) {
return new _AutospiedModule(data.raw, data.id, data.url);
}
toJSON() {
return {
type: this.type,
url: this.url,
id: this.id,
raw: this.raw
};
}
}, RedirectedModule = class _RedirectedModule {
type = "redirect";
constructor(raw, id, url, redirect) {
this.raw = raw, this.id = id, this.url = url, this.redirect = redirect;
}
static fromJSON(data) {
return new _RedirectedModule(data.raw, data.id, data.url, data.redirect);
}
toJSON() {
return {
type: this.type,
url: this.url,
raw: this.raw,
id: this.id,
redirect: this.redirect
};
}
}, ManualMockedModule = class _ManualMockedModule {
cache;
type = "manual";
constructor(raw, id, url, factory) {
this.raw = raw, this.id = id, this.url = url, this.factory = factory;
}
async resolve() {
if (this.cache)
return this.cache;
let exports;
try {
exports = await this.factory();
} catch (err) {
let vitestError = new Error('[vitest] There was an error when mocking a module. If you are using "vi.mock" factory, make sure there are no top level variables inside, since this call is hoisted to top of the file. Read more: https://vitest.dev/api/vi.html#vi-mock');
throw vitestError.cause = err, vitestError;
}
if (exports === null || typeof exports != "object" || Array.isArray(exports))
throw new TypeError(`[vitest] vi.mock("${this.raw}", factory?: () => unknown) is not returning an object. Did you mean to return an object with a "default" key?`);
return this.cache = exports;
}
static fromJSON(data, factory) {
return new _ManualMockedModule(data.raw, data.id, data.url, factory);
}
toJSON() {
return {
type: this.type,
url: this.url,
id: this.id,
raw: this.raw
};
}
};
// ../../node_modules/@vitest/mocker/dist/index.js
function mockObject(options, object, mockExports = {}) {
let finalizers = new Array(), refs = new RefTracker(), define = (container, key, value) => {
try {
return container[key] = value, !0;
} catch {
return !1;
}
}, mockPropertiesOf = (container, newContainer) => {
let containerType = getType(container), isModule = containerType === "Module" || !!container.__esModule;
for (let { key: property, descriptor } of getAllMockableProperties(container, isModule, options.globalConstructors)) {
if (!isModule && descriptor.get) {
try {
Object.defineProperty(newContainer, property, descriptor);
} catch {
}
continue;
}
if (isSpecialProp(property, containerType))
continue;
let value = container[property], refId = refs.getId(value);
if (refId !== void 0) {
finalizers.push(() => define(newContainer, property, refs.getMockedValue(refId)));
continue;
}
let type = getType(value);
if (Array.isArray(value)) {
define(newContainer, property, []);
continue;
}
let isFunction = type.includes("Function") && typeof value == "function";
if ((!isFunction || value._isMockFunction) && type !== "Object" && type !== "Module") {
define(newContainer, property, value);
continue;
}
if (define(newContainer, property, isFunction ? value : {})) {
if (isFunction) {
let mockFunction = function() {
if (this instanceof newContainer[property])
for (let { key, descriptor: descriptor2 } of getAllMockableProperties(this, !1, options.globalConstructors)) {
if (descriptor2.get)
continue;
let value2 = this[key];
if (getType(value2).includes("Function") && typeof value2 == "function") {
let original = this[key], mock2 = spyOn(this, key).mockImplementation(original), origMockReset = mock2.mockReset;
mock2.mockRestore = mock2.mockReset = () => (origMockReset.call(mock2), mock2.mockImplementation(original), mock2);
}
}
};
if (!options.spyOn)
throw new Error("[@vitest/mocker] `spyOn` is not defined. This is a Vitest error. Please open a new issue with reproduction.");
let spyOn = options.spyOn, mock = spyOn(newContainer, property);
if (options.type === "automock") {
mock.mockImplementation(mockFunction);
let origMockReset = mock.mockReset;
mock.mockRestore = mock.mockReset = () => (origMockReset.call(mock), mock.mockImplementation(mockFunction), mock);
}
Object.defineProperty(newContainer[property], "length", { value: 0 });
}
refs.track(value, newContainer[property]), mockPropertiesOf(value, newContainer[property]);
}
}
}, mockedObject = mockExports;
mockPropertiesOf(object, mockedObject);
for (let finalizer of finalizers)
finalizer();
return mockedObject;
}
var RefTracker = class {
idMap = /* @__PURE__ */ new Map();
mockedValueMap = /* @__PURE__ */ new Map();
getId(value) {
return this.idMap.get(value);
}
getMockedValue(id) {
return this.mockedValueMap.get(id);
}
track(originalValue, mockedValue) {
let newId = this.idMap.size;
return this.idMap.set(originalValue, newId), this.mockedValueMap.set(newId, mockedValue), newId;
}
};
function getType(value) {
return Object.prototype.toString.apply(value).slice(8, -1);
}
function isSpecialProp(prop, parentType) {
return parentType.includes("Function") && typeof prop == "string" && [
"arguments",
"callee",
"caller",
"length",
"name"
].includes(prop);
}
function getAllMockableProperties(obj, isModule, constructors) {
let { Map: Map2, Object: Object2, Function: Function2, RegExp: RegExp2, Array: Array2 } = constructors, allProps = new Map2(), curr = obj;
do {
if (curr === Object2.prototype || curr === Function2.prototype || curr === RegExp2.prototype)
break;
collectOwnProperties(curr, (key) => {
let descriptor = Object2.getOwnPropertyDescriptor(curr, key);
descriptor && allProps.set(key, {
key,
descriptor
});
});
} while (curr = Object2.getPrototypeOf(curr));
if (isModule && !allProps.has("default") && "default" in obj) {
let descriptor = Object2.getOwnPropertyDescriptor(obj, "default");
descriptor && allProps.set("default", {
key: "default",
descriptor
});
}
return Array2.from(allProps.values());
}
function collectOwnProperties(obj, collector) {
let collect = typeof collector == "function" ? collector : (key) => collector.add(key);
Object.getOwnPropertyNames(obj).forEach(collect), Object.getOwnPropertySymbols(obj).forEach(collect);
}
// ../../node_modules/@vitest/mocker/dist/chunk-pathe.M-eThtNZ.js
var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
function normalizeWindowsPath(input = "") {
return input && input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
}
var _UNC_REGEX = /^[/\\]{2}/, _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/, _DRIVE_LETTER_RE = /^[A-Za-z]:$/, _EXTNAME_RE = /.(\.[^./]+|\.)$/, normalize = function(path) {
if (path.length === 0)
return ".";
path = normalizeWindowsPath(path);
let isUNCPath = path.match(_UNC_REGEX), isPathAbsolute = isAbsolute(path), trailingSeparator = path[path.length - 1] === "/";
return path = normalizeString(path, !isPathAbsolute), path.length === 0 ? isPathAbsolute ? "/" : trailingSeparator ? "./" : "." : (trailingSeparator && (path += "/"), _DRIVE_LETTER_RE.test(path) && (path += "/"), isUNCPath ? isPathAbsolute ? `//${path}` : `//./${path}` : isPathAbsolute && !isAbsolute(path) ? `/${path}` : path);
}, join = function(...segments) {
let path = "";
for (let seg of segments)
if (seg)
if (path.length > 0) {
let pathTrailing = path[path.length - 1] === "/", segLeading = seg[0] === "/";
pathTrailing && segLeading ? path += seg.slice(1) : path += pathTrailing || segLeading ? seg : `/${seg}`;
} else
path += seg;
return normalize(path);
};
function normalizeString(path, allowAboveRoot) {
let res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, char = null;
for (let index2 = 0; index2 <= path.length; ++index2) {
if (index2 < path.length)
char = path[index2];
else {
if (char === "/")
break;
char = "/";
}
if (char === "/") {
if (!(lastSlash === index2 - 1 || dots === 1)) if (dots === 2) {
if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
if (res.length > 2) {
let lastSlashIndex = res.lastIndexOf("/");
lastSlashIndex === -1 ? (res = "", lastSegmentLength = 0) : (res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/")), lastSlash = index2, dots = 0;
continue;
} else if (res.length > 0) {
res = "", lastSegmentLength = 0, lastSlash = index2, dots = 0;
continue;
}
}
allowAboveRoot && (res += res.length > 0 ? "/.." : "..", lastSegmentLength = 2);
} else
res.length > 0 ? res += `/${path.slice(lastSlash + 1, index2)}` : res = path.slice(lastSlash + 1, index2), lastSegmentLength = index2 - lastSlash - 1;
lastSlash = index2, dots = 0;
} else char === "." && dots !== -1 ? ++dots : dots = -1;
}
return res;
}
var isAbsolute = function(p2) {
return _IS_ABSOLUTE_RE.test(p2);
}, extname = function(p2) {
if (p2 === "..") return "";
let match = _EXTNAME_RE.exec(normalizeWindowsPath(p2));
return match && match[1] || "";
};
// ../../node_modules/@vitest/mocker/dist/chunk-mocker.js
var f = {
reset: [0, 0],
bold: [1, 22, "\x1B[22m\x1B[1m"],
dim: [2, 22, "\x1B[22m\x1B[2m"],
italic: [3, 23],
underline: [4, 24],
inverse: [7, 27],
hidden: [8, 28],
strikethrough: [9, 29],
black: [30, 39],
red: [31, 39],
green: [32, 39],
yellow: [33, 39],
blue: [34, 39],
magenta: [35, 39],
cyan: [36, 39],
white: [37, 39],
gray: [90, 39],
bgBlack: [40, 49],
bgRed: [41, 49],
bgGreen: [42, 49],
bgYellow: [43, 49],
bgBlue: [44, 49],
bgMagenta: [45, 49],
bgCyan: [46, 49],
bgWhite: [47, 49],
blackBright: [90, 39],
redBright: [91, 39],
greenBright: [92, 39],
yellowBright: [93, 39],
blueBright: [94, 39],
magentaBright: [95, 39],
cyanBright: [96, 39],
whiteBright: [97, 39],
bgBlackBright: [100, 49],
bgRedBright: [101, 49],
bgGreenBright: [102, 49],
bgYellowBright: [103, 49],
bgBlueBright: [104, 49],
bgMagentaBright: [105, 49],
bgCyanBright: [106, 49],
bgWhiteBright: [107, 49]
}, h = Object.entries(f);
function a(n) {
return String(n);
}
a.open = "";
a.close = "";
function C(n = !1) {
let e = typeof process < "u" ? process : void 0, i = e?.env || {}, g = e?.argv || [];
return !("NO_COLOR" in i || g.includes("--no-color")) && ("FORCE_COLOR" in i || g.includes("--color") || e?.platform === "win32" || n && i.TERM !== "dumb" || "CI" in i) || typeof window < "u" && !!window.chrome;
}
function p(n = !1) {
let e = C(n), i = (r, t, c, o) => {
let l = "", s = 0;
do
l += r.substring(s, o) + c, s = o + t.length, o = r.indexOf(t, s);
while (~o);
return l + r.substring(s);
}, g = (r, t, c = r) => {
let o = (l) => {
let s = String(l), b = s.indexOf(t, r.length);
return ~b ? r + i(s, t, c, b) + t : r + s + t;
};
return o.open = r, o.close = t, o;
}, u = {
isColorSupported: e
}, d = (r) => `\x1B[${r}m`;
for (let [r, t] of h)
u[r] = e ? g(
d(t[0]),
d(t[1]),
t[2]
) : a;
return u;
}
p();
function _mergeNamespaces(n, m) {
return m.forEach(function(e) {
e && typeof e != "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k) {
if (k !== "default" && !(k in n)) {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: !0,
get: function() {
return e[k];
}
});
}
});
}), Object.freeze(n);
}
function getDefaultExportFromCjs(x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x.default : x;
}
var reactIs$1 = { exports: {} }, reactIs_production = {};
var hasRequiredReactIs_production;
function requireReactIs_production() {
if (hasRequiredReactIs_production) return reactIs_production;
hasRequiredReactIs_production = 1;
var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo"), REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy"), REACT_VIEW_TRANSITION_TYPE = /* @__PURE__ */ Symbol.for("react.view_transition"), REACT_CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for("react.client.reference");
function typeOf(object) {
if (typeof object == "object" && object !== null) {
var $$typeof = object.$$typeof;
switch ($$typeof) {
case REACT_ELEMENT_TYPE:
switch (object = object.type, object) {
case REACT_FRAGMENT_TYPE:
case REACT_PROFILER_TYPE:
case REACT_STRICT_MODE_TYPE:
case REACT_SUSPENSE_TYPE:
case REACT_SUSPENSE_LIST_TYPE:
case REACT_VIEW_TRANSITION_TYPE:
return object;
default:
switch (object = object && object.$$typeof, object) {
case REACT_CONTEXT_TYPE:
case REACT_FORWARD_REF_TYPE:
case REACT_LAZY_TYPE:
case REACT_MEMO_TYPE:
return object;
case REACT_CONSUMER_TYPE:
return object;
default:
return $$typeof;
}
}
case REACT_PORTAL_TYPE:
return $$typeof;
}
}
}
return reactIs_production.ContextConsumer = REACT_CONSUMER_TYPE, reactIs_production.ContextProvider = REACT_CONTEXT_TYPE, reactIs_production.Element = REACT_ELEMENT_TYPE, reactIs_production.ForwardRef = REACT_FORWARD_REF_TYPE, reactIs_production.Fragment = REACT_FRAGMENT_TYPE, reactIs_production.Lazy = REACT_LAZY_TYPE, reactIs_production.Memo = REACT_MEMO_TYPE, reactIs_production.Portal = REACT_PORTAL_TYPE, reactIs_production.Profiler = REACT_PROFILER_TYPE, reactIs_production.StrictMode = REACT_STRICT_MODE_TYPE, reactIs_production.Suspense = REACT_SUSPENSE_TYPE, reactIs_production.SuspenseList = REACT_SUSPENSE_LIST_TYPE, reactIs_production.isContextConsumer = function(object) {
return typeOf(object) === REACT_CONSUMER_TYPE;
}, reactIs_production.isContextProvider = function(object) {
return typeOf(object) === REACT_CONTEXT_TYPE;
}, reactIs_production.isElement = function(object) {
return typeof object == "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
}, reactIs_production.isForwardRef = function(object) {
return typeOf(object) === REACT_FORWARD_REF_TYPE;
}, reactIs_production.isFragment = function(object) {
return typeOf(object) === REACT_FRAGMENT_TYPE;
}, reactIs_production.isLazy = function(object) {
return typeOf(object) === REACT_LAZY_TYPE;
}, reactIs_production.isMemo = function(object) {
return typeOf(object) === REACT_MEMO_TYPE;
}, reactIs_production.isPortal = function(object) {
return typeOf(object) === REACT_PORTAL_TYPE;
}, reactIs_production.isProfiler = function(object) {
return typeOf(object) === REACT_PROFILER_TYPE;
}, reactIs_production.isStrictMode = function(object) {
return typeOf(object) === REACT_STRICT_MODE_TYPE;
}, reactIs_production.isSuspense = function(object) {
return typeOf(object) === REACT_SUSPENSE_TYPE;
}, reactIs_production.isSuspenseList = function(object) {
return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
}, reactIs_production.isValidElementType = function(type) {
return typeof type == "string" || typeof type == "function" || type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type == "object" && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_CONSUMER_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_CLIENT_REFERENCE || type.getModuleId !== void 0);
}, reactIs_production.typeOf = typeOf, reactIs_production;
}
var hasRequiredReactIs$1;
function requireReactIs$1() {
return hasRequiredReactIs$1 || (hasRequiredReactIs$1 = 1, reactIs$1.exports = requireReactIs_production()), reactIs$1.exports;
}
var reactIsExports$1 = requireReactIs$1(), index$1 = getDefaultExportFromCjs(reactIsExports$1), ReactIs19 = _mergeNamespaces({
__proto__: null,
default: index$1
}, [reactIsExports$1]), reactIs = { exports: {} }, reactIs_production_min = {};
var hasRequiredReactIs_production_min;
function requireReactIs_production_min() {
if (hasRequiredReactIs_production_min) return reactIs_production_min;
hasRequiredReactIs_production_min = 1;
var b = /* @__PURE__ */ Symbol.for("react.element"), c = /* @__PURE__ */ Symbol.for("react.portal"), d = /* @__PURE__ */ Symbol.for("react.fragment"), e = /* @__PURE__ */ Symbol.for("react.strict_mode"), f2 = /* @__PURE__ */ Symbol.for("react.profiler"), g = /* @__PURE__ */ Symbol.for("react.provider"), h2 = /* @__PURE__ */ Symbol.for("react.context"), k = /* @__PURE__ */ Symbol.for("react.server_context"), l = /* @__PURE__ */ Symbol.for("react.forward_ref"), m = /* @__PURE__ */ Symbol.for("react.suspense"), n = /* @__PURE__ */ Symbol.for("react.suspense_list"), p2 = /* @__PURE__ */ Symbol.for("react.memo"), q = /* @__PURE__ */ Symbol.for("react.lazy"), t = /* @__PURE__ */ Symbol.for("react.offscreen"), u;
u = /* @__PURE__ */ Symbol.for("react.module.reference");
function v(a2) {
if (typeof a2 == "object" && a2 !== null) {
var r = a2.$$typeof;
switch (r) {
case b:
switch (a2 = a2.type, a2) {
case d:
case f2:
case e:
case m:
case n:
return a2;
default:
switch (a2 = a2 && a2.$$typeof, a2) {
case k:
case h2:
case l:
case q:
case p2:
case g:
return a2;
default:
return r;
}
}
case c:
return r;
}
}
}
return reactIs_production_min.ContextConsumer = h2, reactIs_production_min.ContextProvider = g, reactIs_production_min.Element = b, reactIs_production_min.ForwardRef = l, reactIs_production_min.Fragment = d, reactIs_production_min.Lazy = q, reactIs_production_min.Memo = p2, reactIs_production_min.Portal = c, reactIs_production_min.Profiler = f2, reactIs_production_min.StrictMode = e, reactIs_production_min.Suspense = m, reactIs_production_min.SuspenseList = n, reactIs_production_min.isAsyncMode = function() {
return !1;
}, reactIs_production_min.isConcurrentMode = function() {
return !1;
}, reactIs_production_min.isContextConsumer = function(a2) {
return v(a2) === h2;
}, reactIs_production_min.isContextProvider = function(a2) {
return v(a2) === g;
}, reactIs_production_min.isElement = function(a2) {
return typeof a2 == "object" && a2 !== null && a2.$$typeof === b;
}, reactIs_production_min.isForwardRef = function(a2) {
return v(a2) === l;
}, reactIs_production_min.isFragment = function(a2) {
return v(a2) === d;
}, reactIs_production_min.isLazy = function(a2) {
return v(a2) === q;
}, reactIs_production_min.isMemo = function(a2) {
return v(a2) === p2;
}, reactIs_production_min.isPortal = function(a2) {
return v(a2) === c;
}, reactIs_production_min.isProfiler = function(a2) {
return v(a2) === f2;
}, reactIs_production_min.isStrictMode = function(a2) {
return v(a2) === e;
}, reactIs_production_min.isSuspense = function(a2) {
return v(a2) === m;
}, reactIs_production_min.isSuspenseList = function(a2) {
return v(a2) === n;
}, reactIs_production_min.isValidElementType = function(a2) {
return typeof a2 == "string" || typeof a2 == "function" || a2 === d || a2 === f2 || a2 === e || a2 === m || a2 === n || a2 === t || typeof a2 == "object" && a2 !== null && (a2.$$typeof === q || a2.$$typeof === p2 || a2.$$typeof === g || a2.$$typeof === h2 || a2.$$typeof === l || a2.$$typeof === u || a2.getModuleId !== void 0);
}, reactIs_production_min.typeOf = v, reactIs_production_min;
}
var hasRequiredReactIs;
function requireReactIs() {
return hasRequiredReactIs || (hasRequiredReactIs = 1, reactIs.exports = requireReactIs_production_min()), reactIs.exports;
}
var reactIsExports = requireReactIs(), index = getDefaultExportFromCjs(reactIsExports), ReactIs18 = _mergeNamespaces({
__proto__: null,
default: index
}, [reactIsExports]), reactIsMethods = [
"isAsyncMode",
"isConcurrentMode",
"isContextConsumer",
"isContextProvider",
"isElement",
"isForwardRef",
"isFragment",
"isLazy",
"isMemo",
"isPortal",
"isProfiler",
"isStrictMode",
"isSuspense",
"isSuspenseList",
"isValidElementType"
];
Object.fromEntries(reactIsMethods.map((m) => [m, (v) => ReactIs18[m](v) || ReactIs19[m](v)]));
var getPromiseValue = () => "Promise{\u2026}";
try {
let { getPromiseDetails, kPending, kRejected } = process.binding("util");
Array.isArray(getPromiseDetails(Promise.resolve())) && (getPromiseValue = (value, options) => {
let [state, innerValue] = getPromiseDetails(value);
return state === kPending ? "Promise{<pending>}" : `Promise${state === kRejected ? "!" : ""}{${options.inspect(innerValue, options)}}`;
});
} catch {
}
function createSimpleStackTrace(options) {
let { message = "$$stack trace error", stackTraceLimit = 1 } = options || {}, limit = Error.stackTraceLimit, prepareStackTrace = Error.prepareStackTrace;
Error.stackTraceLimit = stackTraceLimit, Error.prepareStackTrace = (e) => e.stack;
let stackTrace = new Error(message).stack || "";
return Error.prepareStackTrace = prepareStackTrace, Error.stackTraceLimit = limit, stackTrace;
}
var jsTokens_1, hasRequiredJsTokens;
function requireJsTokens() {
if (hasRequiredJsTokens) return jsTokens_1;
hasRequiredJsTokens = 1;
var Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
return RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\\]).|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/uy, Punctuator = /--|\+\+|=>|\.{3}|\??\.(?!\d)|(?:&&|\|\||\?\?|[+\-%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2}|\/(?![\/*]))=?|[?~,:;[\](){}]/y, Identifier = /(\x23?)(?=[$_\p{ID_Start}\\])(?:[$_\u200C\u200D\p{ID_Continue}]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+/uy, StringLiteral = /(['"])(?:(?!\1)[^\\\n\r]|\\(?:\r\n|[^]))*(\1)?/y, NumericLiteral = /(?:0[xX][\da-fA-F](?:_?[\da-fA-F])*|0[oO][0-7](?:_?[0-7])*|0[bB][01](?:_?[01])*)n?|0n|[1-9](?:_?\d)*n|(?:(?:0(?!\d)|0\d*[89]\d*|[1-9](?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:[eE][+-]?\d(?:_?\d)*)?|0[0-7]+/y, Template = /[`}](?:[^`\\$]|\\[^]|\$(?!\{))*(`|\$\{)?/y, WhiteSpace = /[\t\v\f\ufeff\p{Zs}]+/uy, LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y, MultiLineComment = /\/\*(?:[^*]|\*(?!\/))*(\*\/)?/y, SingleLineComment = /\/\/.*/y, JSXPunctuator = /[<>.:={}]|\/(?![\/*])/y, JSXIdentifier = /[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}-]*/uy, JSXString = /(['"])(?:(?!\1)[^])*(\1)?/y, JSXText = /[^<>{}]+/y, TokensPrecedingExpression = /^(?:[\/+-]|\.{3}|\?(?:InterpolationIn(?:JSX|Template)|NoLineTerminatorHere|NonExpressionParenEnd|UnaryIncDec))?$|[{}([,;<>=*%&|^!~?:]$/, TokensNotPrecedingObjectLiteral = /^(?:=>|[;\]){}]|else|\?(?:NoLineTerminatorHere|NonExpressionParenEnd))?$/, KeywordsWithExpressionAfter = /^(?:await|case|default|delete|do|else|instanceof|new|return|throw|typeof|void|yield)$/, KeywordsWithNoLineTerminatorAfter = /^(?:return|throw|yield)$/, Newline = RegExp(LineTerminatorSequence.source), jsTokens_1 = function* (input, { jsx = !1 } = {}) {
var braces, firstCodePoint, isExpression, lastIndex, lastSignificantToken, length, match, mode, nextLastIndex, nextLastSignificantToken, parenNesting, postfixIncDec, punctuator, stack;
for ({ length } = input, lastIndex = 0, lastSignificantToken = "", stack = [{ tag: "JS" }], braces = [], parenNesting = 0, postfixIncDec = !1; lastIndex < length; ) {
switch (mode = stack[stack.length - 1], mode.tag) {
case "JS":
case "JSNonExpressionParen":
case "InterpolationInTemplate":
case "InterpolationInJSX":
if (input[lastIndex] === "/" && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken)) && (RegularExpressionLiteral.lastIndex = lastIndex, match = RegularExpressionLiteral.exec(input))) {
lastIndex = RegularExpressionLiteral.lastIndex, lastSignificantToken = match[0], postfixIncDec = !0, yield {
type: "RegularExpressionLiteral",
value: match[0],
closed: match[1] !== void 0 && match[1] !== "\\"
};
continue;
}
if (Punctuator.lastIndex = lastIndex, match = Punctuator.exec(input)) {
switch (punctuator = match[0], nextLastIndex = Punctuator.lastIndex, nextLastSignificantToken = punctuator, punctuator) {
case "(":
lastSignificantToken === "?NonExpressionParenKeyword" && stack.push({
tag: "JSNonExpressionParen",
nesting: parenNesting
}), parenNesting++, postfixIncDec = !1;
break;
case ")":
parenNesting--, postfixIncDec = !0, mode.tag === "JSNonExpressionParen" && parenNesting === mode.nesting && (stack.pop(), nextLastSignificantToken = "?NonExpressionParenEnd", postfixIncDec = !1);
break;
case "{":
Punctuator.lastIndex = 0, isExpression = !TokensNotPrecedingObjectLiteral.test(lastSignificantToken) && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken)), braces.push(isExpression), postfixIncDec = !1;
break;
case "}":
switch (mode.tag) {
case "InterpolationInTemplate":
if (braces.length === mode.nesting) {
Template.lastIndex = lastIndex, match = Template.exec(input), lastIndex = Template.lastIndex, lastSignificantToken = match[0], match[1] === "${" ? (lastSignificantToken = "?InterpolationInTemplate", postfixIncDec = !1, yield {
type: "TemplateMiddle",
value: match[0]
}) : (stack.pop(), postfixIncDec = !0, yield {
type: "TemplateTail",
value: match[0],
closed: match[1] === "`"
});
continue;
}
break;
case "InterpolationInJSX":
if (braces.length === mode.nesting) {
stack.pop(), lastIndex += 1, lastSignificantToken = "}", yield {
type: "JSXPunctuator",
value: "}"
};
continue;
}
}
postfixIncDec = braces.pop(), nextLastSignificantToken = postfixIncDec ? "?ExpressionBraceEnd" : "}";
break;
case "]":
postfixIncDec = !0;
break;
case "++":
case "--":
nextLastSignificantToken = postfixIncDec ? "?PostfixIncDec" : "?UnaryIncDec";
break;
case "<":
if (jsx && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
stack.push({ tag: "JSXTag" }), lastIndex += 1, lastSignificantToken = "<", yield {
type: "JSXPunctuator",
value: punctuator
};
continue;
}
postfixIncDec = !1;
break;
default:
postfixIncDec = !1;
}
lastIndex = nextLastIndex, lastSignificantToken = nextLastSignificantToken, yield {
type: "Punctuator",
value: punctuator
};
continue;
}
if (Identifier.lastIndex = lastIndex, match = Identifier.exec(input)) {
switch (lastIndex = Identifier.lastIndex, nextLastSignificantToken = match[0], match[0]) {
case "for":
case "if":
case "while":
case "with":
lastSignificantToken !== "." && lastSignificantToken !== "?." && (nextLastSignificantToken = "?NonExpressionParenKeyword");
}
lastSignificantToken = nextLastSignificantToken, postfixIncDec = !KeywordsWithExpressionAfter.test(match[0]), yield {
type: match[1] === "#" ? "PrivateIdentifier" : "IdentifierName",
value: match[0]
};
continue;
}
if (StringLiteral.lastIndex = lastIndex, match = StringLiteral.exec(input)) {
lastIndex = StringLiteral.lastIndex, lastSignificantToken = match[0], postfixIncDec = !0, yield {
type: "StringLiteral",
value: match[0],
closed: match[2] !== void 0
};
continue;
}
if (NumericLiteral.lastIndex = lastIndex, match = NumericLiteral.exec(input)) {
lastIndex = NumericLiteral.lastIndex, lastSignificantToken = match[0], postfixIncDec = !0, yield {
type: "NumericLiteral",
value: match[0]
};
continue;
}
if (Template.lastIndex = lastIndex, match = Template.exec(input)) {
lastIndex = Template.lastIndex, lastSignificantToken = match[0], match[1] === "${" ? (lastSignificantToken = "?InterpolationInTemplate", stack.push({
tag: "InterpolationInTemplate",
nesting: braces.length
}), postfixIncDec = !1, yield {
type: "TemplateHead",
value: match[0]
}) : (postfixIncDec = !0, yield {
type: "NoSubstitutionTemplate",
value: match[0],
closed: match[1] === "`"
});
continue;
}
break;
case "JSXTag":
case "JSXTagEnd":
if (JSXPunctuator.lastIndex = lastIndex, match = JSXPunctuator.exec(input)) {
switch (lastIndex = JSXPunctuator.lastIndex, nextLastSignificantToken = match[0], match[0]) {
case "<":
stack.push({ tag: "JSXTag" });
break;
case ">":
stack.pop(), lastSignificantToken === "/" || mode.tag === "JSXTagEnd" ? (nextLastSignificantToken = "?JSX", postfixIncDec = !0) : stack.push({ tag: "JSXChildren" });
break;
case "{":
stack.push({
tag: "InterpolationInJSX",
nesting: braces.length
}), nextLastSignificantToken = "?InterpolationInJSX", postfixIncDec = !1;
break;
case "/":
lastSignificantToken === "<" && (stack.pop(), stack[stack.length - 1].tag === "JSXChildren" && stack.pop(), stack.push({ tag: "JSXTagEnd" }));
}
lastSignificantToken = nextLastSignificantToken, yield {
type: "JSXPunctuator",
value: match[0]
};
continue;
}
if (JSXIdentifier.lastIndex = lastIndex, match = JSXIdentifier.exec(input)) {
lastIndex = JSXIdentifier.lastIndex, lastSignificantToken = match[0], yield {
type: "JSXIdentifier",
value: match[0]
};
continue;
}
if (JSXString.lastIndex = lastIndex, match = JSXString.exec(input)) {
lastIndex = JSXString.lastIndex, lastSignificantToken = match[0], yield {
type: "JSXString",
value: match[0],
closed: match[2] !== void 0
};
continue;
}
break;
case "JSXChildren":
if (JSXText.lastIndex = lastIndex, match = JSXText.exec(input)) {
lastIndex = JSXText.lastIndex, lastSignificantToken = match[0], yield {
type: "JSXText",
value: match[0]
};
continue;
}
switch (input[lastIndex]) {
case "<":
stack.push({ tag: "JSXTag" }), lastIndex++, lastSignificantToken = "<", yield {
type: "JSXPunctuator",
value: "<"
};
continue;
case "{":
stack.push({
tag: "InterpolationInJSX",
nesting: braces.length
}), lastIndex++, lastSignificantToken = "?InterpolationInJSX", postfixIncDec = !1, yield {
type: "JSXPunctuator",
value: "{"
};
continue;
}
}
if (WhiteSpace.lastIndex = lastIndex, match = WhiteSpace.exec(input)) {
lastIndex = WhiteSpace.lastIndex, yield {
type: "WhiteSpace",
value: match[0]
};
continue;
}
if (LineTerminatorSequence.lastIndex = lastIndex, match = LineTerminatorSequence.exec(input)) {
lastIndex = LineTerminatorSequence.lastIndex, postfixIncDec = !1, KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken) && (lastSignificantToken = "?NoLineTerminatorHere"), yield {
type: "LineTerminatorSequence",
value: match[0]
};
continue;
}
if (MultiLineComment.lastIndex = lastIndex, match = MultiLineComment.exec(input)) {
lastIndex = MultiLineComment.lastIndex, Newline.test(match[0]) && (postfixIncDec = !1, KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken) && (lastSignificantToken = "?NoLineTerminatorHere")), yield {
type: "MultiLineComment",
value: match[0],
closed: match[1] !== void 0
};
continue;
}
if (SingleLineComment.lastIndex = lastIndex, match = SingleLineComment.exec(input)) {
lastIndex = SingleLineComment.lastIndex, postfixIncDec = !1, yield {
type: "SingleLineComment",
value: match[0]
};
continue;
}
firstCodePoint = String.fromCodePoint(input.codePointAt(lastIndex)), lastIndex += firstCodePoint.length, lastSignificantToken = firstCodePoint, postfixIncDec = !1, yield {
type: mode.tag.startsWith("JSX") ? "JSXInvalid" : "Invalid",
value: firstCodePoint
};
}
}, jsTokens_1;
}
requireJsTokens();
var reservedWords = {
keyword: [
"break",
"case",
"catch",
"continue",
"debugger",
"default",
"do",
"else",
"finally",
"for",
"function",
"if",
"return",
"switch",
"throw",
"try",
"var",
"const",
"while",
"with",
"new",
"this",
"super",
"class",
"extends",
"export",
"import",
"null",
"true",
"false",
"in",
"instanceof",
"typeof",
"void",
"delete"
],
strict: [
"implements",
"interface",
"let",
"package",
"private",
"protected",
"public",
"static",
"yield"
]
};
new Set(reservedWords.keyword);
new Set(reservedWords.strict);
var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", intToChar = new Uint8Array(64), charToInt = new Uint8Array(128);
for (let i = 0; i < chars.length; i++) {
let c = chars.charCodeAt(i);
intToChar[i] = c, charToInt[c] = i;
}
var UrlType;
(function(UrlType2) {
UrlType2[UrlType2.Empty = 1] = "Empty", UrlType2[UrlType2.Hash = 2] = "Hash", UrlType2[UrlType2.Query = 3] = "Query", UrlType2[UrlType2.RelativePath = 4] = "RelativePath", UrlType2[UrlType2.AbsolutePath = 5] = "AbsolutePath", UrlType2[UrlType2.SchemeRelative = 6] = "SchemeRelative", UrlType2[UrlType2.Absolute = 7] = "Absolute";
})(UrlType || (UrlType = {}));
var _DRIVE_LETTER_START_RE2 = /^[A-Za-z]:\//;
function normalizeWindowsPath2(input = "") {
return input && input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE2, (r) => r.toUpperCase());
}
var _IS_ABSOLUTE_RE2 = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
function cwd() {
return typeof process < "u" && typeof process.cwd == "function" ? process.cwd().replace(/\\/g, "/") : "/";
}
var resolve = function(...arguments_) {
arguments_ = arguments_.map((argument) => normalizeWindowsPath2(argument));
let resolvedPath = "", resolvedAbsolute = !1;
for (let index2 = arguments_.length - 1; index2 >= -1 && !resolvedAbsolute; index2--) {
let path = index2 >= 0 ? arguments_[index2] : cwd();
!path || path.length === 0 || (resolvedPath = `${path}/${resolvedPath}`, resolvedAbsolute = isAbsolute2(path));
}
return resolvedPath = normalizeString2(resolvedPath, !resolvedAbsolute), resolvedAbsolute && !isAbsolute2(resolvedPath) ? `/${resolvedPath}` : resolvedPath.length > 0 ? resolvedPath : ".";
};
function normalizeString2(path, allowAboveRoot) {
let res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, char = null;
for (let index2 = 0; index2 <= path.length; ++index2) {
if (index2 < path.length)
char = path[index2];
else {
if (char === "/")
break;
char = "/";
}
if (char === "/") {
if (!(lastSlash === index2 - 1 || dots === 1)) if (dots === 2) {
if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
if (res.length > 2) {
let lastSlashIndex = res.lastIndexOf("/");
lastSlashIndex === -1 ? (res = "", lastSegmentLength = 0) : (res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/")), lastSlash = index2, dots = 0;
continue;
} else if (res.length > 0) {
res = "", lastSegmentLength = 0, lastSlash = index2, dots = 0;
continue;
}
}
allowAboveRoot && (res += res.length > 0 ? "/.." : "..", lastSegmentLength = 2);
} else
res.length > 0 ? res += `/${path.slice(lastSlash + 1, index2)}` : res = path.slice(lastSlash + 1, index2), lastSegmentLength = index2 - lastSlash - 1;
lastSlash = index2, dots = 0;
} else char === "." && dots !== -1 ? ++dots : dots = -1;
}
return res;
}
var isAbsolute2 = function(p2) {
return _IS_ABSOLUTE_RE2.test(p2);
}, CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m, SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
function extractLocation(urlLike) {
if (!urlLike.includes(":"))
return [urlLike];
let parts = /(.+?)(?::(\d+))?(?::(\d+))?$/.exec(urlLike.replace(/^\(|\)$/g, ""));
if (!parts)
return [urlLike];
let url = parts[1];
if (url.startsWith("async ") && (url = url.slice(6)), url.startsWith("http:") || url.startsWith("https:")) {
let urlObj = new URL(url);
urlObj.searchParams.delete("import"), urlObj.searchParams.delete("browserv"), url = urlObj.pathname + urlObj.hash + urlObj.search;
}
if (url.startsWith("/@fs/")) {
let isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url);
url = url.slice(isWindows ? 5 : 4);
}
return [
url,
parts[2] || void 0,
parts[3] || void 0
];
}
function parseSingleFFOrSafariStack(raw) {
let line = raw.trim();
if (SAFARI_NATIVE_CODE_REGEXP.test(line) || (line.includes(" > eval") && (line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1")), !line.includes("@") && !line.includes(":")))
return null;
let functionNameRegex = /((.*".+"[^@]*)?[^@]*)(@)/, matches = line.match(functionNameRegex), functionName = matches && matches[1] ? matches[1] : void 0, [url, lineNumber, columnNumber] = extractLocation(line.replace(functionNameRegex, ""));
return !url || !lineNumber || !columnNumber ? null : {
file: url,
method: functionName || "",
line: Number.parseInt(lineNumber),
column: Number.parseInt(columnNumber)
};
}
function parseSingleStack(raw) {
let line = raw.trim();
return CHROME_IE_STACK_REGEXP.test(line) ? parseSingleV8Stack(line) : parseSingleFFOrSafariStack(line);
}
function parseSingleV8Stack(raw) {
let line = raw.trim();
if (!CHROME_IE_STACK_REGEXP.test(line))
return null;
line.includes("(eval ") && (line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, ""));
let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, ""), location2 = sanitizedLine.match(/ (\(.+\)$)/);
sanitizedLine = location2 ? sanitizedLine.replace(location2[0], "") : sanitizedLine;
let [url, lineNumber, columnNumber] = extractLocation(location2 ? location2[1] : sanitizedLine), method = location2 && sanitizedLine || "", file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
return !file || !lineNumber || !columnNumber ? null : (method.startsWith("async ") && (method = method.slice(6)), file.startsWith("file://") && (file = file.slice(7)), file = file.startsWith("node:") || file.startsWith("internal:") ? file : resolve(file), method && (method = method.replace(/__vite_ssr_import_\d+__\./g, "")), {
method,
file,
line: Number.parseInt(lineNumber),
column: Number.parseInt(columnNumber)
});
}
function createCompilerHints(options) {
let globalThisAccessor = options?.globalThisKey || "__vitest_mocker__";
function _mocker() {
return typeof globalThis[globalThisAccessor] < "u" ? globalThis[globalThisAccessor] : new Proxy({}, { get(_, name) {
throw new Error(`Vitest mocker was not initialized in this environment. vi.${String(name)}() is forbidden.`);
} });
}
return {
hoisted(factory) {
if (typeof factory != "function")
throw new TypeError(`vi.hoisted() expects a function, but received a ${typeof factory}`);
return factory();
},
mock(path, factory) {
if (typeof path != "string")
throw new TypeError(`vi.mock() expects a string path, but received a ${typeof path}`);
let importer = getImporter("mock");
_mocker().queueMock(path, importer, typeof factory == "function" ? () => factory(() => _mocker().importActual(path, importer)) : factory);
},
unmock(path) {
if (typeof path != "string")
throw new TypeError(`vi.unmock() expects a string path, but received a ${typeof path}`);
_mocker().queueUnmock(path, getImporter("unmock"));
},
doMock(path, factory) {
if (typeof path != "string")
throw new TypeError(`vi.doMock() expects a string path, but received a ${typeof path}`);
let importer = getImporter("doMock");
_mocker().queueMock(path, importer, typeof factory == "function" ? () => factory(() => _mocker().importActual(path, importer)) : factory);
},
doUnmock(path) {
if (typeof path != "string")
throw new TypeError(`vi.doUnmock() expects a string path, but received a ${typeof path}`);
_mocker().queueUnmock(path, getImporter("doUnmock"));
},
async importActual(path) {
return _mocker().importActual(path, getImporter("importActual"));
},
async importMock(path) {
return _mocker().importMock(path, getImporter("importMock"));
}
};
}
function getImporter(name) {
let stackArray = createSimpleStackTrace({ stackTraceLimit: 5 }).split(`
`), importerStackIndex = stackArray.findIndex((stack2) => stack2.includes(` at Object.${name}`) || stack2.includes(`${name}@`)), stack = parseSingleStack(stackArray[importerStackIndex + 1]);
return stack?.file || "";
}
var hot = import.meta.hot || {
on: warn,
off: warn,
send: warn
};
function warn() {
console.warn("Vitest mocker cannot work if Vite didn't establish WS connection.");
}
var { now } = Date, ModuleMocker = class {
registry = new MockerRegistry();
queue = /* @__PURE__ */ new Set();
mockedIds = /* @__PURE__ */ new Set();
constructor(interceptor, rpc3, spyOn, config) {
this.interceptor = interceptor, this.rpc = rpc3, this.spyOn = spyOn, this.config = config;
}
async prepare() {
this.queue.size && await Promise.all([...this.queue.values()]);
}
async resolveFactoryModule(id) {
let mock = this.registry.get(id);
if (!mock || mock.type !== "manual")
throw new Error(`Mock ${id} wasn't registered. This is probably a Vitest error. Please, open a new issue with reproduction.`);
return await mock.resolve();
}
getFactoryModule(id) {
let mock = this.registry.get(id);
if (!mock || mock.type !== "manual")
throw new Error(`Mock ${id} wasn't registered. This is probably a Vitest error. Please, open a new issue with reproduction.`);
if (!mock.cache)
throw new Error(`Mock ${id} wasn't resolved. This is probably a Vitest error. Please, open a new issue with reproduction.`);
return mock.cache;
}
async invalidate() {
let ids = Array.from(this.mockedIds);
ids.length && (await this.rpc.invalidate(ids), await this.interceptor.invalidate(), this.registry.clear());
}
async importActual(id, importer) {
let resolved = await this.rpc.resolveId(id, importer);
if (resolved == null)
throw new Error(`[vitest] Cannot resolve "${id}" imported from "${importer}"`);
let ext = extname(resolved.id), url = new URL(resolved.url, location.href), query = `_vitest_original&ext${ext}`, actualUrl = `${url.pathname}${url.search ? `${url.search}&${query}` : `?${query}`}${url.hash}`;
return this.wrapDynamicImport(() => import(
/* @vite-ignore */
actualUrl
)).then((mod) => {
if (!resolved.optimized || typeof mod.default > "u")
return mod;
let m = mod.default;
return m?.__esModule ? m : {
...typeof m == "object" && !Array.isArray(m) || typeof m == "function" ? m : {},
default: m
};
});
}
async importMock(rawId, importer) {
await this.prepare();
let { resolvedId, resolvedUrl, redirectUrl } = await this.rpc.resolveMock(rawId, importer, { mock: "auto" }), mockUrl = this.resolveMockPath(cleanVersion(resolvedUrl)), mock = this.registry.get(mockUrl);
if (!mock)
if (redirectUrl) {
let resolvedRedirect = new URL(this.resolveMockPath(cleanVersion(redirectUrl)), location.href).toString();
mock = new RedirectedModule(rawId, resolvedId, mockUrl, resolvedRedirect);
} else
mock = new AutomockedModule(rawId, resolvedId, mockUrl);
if (mock.type === "manual")
return await mock.resolve();
if (mock.type === "automock" || mock.type === "autospy") {
let url = new URL(`/@id/${resolvedId}`, location.href), query = url.search ? `${url.search}&t=${now()}` : `?t=${now()}`, moduleObject = await import(
/* @vite-ignore */
`${url.pathname}${query}&mock=${mock.type}${url.hash}`
);
return this.mockObject(moduleObject, mock.type);
}
return import(
/* @vite-ignore */
mock.redirect
);
}
mockObject(object, moduleType = "automock") {
return mockObject({
globalConstructors: {
Object,
Function,
Array,
Map,
RegExp
},
spyOn: this.spyOn,
type: moduleType
}, object);
}
queueMock(rawId, importer, factoryOrOptions) {
let promise = this.rpc.resolveMock(rawId, importer, { mock: typeof factoryOrOptions == "function" ? "factory" : factoryOrOptions?.spy ? "spy" : "auto" }).then(async ({ redirectUrl, resolvedId, resolvedUrl, needsInterop, mockType }) => {
let mockUrl = this.resolveMockPath(cleanVersion(resolvedUrl));
this.mockedIds.add(resolvedId);
let factory = typeof factoryOrOptions == "function" ? async () => {
let data = await factoryOrOptions();
return needsInterop ? { default: data } : data;
} : void 0, mockRedirect = typeof redirectUrl == "string" ? new URL(this.resolveMockPath(cleanVersion(redirectUrl)), location.href).toString() : null, module;
mockType === "manual" ? module = this.registry.register("manual", rawId, resolvedId, mockUrl, factory) : mockType === "autospy" ? module = this.registry.register("autospy", rawId, resolvedId, mockUrl) : mockType === "redirect" ? module = this.registry.register("redirect", rawId, resolvedId, mockUrl, mockRedirect) : module = this.registry.register("automock", rawId, resolvedId, mockUrl), await this.interceptor.register(module);
}).finally(() => {
this.queue.delete(promise);
});
this.queue.add(promise);
}
queueUnmock(id, importer) {
let promise = this.rpc.resolveId(id, importer).then(async (resolved) => {
if (!resolved)
return;
let mockUrl = this.resolveMockPath(cleanVersion(resolved.url));
this.mockedIds.add(resolved.id), this.registry.delete(mockUrl), await this.interceptor.delete(mockUrl);
}).finally(() => {
this.queue.delete(promise);
});
this.queue.add(promise);
}
// We need to await mock registration before importing the actual module
// In case there is a mocked module in the import chain
wrapDynamicImport(moduleFactory) {
return typeof moduleFactory == "function" ? new Promise((resolve2, reject) => {
this.prepare().finally(() => {
moduleFactory().then(resolve2, reject);
});
}) : moduleFactory;
}
resolveMockPath(path) {
let config = this.config, fsRoot = join("/@fs/", config.root);
return path.startsWith(config.root) ? path.slice(config.root.length) : path.startsWith(fsRoot) ? path.slice(fsRoot.length) : path;
}
}, versionRegexp = /(\?|&)v=\w{8}/;
function cleanVersion(url) {
return url.replace(versionRegexp, "");
}
// src/mocking-utils/mocker-runtime.js
var ModuleMockerInterceptor = class {
// A registry for runtime mocks (e.g., `sb.mock('path', () => ({}))`)
mocks = new MockerRegistry();
constructor() {
}
/**
* Called by ModuleMocker when `sb.mock()` is executed. We just store the mock in our registry.
* The dynamic MSW handler will pick it up on the next relevant network request. Currently, we
* don't use this.mocks in any way. Mocks will be registered in the user's preview file and live
* until the end. There is no way to invalidate or delete them.
*/
async register(module) {
this.mocks.add(module);
}
async delete(url) {
this.mocks.delete(url);
}
async invalidate() {
this.mocks.clear();
}
}, rpc2 = (method) => {
switch (method) {
case "resolveId":
return Promise.resolve({
id: "",
url: "",
optimized: !1
});
case "resolveMock":
return Promise.resolve({
mockType: "dummy",
resolvedId: "",
resolvedUrl: "",
redirectUrl: "",
needsInterop: !1
});
case "invalidate":
return Promise.resolve();
}
}, BuildModuleMocker = class extends ModuleMocker {
queueMock() {
}
};
function registerModuleMocker(interceptor) {
let mocker = new BuildModuleMocker(
interceptor("__vitest_mocker__"),
{
resolveId(id, importer) {
return rpc2("resolveId", { id, importer });
},
resolveMock(id, importer, options) {
return rpc2("resolveMock", { id, importer, options });
},
async invalidate(ids) {
return rpc2("invalidate", { ids });
}
},
(...args) => globalThis.__STORYBOOK_MODULE_TEST__.spyOn(...args),
{
root: ""
}
);
return globalThis.__vitest_mocker__ = mocker, createCompilerHints({
globalThisKey: "__vitest_mocker__"
});
}
globalThis.__STORYBOOK_MOCKER__ = registerModuleMocker(() => new ModuleMockerInterceptor());
export {
ModuleMockerInterceptor
};