@isentinel/eslint-config 6.1.0 → 6.3.0

package/dist/oxfmt.mjs

@@ -0,0 +1,750 @@
+import { createRequire } from "node:module";
+import { getStaticJSONValue, parseJSON } from "jsonc-eslint-parser";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { getStaticYAMLValue, parseYAML } from "yaml-eslint-parser";
+const GLOB_JS = "**/*.{,c,m}js";
+const GLOB_JSX = "**/*.{,c,m}jsx";
+const GLOB_TS = "**/*.{,c,m}ts";
+const GLOB_TSX = "**/*.{,c,m}tsx";
+const GLOB_CSS = "**/*.css";
+const GLOB_POSTCSS = "**/*.{p,post}css";
+const GLOB_LESS = "**/*.less";
+const GLOB_SCSS = "**/*.scss";
+const GLOB_JSON5 = "**/*.json5";
+const GLOB_ALL_JSON = "**/*.json{,5,c}";
+const GLOB_MARKDOWN = "**/*.md";
+const GLOB_YAML = "**/*.y{,a}ml";
+const GLOB_EXCLUDE = [
+	"**/.pnpm-store",
+	"**/bun.lockb",
+	"**/dist",
+	"**/node_modules",
+	"**/package-lock.json",
+	"**/pnpm-lock.yaml",
+	"**/yarn.lock",
+	"**/skills-lock.json",
+	"**/.cache",
+	"**/.changeset",
+	"**/.agents",
+	"**/.claude/**/*",
+	"!**/.claude/settings.json",
+	"**/.gemini",
+	"**/.kilocode",
+	"**/.opencode",
+	"**/.history",
+	"**/.idea",
+	"**/.next",
+	"**/.nuxt",
+	"**/.output",
+	"**/.svelte-kit",
+	"**/.temp",
+	"**/.tmp",
+	"**/.vercel",
+	"**/.vite-inspect",
+	"**/.vitepress/cache",
+	"**/.worktree",
+	"**/.yarn",
+	"**/coverage",
+	"**/out",
+	"**/output",
+	"**/temp",
+	"**/tmp",
+	"**/vite.config.*.timestamp-*",
+	"**/eslint-suppressions.json",
+	"**/*.min.*",
+	"**/CHANGELOG*.md",
+	"**/LICENSE*",
+	"**/__snapshots__",
+	"**/auto-import{,s}.d.ts",
+	"**/components.d.ts",
+	"**/roblox.yml",
+	"**/.scratch/**",
+	"**/scratch/**"
+];
+//#endregion
+//#region src/formatted-files.ts
+/**
+* The files the preset formats with oxfmt. ESLint mode enables `oxfmt/oxfmt`
+* on these globs; the standalone oxfmt config ignores every other file. One
+* list keeps both modes formatting the same files.
+*
+* Imported by the standalone oxfmt config, so keep it light.
+*/
+/** Formatted globs, by `oxfmt/oxfmt` config block. */
+const FORMATTED_FILES = {
+	css: [GLOB_CSS, GLOB_POSTCSS],
+	graphql: ["**/*.graphql"],
+	html: ["**/*.html"],
+	javascript: [GLOB_JS, GLOB_JSX],
+	json: [GLOB_ALL_JSON],
+	less: [GLOB_LESS],
+	markdown: [GLOB_MARKDOWN],
+	scss: [GLOB_SCSS],
+	typescript: [GLOB_TS, GLOB_TSX],
+	yaml: [GLOB_YAML]
+};
+/** The blocks `formatters` turns off, with the key that does it. */
+const LANGUAGE_BLOCKS = [
+	["css", "css"],
+	["scss", "css"],
+	["less", "css"],
+	["html", "html"],
+	["markdown", "markdown"],
+	["graphql", "graphql"],
+	["json", "json"],
+	["yaml", "yaml"]
+];
+/**
+* Resolve `formatters` to one flag per language.
+*
+* @param formatters - The `formatters` option.
+* @returns Whether each language is formatted.
+*/
+function resolveFormattedLanguages(formatters = true) {
+	const enabled = formatters !== false;
+	const toggles = typeof formatters === "object" ? formatters : {};
+	return {
+		css: enabled && toggles.css !== false,
+		graphql: enabled && toggles.graphql !== false,
+		html: enabled && toggles.html !== false,
+		json: enabled && toggles.json !== false,
+		markdown: enabled && toggles.markdown !== false,
+		yaml: enabled && toggles.yaml !== false
+	};
+}
+/**
+* Every glob the preset formats.
+*
+* @param options - Component extensions and language toggles.
+* @returns The formatted globs.
+*/
+function formattedFiles({ componentExts: componentExtensions = [], formatters = true } = {}) {
+	const languages = resolveFormattedLanguages(formatters);
+	return [
+		...FORMATTED_FILES.javascript,
+		...FORMATTED_FILES.typescript,
+		...componentExtensions.map((extension) => `**/*.${extension}`),
+		...LANGUAGE_BLOCKS.filter(([, language]) => languages[language]).flatMap(([block]) => {
+			return FORMATTED_FILES[block];
+		})
+	];
+}
+/**
+* Expand the brace sets in a glob (`*.{,c,m}js` to `*.js`, `*.cjs`, `*.mjs`).
+*
+* @param glob - A glob.
+* @returns The globs it stands for.
+*/
+function expandBraces(glob) {
+	const open = glob.indexOf("{");
+	if (open === -1) return [glob];
+	let depth = 0;
+	let close = -1;
+	const commas = [];
+	for (let index = open; index < glob.length; index++) {
+		const character = glob[index];
+		if (character === "{") depth++;
+		else if (character === "}") {
+			depth--;
+			if (depth === 0) {
+				close = index;
+				break;
+			}
+		} else if (character === "," && depth === 1) commas.push(index);
+	}
+	if (close === -1) return [glob];
+	const bounds = [
+		open,
+		...commas,
+		close
+	];
+	const alternatives = bounds.slice(0, -1).map((start, index) => {
+		return glob.slice(start + 1, bounds[index + 1]);
+	});
+	const prefix = glob.slice(0, open);
+	const suffix = glob.slice(close + 1);
+	return alternatives.flatMap((alternative) => expandBraces(`${prefix}${alternative}${suffix}`));
+}
+/**
+* Oxfmt ignore patterns that leave only the formatted files: ignore
+* everything, then re-include directories and each formatted glob. Ignore
+* files take no brace sets, so those are expanded.
+*
+* @param options - Component extensions and language toggles.
+* @returns Gitignore-style patterns.
+*/
+function unformattedFilePatterns(options = {}) {
+	const included = formattedFiles(options).flatMap((glob) => expandBraces(glob));
+	return [
+		"*",
+		"!*/",
+		...Array.from(new Set(included), (glob) => `!${glob}`)
+	];
+}
+//#endregion
+//#region src/prettier-config.ts
+/**
+* Synchronous resolution of the effective Prettier-shaped formatting settings
+* (`printWidth`, `tabWidth`, `useTabs`, ...) shared by both factories.
+*
+* These settings do not only drive formatting: `printWidth` and `tabWidth`
+* feed rule options such as `flawless/arrow-return-style`'s `maxLen`,
+* `tabWidth` and `useOxfmt.printWidth`. The ESLint and oxlint factories must
+* therefore resolve them identically, or the same rule reaches opposite
+* conclusions in each engine and `--fix` ping-pongs the code between both
+* forms.
+*
+* Prettier's own `resolveConfig` is async-only since v3, and the oxlint
+* factory is synchronous, so resolution is reimplemented here against the
+* config formats that can be read synchronously. TypeScript config files
+* (`prettier.config.ts` and friends) need a loader and are skipped.
+*/
+/** Preset defaults, overridden by any project-level configuration. */
+const PRETTIER_DEFAULTS = {
+	arrowParens: "always",
+	printWidth: 100,
+	quoteProps: "consistent",
+	semi: true,
+	singleQuote: false,
+	tabWidth: 4,
+	trailingComma: "all",
+	useTabs: true
+};
+/**
+* Config file names searched in each directory, in Prettier's own precedence
+* order. `package.json` is handled separately (it only counts when it carries
+* a `prettier` key).
+*/
+const CONFIG_FILES = [
+	".prettierrc",
+	".prettierrc.json",
+	".prettierrc.jsonc",
+	".prettierrc.json5",
+	".prettierrc.yaml",
+	".prettierrc.yml",
+	".prettierrc.js",
+	".prettierrc.cjs",
+	".prettierrc.mjs",
+	"prettier.config.js",
+	"prettier.config.cjs",
+	"prettier.config.mjs"
+];
+/**
+* EditorConfig section matched against a representative source file rather
+* than `package.json`: the settings feed JS/TS rule options, so per-extension
+* sections must resolve the way they do for the files those rules lint.
+*/
+const EDITORCONFIG_PROBE_FILE = "index.ts";
+const LINE_BREAK = /\r?\n/;
+const LEADING_SLASH = /^\//;
+const REGEXP_SPECIAL = /[$()*+.?[\\\]^{|}]/g;
+/**
+* Glob constructs expanded by {@link expandGlobToken}; anything else is
+* escaped.
+*/
+const GLOB_TOKEN = /\*\*\/?|\{[^{}]*\}|[$()*+.?[\\\]^{|}]/g;
+/**
+* Resolve the project's Prettier configuration, EditorConfig included, without
+* awaiting.
+*
+* @param cwd - Directory to start the upward search from.
+* @returns The resolved options, or an empty object when none are found.
+*/
+function resolveProjectPrettierConfig(cwd = process.cwd()) {
+	return {
+		...resolveEditorConfigOptions(cwd),
+		...resolvePrettierRcOptions(cwd)
+	};
+}
+/**
+* Resolve the effective formatting settings: preset defaults, overridden by
+* the project's EditorConfig and Prettier configuration, overridden by the
+* options passed to the factory.
+*
+* @param prettierOptions - Explicit `formatters.prettierOptions`.
+* @param cwd - Directory to resolve project configuration from.
+* @returns The merged settings.
+*/
+function resolvePrettierSettings(prettierOptions = {}, cwd = process.cwd()) {
+	return {
+		...PRETTIER_DEFAULTS,
+		...resolveProjectPrettierConfig(cwd),
+		...prettierOptions
+	};
+}
+/**
+* Turn the nearest `.editorconfig`'s sections into oxfmt overrides, the way
+* the `oxfmt/oxfmt` rule's config loader does: `[*]` is skipped (it feeds the
+* root options), and each other section becomes an override whose globs are
+* relative to `cwd`. A key set in the oxfmt config root wins over the
+* sections.
+*
+* @param cwd - The config directory.
+* @param root - The oxfmt config root options.
+* @returns The overrides, in file order.
+*/
+function editorConfigOverrides(cwd = process.cwd(), root = {}) {
+	for (const directory of ancestorDirectories(cwd)) {
+		const contents = readFileOrUndefined(path.join(directory, ".editorconfig"));
+		if (contents === void 0) continue;
+		const prefix = path.relative(cwd, directory).split(path.sep).join("/");
+		return parseEditorConfig(contents).sections.flatMap(({ pattern, properties }) => {
+			const options = Object.fromEntries(Object.entries(editorConfigToOxfmt(properties)).filter(([key]) => !Object.hasOwn(root, key)));
+			if (pattern === "*" || Object.keys(options).length === 0) return [];
+			return [{
+				files: [prefix === "" ? pattern : `${prefix}/${pattern.replace(LEADING_SLASH, "")}`],
+				options
+			}];
+		});
+	}
+	return [];
+}
+function readFileOrUndefined(filePath) {
+	try {
+		return fs.readFileSync(filePath, "utf-8");
+	} catch {
+		return;
+	}
+}
+function parseJsonLike(contents) {
+	try {
+		return getStaticJSONValue(parseJSON(contents, { jsonSyntax: "json5" }));
+	} catch {
+		return;
+	}
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readPackageJsonPrettierKey(filePath) {
+	const contents = readFileOrUndefined(filePath);
+	if (contents === void 0) return;
+	const parsed = parseJsonLike(contents);
+	const prettierKey = isRecord$1(parsed) ? parsed["prettier"] : void 0;
+	return isRecord$1(prettierKey) ? prettierKey : void 0;
+}
+/**
+* Load a JS Prettier config. Node's `require` handles ESM entry points
+* synchronously on the versions this package supports, so both module systems
+* work; a config that cannot be loaded is treated as absent rather than fatal.
+*
+* @param filePath - Absolute path of the config module.
+* @returns The exported options, or `undefined`.
+*/
+function requireConfigModule(filePath) {
+	try {
+		const loaded = createRequire(filePath)(filePath);
+		const value = isRecord$1(loaded) && "default" in loaded ? loaded["default"] : loaded;
+		return isRecord$1(value) ? value : void 0;
+	} catch {
+		return;
+	}
+}
+function parseYamlLike(contents) {
+	try {
+		return getStaticYAMLValue(parseYAML(contents));
+	} catch {
+		return;
+	}
+}
+function readConfigFile(filePath) {
+	const extension = path.extname(filePath);
+	if (extension === ".js" || extension === ".cjs" || extension === ".mjs") return fs.existsSync(filePath) ? requireConfigModule(filePath) : void 0;
+	const contents = readFileOrUndefined(filePath);
+	if (contents === void 0) return;
+	const parsed = parseJsonLike(contents) ?? parseYamlLike(contents);
+	return isRecord$1(parsed) ? parsed : void 0;
+}
+function ancestorDirectories(cwd) {
+	const directories = [];
+	let current = path.resolve(cwd);
+	while (true) {
+		directories.push(current);
+		const parent = path.dirname(current);
+		if (parent === current) return directories;
+		current = parent;
+	}
+}
+/**
+* Walk up from `cwd` looking for a Prettier configuration file.
+*
+* @param cwd - Directory to start the upward search from.
+* @returns The first configuration found, or an empty object.
+*/
+function resolvePrettierRcOptions(cwd) {
+	for (const directory of ancestorDirectories(cwd)) {
+		const fromPackageJson = readPackageJsonPrettierKey(path.join(directory, "package.json"));
+		if (fromPackageJson !== void 0) return fromPackageJson;
+		for (const filename of CONFIG_FILES) {
+			const config = readConfigFile(path.join(directory, filename));
+			if (config !== void 0) return config;
+		}
+	}
+	return {};
+}
+function editorConfigToPrettier(properties) {
+	const options = {};
+	const indentStyle = properties["indent_style"];
+	if (indentStyle === "tab" || indentStyle === "space") options.useTabs = indentStyle === "tab";
+	const indentSize = properties["indent_size"];
+	const width = indentSize === void 0 || indentSize === "tab" ? properties["tab_width"] : indentSize;
+	const tabWidth = Number.parseInt(width ?? "", 10);
+	if (Number.isFinite(tabWidth)) options.tabWidth = tabWidth;
+	const printWidth = Number.parseInt(properties["max_line_length"] ?? "", 10);
+	if (Number.isFinite(printWidth)) options.printWidth = printWidth;
+	const endOfLine = properties["end_of_line"];
+	if (endOfLine === "cr" || endOfLine === "crlf" || endOfLine === "lf") options.endOfLine = endOfLine;
+	return options;
+}
+function parseEditorConfig(contents) {
+	const sections = [];
+	let current;
+	let isRoot = false;
+	for (const rawLine of contents.split(LINE_BREAK)) {
+		const line = rawLine.trim();
+		if (line === "" || line.startsWith("#") || line.startsWith(";")) continue;
+		if (line.startsWith("[") && line.endsWith("]")) {
+			current = {
+				pattern: line.slice(1, -1),
+				properties: {}
+			};
+			sections.push(current);
+			continue;
+		}
+		const separator = line.indexOf("=");
+		if (separator === -1) continue;
+		const key = line.slice(0, separator).trim().toLowerCase();
+		const value = line.slice(separator + 1).trim();
+		if (current === void 0) {
+			isRoot ||= key === "root" && value.toLowerCase() === "true";
+			continue;
+		}
+		current.properties[key] = value;
+	}
+	return {
+		isRoot,
+		sections
+	};
+}
+function escapeRegExp(value) {
+	return value.replaceAll(REGEXP_SPECIAL, (character) => `\\${character}`);
+}
+/**
+* Expand one glob token into its regular-expression equivalent.
+*
+* @param token - A token matched by {@link GLOB_TOKEN}.
+* @returns The regular-expression source for the token.
+*/
+function expandGlobToken(token) {
+	if (token.startsWith("**")) return "(?:.*)";
+	if (token === "*") return "[^/]*";
+	if (token === "?") return "[^/]";
+	if (token.startsWith("{")) return `(?:${token.slice(1, -1).split(",").map((alternative) => escapeRegExp(alternative)).join("|")})`;
+	return `\\${token}`;
+}
+/**
+* Match an EditorConfig section pattern against a path relative to the
+* `.editorconfig` file. Supports the `*`, `**`, `?` and `{a,b}` constructs;
+* numeric ranges and character classes are rare enough in formatting sections
+* to fall through as non-matches.
+*
+* @param pattern - The section pattern.
+* @param relativePath - Path relative to the `.editorconfig` directory.
+* @returns Whether the section applies.
+*/
+function matchesEditorConfigPattern(pattern, relativePath) {
+	const normalized = pattern.includes("/") ? pattern.replace(LEADING_SLASH, "") : `**/${pattern}`;
+	const subject = relativePath.split(path.sep).join("/");
+	const source = normalized.replaceAll(GLOB_TOKEN, (token) => expandGlobToken(token));
+	return new RegExp(`^${source}$`).test(subject);
+}
+/**
+* Resolve EditorConfig settings for a representative source file and translate
+* them into their Prettier equivalents.
+*
+* @param cwd - Directory to start the upward search from.
+* @returns The translated options.
+*/
+function resolveEditorConfigOptions(cwd) {
+	const properties = {};
+	for (const directory of ancestorDirectories(cwd).toReversed()) {
+		const contents = readFileOrUndefined(path.join(directory, ".editorconfig"));
+		if (contents === void 0) continue;
+		const { isRoot, sections } = parseEditorConfig(contents);
+		const relative = path.relative(directory, path.join(cwd, EDITORCONFIG_PROBE_FILE));
+		const forProbe = sections.filter(({ pattern }) => matchesEditorConfigPattern(pattern, relative)).reduce((accumulator, section) => Object.assign(accumulator, section.properties), {});
+		if (isRoot) for (const key of Object.keys(properties)) delete properties[key];
+		Object.assign(properties, forProbe);
+	}
+	return editorConfigToPrettier(properties);
+}
+/**
+* Map one `.editorconfig` section to oxfmt options, as the rule's config
+* loader does.
+*
+* @param properties - The section's properties.
+* @returns The oxfmt options it sets.
+*/
+function editorConfigToOxfmt(properties) {
+	const options = {};
+	const endOfLine = properties["end_of_line"];
+	if (endOfLine === "cr" || endOfLine === "crlf" || endOfLine === "lf") options["endOfLine"] = endOfLine;
+	const indentStyle = properties["indent_style"];
+	if (indentStyle === "tab" || indentStyle === "space") options["useTabs"] = indentStyle === "tab";
+	const quoteType = properties["quote_type"];
+	if (quoteType === "single" || quoteType === "double") options["singleQuote"] = quoteType === "single";
+	const indentSize = Number(properties["indent_size"]);
+	const tabWidth = Number(properties["tab_width"]);
+	if (options["useTabs"] === false && properties["indent_size"] && Number.isFinite(indentSize)) options["tabWidth"] = indentSize;
+	else if (properties["tab_width"] && Number.isFinite(tabWidth)) options["tabWidth"] = tabWidth;
+	const printWidth = Number(properties["max_line_length"]);
+	if (properties["max_line_length"] && Number.isFinite(printWidth)) options["printWidth"] = printWidth;
+	const finalNewline = properties["insert_final_newline"];
+	if (finalNewline === "true" || finalNewline === "false") options["insertFinalNewline"] = finalNewline === "true";
+	return options;
+}
+//#endregion
+//#region src/guards.ts
+/**
+* Internal runtime type guards. Prefer these over `as` assertions so values
+* crossing untyped boundaries (`JSON.parse`, dynamic `import`, plugin objects)
+* are validated at runtime rather than asserted away.
+*/
+/**
+* Whether a value is a non-null, non-array object usable as a string-keyed
+* record. Narrows `unknown` without an assertion.
+*
+* @param value - The value to test.
+* @returns Whether the value is a plain object.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/rules/oxfmt.ts
+const UNSUPPORTED_PRETTIER_KEYS = /* @__PURE__ */ new Set([
+	"experimentalOperatorPosition",
+	"experimentalTernaries",
+	"jsdocPreferCodeFences",
+	"jsdocPrintWidth",
+	"parser",
+	"plugins",
+	"tsdoc"
+]);
+const defaultSortImports = {
+	customGroups: [{
+		elementNamePattern: ["react"],
+		groupName: "react"
+	}, {
+		elementNamePattern: ["@*/**"],
+		groupName: "scoped"
+	}],
+	groups: [
+		"react",
+		"scoped",
+		[
+			"type-builtin",
+			"type-external",
+			"builtin",
+			"external"
+		],
+		[
+			"type-internal",
+			"internal",
+			"type-parent",
+			"type-sibling",
+			"type-index",
+			"parent",
+			"sibling",
+			"index"
+		],
+		"unknown"
+	],
+	newlinesBetween: true
+};
+/**
+* Migrate Prettier options to oxfmt options, dropping unsupported keys.
+*
+* @param prettierOptions - The Prettier options to migrate.
+* @returns The migrated oxfmt options.
+*/
+function migratePrettierOptions(prettierOptions) {
+	const oxfmtOptions = {};
+	for (const [key, value] of Object.entries(prettierOptions)) {
+		if (UNSUPPORTED_PRETTIER_KEYS.has(key)) continue;
+		if (key === "endOfLine" && value === "auto") continue;
+		oxfmtOptions[key] = key === "overrides" ? migratePrettierOverrides(value) : value;
+	}
+	return oxfmtOptions;
+}
+/**
+* Migrate Prettier `overrides`: oxfmt wants `files` as an array, and the
+* nested options migrated like the root ones.
+*
+* @param overrides - The `overrides` value, of unknown shape.
+* @returns The overrides in oxfmt's shape; empty when not an array.
+*/
+function migratePrettierOverrides(overrides) {
+	if (!Array.isArray(overrides)) return [];
+	return overrides.flatMap((override) => {
+		if (!isRecord(override)) return [];
+		const { excludeFiles, files, options } = override;
+		return [{
+			...excludeFiles === void 0 ? {} : { excludeFiles: stringsOf(excludeFiles) },
+			files: stringsOf(files),
+			options: isRecord(options) ? migratePrettierOptions(options) : {}
+		}];
+	});
+}
+/**
+* Anchor slash-less override globs to the config directory. The oxfmt CLI
+* matches `*.json` at any depth, but the ESLint rule matches it against the
+* path from the config directory, so only top-level files; `./*.json` means
+* the latter to both.
+*
+* @template T - The override shape.
+* @param overrides - Oxfmt overrides.
+* @returns The overrides with anchored globs.
+*/
+function anchorOverrideGlobs(overrides) {
+	return overrides.map((override) => {
+		return {
+			...override,
+			...override.excludeFiles ? { excludeFiles: override.excludeFiles.map(anchorGlob) } : {},
+			files: override.files.map(anchorGlob)
+		};
+	});
+}
+/**
+* Build the effective oxfmt options shared between the ESLint and oxlint
+* factories.
+*
+* @param options - The option sources, in increasing precedence.
+* @returns The effective oxfmt options.
+*/
+function buildOxfmtOptions({ oxfmtConfigOptions = {}, oxfmtOptions, prettierOptions = {} }) {
+	return {
+		sortImports: defaultSortImports,
+		sortPackageJson: false,
+		...migratePrettierOptions(prettierOptions),
+		...oxfmtConfigOptions,
+		...oxfmtOptions
+	};
+}
+/**
+* Markdown formatting options layered over the base options. Shared by the
+* ESLint config and the standalone oxfmt config so both format Markdown the
+* same way.
+*
+* Oxfmt would format code blocks with these options too, at the prose width.
+* It leaves them alone instead, and ESLint formats each block with the options
+* of its own language (see `isentinel/oxfmt/markdown-code/*`).
+*
+* @param jsdocPrintWidth - Width for Markdown prose; 80 when unset.
+* @returns Options applied on top of the base for Markdown files.
+*/
+function markdownOxfmtOptions(jsdocPrintWidth) {
+	return {
+		embeddedLanguageFormatting: "off",
+		printWidth: Number(jsdocPrintWidth) || 80,
+		proseWrap: "always",
+		tabWidth: 2
+	};
+}
+function stringsOf(value) {
+	return [value].flat().filter((item) => typeof item === "string");
+}
+/**
+* JSON5 formatting options layered over the base options. `jsonc/quote-props`
+* owns the quoting of JSON5 keys; oxfmt's `consistent` would strip the quotes
+* it adds, and `--fix` would loop.
+*/
+const JSON5_OXFMT_OPTIONS = { quoteProps: "preserve" };
+/** YAML formatting options layered over the base options. */
+const YAML_OXFMT_OPTIONS = {
+	tabWidth: 2,
+	useTabs: false
+};
+/**
+* Anchor one slash-less glob to the config directory, keeping its negation.
+*
+* @param glob - An override glob.
+* @returns The anchored glob.
+*/
+function anchorGlob(glob) {
+	const negated = glob.startsWith("!");
+	const body = negated ? glob.slice(1) : glob;
+	const anchored = body.includes("/") ? body : `./${body}`;
+	return negated ? `!${anchored}` : anchored;
+}
+//#endregion
+//#region src/oxfmt/index.ts
+/**
+* Build the preset's oxfmt config.
+*
+* Root format options start from the same defaults the ESLint and oxlint
+* factories use (preset defaults < `.editorconfig` < `.prettierrc`), and every
+* key in `config` replaces its base value. `ignorePatterns` and `overrides`
+* are the exception: the user's entries are appended to the preset's, so a
+* user override wins over the preset's Markdown, YAML and JSON5 overrides.
+* The `.prettierrc` overrides come last, as in ESLint mode. Slash-less
+* override globs are anchored to the config directory (`*.json` becomes
+* `./*.json`), so they match the files the ESLint rule matches.
+*
+* Oxfmt formats the files ESLint mode formats, and no others: TOML, `.mdx` and
+* the like stay as they are.
+*
+* @param config - Options that replace the preset's, plus extra ignore
+*   patterns and overrides.
+* @param config.componentExts - Component extensions to format, as the
+*   factories' `componentExts`.
+* @param config.cwd - Directory to resolve `.prettierrc` and `.editorconfig`
+*   from (default `process.cwd()`).
+* @param config.formatters - Languages to format besides JS and TS, as the
+*   factories' `formatters`.
+* @param config.ignorePatterns - Appended to the preset's ignore patterns.
+* @param config.overrides - Appended to the preset's overrides.
+* @returns The oxfmt config.
+*/
+function isentinelOxfmt({ componentExts, cwd, formatters, ignorePatterns = [], overrides = [], ...rest } = {}) {
+	const prettierSettings = resolvePrettierSettings({}, cwd);
+	const base = buildOxfmtOptions({ prettierOptions: prettierSettings });
+	const prettierOverrides = migratePrettierOverrides(prettierSettings["overrides"]);
+	const languages = resolveFormattedLanguages(formatters);
+	const sectionOverrides = editorConfigOverrides(cwd, rest);
+	return {
+		...base,
+		...rest,
+		ignorePatterns: [
+			...unformattedFilePatterns({
+				componentExts,
+				formatters
+			}),
+			...GLOB_EXCLUDE,
+			...ignorePatterns
+		],
+		overrides: [
+			...languages.markdown ? [{
+				files: [GLOB_MARKDOWN],
+				options: markdownOxfmtOptions(prettierSettings["jsdocPrintWidth"])
+			}] : [],
+			...languages.yaml ? [{
+				files: [GLOB_YAML],
+				options: { ...YAML_OXFMT_OPTIONS }
+			}] : [],
+			...languages.json ? [{
+				files: [GLOB_JSON5],
+				options: { ...JSON5_OXFMT_OPTIONS }
+			}] : [],
+			...anchorOverrideGlobs([
+				...sectionOverrides,
+				...overrides,
+				...prettierOverrides
+			])
+		]
+	};
+}
+//#endregion
+export { isentinelOxfmt };