load-oxfmt-config 0.23.0 → 0.25.0

package/dist/index.mjs

@@ -7,6 +7,7 @@ import { readFile, realpath, stat } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
 import { parse, printParseErrorCode } from "jsonc-parser";
 import { parseBuffer } from "editorconfig";
+import { Minimatch } from "minimatch";
 import ignore from "ignore";
 //#region src/constants.ts
 /**
@@ -79,6 +80,26 @@ const EDITORCONFIG_GLOBAL_SECTION_NAMES = ["*"];
 //#endregion
 //#region src/utils.ts
 /**
+* Return a cached promise by key, creating and storing it on miss.
+*
+* If the promise rejects, the cache entry is removed so future calls can retry.
+*
+* @param cache - Map used to store inflight/resolved promises.
+* @param key - Cache key.
+* @param factory - Factory to create the promise when missing.
+* @returns Cached or newly created promise.
+*/
+function cachePromise(cache, key, factory) {
+	const cached = getCacheValue(cache, key);
+	if (cached) return cached;
+	const task = factory().catch((error) => {
+		if (cache.get(key) === task) cache.delete(key);
+		throw error;
+	});
+	setCacheValue(cache, key, task);
+	return task;
+}
+/**
 * Read a cache value and move it to the most-recent position.
 *
 * @param cache - Cache map to read.
@@ -93,6 +114,19 @@ function getCacheValue(cache, key) {
 	return value;
 }
 /**
+* Check whether a relative path points outside its intended base directory.
+*
+* This also recognizes Windows drive-qualified paths when running on another
+* platform so the behavior can be tested consistently.
+*
+* @param path - Relative path candidate.
+* @returns True when the path escapes or is absolute.
+*/
+function isPathOutsideBase(path) {
+	const normalizedPath = toPosixPath(path);
+	return normalizedPath === ".." || normalizedPath.startsWith("../") || normalizedPath.startsWith("/") || /^[A-Za-z]:\//u.test(normalizedPath);
+}
+/**
 * Store a cache value and evict the least-recent entry when over capacity.
 *
 * @param cache - Cache map to update.
@@ -107,35 +141,6 @@ function setCacheValue(cache, key, value) {
 	if (!oldestKey.done) cache.delete(oldestKey.value);
 }
 /**
-* Return a cached promise by key, creating and storing it on miss.
-*
-* If the promise rejects, the cache entry is removed so future calls can retry.
-*
-* @param cache - Map used to store inflight/resolved promises.
-* @param key - Cache key.
-* @param factory - Factory to create the promise when missing.
-* @returns Cached or newly created promise.
-*/
-function cachePromise(cache, key, factory) {
-	const cached = getCacheValue(cache, key);
-	if (cached) return cached;
-	const task = factory().catch((error) => {
-		if (cache.get(key) === task) cache.delete(key);
-		throw error;
-	});
-	setCacheValue(cache, key, task);
-	return task;
-}
-/**
-* Normalize a filesystem path to POSIX-style separators.
-*
-* @param path - Original path.
-* @returns Path using `/` as separator.
-*/
-function toPosixPath(path) {
-	return path.replaceAll("\\", "/");
-}
-/**
 * Split a path into non-empty segments.
 *
 * @param path - Original path.
@@ -145,17 +150,13 @@ function splitPathSegments(path) {
 	return path.split(/[\\/]+/u).filter(Boolean);
 }
 /**
-* Check whether a relative path points outside its intended base directory.
-*
-* This also recognizes Windows drive-qualified paths when running on another
-* platform so the behavior can be tested consistently.
+* Normalize a filesystem path to POSIX-style separators.
 *
-* @param path - Relative path candidate.
-* @returns True when the path escapes or is absolute.
+* @param path - Original path.
+* @returns Path using `/` as separator.
 */
