locter 2.2.0 → 3.0.0

package/dist/index.mjs

@@ -1,718 +1,734 @@
-import { destr } from 'destr';
-import flat from 'flat';
-import fs from 'node:fs';
-import fg from 'fast-glob';
-import path from 'node:path';
-import { BaseError } from 'ebec';
-import { createJiti } from 'jiti';
-import { pathToFileURL } from 'node:url';
-import { parse } from 'yaml';
-
-
-// -- Shims --
-import cjsUrl from 'node:url';
-import cjsPath from 'node:path';
-import cjsModule from 'node:module';
-const __filename = cjsUrl.fileURLToPath(import.meta.url);
-const __dirname = cjsPath.dirname(__filename);
-const require = cjsModule.createRequire(import.meta.url);
+import { createRequire } from "node:module";
+import { BaseError, hasInstanceof, markInstanceof } from "@ebec/core";
+import path from "node:path";
+import { destr } from "destr";
+import { unflatten } from "flat";
+import fs from "node:fs";
+import fg from "fast-glob";
+import { createJiti } from "jiti";
+import { pathToFileURL } from "node:url";
+import { parse } from "yaml";
+//#region src/errors/base.ts
+const LOCTER_ERROR_MARKER = Symbol.for("@locter/error");
+var LocterError = class extends BaseError {
+	static [Symbol.hasInstance](input) {
+		return hasInstanceof(input, LOCTER_ERROR_MARKER);
+	}
+	path;
+	constructor(input = {}) {
+		if (typeof input === "string") super(input);
+		else {
+			const { path, ...rest } = input;
+			super(rest);
+			this.path = path;
+		}
+		markInstanceof(this, LOCTER_ERROR_MARKER);
+	}
+};
+//#endregion
+//#region src/errors/load.ts
+const LOCTER_LOAD_ERROR_MARKER = Symbol.for("@locter/load-error");
+var LocterLoadError = class extends LocterError {
+	static [Symbol.hasInstance](input) {
+		return hasInstanceof(input, LOCTER_LOAD_ERROR_MARKER);
+	}
+	constructor(input = {}) {
+		super(input);
+		markInstanceof(this, LOCTER_LOAD_ERROR_MARKER);
+	}
+};
+//#endregion
+//#region src/errors/not-found.ts
+const LOCTER_NOT_FOUND_ERROR_MARKER = Symbol.for("@locter/not-found-error");
+var LocterNotFoundError = class extends LocterError {
+	static [Symbol.hasInstance](input) {
+		return hasInstanceof(input, LOCTER_NOT_FOUND_ERROR_MARKER);
+	}
+	constructor(input = {}) {
+		super(input);
+		markInstanceof(this, LOCTER_NOT_FOUND_ERROR_MARKER);
+	}
+};
+//#endregion
+//#region src/errors/unknown-extension.ts
+const LOCTER_UNKNOWN_EXTENSION_ERROR_MARKER = Symbol.for("@locter/unknown-extension-error");
+var LocterUnknownExtensionError = class extends LocterError {
+	static [Symbol.hasInstance](input) {
+		return hasInstanceof(input, LOCTER_UNKNOWN_EXTENSION_ERROR_MARKER);
+	}
+	constructor(input = {}) {
+		super(input);
+		markInstanceof(this, LOCTER_UNKNOWN_EXTENSION_ERROR_MARKER);
+	}
+};
+//#endregion
+//#region src/utils/file-name.ts
+function getFileNameExtension(input, allowed) {
+	const extension = path.extname(input);
+	if (extension === "" || extension === ".") return;
+	if (typeof allowed === "undefined" || allowed.includes(extension)) return extension;
+}
+function removeFileNameExtension(input, extensions) {
+	const extension = getFileNameExtension(input, extensions);
+	if (extension) return input.substring(0, input.length - extension.length);
+	return input;
+}
+//#endregion
+//#region src/utils/has-property.ts
 function hasOwnProperty(obj, prop) {
-    return Object.prototype.hasOwnProperty.call(obj, prop);
+	return Object.prototype.hasOwnProperty.call(obj, prop);
 }
 function hasStringProperty(obj, prop) {
-    return hasOwnProperty(obj, prop) && typeof obj[prop] === 'string';
+	return hasOwnProperty(obj, prop) && typeof obj[prop] === "string";
 }
