class MockerRegistry {
	registryByUrl = new Map();
	registryById = 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) {
		const type = typeof typeOrEvent === "object" ? typeOrEvent.type : typeOrEvent;
		if (typeof typeOrEvent === "object") {
			const 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") {
				const module = AutomockedModule.fromJSON(event);
				this.add(module);
				return module;
			} else if (event.type === "autospy") {
				const module = AutospiedModule.fromJSON(event);
				this.add(module);
				return module;
			} else if (event.type === "redirect") {
				const module = RedirectedModule.fromJSON(event);
				this.add(module);
				return module;
			} else if (event.type === "manual") {
				throw new Error(`Cannot set serialized manual mock. Define a factory function manually with \`ManualMockedModule.fromJSON()\`.`);
			} else {
				throw 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.");
			}
			const mock = new ManualMockedModule(raw, id, url, factoryOrRedirect);
			this.add(mock);
			return mock;
		} else if (type === "automock" || type === "autospy") {
			const mock = type === "automock" ? new AutomockedModule(raw, id, url) : new AutospiedModule(raw, id, url);
			this.add(mock);
			return mock;
		} else if (type === "redirect") {
			if (typeof factoryOrRedirect !== "string") {
				throw new TypeError("[vitest] Redirect mocks require a redirect string.");
			}
			const mock = new RedirectedModule(raw, id, url, factoryOrRedirect);
			this.add(mock);
			return mock;
		} else {
			throw new Error(`[vitest] Unknown mock type: ${type}`);
		}
	}
	delete(id) {
		this.registryByUrl.delete(id);
	}
	deleteById(id) {
		this.registryById.delete(id);
	}
	get(id) {
		return this.registryByUrl.get(id);
	}
	getById(id) {
		return this.registryById.get(id);
	}
	has(id) {
		return this.registryByUrl.has(id);
	}
}
class AutomockedModule {
	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
		};
	}
}
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
		};
	}
}
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
		};
	}
}
class ManualMockedModule {
	cache;
	type = "manual";
	constructor(raw, id, url, factory) {
		this.raw = raw;
		this.id = id;
		this.url = url;
		this.factory = factory;
	}
	resolve() {
		if (this.cache) {
			return this.cache;
		}
		let exports$1;
		try {
			exports$1 = this.factory();
		} catch (err) {
			throw createHelpfulError(err);
		}
		if (typeof exports$1 === "object" && typeof exports$1?.then === "function") {
			return exports$1.then((result) => {
				assertValidExports(this.raw, result);
				return this.cache = result;
			}, (error) => {
				throw createHelpfulError(error);
			});
		}
		assertValidExports(this.raw, exports$1);
		return this.cache = exports$1;
	}
	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
		};
	}
}
function createHelpfulError(cause) {
	const error = 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");
	error.cause = cause;
	return error;
}
function assertValidExports(raw, exports$1) {
	if (exports$1 === null || typeof exports$1 !== "object" || Array.isArray(exports$1)) {
		throw new TypeError(`[vitest] vi.mock("${raw}", factory?: () => unknown) is not returning an object. Did you mean to return an object with a "default" key?`);
	}
}

export { AutomockedModule as A, MockerRegistry as M, RedirectedModule as R, ManualMockedModule as a, AutospiedModule as b };