-function isPathOutsideBase(path) {
-	const normalizedPath = toPosixPath(path);
-	return normalizedPath === ".." || normalizedPath.startsWith("../") || normalizedPath.startsWith("/") || /^[A-Za-z]:\//u.test(normalizedPath);
+function toPosixPath(path) {
+	return path.replaceAll("\\", "/");
 }
 //#endregion
 //#region src/config.ts
@@ -185,105 +186,109 @@ const syntaxFallbackMessages = [
 */
 const freshJavaScriptModuleCache = /* @__PURE__ */ new Map();
 /**
-* Check whether an unknown config export is an object accepted by oxfmt.
-*
-* @param value - Runtime value to validate.
-* @returns True when the value can be treated as an oxfmt options object.
-*/
-function isConfigObject(value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null;
-}
-/**
-* Read a parsed JSON-like config value as an oxfmt config object.
-*
-* @param config - Runtime config value.
-* @returns Oxfmt config object.
-* @throws When the config value is not an object.
-*/
-function readParsedConfigObject(config) {
-	if (!isConfigObject(config)) throw new Error("Configuration file must be an object.");
-	return config;
-}
-/**
-* Read the default export from a JavaScript or TypeScript config module.
+* Build a cache key for config content; prefixes missing entries.
 *
-* @param mod - Imported config module namespace.
-* @returns Oxfmt config object from the module default export.
-* @throws When the module has no default export or the default export is not an object.
+* @param resolvedPath - Resolved oxfmt config path.
+* @param editorconfigPath - Resolved editorconfig path.
+* @param resolveKey - Resolution cache key.
+* @returns Cache key for config content cache.
 */
-function readConfigDefaultExport(mod) {
-	if (!hasOwn(mod, "default")) throw new Error("Configuration file has no default export.");
-	const config = mod["default"];
-	if (!isConfigObject(config)) throw new Error("Configuration file must have a default export that is an object.");
-	return config;
+function getConfigCacheKey(resolvedPath, editorconfigPath, resolveKey) {
+	return JSON.stringify([
+		resolvedPath ?? null,
+		editorconfigPath ?? null,
+		resolveKey
+	]);
 }
 /**
-* Read a CommonJS module export as an oxfmt config object.
+* Build a cache key for path resolution (cwd + configPath).
 *
-* @param config - Runtime CommonJS export value.
-* @returns Oxfmt config object from the module export.
-* @throws When the module export is not an object.
+* @param cwd - Current working directory.
+* @param configPath - Optional config path.
+* @returns Cache key for resolve cache.
 */
-function readConfigModuleExports(config) {
-	if (!isConfigObject(config)) throw new Error("Configuration file must export an object.");
-	return config;
+function getResolveCacheKey(cwd, configPath) {
+	return JSON.stringify([cwd, configPath ?? null]);
 }
 /**
-* Import a JavaScript or TypeScript config module through jiti.
+* Read and parse an oxfmt config file.
 *
-* @param resolvedPath - Absolute config file path to import.
-* @param useCache - Whether jiti should use its filesystem and module caches.
-* @returns Imported module namespace.
+* @param resolvedPath - Absolute path to config file.
+* @param options - Config loading options.
+* @param options.useCache - Whether to reuse cached config modules.
+* @returns Parsed config object.
 */
-async function importJitiConfigModule(resolvedPath, useCache) {
-	return (await interopDefault(import("jiti")))(import.meta.url, useCache ? void 0 : {
-		fsCache: false,
-		moduleCache: false
-	}).import(resolvedPath);
+async function readConfigFromFile(resolvedPath, options = {}) {
+	const extension = extname(resolvedPath);
+	const useCache = options.useCache !== false;
+	if ([
+		".cjs",
+		".cts",
+		".js",
+		".mjs",
+		".mts",
+		".ts"
+	].includes(extension)) {
+		if (!useCache && extension === ".cjs") return requireFreshCommonJSConfig(resolvedPath);
+		if (!useCache && extension === ".mjs") return readConfigDefaultExport(await importNativeFreshModule(resolvedPath));
+		if (!useCache && extension === ".js") return readConfigDefaultExport(await importFreshJavaScriptConfigModule(resolvedPath));
+		return readConfigDefaultExport(await importJitiConfigModule(resolvedPath, useCache));
+	}
+	const content = await readFile(resolvedPath, "utf8");
+	if (extension === ".jsonc") {
+		const parseErrors = [];
+		const parsed = parse(content, parseErrors, {
+			allowEmptyContent: true,
+			allowTrailingComma: true
+		});
+		if (parseErrors.length > 0) {
+			const firstError = parseErrors[0];
+			const errorCode = isUndefined(firstError) ? "Unknown" : printParseErrorCode(firstError.error);
+			throw new Error(`Invalid JSONC syntax: ${errorCode}`);
+		}
+		return readParsedConfigObject(isUndefined(parsed) && content.trim() === "" ? {} : parsed);
+	}
+	if (extension === ".json") return readParsedConfigObject(JSON.parse(content));
+	if (!extension) return readParsedConfigObject(JSON.parse(content));
+	if (!OXFMT_EXPLICIT_CONFIG_EXTENSIONS.includes(extension)) throw new Error(`Unsupported oxfmt config extension "${extension}" at ${resolvedPath}`);
+	return readParsedConfigObject(JSON.parse(content));
 }
 /**
-* Build a cache-busting import key from entry file contents.
+* Resolve the oxfmt config file path.
 *
-* @param resolvedPath - Absolute config file path.
-* @returns Stable key that changes when the entry file contents change.
-*/
-async function getFreshImportCacheKey(resolvedPath) {
-	const content = await readFile(resolvedPath);
-	return createHash("sha256").update(content).digest("hex");
-}
-/**
-* Read a Node-style `code` field from an unknown thrown value.
+* - If `configPath` is provided, absolute paths are returned as-is;
+*   relative paths are joined to `cwd`.
+* - Otherwise, walk upward from `cwd` to find known filenames.
 *
-* @param error - Thrown value to inspect.
-* @returns Error code when present.
-*/
-function getErrorCode(error) {
-	return isObject(error) && "code" in error && isString(error.code) ? error.code : void 0;
-}
-/**
-* Check whether a loader error should continue the JS config fallback chain.
+* @param cwd - Starting directory for resolution.
+* @param configPath - Optional explicit path.
+* @returns Absolute path to config file, or undefined when not found.
 *
-* @param error - Thrown value from require or native import.
-* @param resolvedPaths - Entry module paths that may appear in parser errors.
-* @returns True when the error is from loader compatibility, not config execution.
-*/
-function isJavaScriptLoaderFallbackError(error, resolvedPaths) {
-	const code = getErrorCode(error);
-	if (code && requireFallbackErrorCodes.has(code)) return true;
-	return error instanceof SyntaxError && resolvedPaths.some((resolvedPath) => error.stack?.startsWith(`${resolvedPath}:`) === true) && syntaxFallbackMessages.some((pattern) => pattern.test(error.message));
-}
-/**
-* Import an ESM config module with entry-file cache busting.
+* @example
+* ```ts
+* import { resolveOxfmtrcPath } from 'load-oxfmt-config'
 *
-* @param resolvedPath - Absolute config file path to import.
-* @returns Imported module namespace.
+* const path = await resolveOxfmtrcPath(process.cwd())
+* ```
 */
-async function importNativeFreshModule(resolvedPath) {
-	const url = pathToFileURL(resolvedPath);
-	url.searchParams.set("oxfmtConfigCacheBust", await getFreshImportCacheKey(resolvedPath));
-	return import(url.href);
+async function resolveOxfmtrcPath(cwd, configPath) {
+	const resolvedCwd = resolve(cwd);
+	if (configPath) return isAbsolute(configPath) ? configPath : join(resolvedCwd, configPath);
+	let currentDir = resolvedCwd;
+	while (true) {
+		for (const filename of OXFMT_CONFIG_FILES) {
+			const configFilePath = join(currentDir, filename);
+			try {
+				if ((await stat(configFilePath)).isFile()) return configFilePath;
+			} catch (error) {
+				const code = error.code;
+				if (code !== "ENOENT" && code !== "ENOTDIR") throw error;
+			}
+		}
+		const parentDir = join(currentDir, "..");
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
 }
 /**
 * Delete a CommonJS module and all cached children reachable from it.
@@ -301,26 +306,23 @@ function deleteRequireCacheTree(requirePath, seen = /* @__PURE__ */ new Set()) {
 	Reflect.deleteProperty(require.cache, requirePath);
 }
 /**
-* Require a CommonJS module after removing it from Node's require cache.
+* Read a Node-style `code` field from an unknown thrown value.
 *
-* @param resolvedPath - Absolute config file path to require.
-* @returns Runtime module export value.
+* @param error - Thrown value to inspect.
+* @returns Error code when present.
 */
-function requireFreshModule(resolvedPath) {
-	const requirePath = require.resolve(resolvedPath);
-	deleteRequireCacheTree(requirePath);
-	return require(requirePath);
+function getErrorCode(error) {
+	return isObject(error) && "code" in error && isString(error.code) ? error.code : void 0;
 }
 /**
-* Load a CommonJS config file without reusing Node's require cache.
+* Build a cache-busting import key from entry file contents.
 *
-* @param resolvedPath - Absolute `.cjs` config file path.
-* @returns Oxfmt config object from default or module exports.
+* @param resolvedPath - Absolute config file path.
+* @returns Stable key that changes when the entry file contents change.
 */
-function requireFreshCommonJSConfig(resolvedPath) {
-	const configModule = requireFreshModule(resolvedPath);
-	if (Object.prototype.toString.call(configModule) === "[object Module]") return readConfigDefaultExport(configModule);
-	return readConfigModuleExports(configModule);
+async function getFreshImportCacheKey(resolvedPath) {
+	const content = await readFile(resolvedPath);
+	return createHash("sha256").update(content).digest("hex");
 }
 /**
 * Load a JavaScript config file without reusing stale module contents.
@@ -372,105 +374,117 @@ async function importFreshJavaScriptConfigModule(resolvedPath) {
 	}
 }
 /**
-* Build a cache key for path resolution (cwd + configPath).
+* Import a JavaScript or TypeScript config module through jiti.
 *
-* @param cwd - Current working directory.
-* @param configPath - Optional config path.
-* @returns Cache key for resolve cache.
+* @param resolvedPath - Absolute config file path to import.
+* @param useCache - Whether jiti should use its filesystem and module caches.
+* @returns Imported module namespace.
 */
-function getResolveCacheKey(cwd, configPath) {
-	return JSON.stringify([cwd, configPath ?? null]);
+async function importJitiConfigModule(resolvedPath, useCache) {
+	return (await interopDefault(import("jiti")))(import.meta.url, useCache ? void 0 : {
+		fsCache: false,
+		moduleCache: false
+	}).import(resolvedPath);
 }
 /**
-* Build a cache key for config content; prefixes missing entries.
+* Import an ESM config module with entry-file cache busting.
 *
-* @param resolvedPath - Resolved oxfmt config path.
-* @param editorconfigPath - Resolved editorconfig path.
-* @param resolveKey - Resolution cache key.
-* @returns Cache key for config content cache.
+* @param resolvedPath - Absolute config file path to import.
+* @returns Imported module namespace.
 */
-function getConfigCacheKey(resolvedPath, editorconfigPath, resolveKey) {
-	return JSON.stringify([
-		resolvedPath ?? null,
-		editorconfigPath ?? null,
-		resolveKey
-	]);
+async function importNativeFreshModule(resolvedPath) {
+	const url = pathToFileURL(resolvedPath);
+	url.searchParams.set("oxfmtConfigCacheBust", await getFreshImportCacheKey(resolvedPath));
+	return import(url.href);
 }
 /**
-* Resolve the oxfmt config file path.
-*
-* - If `configPath` is provided, absolute paths are returned as-is;
-*   relative paths are joined to `cwd`.
-* - Otherwise, walk upward from `cwd` to find known filenames.
+* Check whether an unknown config export is an object accepted by oxfmt.
 *
-* @param cwd - Starting directory for resolution.
-* @param configPath - Optional explicit path.
-* @returns Absolute path to config file, or undefined when not found.
+* @param value - Runtime value to validate.
+* @returns True when the value can be treated as an oxfmt options object.
+*/
+function isConfigObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+/**
+* Check whether a loader error should continue the JS config fallback chain.
 *
-* @example
-* ```ts
-* import { resolveOxfmtrcPath } from 'load-oxfmt-config'
+* @param error - Thrown value from require or native import.
+* @param resolvedPaths - Entry module paths that may appear in parser errors.
+* @returns True when the error is from loader compatibility, not config execution.
+*/
+function isJavaScriptLoaderFallbackError(error, resolvedPaths) {
+	const code = getErrorCode(error);
+	if (code && requireFallbackErrorCodes.has(code)) return true;
+	return error instanceof SyntaxError && resolvedPaths.some((resolvedPath) => error.stack?.startsWith(`${resolvedPath}:`) === true) && syntaxFallbackMessages.some((pattern) => pattern.test(error.message));
+}
+/**
+* Read the default export from a JavaScript or TypeScript config module.
 *
-* const path = await resolveOxfmtrcPath(process.cwd())
-* ```
+* @param mod - Imported config module namespace.
+* @returns Oxfmt config object from the module default export.
+* @throws When the module has no default export or the default export is not an object.
 */
-async function resolveOxfmtrcPath(cwd, configPath) {
-	const resolvedCwd = resolve(cwd);
-	if (configPath) return isAbsolute(configPath) ? configPath : join(resolvedCwd, configPath);
-	let currentDir = resolvedCwd;
-	while (true) {
-		for (const filename of OXFMT_CONFIG_FILES) {
-			const configFilePath = join(currentDir, filename);
-			try {
-				if ((await stat(configFilePath)).isFile()) return configFilePath;
-			} catch (error) {
-				const code = error.code;
-				if (code !== "ENOENT" && code !== "ENOTDIR") throw error;
-			}
-		}
-		const parentDir = join(currentDir, "..");
-		if (parentDir === currentDir) break;
-		currentDir = parentDir;
-	}
+function readConfigDefaultExport(mod) {
+	if (!hasOwn(mod, "default")) throw new Error("Configuration file has no default export.");
+	const config = mod.default;
+	if (!isConfigObject(config)) throw new Error("Configuration file must have a default export that is an object.");
+	return config;
 }
 /**
-* Read and parse an oxfmt config file.
+* Read a CommonJS module export as an oxfmt config object.
 *
-* @param resolvedPath - Absolute path to config file.
-* @param options - Config loading options.
-* @returns Parsed config object.
+* @param config - Runtime CommonJS export value.
+* @returns Oxfmt config object from the module export.
+* @throws When the module export is not an object.
 */
-async function readConfigFromFile(resolvedPath, options = {}) {
-	const extension = extname(resolvedPath);
-	const useCache = options.useCache !== false;
-	if (extension === ".ts" || extension === ".mts" || extension === ".cts" || extension === ".js" || extension === ".mjs" || extension === ".cjs") {
-		if (!useCache && extension === ".cjs") return requireFreshCommonJSConfig(resolvedPath);
-		if (!useCache && extension === ".mjs") return readConfigDefaultExport(await importNativeFreshModule(resolvedPath));
-		if (!useCache && extension === ".js") return readConfigDefaultExport(await importFreshJavaScriptConfigModule(resolvedPath));
-		return readConfigDefaultExport(await importJitiConfigModule(resolvedPath, useCache));
-	}
-	const content = await readFile(resolvedPath, "utf8");
-	if (extension === ".jsonc") {
-		const parseErrors = [];
-		const parsed = parse(content, parseErrors, {
-			allowTrailingComma: true,
-			allowEmptyContent: true
-		});
-		if (parseErrors.length > 0) {
-			const firstError = parseErrors[0];
-			const errorCode = isUndefined(firstError) ? "Unknown" : printParseErrorCode(firstError.error);
-			throw new Error(`Invalid JSONC syntax: ${errorCode}`);
-		}
-		return readParsedConfigObject(isUndefined(parsed) && content.trim() === "" ? {} : parsed);
-	}
-	if (extension === ".json") return readParsedConfigObject(JSON.parse(content));
-	if (!extension) return readParsedConfigObject(JSON.parse(content));
-	if (!OXFMT_EXPLICIT_CONFIG_EXTENSIONS.includes(extension)) throw new Error(`Unsupported oxfmt config extension "${extension}" at ${resolvedPath}`);
-	return readParsedConfigObject(JSON.parse(content));
+function readConfigModuleExports(config) {
+	if (!isConfigObject(config)) throw new Error("Configuration file must export an object.");
+	return config;
+}
+/**
+* Read a parsed JSON-like config value as an oxfmt config object.
+*
+* @param config - Runtime config value.
+* @returns Oxfmt config object.
+* @throws When the config value is not an object.
+*/
+function readParsedConfigObject(config) {
+	if (!isConfigObject(config)) throw new Error("Configuration file must be an object.");
+	return config;
+}
+/**
+* Load a CommonJS config file without reusing Node's require cache.
+*
+* @param resolvedPath - Absolute `.cjs` config file path.
+* @returns Oxfmt config object from default or module exports.
+*/
+function requireFreshCommonJSConfig(resolvedPath) {
+	const configModule = requireFreshModule(resolvedPath);
+	if (Object.prototype.toString.call(configModule) === "[object Module]") return readConfigDefaultExport(configModule);
+	return readConfigModuleExports(configModule);
+}
+/**
+* Require a CommonJS module after removing it from Node's require cache.
+*
+* @param resolvedPath - Absolute config file path to require.
+* @returns Runtime module export value.
+*/
+function requireFreshModule(resolvedPath) {
+	const requirePath = require.resolve(resolvedPath);
+	deleteRequireCacheTree(requirePath);
+	return require(requirePath);
 }
 //#endregion
 //#region src/editorconfig.ts
 /**
+* Shared input caches for static and per-file EditorConfig resolution.
+*/
+const sectionCache = /* @__PURE__ */ new Map();
+const matcherCache = /* @__PURE__ */ new Map();
+/**
 * Builds the cache key used for resolved EditorConfig lookups.
 *
 * @param resolveKey - The base resolution key for the current lookup.
@@ -492,19 +506,6 @@ function getEditorconfigSearchDir(cwd, configPath) {
 	return dirname(resolvedConfigPath);
 }
 /**
-* Merges root-level EditorConfig options with oxfmt config options.
-*
-* @param oxfmtConfig - The explicit oxfmt options.
-* @param editorconfigRootOptions - Root options derived from .editorconfig.
-* @returns A single root options object where oxfmt takes precedence.
-*/
-function mergeRootOptions(oxfmtConfig, editorconfigRootOptions) {
-	return {
-		...editorconfigRootOptions,
-		...oxfmtConfig
-	};
-}
-/**
 * Merges EditorConfig-derived overrides with explicit oxfmt overrides.
 *
 * @param oxfmtConfig - Explicit root options and overrides from the oxfmt config.
@@ -522,6 +523,63 @@ function mergeOverrides(oxfmtConfig, editorconfigOverrides) {
 	return mergedOverrides.length > 0 ? mergedOverrides : void 0;
 }
 /**
+* Merges root-level EditorConfig options with oxfmt config options.
+*
+* @param oxfmtConfig - The explicit oxfmt options.
+* @param editorconfigRootOptions - Root options derived from .editorconfig.
+* @returns A single root options object where oxfmt takes precedence.
+*/
+function mergeRootOptions(oxfmtConfig, editorconfigRootOptions) {
+	return {
+		...editorconfigRootOptions,
+		...oxfmtConfig
+	};
+}
+/**
+* Reads a .editorconfig file and converts it into root options and override entries.
+*
+* @param editorconfigPath - The absolute path to the .editorconfig file.
+* @param anchorDir - The directory used to rebase section patterns.
+* @param options - Optional per-file resolution and cache controls.
+* @param options.filepath - Resolve matching sections for this absolute file path.
+* @param options.useCache - Reuse parsed sections and compiled matchers.
+* @returns Parsed EditorConfig data ready to merge into oxfmt config.
+*/
+async function readEditorconfigFromFile(editorconfigPath, anchorDir, options = {}) {
+	const useCache = options.useCache !== false;
+	const readSections = async () => parseBuffer(await readFile(editorconfigPath));
+	const parsedSections = useCache ? await cachePromise(sectionCache, editorconfigPath, readSections) : await readSections();
+	const editorconfigDir = dirname(editorconfigPath);
+	const rootOptions = {};
+	const overrides = [];
+	const relativeFile = options.filepath ? toPosixPath(relative(editorconfigDir, options.filepath)) : void 0;
+	if (relativeFile !== void 0 && isPathOutsideBase(relativeFile)) return {
+		overrides,
+		rootOptions
+	};
+	for (const [sectionName, sectionBody] of parsedSections) {
+		if (!sectionName) continue;
+		const mappedOptions = mapEditorconfigSectionToOptions(sectionBody);
+		if (Object.keys(mappedOptions).length === 0) continue;
+		if (relativeFile !== void 0) {
+			if (matchesEditorconfigSection(sectionName, relativeFile, useCache)) Object.assign(rootOptions, mappedOptions);
+			continue;
+		}
+		if (isEditorconfigGlobalSection(sectionName)) {
+			Object.assign(rootOptions, mappedOptions);
+			if (overrides.length === 0) continue;
+		}
+		overrides.push({
+			options: mappedOptions,
+			files: [rebaseEditorconfigPattern(sectionName, editorconfigDir, anchorDir)]
+		});
+	}
+	return {
+		overrides,
+		rootOptions
+	};
+}
+/**
 * Resolves the nearest .editorconfig file starting from a directory and optionally walking upward.
 *
 * @param startDir - The directory where the search starts.
@@ -554,6 +612,61 @@ function isEditorconfigGlobalSection(sectionName) {
 	return Boolean(sectionName && EDITORCONFIG_GLOBAL_SECTION_NAMES.includes(sectionName));
 }
 /**
+* Maps a parsed EditorConfig section to the subset of oxfmt formatter options it supports.
+*
+* @param section - The parsed EditorConfig section body.
+* @returns Formatter options derived from the section.
+*/
+function mapEditorconfigSectionToOptions(section) {
+	const options = {};
+	const endOfLine = parseEditorconfigEndOfLine(section.end_of_line);
+	if (endOfLine) options.endOfLine = endOfLine;
+	if (section.indent_style === "tab") options.useTabs = true;
+	else if (section.indent_style === "space") options.useTabs = false;
+	const singleQuote = parseEditorconfigQuoteType(section.quote_type);
+	if (isBoolean(singleQuote)) options.singleQuote = singleQuote;
+	const tabWidth = parseEditorconfigTabWidth(section, options.useTabs);
+	if (isNumber(tabWidth)) options.tabWidth = tabWidth;
+	if (section.max_line_length && section.max_line_length !== "unset") {
+		const parsedPrintWidth = Number(section.max_line_length);
+		if (Number.isFinite(parsedPrintWidth)) options.printWidth = parsedPrintWidth;
+	}
+	const insertFinalNewline = parseEditorconfigBoolean(section.insert_final_newline);
+	if (isBoolean(insertFinalNewline)) options.insertFinalNewline = insertFinalNewline;
+	return options;
+}
+/**
+* Match a section against its source-relative file path without oxfmt rebasing.
+*
+* @param pattern - Original section name.
+* @param filepath - File path relative to the EditorConfig directory.
+* @param useCache - Whether compiled matchers can be reused.
+* @returns Whether the section applies to the file.
+*/
+function matchesEditorconfigSection(pattern, filepath, useCache) {
+	let matcher = useCache ? getCacheValue(matcherCache, pattern) : void 0;
+	if (!matcher) {
+		matcher = new Minimatch(normalizeEditorconfigPattern(pattern), {
+			dot: true,
+			nocomment: true,
+			noext: true,
+			nonegate: true
+		});
+		if (useCache) setCacheValue(matcherCache, pattern, matcher);
+	}
+	return matcher.match(filepath);
+}
+/**
+* Keep basename patterns recursive without changing path-scoped patterns.
+*
+* @param pattern - Original EditorConfig section name.
+* @returns Pattern suitable for matching a path relative to EditorConfig.
+*/
+function normalizeEditorconfigPattern(pattern) {
+	if (pattern === "*" || pattern === "**") return "**";
+	return pattern.includes("/") ? pattern : `**/${pattern}`;
+}
+/**
 * Parses an EditorConfig boolean string.
 *
 * @param value - The raw EditorConfig value.
@@ -570,7 +683,11 @@ function parseEditorconfigBoolean(value) {
 * @returns The normalized line ending value, or undefined when unsupported.
 */
 function parseEditorconfigEndOfLine(value) {
-	if (value === "lf" || value === "crlf" || value === "cr") return value;
+	switch (value) {
+		case "cr":
+		case "crlf":
+		case "lf": return value;
+	}
 }
 /**
 * Parses the single quote preference from an EditorConfig section.
@@ -590,8 +707,8 @@ function parseEditorconfigQuoteType(value) {
 * @returns The resolved tab width, or undefined when no numeric value is available.
 */
 function parseEditorconfigTabWidth(section, useTabs) {
-	const indentSize = section["indent_size"];
-	const tabWidth = section["tab_width"];
+	const indentSize = section.indent_size;
+	const tabWidth = section.tab_width;
 	if (useTabs === false && indentSize && indentSize !== "unset" && indentSize !== "tab") {
 		const parsedIndentSize = Number(indentSize);
 		if (Number.isFinite(parsedIndentSize)) return parsedIndentSize;
@@ -602,30 +719,6 @@ function parseEditorconfigTabWidth(section, useTabs) {
 	}
 }
 /**
-* Maps a parsed EditorConfig section to the subset of oxfmt formatter options it supports.
-*
-* @param section - The parsed EditorConfig section body.
-* @returns Formatter options derived from the section.
-*/
-function mapEditorconfigSectionToOptions(section) {
-	const options = {};
-	const endOfLine = parseEditorconfigEndOfLine(section["end_of_line"]);
-	if (endOfLine) options.endOfLine = endOfLine;
-	if (section["indent_style"] === "tab") options.useTabs = true;
-	else if (section["indent_style"] === "space") options.useTabs = false;
-	const singleQuote = parseEditorconfigQuoteType(section["quote_type"]);
-	if (isBoolean(singleQuote)) options.singleQuote = singleQuote;
-	const tabWidth = parseEditorconfigTabWidth(section, options.useTabs);
-	if (isNumber(tabWidth)) options.tabWidth = tabWidth;
-	if (section["max_line_length"] && section["max_line_length"] !== "unset") {
-		const parsedPrintWidth = Number(section["max_line_length"]);
-		if (Number.isFinite(parsedPrintWidth)) options.printWidth = parsedPrintWidth;
-	}
-	const insertFinalNewline = parseEditorconfigBoolean(section["insert_final_newline"]);
-	if (isBoolean(insertFinalNewline)) options.insertFinalNewline = insertFinalNewline;
-	return options;
-}
-/**
 * Rebases an EditorConfig section pattern from the config directory to the target anchor directory.
 *
 * @param pattern - The original EditorConfig section pattern.
@@ -634,40 +727,10 @@ function mapEditorconfigSectionToOptions(section) {
 * @returns The rebased glob pattern.
 */
 function rebaseEditorconfigPattern(pattern, editorconfigDir, anchorDir) {
+	const normalizedPattern = normalizeEditorconfigPattern(pattern);
 	const relativePrefix = toPosixPath(relative(anchorDir, editorconfigDir));
-	if (!relativePrefix || relativePrefix === ".") return pattern;
-	return `${relativePrefix}/${pattern.replace(/^\//u, "")}`;
-}
-/**
-* Reads a .editorconfig file and converts it into root options and override entries.
-*
-* @param editorconfigPath - The absolute path to the .editorconfig file.
-* @param anchorDir - The directory used to rebase section patterns.
-* @returns Parsed EditorConfig data ready to merge into oxfmt config.
-*/
-async function readEditorconfigFromFile(editorconfigPath, anchorDir) {
-	const content = await readFile(editorconfigPath);
-	const parsedSections = parseBuffer(content);
-	const editorconfigDir = dirname(editorconfigPath);
-	const rootOptions = {};
-	const overrides = [];
-	for (const [sectionName, sectionBody] of parsedSections) {
-		if (!sectionName) continue;
-		const mappedOptions = mapEditorconfigSectionToOptions(sectionBody);
-		if (Object.keys(mappedOptions).length === 0) continue;
-		if (isEditorconfigGlobalSection(sectionName)) {
-			Object.assign(rootOptions, mappedOptions);
-			continue;
-		}
-		overrides.push({
-			files: [rebaseEditorconfigPattern(sectionName, editorconfigDir, anchorDir)],
-			options: mappedOptions
-		});
-	}
-	return {
-		overrides,
-		rootOptions
-	};
+	if (!relativePrefix || relativePrefix === ".") return normalizedPattern;
+	return `${relativePrefix}/${normalizedPattern.replace(/^\//u, "")}`;
 }
 //#endregion
 //#region src/core.ts
@@ -680,6 +743,10 @@ const resolveCache = /* @__PURE__ */ new Map();
 */
 const configCache = /* @__PURE__ */ new Map();
 /**
+* Share raw config reads across files without caching file-specific fallbacks.
+*/
+const sourceCache = /* @__PURE__ */ new Map();
+/**
 * Resolve config + editorconfig and return merged config with metadata.
 *
 * @param options - Loader settings.
@@ -694,6 +761,26 @@ const configCache = /* @__PURE__ */ new Map();
 * ```
 */
 async function loadOxfmtConfig(options = {}) {
+	return loadConfig(options);
+}
+/**
+* Load config with EditorConfig fallbacks resolved for one file.
+* Explicit oxfmt overrides remain unevaluated and retain their config-relative globs.
+*
+* @param options - Loader settings with the target file path.
+* @returns Config with per-file EditorConfig defaults and config metadata.
+*/
+async function loadOxfmtConfigForFile(options) {
+	return loadConfig(options, true);
+}
+/**
+* Share discovery and caches between static and per-file loading.
+*
+* @param options - Loader settings.
+* @param resolveEditorconfig - Resolve EditorConfig sections against the target file.
+* @returns Loaded config and metadata.
+*/
+async function loadConfig(options, resolveEditorconfig = false) {
 	const useCache = options.useCache !== false;
 	const cwd = resolve(options.cwd || process.cwd());
 	const filepath = options.filepath ? resolve(cwd, options.filepath) : void 0;
@@ -709,12 +796,17 @@ async function loadOxfmtConfig(options = {}) {
 	const resolvedPath = useCache ? await cachePromise(resolveCache, resolveKey, () => resolveOxfmtrcPath(configLookupCwd, options.configPath)) : await resolveOxfmtrcPath(configLookupCwd, options.configPath);
 	const editorconfigPath = useEditorconfig ? await (useCache ? cachePromise(resolveCache, editorconfigResolveKey, () => resolveEditorconfigPath(editorconfigSearchDir, onlyCwd)) : resolveEditorconfigPath(editorconfigSearchDir, onlyCwd)) : void 0;
 	const anchorDir = dirname(resolvedPath || editorconfigPath || cwd);
+	const configKey = getConfigCacheKey(resolvedPath, editorconfigPath, JSON.stringify([resolveKey, resolveEditorconfig ? filepath : null]));
 	const loadTask = async () => {
-		const oxfmtConfig = resolvedPath ? await readConfigFromFile(resolvedPath, { useCache }).catch((error) => {
+		const readConfig = async () => resolvedPath ? await readConfigFromFile(resolvedPath, { useCache }).catch((error) => {
 			throw new Error(`Failed to parse oxfmt configuration file at ${resolvedPath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
 		}) : {};
+		const oxfmtConfig = useCache && resolvedPath ? await cachePromise(sourceCache, resolvedPath, readConfig) : await readConfig();
 		if (!editorconfigPath) return oxfmtConfig;
-		const editorconfigData = await readEditorconfigFromFile(editorconfigPath, anchorDir);
+		const editorconfigData = await readEditorconfigFromFile(editorconfigPath, anchorDir, {
+			filepath: resolveEditorconfig ? filepath : void 0,
+			useCache
+		});
 		const mergedConfig = mergeRootOptions(oxfmtConfig, editorconfigData.rootOptions);
 		const mergedOverrides = mergeOverrides(oxfmtConfig, editorconfigData.overrides);
 		if (!mergedOverrides) return mergedConfig;
@@ -723,15 +815,11 @@ async function loadOxfmtConfig(options = {}) {
 			overrides: mergedOverrides
 		};
 	};
-	const hasNoConfigSources = !resolvedPath && !editorconfigPath;
 	return {
-		config: await (async () => {
-			if (hasNoConfigSources) return useCache ? await cachePromise(configCache, getConfigCacheKey(resolvedPath, editorconfigPath, resolveKey), () => Promise.resolve({})) : {};
-			return useCache ? await cachePromise(configCache, getConfigCacheKey(resolvedPath, editorconfigPath, resolveKey), loadTask) : await loadTask();
-		})(),
+		config: useCache ? await cachePromise(configCache, configKey, loadTask) : await loadTask(),
 		...resolvedPath ? {
-			filepath: resolvedPath,
-			dirname: dirname(resolvedPath)
+			dirname: dirname(resolvedPath),
+			filepath: resolvedPath
 		} : {}
 	};
 }
@@ -746,10 +834,108 @@ const ignoreMatcherCache = /* @__PURE__ */ new Map();
 */
 const configIgnoreMatcherCache = /* @__PURE__ */ new Map();
 /**
+* Resolve whether a file should be ignored using oxfmt-like CLI semantics.
+*
+* @param options - Ignore resolution options.
+* @returns Ignore status with optional reason.
+*
+* @example
+* ```ts
+* import { isOxfmtIgnored } from 'load-oxfmt-config'
+*
+* const result = await isOxfmtIgnored({
+*   cwd: process.cwd(),
+*   filepath: 'src/generated/file.ts',
+* })
+* ```
+*/
+async function isOxfmtIgnored(options) {
+	const useCache = options.useCache !== false;
+	const includeConfigIgnorePatterns = options.includeConfigIgnorePatterns !== false;
+	const loadConfigForIgnorePatterns = options.loadConfigForIgnorePatterns !== false;
+	const cwd = resolve(options.cwd ?? process.cwd());
+	const filepath = isAbsolute(options.filepath) ? resolve(options.filepath) : resolve(cwd, options.filepath);
+	if (options.includeDefaultIgnores !== false) {
+		const defaultResult = await resolveDefaultIgnores(filepath, cwd, options, useCache);
+		if (defaultResult.ignored) return defaultResult;
+	}
+	if (!loadConfigForIgnorePatterns) return { ignored: false };
+	const configResult = await loadOxfmtConfig({
+		cwd,
+		filepath,
+		...options.disableNestedConfig === true ? { disableNestedConfig: true } : {},
+		...options.configPath ? { configPath: options.configPath } : {},
+		editorconfig: false,
+		useCache
+	});
+	if (includeConfigIgnorePatterns && configResult.dirname && configResult.config.ignorePatterns && configResult.config.ignorePatterns.length > 0 && matchConfigIgnorePatterns(filepath, configResult.dirname, configResult.config.ignorePatterns, useCache)) return {
+		ignored: true,
+		reason: "config-ignore-patterns"
+	};
+	return { ignored: false };
+}
+/**
+* Collect `.gitignore` files from file directory up to git repo boundary.
+*
+* @param filepath - Absolute file path to test.
+* @returns Collected ignore files and repo root when found.
+*/
+async function collectGitignorePaths(filepath) {
+	const fileDir = dirname(filepath);
+	const repoRoot = await findGitRepoRoot(fileDir);
+	const paths = [];
+	let current = fileDir;
+	while (true) {
+		paths.push(join(current, ".gitignore"));
+		if (repoRoot && current === repoRoot) break;
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return {
+		paths,
+		repoRoot
+	};
+}
+/**
+* Find the nearest git repo root by walking up from a start directory.
+*
+* @param fromDir - Directory to start from.
+* @returns Repo root directory, or undefined when no git boundary is found.
+*/
+async function findGitRepoRoot(fromDir) {
+	let current = fromDir;
+	while (true) {
+		if (await hasGitEntry(current)) return current;
+		const parent = dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+/**
+* Check whether a directory looks like a git repo root.
+*
+* A `.git` entry can be either a directory (regular repo) or a file (worktree/submodule).
+*
+* @param dir - Directory to inspect.
+* @returns True when `.git` exists under the directory.
+*/
+async function hasGitEntry(dir) {
+	try {
+		await stat(join(dir, ".git"));
+		return true;
+	} catch (error) {
+		const code = error.code;
+		if (code === "ENOENT" || code === "ENOTDIR") return false;
+		throw error;
+	}
+}
+/**
 * Check whether a file is under oxfmt's default ignored directories.
 *
 * @param filepath - Absolute file path to test.
 * @param options - Matching options.
+* @param options.withNodeModules - Whether node_modules should remain eligible.
 * @returns True when the path should be ignored by default directory rules.
 */
 function isDefaultIgnoredDir(filepath, options) {
@@ -787,14 +973,25 @@ function loadIgnoreMatcher(ignoreFilePath, useCache) {
 	return cachePromise(ignoreMatcherCache, ignoreFilePath, loadTask);
 }
 /**
-* Build a POSIX relative path.
+* Match `ignorePatterns` from config with support for negated patterns.
 *
-* @param from - Base directory.
-* @param to - Target path.
-* @returns POSIX relative path.
+* @param filepath - Absolute file path.
+* @param configDir - Resolved config directory.
+* @param patterns - Config ignore patterns.
+* @param useCache - Whether to reuse compiled pattern matchers.
+* @returns True when patterns mark the file as ignored.
 */
-function relativeSafe(from, to) {
-	return toPosixPath(relative(from, to));
+function matchConfigIgnorePatterns(filepath, configDir, patterns, useCache) {
+	validateConfigIgnorePatterns(patterns);
+	const relativeFile = relativeSafe(configDir, filepath);
+	if (isPathOutsideBase(relativeFile)) return false;
+	if (!useCache) return ignore().add(patterns).ignores(relativeFile);
+	const cacheKey = `${configDir}::${JSON.stringify(patterns)}`;
+	const cachedMatcher = getCacheValue(configIgnoreMatcherCache, cacheKey);
+	if (cachedMatcher) return cachedMatcher.ignores(relativeFile);
+	const matcher = ignore().add(patterns);
+	setCacheValue(configIgnoreMatcherCache, cacheKey, matcher);
+	return matcher.ignores(relativeFile);
 }
 /**
 * Match file path against one ignore file.
@@ -813,6 +1010,28 @@ async function matchIgnoreFile(filepath, ignoreFilePath, useCache, baseDir) {
 	return matcher.ignores(relativeToIgnore);
 }
 /**
+* Match a file path against ordered ignore files while preserving negation state.
+*
+* @param filepath - Absolute file path.
+* @param ignoreFileEntries - Ignore files in increasing precedence order.
+* @param useCache - Whether to use matcher cache.
+* @param stopAtIgnoredDirectory - Whether ignored directories prevent reading nested ignore files.
+* @returns True when the ordered ignore files mark the file as ignored.
+*/
+async function matchIgnoreFileChain(filepath, ignoreFileEntries, useCache, stopAtIgnoredDirectory = false) {
+	const matcherEntries = [];
+	for (const entry of ignoreFileEntries) {
+		const baseDir = entry.baseDir ?? dirname(entry.path);
+		if (stopAtIgnoredDirectory && matchLoadedIgnoreMatchers(baseDir, matcherEntries, true).ignored) break;
+		const matcher = await loadIgnoreMatcher(entry.path, useCache);
+		if (matcher) matcherEntries.push({
+			baseDir,
+			matcher
+		});
+	}
+	return matchLoadedIgnoreMatchers(filepath, matcherEntries);
+}
+/**
 * Match a path against loaded ignore matchers in precedence order.
 *
 * @param filepath - Absolute file or directory path to test.
@@ -842,54 +1061,57 @@ function matchLoadedIgnoreMatchers(filepath, matcherEntries, isDirectory = false
 	};
 }
 /**
-* Match a file path against ordered ignore files while preserving negation state.
-*
-* @param filepath - Absolute file path.
-* @param ignoreFileEntries - Ignore files in increasing precedence order.
-* @param useCache - Whether to use matcher cache.
-* @param stopAtIgnoredDirectory - Whether ignored directories prevent reading nested ignore files.
-* @returns True when the ordered ignore files mark the file as ignored.
-*/
-async function matchIgnoreFileChain(filepath, ignoreFileEntries, useCache, stopAtIgnoredDirectory = false) {
-	const matcherEntries = [];
-	for (const entry of ignoreFileEntries) {
-		const baseDir = entry.baseDir ?? dirname(entry.path);
-		if (stopAtIgnoredDirectory && matchLoadedIgnoreMatchers(baseDir, matcherEntries, true).ignored) break;
-		const matcher = await loadIgnoreMatcher(entry.path, useCache);
-		if (matcher) matcherEntries.push({
-			baseDir,
-			matcher
-		});
-	}
-	return matchLoadedIgnoreMatchers(filepath, matcherEntries);
-}
-/**
-* Resolve an ignore file path against cwd when needed.
+* Build a POSIX relative path.
 *
-* @param path - Absolute or relative path.
-* @param cwd - Current working directory.
-* @returns Absolute ignore file path.
+* @param from - Base directory.
+* @param to - Target path.
+* @returns POSIX relative path.
 */
-function resolveIgnoreFilePath(path, cwd) {
-	return isAbsolute(path) ? path : resolve(cwd, path);
+function relativeSafe(from, to) {
+	return toPosixPath(relative(from, to));
 }
 /**
-* Check whether a directory looks like a git repo root.
+* Evaluate global ignore rules separately from explicit config patterns.
 *
-* A `.git` entry can be either a directory (regular repo) or a file (worktree/submodule).
-*
-* @param dir - Directory to inspect.
-* @returns True when `.git` exists under the directory.
+* @param filepath - Absolute target file path.
+* @param cwd - Base directory for ignore file resolution.
+* @param options - Ignore file and node_modules settings.
+* @param useCache - Whether ignore matchers can be reused.
+* @returns Global ignore status.
 */
-async function hasGitEntry(dir) {
-	try {
-		await stat(join(dir, ".git"));
-		return true;
-	} catch (error) {
-		const code = error.code;
-		if (code === "ENOENT" || code === "ENOTDIR") return false;
-		throw error;
+async function resolveDefaultIgnores(filepath, cwd, options, useCache) {
+	if (isDefaultIgnoredDir(filepath, options.withNodeModules ? { withNodeModules: true } : {})) return {
+		ignored: true,
+		reason: "default-dir"
+	};
+	if (isLockfile(filepath)) return {
+		ignored: true,
+		reason: "lockfile"
+	};
+	const explicitIgnorePaths = (typeof options.ignorePath === "string" ? [options.ignorePath] : options.ignorePath)?.map((path) => resolveIgnoreFilePath(path, cwd));
+	const { paths: gitignorePaths, repoRoot } = await collectGitignorePaths(filepath);
+	const gitignoreResult = await matchIgnoreFileChain(filepath, [...gitignorePaths].reverse().map((path) => ({ path })), useCache, true);
+	if (gitignoreResult.ignored) return {
+		ignored: true,
+		reason: "gitignore"
+	};
+	if (repoRoot && !gitignoreResult.matched) {
+		const infoExcludePath = await resolveGitInfoExcludePath(repoRoot);
+		if (infoExcludePath && await matchIgnoreFile(filepath, infoExcludePath, useCache, repoRoot)) return {
+			ignored: true,
+			reason: "git-info-exclude"
+		};
 	}
+	if (explicitIgnorePaths && explicitIgnorePaths.length > 0) {
+		if ((await matchIgnoreFileChain(filepath, explicitIgnorePaths.map((path) => ({ path })), useCache)).ignored) return {
+			ignored: true,
+			reason: "ignore-path"
+		};
+	} else if (await matchIgnoreFile(filepath, resolve(cwd, ".prettierignore"), useCache)) return {
+		ignored: true,
+		reason: "prettierignore"
+	};
+	return { ignored: false };
 }
 /**
 * Resolve the git info exclude file from a repo root.
@@ -927,42 +1149,14 @@ async function resolveGitInfoExcludePath(repoRoot) {
 	}
 }
 /**
-* Find the nearest git repo root by walking up from a start directory.
-*
-* @param fromDir - Directory to start from.
-* @returns Repo root directory, or undefined when no git boundary is found.
-*/
-async function findGitRepoRoot(fromDir) {
-	let current = fromDir;
-	while (true) {
-		if (await hasGitEntry(current)) return current;
-		const parent = dirname(current);
-		if (parent === current) return;
-		current = parent;
-	}
-}
-/**
-* Collect `.gitignore` files from file directory up to git repo boundary.
+* Resolve an ignore file path against cwd when needed.
 *
-* @param filepath - Absolute file path to test.
-* @returns Collected ignore files and repo root when found.
+* @param path - Absolute or relative path.
+* @param cwd - Current working directory.
+* @returns Absolute ignore file path.
 */
-async function collectGitignorePaths(filepath) {
-	const fileDir = dirname(filepath);
-	const repoRoot = await findGitRepoRoot(fileDir);
-	const paths = [];
-	let current = fileDir;
-	while (true) {
-		paths.push(join(current, ".gitignore"));
-		if (repoRoot && current === repoRoot) break;
-		const parent = dirname(current);
-		if (parent === current) break;
-		current = parent;
-	}
-	return {
-		paths,
-		repoRoot
-	};
+function resolveIgnoreFilePath(path, cwd) {
+	return isAbsolute(path) ? path : resolve(cwd, path);
 }
 /**
 * Validate config ignore patterns using oxfmt's path constraints.
@@ -976,94 +1170,5 @@ function validateConfigIgnorePatterns(patterns) {
 		if ((pathPart.endsWith(String.raw`\ `) ? pathPart : pathPart.trimEnd()).split("/").includes("..")) throw new Error(`Invalid pattern \`${pattern}\` in \`ignorePatterns\`: \`..\` is not supported, patterns are resolved within the config file's directory`);
 	}
 }
-/**
-* Match `ignorePatterns` from config with support for negated patterns.
-*
-* @param filepath - Absolute file path.
-* @param configDir - Resolved config directory.
-* @param patterns - Config ignore patterns.
-* @param useCache - Whether to reuse compiled pattern matchers.
-* @returns True when patterns mark the file as ignored.
-*/
-function matchConfigIgnorePatterns(filepath, configDir, patterns, useCache) {
-	validateConfigIgnorePatterns(patterns);
-	const relativeFile = relativeSafe(configDir, filepath);
-	if (isPathOutsideBase(relativeFile)) return false;
-	if (!useCache) return ignore().add(patterns).ignores(relativeFile);
-	const cacheKey = `${configDir}::${JSON.stringify(patterns)}`;
-	const cachedMatcher = getCacheValue(configIgnoreMatcherCache, cacheKey);
-	if (cachedMatcher) return cachedMatcher.ignores(relativeFile);
-	const matcher = ignore().add(patterns);
-	setCacheValue(configIgnoreMatcherCache, cacheKey, matcher);
-	return matcher.ignores(relativeFile);
-}
-/**
-* Resolve whether a file should be ignored using oxfmt-like CLI semantics.
-*
-* @param options - Ignore resolution options.
-* @returns Ignore status with optional reason.
-*
-* @example
-* ```ts
-* import { isOxfmtIgnored } from 'load-oxfmt-config'
-*
-* const result = await isOxfmtIgnored({
-*   cwd: process.cwd(),
-*   filepath: 'src/generated/file.ts',
-* })
-* ```
-*/
-async function isOxfmtIgnored(options) {
-	const useCache = options.useCache !== false;
-	const includeConfigIgnorePatterns = options.includeConfigIgnorePatterns !== false;
-	const loadConfigForIgnorePatterns = options.loadConfigForIgnorePatterns !== false;
-	const cwd = resolve(options.cwd ?? process.cwd());
-	const filepath = isAbsolute(options.filepath) ? resolve(options.filepath) : resolve(cwd, options.filepath);
-	if (isDefaultIgnoredDir(filepath, options.withNodeModules ? { withNodeModules: true } : {})) return {
-		ignored: true,
-		reason: "default-dir"
-	};
-	if (isLockfile(filepath)) return {
-		ignored: true,
-		reason: "lockfile"
-	};
-	const explicitIgnorePaths = (typeof options.ignorePath === "string" ? [options.ignorePath] : options.ignorePath)?.map((path) => resolveIgnoreFilePath(path, cwd));
-	const { paths: gitignorePaths, repoRoot } = await collectGitignorePaths(filepath);
-	const gitignoreResult = await matchIgnoreFileChain(filepath, [...gitignorePaths].reverse().map((path) => ({ path })), useCache, true);
-	if (gitignoreResult.ignored) return {
-		ignored: true,
-		reason: "gitignore"
-	};
-	if (repoRoot && !gitignoreResult.matched) {
-		const infoExcludePath = await resolveGitInfoExcludePath(repoRoot);
-		if (infoExcludePath && await matchIgnoreFile(filepath, infoExcludePath, useCache, repoRoot)) return {
-			ignored: true,
-			reason: "git-info-exclude"
-		};
-	}
-	if (explicitIgnorePaths && explicitIgnorePaths.length > 0) {
-		if ((await matchIgnoreFileChain(filepath, explicitIgnorePaths.map((path) => ({ path })), useCache)).ignored) return {
-			ignored: true,
-			reason: "ignore-path"
-		};
-	} else if (await matchIgnoreFile(filepath, resolve(cwd, ".prettierignore"), useCache)) return {
-		ignored: true,
-		reason: "prettierignore"
-	};
-	if (!loadConfigForIgnorePatterns) return { ignored: false };
-	const configResult = await loadOxfmtConfig({
-		cwd,
-		filepath,
-		...options.disableNestedConfig === true ? { disableNestedConfig: true } : {},
-		...options.configPath ? { configPath: options.configPath } : {},
-		editorconfig: false,
-		useCache
-	});
-	if (includeConfigIgnorePatterns && configResult.dirname && configResult.config.ignorePatterns && configResult.config.ignorePatterns.length > 0 && matchConfigIgnorePatterns(filepath, configResult.dirname, configResult.config.ignorePatterns, useCache)) return {
-		ignored: true,
-		reason: "config-ignore-patterns"
-	};
-	return { ignored: false };
-}
 //#endregion
-export { getConfigCacheKey, getResolveCacheKey, isOxfmtIgnored, loadOxfmtConfig, readConfigFromFile, resolveOxfmtrcPath };
+export { getConfigCacheKey, getResolveCacheKey, isOxfmtIgnored, loadOxfmtConfig, loadOxfmtConfigForFile, readConfigFromFile, resolveOxfmtrcPath };