-
-/*
- * Copyright (c) 2022.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ function isObject(item) {
-    return !!item && typeof item === 'object' && !Array.isArray(item);
+//#endregion
+//#region src/utils/object.ts
+function isObject(item) {
+	return !!item && typeof item === "object" && !Array.isArray(item);
 }
 function isSafeObjectKey(key) {
-    return key !== '__proto__' && key !== 'prototype' && key !== 'constructor';
-}
-
-function handleException(e) {
-    if (e instanceof Error) {
-        throw e;
-    }
-    const error = new Error('Can not process thrown exception.');
-    if (isObject(e)) {
-        if (hasOwnProperty(e, 'message') && typeof e.message === 'string') {
-            error.message = e.message;
-        }
-        if (hasOwnProperty(e, 'stack') && typeof e.stack === 'string') {
-            error.stack = e.stack;
-        }
-    }
-    throw error;
+	return key !== "__proto__" && key !== "prototype" && key !== "constructor";
 }
-
-function getFileNameExtension(input, allowed) {
-    const extension = path.extname(input);
-    if (extension === '' || extension === '.') {
-        return undefined;
-    }
-    if (typeof allowed === 'undefined' || allowed.indexOf(extension) !== -1) {
-        return extension;
-    }
-    return undefined;
+//#endregion
+//#region src/utils/to-array.ts
+function toArray(input) {
+	return Array.isArray(input) ? input : [input];
 }
-function removeFileNameExtension(input, extensions) {
-    const extension = getFileNameExtension(input, extensions);
-    if (extension) {
-        return input.substring(0, input.length - extension.length);
-    }
-    return input;
-}
-
-/*
- * Copyright (c) 2022.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ function toArray(input) {
-    return Array.isArray(input) ? input : [
-        input
-    ];
-}
-
+//#endregion
+//#region src/utils/file-path.ts
 function isFilePath(input) {
-    const extension = path.extname(input);
-    return extension && extension !== '';
+	const extension = path.extname(input);
+	return extension && extension !== "";
 }
-
-/*
- * Copyright (c) 2024.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ function isJestRuntimeEnvironment() {
-    return process.env && process.env.JEST_WORKER_ID !== undefined;
+//#endregion
+//#region src/utils/runtime.ts
+function isJestRuntimeEnvironment() {
+	return process.env && process.env.JEST_WORKER_ID !== void 0;
+}
+function isVitestRuntimeEnvironment() {
+	return typeof process !== "undefined" && process.env.VITEST === "true";
 }
 function isTsNodeRuntimeEnvironment() {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    return !!process[Symbol.for('ts-node.register.instance')];
+	return !!process[Symbol.for("ts-node.register.instance")];
 }
-
+//#endregion
+//#region src/utils/typescript.ts
 function isTypeScriptError(input) {
-    if (!isObject(input)) {
-        return false;
-    }
-    if (typeof input.diagnosticCodes !== 'undefined') {
-        return true;
-    }
-    return typeof input.message === 'string' && /TS\d+/.test(input.message);
-}
-
+	if (!isObject(input)) return false;
+	if (typeof input.diagnosticCodes !== "undefined") return true;
+	return typeof input.message === "string" && /TS\d+/.test(input.message);
+}
+//#endregion
+//#region src/errors/wrap.ts
+const NOT_FOUND_CODES = new Set([
+	"ENOENT",
+	"MODULE_NOT_FOUND",
+	"ERR_MODULE_NOT_FOUND"
+]);
+function wrapLoaderError(input, path) {
+	if (input instanceof LocterError) return input;
+	const code = isObject(input) && hasStringProperty(input, "code") ? input.code : void 0;
+	const message = isObject(input) && hasStringProperty(input, "message") ? input.message : `Failed to load: ${path}`;
+	if (code && NOT_FOUND_CODES.has(code)) return new LocterNotFoundError({
+		message,
+		code,
+		cause: input,
+		path
+	});
+	return new LocterLoadError({
+		message,
+		code,
+		cause: input,
+		path
+	});
+}
+//#endregion
+//#region src/locator/utils.ts
 function buildLocatorPatterns(pattern) {
-    return Array.isArray(pattern) ? pattern : [
-        pattern
-    ];
+	return Array.isArray(pattern) ? pattern : [pattern];
 }
 function buildLocatorOptions(options = {}) {
-    const paths = options.path ? toArray(options.path) : [];
-    const ignore = options.ignore ? toArray(options.ignore) : [];
-    if (paths.length === 0) {
-        paths.push(process.cwd());
-    }
-    let onlyFiles;
-    let onlyDirectories;
-    if (options.onlyDirectories === options.onlyFiles) {
-        onlyDirectories = false;
-        onlyFiles = !options.onlyDirectories;
-    } else if (typeof options.onlyFiles === 'undefined') {
-        onlyDirectories = options.onlyDirectories ?? false;
-        onlyFiles = !options.onlyDirectories;
-    } else {
-        onlyFiles = options.onlyFiles ?? true;
-        onlyDirectories = !options.onlyFiles;
-    }
-    return {
-        path: paths,
-        ignore,
-        onlyDirectories,
-        onlyFiles
-    };
+	const cwd = options.cwd ? toArray(options.cwd) : [];
+	const ignore = options.ignore ? toArray(options.ignore) : [];
+	if (cwd.length === 0) cwd.push(process.cwd());
+	let onlyFiles;
+	let onlyDirectories;
+	if (options.onlyDirectories === options.onlyFiles) {
+		onlyDirectories = false;
+		onlyFiles = !options.onlyDirectories;
+	} else if (typeof options.onlyFiles === "undefined") {
+		onlyDirectories = options.onlyDirectories ?? false;
+		onlyFiles = !options.onlyDirectories;
+	} else {
+		onlyFiles = options.onlyFiles ?? true;
+		onlyDirectories = !options.onlyFiles;
+	}
+	return {
+		cwd,
+		ignore,
+		onlyDirectories,
+		onlyFiles,
+		dot: options.dot ?? false
+	};
 }
 function pathToLocatorInfo(input, skipResolve) {
-    if (!skipResolve && !path.isAbsolute(input)) {
-        input = path.resolve(process.cwd(), input);
-    }
-    const info = path.parse(input);
-    return {
-        path: info.dir.split('/').join(path.sep),
-        name: info.name,
-        extension: info.ext ? info.ext : undefined
-    };
+	if (!skipResolve && !path.isAbsolute(input)) input = path.resolve(process.cwd(), input);
+	const info = path.parse(input);
+	const directory = info.dir.split("/").join(path.sep);
+	const extension = info.ext ? info.ext : void 0;
+	const filePath = extension ? path.join(directory, info.name) + extension : path.join(directory, info.name);
+	return {
+		directory,
+		name: info.name,
+		extension,
+		path: filePath
+	};
 }
 function isLocatorInfo(input) {
-    return isObject(input) && typeof input.path === 'string' && typeof input.name === 'string' && typeof input.extension === 'string';
+	return isObject(input) && typeof input.directory === "string" && typeof input.name === "string" && (typeof input.extension === "undefined" || typeof input.extension === "string") && typeof input.path === "string";
 }
 function buildFilePath(input) {
-    if (typeof input === 'string') {
-        return input;
-    }
-    if (input.extension) {
-        return path.join(input.path, input.name) + input.extension;
-    }
-    return path.join(input.path, input.name);
+	if (typeof input === "string") return input;
+	return input.path;
 }
 function buildFilePathWithoutExtension(input) {
-    let info;
-    if (typeof input === 'string') {
-        info = pathToLocatorInfo(input);
-    } else {
-        info = input;
-    }
-    return path.join(info.path, info.name);
+	let info;
+	if (typeof input === "string") info = pathToLocatorInfo(input);
+	else info = input;
+	return path.join(info.directory, info.name);
 }
-
+//#endregion
+//#region src/locator/async.ts
 async function locateMany(pattern, options) {
-    const patterns = buildLocatorPatterns(pattern);
-    const opts = buildLocatorOptions(options);
-    const items = [];
-    for(let i = 0; i < patterns.length; i++){
-        for(let j = 0; j < opts.path.length; j++){
-            const files = await fg(patterns[i], {
-                absolute: true,
-                cwd: opts.path[j],
-                ignore: opts.ignore,
-                onlyFiles: opts.onlyFiles,
-                onlyDirectories: opts.onlyDirectories
-            });
-            for(let k = 0; k < files.length; k++){
-                items.push(pathToLocatorInfo(files[k], true));
-            }
-        }
-    }
-    return items;
+	const patterns = buildLocatorPatterns(pattern);
+	const opts = buildLocatorOptions(options);
+	const items = [];
+	for (const p of patterns) for (const cwd of opts.cwd) {
+		const files = await fg(p, {
+			absolute: true,
+			cwd,
+			ignore: opts.ignore,
+			onlyFiles: opts.onlyFiles,
+			onlyDirectories: opts.onlyDirectories,
+			dot: opts.dot
+		});
+		for (const file of files) items.push(pathToLocatorInfo(file, true));
+	}
+	return items;
 }
 async function locate(pattern, options) {
-    const patterns = buildLocatorPatterns(pattern);
-    const opts = buildLocatorOptions(options);
-    for(let i = 0; i < patterns.length; i++){
-        for(let j = 0; j < opts.path.length; j++){
-            const files = await fg(patterns[i], {
-                absolute: true,
-                cwd: opts.path[j],
-                ignore: opts.ignore,
-                onlyFiles: opts.onlyFiles,
-                onlyDirectories: opts.onlyDirectories
-            });
-            const element = files.shift();
-            if (element) {
-                return pathToLocatorInfo(element, true);
-            }
-        }
-    }
-    return undefined;
-}
-
+	const patterns = buildLocatorPatterns(pattern);
+	const opts = buildLocatorOptions(options);
+	for (const p of patterns) for (const cwd of opts.cwd) {
+		const element = (await fg(p, {
+			absolute: true,
+			cwd,
+			ignore: opts.ignore,
+			onlyFiles: opts.onlyFiles,
+			onlyDirectories: opts.onlyDirectories,
+			dot: opts.dot
+		})).shift();
+		if (element) return pathToLocatorInfo(element, true);
+	}
+}
+//#endregion
+//#region src/locator/sync.ts
 function locateManySync(pattern, options) {
-    const patterns = buildLocatorPatterns(pattern);
-    const opts = buildLocatorOptions(options);
-    const items = [];
-    for(let i = 0; i < patterns.length; i++){
-        for(let j = 0; j < opts.path.length; j++){
-            const files = fg.sync(patterns[i], {
-                absolute: true,
-                cwd: opts.path[j],
-                ignore: opts.ignore,
-                onlyFiles: opts.onlyFiles,
-                onlyDirectories: opts.onlyDirectories
-            });
-            for(let k = 0; k < files.length; k++){
-                items.push(pathToLocatorInfo(files[k], true));
-            }
-        }
-    }
-    return items;
+	const patterns = buildLocatorPatterns(pattern);
+	const opts = buildLocatorOptions(options);
+	const items = [];
+	for (const p of patterns) for (const cwd of opts.cwd) {
+		const files = fg.sync(p, {
+			absolute: true,
+			cwd,
+			ignore: opts.ignore,
+			onlyFiles: opts.onlyFiles,
+			onlyDirectories: opts.onlyDirectories,
+			dot: opts.dot
+		});
+		for (const file of files) items.push(pathToLocatorInfo(file, true));
+	}
+	return items;
 }
 function locateSync(pattern, options) {
-    const patterns = buildLocatorPatterns(pattern);
-    const opts = buildLocatorOptions(options);
-    for(let i = 0; i < patterns.length; i++){
-        for(let j = 0; j < opts.path.length; j++){
-            const files = fg.sync(patterns[i], {
-                absolute: true,
-                cwd: opts.path[j],
-                ignore: opts.ignore,
-                onlyFiles: opts.onlyFiles,
-                onlyDirectories: opts.onlyDirectories
-            });
-            const element = files.shift();
-            if (element) {
-                return pathToLocatorInfo(element, true);
-            }
-        }
-    }
-    return undefined;
-}
-
-/*
- * Copyright (c) 2022-2023.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ // Based on https://github.com/unjs/rc9 (MIT)
-class ConfLoader {
-    async execute(input) {
-        const filePath = buildFilePath(input);
-        try {
-            const file = await fs.promises.readFile(filePath, {
-                encoding: 'utf-8'
-            });
-            return this.parse(file);
-        } catch (e) {
-            return handleException(e);
-        }
-    }
-    executeSync(input) {
-        const filePath = buildFilePath(input);
-        try {
-            const file = fs.readFileSync(filePath, {
-                encoding: 'utf-8'
-            });
-            return this.parse(file);
-        } catch (e) {
-            return handleException(e);
-        }
-    }
-    parse(contents) {
-        const config = {};
-        const lines = contents.split(/\n|\r|\r\n/);
-        for(let i = 0; i < lines.length; i++){
-            const match = lines[i].match(/^\s*([^\s=]+)\s*=\s*(.*)?\s*$/);
-            if (!match) {
-                continue;
-            }
-            // Key
-            const key = match[1];
-            if (!key || !isSafeObjectKey(key)) {
-                continue;
-            }
-            const value = destr(match[2].trim());
-            if (key.endsWith('[]')) {
-                const arrKey = key.slice(0, Math.max(0, key.length - 2));
-                config[arrKey] = (config[arrKey] || []).concat(value);
-                continue;
-            }
-            config[key] = value;
-        }
-        return flat.unflatten(config, {
-            overwrite: true
-        });
-    }
-}
-
+	const patterns = buildLocatorPatterns(pattern);
+	const opts = buildLocatorOptions(options);
+	for (const p of patterns) for (const cwd of opts.cwd) {
+		const element = fg.sync(p, {
+			absolute: true,
+			cwd,
+			ignore: opts.ignore,
+			onlyFiles: opts.onlyFiles,
+			onlyDirectories: opts.onlyDirectories,
+			dot: opts.dot
+		}).shift();
+		if (element) return pathToLocatorInfo(element, true);
+	}
+}
+//#endregion
+//#region src/locator/up.ts
+function startWalk(options) {
+	const { cwd, stopAt, ...baseOptions } = options;
+	const current = path.resolve(cwd ?? process.cwd());
+	return {
+		current,
+		stopAt: stopAt ? path.resolve(current, stopAt) : path.parse(current).root,
+		baseOptions
+	};
+}
+function nextDirectory(current, stopAt) {
+	if (current === stopAt) return;
+	const parent = path.dirname(current);
+	if (parent === current) return;
+	return parent;
+}
+async function locateUp(pattern, options = {}) {
+	let walk = startWalk(options);
+	while (true) {
+		const found = await locate(pattern, {
+			...walk.baseOptions,
+			cwd: walk.current
+		});
+		if (found) return found;
+		const next = nextDirectory(walk.current, walk.stopAt);
+		if (!next) return;
+		walk = {
+			...walk,
+			current: next
+		};
+	}
+}
+function locateUpSync(pattern, options = {}) {
+	let walk = startWalk(options);
+	while (true) {
+		const found = locateSync(pattern, {
+			...walk.baseOptions,
+			cwd: walk.current
+		});
+		if (found) return found;
+		const next = nextDirectory(walk.current, walk.stopAt);
+		if (!next) return;
+		walk = {
+			...walk,
+			current: next
+		};
+	}
+}
+//#endregion
+//#region src/loader/built-in/conf/module.ts
+var ConfLoader = class {
+	async execute(input) {
+		const filePath = buildFilePath(input);
+		try {
+			const file = await fs.promises.readFile(filePath, { encoding: "utf-8" });
+			return this.parse(file);
+		} catch (e) {
+			throw wrapLoaderError(e, filePath);
+		}
+	}
+	executeSync(input) {
+		const filePath = buildFilePath(input);
+		try {
+			const file = fs.readFileSync(filePath, { encoding: "utf-8" });
+			return this.parse(file);
+		} catch (e) {
+			throw wrapLoaderError(e, filePath);
+		}
+	}
+	parse(contents) {
+		const config = {};
+		const lines = contents.split(/\n|\r|\r\n/);
+		for (const line of lines) {
+			const match = line.match(/^\s*([^\s=]+)\s*=\s*(.*)?\s*$/);
+			if (!match) continue;
+			const key = match[1];
+			const rawValue = match[2];
+			if (!key || !isSafeObjectKey(key)) continue;
+			const value = destr(rawValue ? rawValue.trim() : "");
+			if (key.endsWith("[]")) {
+				const arrKey = key.slice(0, Math.max(0, key.length - 2));
+				config[arrKey] = (config[arrKey] || []).concat(value);
+				continue;
+			}
+			config[key] = value;
+		}
+		return unflatten(config, { overwrite: true });
+	}
+};
+//#endregion
+//#region src/loader/built-in/json/module.ts
+var JSONLoader = class {
+	async execute(input) {
+		const filePath = buildFilePath(input);
+		try {
+			const file = await fs.promises.readFile(filePath, { encoding: "utf-8" });
+			return JSON.parse(file);
+		} catch (e) {
+			throw wrapLoaderError(e, filePath);
+		}
+	}
+	executeSync(input) {
+		const filePath = buildFilePath(input);
+		try {
+			const file = fs.readFileSync(filePath, { encoding: "utf-8" });
+			return JSON.parse(file);
+		} catch (e) {
+			throw wrapLoaderError(e, filePath);
+		}
+	}
+};
+//#endregion
+//#region src/loader/built-in/module/utils.ts
 function isESModule(input) {
-    return isObject(input) && // eslint-disable-next-line no-underscore-dangle
-    typeof input.__esModule !== 'undefined';
+	return isObject(input) && typeof input.__esModule !== "undefined";
 }
-// https://2ality.com/2017/01/babel-esm-spec-mode.html
 function toModuleRecord(data) {
-    if (isESModule(data)) {
-        // @see https://github.com/testing-library/user-event/issues/813
-        // @see https://stackoverflow.com/questions/62717394/export-default-class-exports-double-nested-default
-        if (isESModule(data.default) && data.default.default) {
-            return {
-                ...data,
-                default: data.default.default
-            };
-        }
-        return data;
-    }
-    const output = Object.create(null, {
-        __esModule: {
-            value: true
-        },
-        [Symbol.toStringTag]: {
-            value: 'Module'
-        }
-    });
-    if (isObject(data)) {
-        // eslint-disable-next-line no-restricted-syntax
-        for(const key in data){
-            if (hasOwnProperty(output, key)) {
-                continue;
-            }
-            let descriptor = Object.getOwnPropertyDescriptor(data, key);
-            if (!descriptor || 'get' in descriptor || descriptor.writable || descriptor.configurable) {
-                descriptor = {
-                    enumerable: true,
-                    get () {
-                        return data[key];
-                    }
-                };
-            }
-            Object.defineProperty(output, key, descriptor);
-        }
-    }
-    if (!hasOwnProperty(output, 'default')) {
-        Object.defineProperty(output, 'default', {
-            value: data,
-            enumerable: true
-        });
-    }
-    return Object.freeze(output);
+	if (isESModule(data)) {
+		if (isESModule(data.default) && data.default.default) return {
+			...data,
+			default: data.default.default
+		};
+		return data;
+	}
+	const output = Object.create(null, {
+		__esModule: { value: true },
+		[Symbol.toStringTag]: { value: "Module" }
+	});
+	if (isObject(data)) for (const key in data) {
+		if (hasOwnProperty(output, key)) continue;
+		let descriptor = Object.getOwnPropertyDescriptor(data, key);
+		if (!descriptor || "get" in descriptor || descriptor.writable || descriptor.configurable) descriptor = {
+			enumerable: true,
+			get() {
+				return data[key];
+			}
+		};
+		Object.defineProperty(output, key, descriptor);
+	}
+	if (!hasOwnProperty(output, "default")) Object.defineProperty(output, "default", {
+		value: data,
+		enumerable: true
+	});
+	return Object.freeze(output);
 }
 function getModuleExport(data, filterFn) {
-    const keys = Object.keys(data);
-    for(let i = 0; i < keys.length; i++){
-        if (filterFn(keys[i], data[keys[i]])) {
-            return {
-                key: keys[i],
-                value: data[keys[i]]
-            };
-        }
-    }
-    return undefined;
-}
-
-class ModuleLoader {
-    async execute(input) {
-        let output;
-        try {
-            output = await this.load(input);
-        } catch (e) {
-            if (e instanceof SyntaxError || e instanceof ReferenceError || isTypeScriptError(e)) {
-                throw e;
-            }
-            // jiti + ts-node
-            // issue: https://github.com/nuxt/bridge/issues/228
-            if (isTsNodeRuntimeEnvironment()) {
-                output = this.loadSync(input);
-            } else {
-                output = this.instance(input);
-            }
-        }
-        return toModuleRecord(output);
-    }
-    executeSync(input) {
-        let output;
-        try {
-            output = this.loadSync(input);
-        } catch (e) {
-            if (e instanceof SyntaxError || e instanceof ReferenceError || isTypeScriptError(e)) {
-                throw e;
-            }
-            output = this.instance(input);
-        }
-        return toModuleRecord(output);
-    }
-    // ---------------------------------------------------------------------------
-    async load(data, options = {}) {
-        const id = this.build(data, options);
-        try {
-            // segmentation fault
-            // issue: https://github.com/nodejs/node/issues/35889
-            if (isJestRuntimeEnvironment()) {
-                // eslint-disable-next-line global-require,import/no-dynamic-require
-                return require(id);
-            }
-            return await import(id);
-        } catch (e) {
-            /* istanbul ignore next */ if (isObject(e) && hasStringProperty(e, 'code')) {
-                if (!options.withFilePrefix && (e.code === 'ERR_UNSUPPORTED_ESM_URL_SCHEME' || e.code === 'UNSUPPORTED_ESM_URL_SCHEME')) {
-                    return this.load(data, {
-                        ...options,
-                        withFilePrefix: true
-                    });
-                }
-                throw new BaseError({
-                    code: e.code,
-                    message: hasStringProperty(e, 'message') ? e.message : undefined,
-                    stack: hasStringProperty(e, 'stack') ? e.stack : undefined
-                });
-            }
-            /* istanbul ignore next */ return handleException(e);
-        }
-    }
-    loadSync(data, options = {}) {
-        const id = this.build(data, options);
-        try {
-            // eslint-disable-next-line global-require,import/no-dynamic-require
-            return require(id);
-        } catch (e) {
-            /* istanbul ignore next */ if (isObject(e) && hasStringProperty(e, 'code')) {
-                throw new BaseError({
-                    code: e.code,
-                    message: hasStringProperty(e, 'message') ? e.message : undefined,
-                    stack: hasStringProperty(e, 'stack') ? e.stack : undefined
-                });
-            }
-            return handleException(e);
-        }
-    }
-    build(data, options = {}) {
-        if (isLocatorInfo(data) || isFilePath(data)) {
-            if (typeof data !== 'string') {
-                data = buildFilePath(data);
-            }
-            if (options.withFilePrefix) {
-                data = pathToFileURL(data).href;
-            }
-        }
-        return data;
-    }
-    constructor(){
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        this.instance = createJiti(undefined, {
-            extensions: [
-                '.js',
-                '.mjs',
-                '.mts',
-                '.cjs',
-                '.cts',
-                '.ts'
-            ]
-        });
-    }
-}
-
-class JSONLoader {
-    async execute(input) {
-        const filePath = buildFilePath(input);
-        try {
-            const file = await fs.promises.readFile(filePath, {
-                encoding: 'utf-8'
-            });
-            return JSON.parse(file);
-        } catch (e) {
-            return handleException(e);
-        }
-    }
-    executeSync(input) {
-        const filePath = buildFilePath(input);
-        try {
-            const file = fs.readFileSync(filePath, {
-                encoding: 'utf-8'
-            });
-            return JSON.parse(file);
-        } catch (e) {
-            return handleException(e);
-        }
-    }
-}
-
-class YAMLLoader {
-    async execute(input) {
-        const filePath = buildFilePath(input);
-        try {
-            const file = await fs.promises.readFile(filePath, {
-                encoding: 'utf-8'
-            });
-            return parse(file);
-        } catch (e) {
-            return handleException(e);
-        }
-    }
-    executeSync(input) {
-        const filePath = buildFilePath(input);
-        try {
-            const file = fs.readFileSync(filePath, {
-                encoding: 'utf-8'
-            });
-            return parse(file);
-        } catch (e) {
-            return handleException(e);
-        }
-    }
-}
-
-/*
- * Copyright (c) 2023.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ var LoaderId = /*#__PURE__*/ function(LoaderId) {
-    LoaderId["MODULE"] = "module";
-    LoaderId["JSON"] = "json";
-    LoaderId["CONF"] = "conf";
-    LoaderId["YAML"] = "yaml";
-    return LoaderId;
-}({});
-
-class LoaderManager {
-    register(test, loader) {
-        if (typeof loader !== 'undefined') {
-            this.rules.push({
-                test,
-                loader
-            });
-            return;
-        }
-        this.rules.push(test);
-    }
-    async execute(input) {
-        const id = this.findLoader(input);
-        if (!id) {
-            const info = pathToLocatorInfo(input);
-            throw new Error(`No loader registered for extension: "${info.extension}"`);
-        }
-        const loader = this.resolve(id);
-        return loader.execute(input);
-    }
-    executeSync(input) {
-        const id = this.findLoader(input);
-        if (!id) {
-            const info = pathToLocatorInfo(input);
-            throw new Error(`No loader registered for extension: ${info.extension || 'unknown'}`);
-        }
-        const loader = this.resolve(id);
-        return loader.executeSync(input);
-    }
-    findLoader(input) {
-        if (!isFilePath(input)) {
-            return LoaderId.MODULE;
-        }
-        const info = pathToLocatorInfo(input);
-        for(let i = 0; i < this.rules.length; i++){
-            const { test } = this.rules[i];
-            if (Array.isArray(test)) {
-                if (info.extension && test.indexOf(info.extension) !== -1) {
-                    return this.rules[i].loader;
-                }
-            } else if (test.test(buildFilePath(info))) {
-                return this.rules[i].loader;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Resolve loader by id.
-     *
-     * @param id
-     */ resolve(id) {
-        if (typeof id !== 'string') {
-            return id;
-        }
-        if (Object.prototype.hasOwnProperty.call(this.loaders, id)) {
-            return this.loaders[id];
-        }
-        let loader;
-        // built-in
-        switch(id){
-            case LoaderId.CONF:
-                {
-                    loader = new ConfLoader();
-                    break;
-                }
-            case LoaderId.MODULE:
-                {
-                    loader = new ModuleLoader();
-                    break;
-                }
-            case LoaderId.JSON:
-                {
-                    loader = new JSONLoader();
-                    break;
-                }
-            case LoaderId.YAML:
-                {
-                    loader = new YAMLLoader();
-                    break;
-                }
-            /* istanbul ignore next */ default:
-                {
-                    const pluginPath = this.normalizePath(id);
-                    const moduleLoader = this.resolve(LoaderId.MODULE);
-                    loader = moduleLoader.executeSync(pluginPath);
-                    break;
-                }
-        }
-        if (typeof loader !== 'undefined') {
-            this.loaders[id] = loader;
-            return loader;
-        }
-        throw new Error(`The loader ${id} could not be resolved.`);
-    }
-    /* istanbul ignore next */ normalizePath(input) {
-        if (path.isAbsolute(input) || input.startsWith('./')) {
-            return input;
-        }
-        if (input.startsWith('module:')) {
-            return input.substring(0, 'module:'.length);
-        }
-        if (!input.startsWith('@')) {
-            return `@locter/${input}`;
-        }
-        return input;
-    }
-    constructor(){
-        this.loaders = {};
-        this.rules = [
-            {
-                test: [
-                    '.js',
-                    '.mjs',
-                    '.mts',
-                    '.cjs',
-                    '.cts',
-                    '.ts'
-                ],
-                loader: LoaderId.MODULE
-            },
-            {
-                test: [
-                    '.conf'
-                ],
-                loader: LoaderId.CONF
-            },
-            {
-                test: [
-                    '.json'
-                ],
-                loader: LoaderId.JSON
-            },
-            {
-                test: [
-                    '.yml',
-                    '.yaml'
-                ],
-                loader: LoaderId.YAML
-            }
-        ];
-    }
-}
-
+	const keys = Object.keys(data);
+	for (const key of keys) if (filterFn(key, data[key])) return {
+		key,
+		value: data[key]
+	};
+}
+//#endregion
+//#region src/loader/built-in/module/module.ts
+const require = createRequire(import.meta.url);
+function originalPath(data) {
+	return typeof data === "string" ? data : buildFilePath(data);
+}
+function isUnrecoverableError(error) {
+	const underlying = error instanceof LocterError ? error.cause : error;
+	return underlying instanceof SyntaxError || underlying instanceof ReferenceError || isTypeScriptError(underlying);
+}
+var ModuleLoader = class {
+	instance;
+	loadFn;
+	loadSyncFn;
+	constructor(options = {}) {
+		this.instance = createJiti(void 0, { extensions: [
+			".js",
+			".mjs",
+			".mts",
+			".cjs",
+			".cts",
+			".ts"
+		] });
+		this.loadFn = options.load;
+		this.loadSyncFn = options.loadSync;
+	}
+	configure(options) {
+		if ("load" in options) this.loadFn = options.load;
+		if ("loadSync" in options) this.loadSyncFn = options.loadSync;
+	}
+	async execute(input) {
+		let output;
+		try {
+			output = await this.load(input);
+		} catch (e) {
+			if (isUnrecoverableError(e)) throw e;
+			if (isTsNodeRuntimeEnvironment()) output = this.loadSync(input);
+			else output = this.instance(input);
+		}
+		return toModuleRecord(output);
+	}
+	executeSync(input) {
+		let output;
+		try {
+			output = this.loadSync(input);
+		} catch (e) {
+			if (isUnrecoverableError(e)) throw e;
+			output = this.instance(input);
+		}
+		return toModuleRecord(output);
+	}
+	async load(data, options = {}) {
+		const id = this.build(data, options);
+		try {
+			if (this.loadFn) return await this.loadFn(id);
+			if (isJestRuntimeEnvironment()) return require(id);
+			return await import(id);
+		} catch (e) {
+			/* istanbul ignore next */
+			if (!options.withFilePrefix && isObject(e) && hasStringProperty(e, "code") && (e.code === "ERR_UNSUPPORTED_ESM_URL_SCHEME" || e.code === "UNSUPPORTED_ESM_URL_SCHEME")) return this.load(data, {
+				...options,
+				withFilePrefix: true
+			});
+			throw wrapLoaderError(e, originalPath(data));
+		}
+	}
+	loadSync(data, options = {}) {
+		const id = this.build(data, options);
+		try {
+			if (this.loadSyncFn) return this.loadSyncFn(id);
+			return require(id);
+		} catch (e) {
+			throw wrapLoaderError(e, originalPath(data));
+		}
+	}
+	build(data, options = {}) {
+		if (isLocatorInfo(data) || isFilePath(data)) {
+			if (typeof data !== "string") data = buildFilePath(data);
+			if (options.withFilePrefix) data = pathToFileURL(data).href;
+		}
+		return data;
+	}
+};
+//#endregion
+//#region src/loader/built-in/yaml/module.ts
+var YAMLLoader = class {
+	async execute(input) {
+		const filePath = buildFilePath(input);
+		try {
+			return parse(await fs.promises.readFile(filePath, { encoding: "utf-8" }));
+		} catch (e) {
+			throw wrapLoaderError(e, filePath);
+		}
+	}
+	executeSync(input) {
+		const filePath = buildFilePath(input);
+		try {
+			return parse(fs.readFileSync(filePath, { encoding: "utf-8" }));
+		} catch (e) {
+			throw wrapLoaderError(e, filePath);
+		}
+	}
+};
+//#endregion
+//#region src/loader/module.ts
+var LoaderManager = class {
+	loaders;
+	rules;
+	constructor() {
+		this.loaders = {};
+		this.rules = [
+			{
+				test: [
+					".js",
+					".mjs",
+					".mts",
+					".cjs",
+					".cts",
+					".ts"
+				],
+				loader: "module"
+			},
+			{
+				test: [".conf"],
+				loader: "conf"
+			},
+			{
+				test: [".json"],
+				loader: "json"
+			},
+			{
+				test: [".yml", ".yaml"],
+				loader: "yaml"
+			}
+		];
+	}
+	register(test, loader) {
+		if (typeof loader !== "undefined") {
+			this.rules.push({
+				test,
+				loader
+			});
+			return;
+		}
+		this.rules.push(test);
+	}
+	async execute(input) {
+		const id = this.findLoader(input);
+		if (!id) throw this.unknownExtensionError(input);
+		const loader = this.resolve(id);
+		try {
+			return await loader.execute(input);
+		} catch (e) {
+			throw wrapLoaderError(e, input);
+		}
+	}
+	executeSync(input) {
+		const id = this.findLoader(input);
+		if (!id) throw this.unknownExtensionError(input);
+		const loader = this.resolve(id);
+		try {
+			return loader.executeSync(input);
+		} catch (e) {
+			throw wrapLoaderError(e, input);
+		}
+	}
+	unknownExtensionError(input) {
+		return new LocterUnknownExtensionError({
+			message: `No loader registered for extension: ${pathToLocatorInfo(input).extension ?? "unknown"}`,
+			path: input
+		});
+	}
+	findLoader(input) {
+		if (!isFilePath(input)) return "module";
+		const info = pathToLocatorInfo(input);
+		for (const rule of this.rules) {
+			const { test } = rule;
+			if (Array.isArray(test)) {
+				if (info.extension && test.includes(info.extension)) return rule.loader;
+			} else if (test.test(buildFilePath(info))) return rule.loader;
+		}
+	}
+	/**
+	* Resolve loader by id.
+	*
+	* @param id
+	*/
+	resolve(id) {
+		if (typeof id !== "string") return id;
+		if (Object.prototype.hasOwnProperty.call(this.loaders, id)) return this.loaders[id];
+		let loader;
+		switch (id) {
+			case "conf":
+				loader = new ConfLoader();
+				break;
+			case "module":
+				loader = new ModuleLoader();
+				break;
+			case "json":
+				loader = new JSONLoader();
+				break;
+			case "yaml":
+				loader = new YAMLLoader();
+				break;
+			/* istanbul ignore next */
+			default: {
+				const pluginPath = this.normalizePath(id);
+				loader = this.resolve("module").executeSync(pluginPath);
+				break;
+			}
+		}
+		if (typeof loader !== "undefined") {
+			this.loaders[id] = loader;
+			return loader;
+		}
+		throw new LocterError({ message: `The loader ${id} could not be resolved.` });
+	}
+	/* istanbul ignore next */
+	normalizePath(input) {
+		if (path.isAbsolute(input) || input.startsWith("./")) return input;
+		if (input.startsWith("module:")) return input.substring(0, 7);
+		if (!input.startsWith("@")) return `@locter/${input}`;
+		return input;
+	}
+};
+//#endregion
+//#region src/loader/singleton.ts
 let instance;
 function useLoader() {
-    if (typeof instance !== 'undefined') {
-        return instance;
-    }
-    instance = new LoaderManager();
-    return instance;
+	if (typeof instance !== "undefined") return instance;
+	instance = new LoaderManager();
+	return instance;
 }
-
+//#endregion
+//#region src/loader/helpers.ts
 function registerLoader(test, loader) {
-    const manager = useLoader();
-    if (typeof loader !== 'undefined') {
-        manager.register(test, loader);
-        return;
-    }
-    manager.register(test);
+	const manager = useLoader();
+	if (typeof loader !== "undefined") {
+		manager.register(test, loader);
+		return;
+	}
+	manager.register(test);
 }
 async function load(input) {
-    const manager = useLoader();
-    if (typeof input === 'string') {
-        return manager.execute(input);
-    }
-    return manager.execute(buildFilePath(input));
+	const manager = useLoader();
+	if (typeof input === "string") return manager.execute(input);
+	return manager.execute(buildFilePath(input));
 }
 function loadSync(input) {
-    const manager = useLoader();
-    if (typeof input === 'string') {
-        return manager.executeSync(input);
-    }
-    return manager.executeSync(buildFilePath(input));
-}
+	const manager = useLoader();
+	if (typeof input === "string") return manager.executeSync(input);
+	return manager.executeSync(buildFilePath(input));
+}
+/**
+* Override the built-in module loader's `import` / `require` calls.
+*
+* Useful for test runners (e.g. Vitest) where the dynamic `import()` inside
+* `node_modules/locter` would bypass the runner's module graph. Calling this
+* from user code (e.g. a Vitest setup file) lets the runner rewrite the
+* `import()` so loaded modules share identity with statically imported ones.
+*
+* @example
+* ```ts
+* // vitest setup file
+* import { setModuleLoader } from 'locter';
+*
+* setModuleLoader({
+*     load: (id) => import(id),
+* });
+* ```
+*/
+function setModuleLoader(options) {
+	useLoader().resolve("module").configure(options);
+}
+//#endregion
+//#region src/loader/package-field.ts
+function extractField(pkg, field) {
+	if (!isObject(pkg) || !hasOwnProperty(pkg, field)) return;
+	return pkg[field];
+}
+async function loadPackageField(field, options = {}) {
+	let info;
+	if (options.walkUp) info = await locateUp("package.json", {
+		cwd: options.cwd,
+		stopAt: options.stopAt
+	});
+	else info = await locate("package.json", { cwd: options.cwd });
+	if (!info) return;
+	try {
+		return extractField(await load(info), field);
+	} catch (e) {
+		if (e instanceof LocterNotFoundError) return;
+		throw e;
+	}
+}
+function loadPackageFieldSync(field, options = {}) {
+	let info;
+	if (options.walkUp) info = locateUpSync("package.json", {
+		cwd: options.cwd,
+		stopAt: options.stopAt
+	});
+	else info = locateSync("package.json", { cwd: options.cwd });
+	if (!info) return;
+	try {
+		return extractField(loadSync(info), field);
+	} catch (e) {
+		if (e instanceof LocterNotFoundError) return;
+		throw e;
+	}
+}
+//#endregion
+export { ConfLoader, JSONLoader, LOCTER_ERROR_MARKER, LOCTER_LOAD_ERROR_MARKER, LOCTER_NOT_FOUND_ERROR_MARKER, LOCTER_UNKNOWN_EXTENSION_ERROR_MARKER, LoaderManager, LocterError, LocterLoadError, LocterNotFoundError, LocterUnknownExtensionError, ModuleLoader, YAMLLoader, buildFilePath, buildFilePathWithoutExtension, buildLocatorOptions, buildLocatorPatterns, getFileNameExtension, getModuleExport, hasOwnProperty, hasStringProperty, isESModule, isFilePath, isJestRuntimeEnvironment, isLocatorInfo, isObject, isSafeObjectKey, isTsNodeRuntimeEnvironment, isTypeScriptError, isVitestRuntimeEnvironment, load, loadPackageField, loadPackageFieldSync, loadSync, locate, locateMany, locateManySync, locateSync, locateUp, locateUpSync, pathToLocatorInfo, registerLoader, removeFileNameExtension, setModuleLoader, toArray, toModuleRecord, wrapLoaderError };
 
-export { ConfLoader, JSONLoader, LoaderManager, ModuleLoader, buildFilePath, buildFilePathWithoutExtension, buildLocatorOptions, buildLocatorPatterns, getFileNameExtension, getModuleExport, handleException, hasOwnProperty, hasStringProperty, isESModule, isFilePath, isJestRuntimeEnvironment, isLocatorInfo, isObject, isSafeObjectKey, isTsNodeRuntimeEnvironment, isTypeScriptError, load, loadSync, locate, locateMany, locateManySync, locateSync, pathToLocatorInfo, registerLoader, removeFileNameExtension, toArray, toModuleRecord };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map