@oxlint/migrate
Version:
Generates a `.oxlintrc.json` from a existing eslint flat config
1,364 lines • 116 kB
JavaScript
import globals from "globals";
//#region \0rolldown/runtime.js
var __defProp = Object.defineProperty;
var __exportAll = (all, no_symbols) => {
let target = {};
for (var name in all) __defProp(target, name, {
get: all[name],
enumerable: true
});
if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
return target;
};
//#endregion
//#region src/env_globals.ts
const ES_VERSIONS = [
6,
2016,
2017,
2018,
2019,
2020,
2021,
2022,
2023,
2024,
2025,
2026
];
const OTHER_SUPPORTED_ENVS = [
"browser",
"node",
"shared-node-browser",
"worker",
"serviceworker",
"amd",
"applescript",
"astro",
"atomtest",
"audioworklet",
"commonjs",
"embertest",
"greasemonkey",
"jasmine",
"jest",
"jquery",
"meteor",
"mocha",
"mongo",
"nashorn",
"protractor",
"prototypejs",
"phantomjs",
"shelljs",
"svelte",
"webextensions",
"qunit",
"vitest",
"vue"
];
const SUPPORTED_ESLINT_PARSERS = ["typescript-eslint/parser"];
const ROOT_GLOBALS_WARNING_THRESHOLD = 10;
const normalizeGlobValue = (value) => {
if (value === "readable" || value === "readonly" || value === false) return false;
if (value === "off") return;
return true;
};
const removeGlobalsWithAreCoveredByEnv = (config) => {
if (config.globals === void 0 || config.globals === null || config.env === void 0 || config.env === null) return;
for (const [env, entries] of Object.entries(globals)) if (config.env[env] === true) {
for (const entry of Object.keys(entries)) if (normalizeGlobValue(config.globals[entry]) === entries[entry]) delete config.globals[entry];
}
if (Object.keys(config.globals).length === 0) delete config.globals;
};
const transformBoolGlobalToString = (config) => {
if (config.globals === void 0 || config.globals === null) return;
for (const [entry, value] of Object.entries(config.globals)) {
if (typeof value === "string") continue;
config.globals[entry] = value ? "writable" : "readonly";
}
};
const transformEslintGlobalAccessToOxlintGlobalValue = (global) => {
if (global === false || global === "readable" || global === "readonly") return "readonly";
else if (global === true || global === "writeable" || global === "writable") return "writable";
else return "off";
};
const THRESHOLD_ENVS = [
"browser",
"node",
"serviceworker",
"worker"
];
const detectEnvironmentByGlobals = (config) => {
if (config.globals === void 0 || config.globals === null) return;
for (const [env, entries] of Object.entries(globals)) {
if (!env.startsWith("es") && !OTHER_SUPPORTED_ENVS.includes(env)) continue;
if (env.startsWith("es") && !ES_VERSIONS.includes(parseInt(env.replace(/^es/, "")))) continue;
let search = Object.keys(entries);
let matches = search.filter((entry) => entry in config.globals && normalizeGlobValue(config.globals[entry]) === entries[entry]);
const useThreshold = THRESHOLD_ENVS.includes(env);
if (useThreshold && matches.length / search.length >= .97 || !useThreshold && matches.length === search.length) {
if (config.env === void 0 || config.env === null) config.env = {};
config.env[env] = true;
}
}
};
const transformEnvAndGlobals = (eslintConfig, targetConfig, options) => {
if (eslintConfig.languageOptions?.parser !== void 0 && eslintConfig.languageOptions?.parser !== null && typeof eslintConfig.languageOptions.parser === "object" && "meta" in eslintConfig.languageOptions.parser && !SUPPORTED_ESLINT_PARSERS.includes(eslintConfig.languageOptions.parser.meta?.name)) options?.reporter?.addWarning("special parser detected: " + eslintConfig.languageOptions.parser.meta?.name);
if (eslintConfig.languageOptions?.globals !== void 0 && eslintConfig.languageOptions?.globals !== null) {
if (targetConfig.globals === void 0 || targetConfig.globals === null) targetConfig.globals = {};
if (options?.merge) {
for (const [global, globalSetting] of Object.entries(eslintConfig.languageOptions.globals)) if (!(global in targetConfig.globals)) targetConfig.globals[global] = transformEslintGlobalAccessToOxlintGlobalValue(globalSetting);
} else for (const [global, globalSetting] of Object.entries(eslintConfig.languageOptions.globals)) targetConfig.globals[global] = transformEslintGlobalAccessToOxlintGlobalValue(globalSetting);
}
if (eslintConfig.languageOptions?.ecmaVersion !== void 0) {
if (eslintConfig.languageOptions.ecmaVersion === "latest") {
if (targetConfig.env === void 0 || targetConfig.env === null) targetConfig.env = {};
const latestVersion = `es${ES_VERSIONS[ES_VERSIONS.length - 1]}`;
if (!(latestVersion in targetConfig.env)) targetConfig.env[latestVersion] = true;
} else if (typeof eslintConfig.languageOptions.ecmaVersion === "number" && ES_VERSIONS.includes(eslintConfig.languageOptions.ecmaVersion)) {
if (targetConfig.env === void 0 || targetConfig.env === null) targetConfig.env = {};
const targetVersion = `es${eslintConfig.languageOptions.ecmaVersion}`;
if (!(targetVersion in targetConfig.env)) targetConfig.env[targetVersion] = true;
}
}
};
const warnAboutLargeRootGlobals = (configs, oxlintConfig, options) => {
const sourceRootGlobals = /* @__PURE__ */ new Set();
for (const config of configs) if (config.files === void 0 && config.languageOptions?.globals) for (const global of Object.keys(config.languageOptions.globals)) sourceRootGlobals.add(global);
const finalRootGlobals = Object.keys(oxlintConfig.globals ?? {});
if (sourceRootGlobals.size <= ROOT_GLOBALS_WARNING_THRESHOLD || finalRootGlobals.length <= ROOT_GLOBALS_WARNING_THRESHOLD) return;
options?.reporter?.addWarning(`Added ${finalRootGlobals.length} globals to the root config. This may happen when your ESLint config uses a different version of the \`globals\` package than @oxlint/migrate. Try updating \`globals\` and rerun the migration to get a simpler config.`);
};
const cleanUpUselessOverridesEnv = (config) => {
if (config.env === void 0 || config.env === null || config.overrides === void 0 || config.overrides === null) return;
for (const override of config.overrides) {
if (override.env === void 0 || override.env === null) continue;
for (const [overrideEnv, overrideEnvConfig] of Object.entries(override.env)) if (overrideEnv in config.env && config.env[overrideEnv] === overrideEnvConfig) delete override.env[overrideEnv];
if (Object.keys(override.env).length === 0) delete override.env;
}
};
const SUPERSET_ENVS = {
node: [
"nodeBuiltin",
"shared-node-browser",
"commonjs"
],
browser: ["shared-node-browser"]
};
/**
* Cleans up superset environments in the config and its overrides.
* If a superset environment is present, its subset environments are removed, e.g. all globals from `shared-node-browser` are also in `browser` and `node`.
*
* This also applies for overrides, where if a superset env is defined in the override or main config,
* the subset envs can be removed from the override if the override has the same value as the superset.
*/
const cleanUpSupersetEnvs = (config) => {
if (config.env !== void 0) for (const [supersetEnv, subsetEnvs] of Object.entries(SUPERSET_ENVS)) {
if (!(supersetEnv in config.env)) continue;
for (const subsetEnv of subsetEnvs) if (config.env[subsetEnv] === config.env[supersetEnv]) delete config.env[subsetEnv];
}
if (config.overrides !== void 0) for (const override of config.overrides) {
if (override.env === void 0 || override.env === null) continue;
for (const [supersetEnv, subsetEnvs] of Object.entries(SUPERSET_ENVS)) {
const supersetInOverride = supersetEnv in override.env;
const supersetInMain = config.env !== void 0 && supersetEnv in config.env;
for (const subsetEnv of subsetEnvs) {
if (!(subsetEnv in override.env)) continue;
if (supersetInOverride && override.env[subsetEnv] === override.env[supersetEnv]) {
delete override.env[subsetEnv];
continue;
}
if (supersetInMain && !supersetInOverride && config.env[supersetEnv] === override.env[subsetEnv]) delete override.env[subsetEnv];
}
}
if (Object.keys(override.env).length === 0) delete override.env;
}
};
//#endregion
//#region src/constants.ts
const rulesPrefixesForPlugins = {
import: "import",
"import-x": "import",
jest: "jest",
jsdoc: "jsdoc",
"jsx-a11y": "jsx-a11y",
"jsx-a11y-x": "jsx-a11y",
"@next/next": "nextjs",
node: "node",
n: "node",
promise: "promise",
react: "react",
"react-perf": "react-perf",
"react-hooks": "react",
"react-refresh": "react",
"@typescript-eslint": "typescript",
unicorn: "unicorn",
vitest: "vitest",
vue: "vue"
};
/**
* Normalizes an ESLint-style rule name to its canonical Oxlint form.
* e.g. "@typescript-eslint/no-floating-promises" → "typescript/no-floating-promises"
* "react-hooks/exhaustive-deps" → "react/exhaustive-deps"
* "@next/next/inline-script-id" → "nextjs/inline-script-id"
* "no-unused-vars" → "no-unused-vars" (unchanged for unprefixed rules)
*/
function normalizeRuleToCanonical(rule) {
for (const [prefix, plugin] of Object.entries(rulesPrefixesForPlugins)) if (prefix !== plugin && rule.startsWith(`${prefix}/`)) return `${plugin}/${rule.slice(prefix.length + 1)}`;
return rule;
}
const eslintRulesToTypescriptEquivalents = {
"dot-notation": "@typescript-eslint/dot-notation",
"consistent-return": "@typescript-eslint/consistent-return"
};
const typescriptRulesExtendEslintRules = [
"class-methods-use-this",
"default-param-last",
"init-declarations",
"max-params",
"no-array-constructor",
"no-dupe-class-members",
"no-empty-function",
"no-invalid-this",
"no-loop-func",
"no-loss-of-precision",
"no-magic-numbers",
"no-redeclare",
"no-restricted-imports",
"no-shadow",
"no-unused-expressions",
"no-unused-vars",
"no-use-before-define",
"no-useless-constructor"
];
//#endregion
//#region src/jsPlugins.ts
const ignorePlugins = /* @__PURE__ */ new Set([
...Object.keys(rulesPrefixesForPlugins),
...Object.values(rulesPrefixesForPlugins),
"local"
]);
const tryResolvePackage = (packageName) => {
try {
import.meta.resolve(packageName);
return true;
} catch {
return false;
}
};
const pluginNameCache = /* @__PURE__ */ new Map();
/**
* Resolves the npm package name for an ESLint plugin given its scope name.
*
* For scoped plugin names (starting with `@`), the mapping is unambiguous:
* - `@scope` -> `@scope/eslint-plugin`
* - `@scope/sub` -> `@scope/eslint-plugin-sub`
*
* For non-scoped names, the npm package could follow either convention:
* - `eslint-plugin-{name}` (e.g. `eslint-plugin-mocha`)
* - `@{name}/eslint-plugin` (e.g. `@e18e/eslint-plugin`)
*
* We try to resolve both candidates against the installed packages and
* use the one that is actually present, falling back to the standard
* `eslint-plugin-{name}` convention when neither can be resolved.
*/
const resolveEslintPluginName = (pluginName) => {
const cached = pluginNameCache.get(pluginName);
if (cached !== void 0) return cached;
let result;
if (pluginName.startsWith("@")) {
const [scope, maybeSub] = pluginName.split("/");
if (maybeSub) result = `${scope}/eslint-plugin-${maybeSub}`;
else result = `${scope}/eslint-plugin`;
} else {
const standardName = `eslint-plugin-${pluginName}`;
const scopedName = `@${pluginName}/eslint-plugin`;
if (tryResolvePackage(standardName)) result = standardName;
else if (tryResolvePackage(scopedName)) result = scopedName;
else result = standardName;
}
pluginNameCache.set(pluginName, result);
return result;
};
const extractPluginId = (ruleId) => {
const firstSlash = ruleId.indexOf("/");
if (firstSlash === -1) return;
if (ruleId.startsWith("@")) {
const secondSlash = ruleId.indexOf("/", firstSlash + 1);
if (secondSlash !== -1) return ruleId.substring(0, secondSlash);
}
return ruleId.substring(0, firstSlash);
};
const isIgnoredPluginRule = (ruleId) => {
const pluginName = extractPluginId(ruleId);
if (pluginName === void 0) return true;
return ignorePlugins.has(pluginName);
};
/**
* Derives the npm package name for a plugin from its `meta.name` field.
*
* If `meta.name` already looks like a full npm package name (contains
* "eslint-plugin"), it is returned as-is. Otherwise it is fed through
* {@link resolveEslintPluginName} for the usual heuristic resolution.
*/
const resolveFromMetaName = (metaName) => {
if (metaName.includes("eslint-plugin")) return metaName;
return resolveEslintPluginName(metaName);
};
/**
* Derives the rule-ID prefix that an npm package exposes.
*
* Examples:
* `eslint-plugin-react-dom` -> `react-dom`
* `eslint-plugin-mocha` -> `mocha`
* `@stylistic/eslint-plugin` -> `@stylistic`
* `@stylistic/eslint-plugin-ts` -> `@stylistic/ts`
*/
const deriveRulePrefix = (packageName) => {
if (packageName.startsWith("@")) {
const slashIdx = packageName.indexOf("/");
const scope = packageName.substring(0, slashIdx);
const rest = packageName.substring(slashIdx + 1);
if (rest === "eslint-plugin") return scope;
if (rest.startsWith("eslint-plugin-")) return `${scope}/${rest.substring(14)}`;
return packageName;
}
if (packageName.startsWith("eslint-plugin-")) return packageName.substring(14);
return packageName;
};
/**
* Resolves the canonical rule name for a jsPlugin rule.
*
* When a plugin is registered under an alias (e.g. `@eslint-react/dom`) but
* its `meta.name` reveals a different canonical package (`eslint-plugin-react-dom`),
* the rule must be rewritten so that oxlint can match it to the loaded plugin.
*
* For example:
* `@eslint-react/dom/no-find-dom-node` -> `react-dom/no-find-dom-node`
*/
const resolveJsPluginRuleName = (rule, plugins) => {
const pluginName = extractPluginId(rule);
if (pluginName === void 0) return rule;
const metaName = plugins?.[pluginName]?.meta?.name;
if (!metaName || !metaName.includes("eslint-plugin")) return rule;
const canonicalPrefix = deriveRulePrefix(metaName);
if (canonicalPrefix === pluginName) return rule;
return `${canonicalPrefix}/${rule.substring(pluginName.length + 1)}`;
};
const enableJsPluginRule = (targetConfig, rule, ruleEntry, plugins) => {
const pluginName = extractPluginId(rule);
if (pluginName === void 0) return false;
if (ignorePlugins.has(pluginName)) return false;
if (targetConfig.jsPlugins === void 0 || targetConfig.jsPlugins === null) targetConfig.jsPlugins = [];
const metaName = plugins?.[pluginName]?.meta?.name;
const eslintPluginName = metaName ? resolveFromMetaName(metaName) : resolveEslintPluginName(pluginName);
if (!targetConfig.jsPlugins.includes(eslintPluginName)) targetConfig.jsPlugins.push(eslintPluginName);
const resolvedRule = resolveJsPluginRuleName(rule, plugins);
targetConfig.rules = targetConfig.rules ?? {};
targetConfig.rules[resolvedRule] = ruleEntry;
return true;
};
/**
* Returns true if any rule name matches the given jsPlugin package.
*
* Handles aliased plugins where the ESLint registration name differs from the
* canonical prefix derived from the npm package name:
* - `@e18e/eslint-plugin` → prefix `@e18e`, but rules may use `e18e/`
* - `@eslint/eslint-plugin-markdown` → prefix `@eslint/markdown`, but rules
* may use `markdown/`
*/
const hasRulesForPlugin = (ruleNames, pluginPackage) => {
const prefix = deriveRulePrefix(pluginPackage);
if (ruleNames.some((rule) => rule.startsWith(`${prefix}/`))) return true;
if (prefix.startsWith("@")) {
const slashIdx = prefix.indexOf("/");
const unscoped = slashIdx === -1 ? prefix.substring(1) : prefix.substring(slashIdx + 1);
return ruleNames.some((rule) => rule.startsWith(`${unscoped}/`));
}
return false;
};
/**
* Removes jsPlugin entries that have no corresponding rules left in the config.
*
* This can happen when an earlier ESLint config enables a plugin rule (adding the
* jsPlugin) but a later config (e.g. eslint-config-prettier) turns all of that
* plugin's rules off (deleting them from the rules object).
*/
const cleanUpUnusedJsPlugins = (config) => {
if (config.jsPlugins === void 0 || config.jsPlugins === null || config.jsPlugins.length === 0) return;
const ruleNames = Object.keys(config.rules ?? {});
config.jsPlugins = config.jsPlugins.filter((entry) => {
return hasRulesForPlugin(ruleNames, typeof entry === "string" ? entry : entry.specifier);
});
if (config.jsPlugins.length === 0) delete config.jsPlugins;
};
//#endregion
//#region src/generated/rules.ts
var rules_exports = /* @__PURE__ */ __exportAll({
correctnessRules: () => correctnessRules,
nurseryRules: () => nurseryRules,
pedanticRules: () => pedanticRules,
perfRules: () => perfRules,
restrictionRules: () => restrictionRules,
styleRules: () => styleRules,
suspiciousRules: () => suspiciousRules,
typeAwareRules: () => typeAwareRules
});
const pedanticRules = [
"accessor-pairs",
"array-callback-return",
"eqeqeq",
"max-classes-per-file",
"max-depth",
"max-lines",
"max-lines-per-function",
"max-nested-callbacks",
"no-array-constructor",
"no-case-declarations",
"no-constructor-return",
"no-else-return",
"no-fallthrough",
"no-inline-comments",
"no-inner-declarations",
"no-lonely-if",
"no-loop-func",
"no-negated-condition",
"no-new-wrappers",
"no-object-constructor",
"no-promise-executor-return",
"no-prototype-builtins",
"no-redeclare",
"no-self-compare",
"no-throw-literal",
"no-useless-return",
"no-warning-comments",
"radix",
"require-await",
"require-unicode-regexp",
"sort-vars",
"symbol-description",
"import/max-dependencies",
"jest/no-conditional-in-test",
"jsdoc/require-param",
"jsdoc/require-param-description",
"jsdoc/require-param-name",
"jsdoc/require-param-type",
"jsdoc/require-returns",
"jsdoc/require-returns-description",
"jsdoc/require-returns-type",
"jsdoc/require-throws-type",
"jsdoc/require-yields-type",
"react/checked-requires-onchange-or-readonly",
"react/display-name",
"react/jsx-no-target-blank",
"react/jsx-no-useless-fragment",
"react/no-unescaped-entities",
"react/rules-of-hooks",
"typescript/ban-ts-comment",
"typescript/ban-types",
"typescript/no-confusing-void-expression",
"typescript/no-deprecated",
"typescript/no-misused-promises",
"typescript/no-mixed-enums",
"typescript/no-unsafe-argument",
"typescript/no-unsafe-assignment",
"typescript/no-unsafe-call",
"typescript/no-unsafe-function-type",
"typescript/no-unsafe-member-access",
"typescript/no-unsafe-return",
"typescript/only-throw-error",
"typescript/prefer-enum-initializers",
"typescript/prefer-includes",
"typescript/prefer-nullish-coalescing",
"typescript/prefer-promise-reject-errors",
"typescript/prefer-readonly-parameter-types",
"typescript/prefer-ts-expect-error",
"typescript/related-getter-setter-pairs",
"typescript/require-await",
"typescript/restrict-plus-operands",
"typescript/return-await",
"typescript/strict-boolean-expressions",
"typescript/strict-void-return",
"typescript/switch-exhaustiveness-check",
"unicorn/consistent-assert",
"unicorn/consistent-empty-array-spread",
"unicorn/escape-case",
"unicorn/explicit-length-check",
"unicorn/new-for-builtins",
"unicorn/no-array-callback-reference",
"unicorn/no-hex-escape",
"unicorn/no-immediate-mutation",
"unicorn/no-instanceof-array",
"unicorn/no-lonely-if",
"unicorn/no-negated-condition",
"unicorn/no-negation-in-equality-check",
"unicorn/no-new-buffer",
"unicorn/no-object-as-default-parameter",
"unicorn/no-static-only-class",
"unicorn/no-this-assignment",
"unicorn/no-typeof-undefined",
"unicorn/no-unnecessary-array-flat-depth",
"unicorn/no-unnecessary-array-splice-count",
"unicorn/no-unnecessary-slice-end",
"unicorn/no-unreadable-iife",
"unicorn/no-useless-promise-resolve-reject",
"unicorn/no-useless-switch-case",
"unicorn/no-useless-undefined",
"unicorn/prefer-array-flat",
"unicorn/prefer-array-some",
"unicorn/prefer-at",
"unicorn/prefer-blob-reading-methods",
"unicorn/prefer-code-point",
"unicorn/prefer-date-now",
"unicorn/prefer-dom-node-append",
"unicorn/prefer-dom-node-dataset",
"unicorn/prefer-dom-node-remove",
"unicorn/prefer-event-target",
"unicorn/prefer-import-meta-properties",
"unicorn/prefer-math-min-max",
"unicorn/prefer-math-trunc",
"unicorn/prefer-native-coercion-functions",
"unicorn/prefer-number-coercion",
"unicorn/prefer-prototype-methods",
"unicorn/prefer-query-selector",
"unicorn/prefer-regexp-test",
"unicorn/prefer-single-call",
"unicorn/prefer-string-replace-all",
"unicorn/prefer-string-slice",
"unicorn/prefer-top-level-await",
"unicorn/prefer-type-error",
"unicorn/require-number-to-fixed-digits-argument",
"vitest/no-conditional-in-test",
"typescript/no-array-constructor",
"typescript/no-loop-func",
"typescript/no-redeclare"
];
const styleRules = [
"arrow-body-style",
"capitalized-comments",
"curly",
"default-case-last",
"default-param-last",
"func-name-matching",
"func-names",
"func-style",
"grouped-accessor-pairs",
"guard-for-in",
"id-length",
"id-match",
"init-declarations",
"logical-assignment-operators",
"max-params",
"max-statements",
"new-cap",
"no-continue",
"no-duplicate-imports",
"no-extra-label",
"no-implicit-coercion",
"no-label-var",
"no-labels",
"no-lone-blocks",
"no-magic-numbers",
"no-multi-assign",
"no-multi-str",
"no-nested-ternary",
"no-new-func",
"no-return-assign",
"no-script-url",
"no-template-curly-in-string",
"no-ternary",
"no-useless-computed-key",
"object-shorthand",
"operator-assignment",
"prefer-arrow-callback",
"prefer-const",
"prefer-destructuring",
"prefer-exponentiation-operator",
"prefer-named-capture-group",
"prefer-numeric-literals",
"prefer-object-has-own",
"prefer-object-spread",
"prefer-promise-reject-errors",
"prefer-regex-literals",
"prefer-rest-params",
"prefer-spread",
"prefer-template",
"sort-imports",
"sort-keys",
"vars-on-top",
"yoda",
"import/consistent-type-specifier-style",
"import/exports-last",
"import/first",
"import/group-exports",
"import/newline-after-import",
"import/no-anonymous-default-export",
"import/no-duplicates",
"import/no-mutable-exports",
"import/no-named-default",
"import/no-named-export",
"import/no-namespace",
"import/no-nodejs-modules",
"import/prefer-default-export",
"jest/consistent-test-it",
"jest/max-expects",
"jest/max-nested-describe",
"jest/no-alias-methods",
"jest/no-confusing-set-timeout",
"jest/no-deprecated-functions",
"jest/no-done-callback",
"jest/no-duplicate-hooks",
"jest/no-hooks",
"jest/no-identical-title",
"jest/no-interpolation-in-snapshots",
"jest/no-jasmine-globals",
"jest/no-large-snapshots",
"jest/no-mocks-import",
"jest/no-restricted-jest-methods",
"jest/no-restricted-matchers",
"jest/no-test-prefixes",
"jest/no-test-return-statement",
"jest/no-unneeded-async-expect-function",
"jest/no-untyped-mock-factory",
"jest/padding-around-after-all-blocks",
"jest/padding-around-test-blocks",
"jest/prefer-called-with",
"jest/prefer-comparison-matcher",
"jest/prefer-each",
"jest/prefer-ending-with-an-expect",
"jest/prefer-equality-matcher",
"jest/prefer-expect-assertions",
"jest/prefer-expect-resolves",
"jest/prefer-hooks-in-order",
"jest/prefer-hooks-on-top",
"jest/prefer-importing-jest-globals",
"jest/prefer-jest-mocked",
"jest/prefer-lowercase-title",
"jest/prefer-mock-promise-shorthand",
"jest/prefer-mock-return-shorthand",
"jest/prefer-spy-on",
"jest/prefer-strict-equal",
"jest/prefer-to-be",
"jest/prefer-to-contain",
"jest/prefer-to-have-been-called",
"jest/prefer-to-have-been-called-times",
"jest/prefer-to-have-length",
"jest/prefer-todo",
"jest/require-hook",
"jest/require-top-level-describe",
"jsdoc/require-throws-description",
"jsdoc/require-yields-description",
"node/callback-return",
"node/global-require",
"node/no-exports-assign",
"node/no-mixed-requires",
"node/no-sync",
"promise/avoid-new",
"promise/no-nesting",
"promise/no-return-wrap",
"promise/param-names",
"promise/prefer-await-to-callbacks",
"promise/prefer-await-to-then",
"promise/prefer-catch",
"react/hook-use-state",
"react/jsx-boolean-value",
"react/jsx-curly-brace-presence",
"react/jsx-fragments",
"react/jsx-handler-names",
"react/jsx-max-depth",
"react/jsx-pascal-case",
"react/jsx-props-no-spreading",
"react/no-redundant-should-component-update",
"react/no-set-state",
"react/prefer-es6-class",
"react/self-closing-comp",
"react/state-in-constructor",
"typescript/adjacent-overload-signatures",
"typescript/array-type",
"typescript/ban-tslint-comment",
"typescript/class-literal-property-style",
"typescript/consistent-generic-constructors",
"typescript/consistent-indexed-object-style",
"typescript/consistent-type-assertions",
"typescript/consistent-type-definitions",
"typescript/consistent-type-exports",
"typescript/consistent-type-imports",
"typescript/dot-notation",
"typescript/method-signature-style",
"typescript/no-empty-interface",
"typescript/no-inferrable-types",
"typescript/no-unnecessary-qualifier",
"typescript/parameter-properties",
"typescript/prefer-find",
"typescript/prefer-for-of",
"typescript/prefer-function-type",
"typescript/prefer-readonly",
"typescript/prefer-reduce-type-parameter",
"typescript/prefer-regexp-exec",
"typescript/prefer-return-this-type",
"typescript/prefer-string-starts-ends-with",
"typescript/unified-signatures",
"unicorn/catch-error-name",
"unicorn/consistent-date-clone",
"unicorn/consistent-existence-index-check",
"unicorn/consistent-template-literal-escape",
"unicorn/custom-error-definition",
"unicorn/empty-brace-spaces",
"unicorn/error-message",
"unicorn/explicit-timer-delay",
"unicorn/filename-case",
"unicorn/max-nested-calls",
"unicorn/no-array-method-this-argument",
"unicorn/no-await-expression-member",
"unicorn/no-console-spaces",
"unicorn/no-nested-ternary",
"unicorn/no-null",
"unicorn/no-unreadable-array-destructuring",
"unicorn/no-useless-collection-argument",
"unicorn/no-zero-fractions",
"unicorn/number-literal-case",
"unicorn/numeric-separators-style",
"unicorn/prefer-array-index-of",
"unicorn/prefer-bigint-literals",
"unicorn/prefer-class-fields",
"unicorn/prefer-classlist-toggle",
"unicorn/prefer-default-parameters",
"unicorn/prefer-dom-node-text-content",
"unicorn/prefer-export-from",
"unicorn/prefer-global-this",
"unicorn/prefer-includes",
"unicorn/prefer-keyboard-event-key",
"unicorn/prefer-logical-operator-over-ternary",
"unicorn/prefer-modern-dom-apis",
"unicorn/prefer-negative-index",
"unicorn/prefer-object-from-entries",
"unicorn/prefer-optional-catch-binding",
"unicorn/prefer-reflect-apply",
"unicorn/prefer-response-static-json",
"unicorn/prefer-spread",
"unicorn/prefer-string-raw",
"unicorn/prefer-string-trim-start-end",
"unicorn/prefer-structured-clone",
"unicorn/prefer-ternary",
"unicorn/relative-url-style",
"unicorn/require-array-join-separator",
"unicorn/require-module-attributes",
"unicorn/switch-case-braces",
"unicorn/switch-case-break-position",
"unicorn/text-encoding-identifier-case",
"unicorn/throw-new-error",
"vitest/consistent-each-for",
"vitest/consistent-test-filename",
"vitest/consistent-test-it",
"vitest/consistent-vitest-vi",
"vitest/max-expects",
"vitest/max-nested-describe",
"vitest/no-alias-methods",
"vitest/no-duplicate-hooks",
"vitest/no-hooks",
"vitest/no-identical-title",
"vitest/no-import-node-test",
"vitest/no-importing-vitest-globals",
"vitest/no-interpolation-in-snapshots",
"vitest/no-large-snapshots",
"vitest/no-mocks-import",
"vitest/no-restricted-matchers",
"vitest/no-restricted-vi-methods",
"vitest/no-test-prefixes",
"vitest/no-test-return-statement",
"vitest/no-unneeded-async-expect-function",
"vitest/padding-around-after-all-blocks",
"vitest/prefer-called-exactly-once-with",
"vitest/prefer-called-once",
"vitest/prefer-called-times",
"vitest/prefer-called-with",
"vitest/prefer-comparison-matcher",
"vitest/prefer-describe-function-title",
"vitest/prefer-each",
"vitest/prefer-equality-matcher",
"vitest/prefer-expect-assertions",
"vitest/prefer-expect-resolves",
"vitest/prefer-expect-type-of",
"vitest/prefer-hooks-in-order",
"vitest/prefer-hooks-on-top",
"vitest/prefer-import-in-mock",
"vitest/prefer-importing-vitest-globals",
"vitest/prefer-lowercase-title",
"vitest/prefer-mock-promise-shorthand",
"vitest/prefer-mock-return-shorthand",
"vitest/prefer-spy-on",
"vitest/prefer-strict-boolean-matchers",
"vitest/prefer-strict-equal",
"vitest/prefer-to-be",
"vitest/prefer-to-be-falsy",
"vitest/prefer-to-be-object",
"vitest/prefer-to-be-truthy",
"vitest/prefer-to-contain",
"vitest/prefer-to-have-been-called-times",
"vitest/prefer-to-have-length",
"vitest/prefer-todo",
"vitest/require-hook",
"vitest/require-top-level-describe",
"vue/component-definition-name-casing",
"vue/define-emits-declaration",
"vue/define-props-declaration",
"vue/define-props-destructuring",
"vue/next-tick-style",
"vue/prop-name-casing",
"vue/require-default-prop",
"vue/require-direct-export",
"vue/require-prop-types",
"vue/require-typed-ref",
"typescript/default-param-last",
"typescript/init-declarations",
"typescript/max-params",
"typescript/no-magic-numbers"
];
const suspiciousRules = [
"block-scoped-var",
"no-extend-native",
"no-extra-bind",
"no-implied-eval",
"no-new",
"no-shadow",
"no-underscore-dangle",
"no-unexpected-multiline",
"no-unmodified-loop-condition",
"no-unneeded-ternary",
"no-useless-concat",
"no-useless-constructor",
"preserve-caught-error",
"import/no-absolute-path",
"import/no-empty-named-blocks",
"import/no-named-as-default",
"import/no-named-as-default-member",
"import/no-self-import",
"import/no-unassigned-import",
"jest/no-commented-out-tests",
"promise/always-return",
"promise/no-multiple-resolved",
"promise/no-promise-in-callback",
"react/iframe-missing-sandbox",
"react/jsx-no-comment-textnodes",
"react/jsx-no-script-url",
"react/no-namespace",
"react/no-unstable-nested-components",
"react/react-in-jsx-scope",
"react/style-prop-object",
"typescript/consistent-return",
"typescript/no-confusing-non-null-assertion",
"typescript/no-extraneous-class",
"typescript/no-unnecessary-boolean-literal-compare",
"typescript/no-unnecessary-template-expression",
"typescript/no-unnecessary-type-arguments",
"typescript/no-unnecessary-type-assertion",
"typescript/no-unnecessary-type-constraint",
"typescript/no-unnecessary-type-conversion",
"typescript/no-unnecessary-type-parameters",
"typescript/no-unsafe-enum-comparison",
"typescript/no-unsafe-type-assertion",
"unicorn/consistent-function-scoping",
"unicorn/no-accessor-recursion",
"unicorn/no-array-fill-with-reference-type",
"unicorn/no-array-reverse",
"unicorn/no-array-sort",
"unicorn/no-confusing-array-with",
"unicorn/no-instanceof-builtins",
"unicorn/prefer-add-event-listener",
"unicorn/require-module-specifiers",
"unicorn/require-post-message-target-origin",
"vitest/no-commented-out-tests",
"vue/no-required-prop-with-default",
"vue/require-default-export",
"typescript/no-shadow",
"typescript/no-useless-constructor"
];
const restrictionRules = [
"class-methods-use-this",
"complexity",
"default-case",
"no-alert",
"no-bitwise",
"no-console",
"no-div-regex",
"no-empty",
"no-empty-function",
"no-eq-null",
"no-implicit-globals",
"no-param-reassign",
"no-plusplus",
"no-proto",
"no-regex-spaces",
"no-restricted-globals",
"no-restricted-imports",
"no-restricted-properties",
"no-sequences",
"no-undefined",
"no-use-before-define",
"no-var",
"no-void",
"unicode-bom",
"import/extensions",
"import/no-amd",
"import/no-commonjs",
"import/no-cycle",
"import/no-default-export",
"import/no-dynamic-require",
"import/no-relative-parent-imports",
"import/no-webpack-loader-syntax",
"import/unambiguous",
"jsdoc/check-access",
"jsdoc/empty-tags",
"jsx-a11y/anchor-ambiguous-text",
"node/handle-callback-err",
"node/no-new-require",
"node/no-path-concat",
"node/no-process-env",
"promise/catch-or-return",
"promise/spec-only",
"react/button-has-type",
"react/forbid-component-props",
"react/forbid-dom-props",
"react/forbid-elements",
"react/jsx-filename-extension",
"react/jsx-no-literals",
"react/no-clone-element",
"react/no-danger",
"react/no-multi-comp",
"react/no-react-children",
"react/no-unknown-property",
"react/only-export-components",
"react/prefer-function-component",
"typescript/explicit-function-return-type",
"typescript/explicit-member-accessibility",
"typescript/explicit-module-boundary-types",
"typescript/no-dynamic-delete",
"typescript/no-empty-object-type",
"typescript/no-explicit-any",
"typescript/no-import-type-side-effects",
"typescript/no-invalid-void-type",
"typescript/no-namespace",
"typescript/no-non-null-asserted-nullish-coalescing",
"typescript/no-non-null-assertion",
"typescript/no-require-imports",
"typescript/no-restricted-types",
"typescript/no-var-requires",
"typescript/non-nullable-type-assertion-style",
"typescript/prefer-literal-enum-member",
"typescript/promise-function-async",
"typescript/use-unknown-in-catch-callback-variable",
"unicorn/import-style",
"unicorn/no-abusive-eslint-disable",
"unicorn/no-anonymous-default-export",
"unicorn/no-array-for-each",
"unicorn/no-array-reduce",
"unicorn/no-document-cookie",
"unicorn/no-length-as-slice-end",
"unicorn/no-magic-array-flat-depth",
"unicorn/no-process-exit",
"unicorn/no-useless-error-capture-stack-trace",
"unicorn/prefer-modern-math-apis",
"unicorn/prefer-module",
"unicorn/prefer-node-protocol",
"unicorn/prefer-number-properties",
"vitest/require-test-timeout",
"vue/max-props",
"vue/no-import-compiler-macros",
"vue/no-multiple-slot-args",
"typescript/class-methods-use-this",
"typescript/no-empty-function",
"typescript/no-restricted-imports",
"typescript/no-use-before-define"
];
const correctnessRules = [
"constructor-super",
"for-direction",
"getter-return",
"no-async-promise-executor",
"no-caller",
"no-class-assign",
"no-compare-neg-zero",
"no-cond-assign",
"no-const-assign",
"no-constant-binary-expression",
"no-constant-condition",
"no-control-regex",
"no-debugger",
"no-delete-var",
"no-dupe-class-members",
"no-dupe-else-if",
"no-dupe-keys",
"no-duplicate-case",
"no-empty-character-class",
"no-empty-pattern",
"no-empty-static-block",
"no-eval",
"no-ex-assign",
"no-extra-boolean-cast",
"no-func-assign",
"no-global-assign",
"no-import-assign",
"no-invalid-regexp",
"no-irregular-whitespace",
"no-iterator",
"no-loss-of-precision",
"no-misleading-character-class",
"no-new-native-nonconstructor",
"no-nonoctal-decimal-escape",
"no-obj-calls",
"no-self-assign",
"no-setter-return",
"no-shadow-restricted-names",
"no-sparse-arrays",
"no-this-before-super",
"no-unassigned-vars",
"no-unreachable",
"no-unsafe-finally",
"no-unsafe-negation",
"no-unsafe-optional-chaining",
"no-unused-expressions",
"no-unused-labels",
"no-unused-private-class-members",
"no-unused-vars",
"no-useless-backreference",
"no-useless-catch",
"no-useless-escape",
"no-useless-rename",
"no-with",
"require-yield",
"use-isnan",
"valid-typeof",
"import/default",
"import/namespace",
"jest/expect-expect",
"jest/no-conditional-expect",
"jest/no-disabled-tests",
"jest/no-export",
"jest/no-focused-tests",
"jest/no-standalone-expect",
"jest/prefer-snapshot-hint",
"jest/require-to-throw-message",
"jest/valid-describe-callback",
"jest/valid-expect",
"jest/valid-expect-in-promise",
"jest/valid-title",
"jsdoc/check-property-names",
"jsdoc/check-tag-names",
"jsdoc/implements-on-classes",
"jsdoc/no-defaults",
"jsdoc/require-property",
"jsdoc/require-property-description",
"jsdoc/require-property-name",
"jsdoc/require-property-type",
"jsdoc/require-yields",
"jsx-a11y/alt-text",
"jsx-a11y/anchor-has-content",
"jsx-a11y/anchor-is-valid",
"jsx-a11y/aria-activedescendant-has-tabindex",
"jsx-a11y/aria-props",
"jsx-a11y/aria-proptypes",
"jsx-a11y/aria-role",
"jsx-a11y/aria-unsupported-elements",
"jsx-a11y/autocomplete-valid",
"jsx-a11y/click-events-have-key-events",
"jsx-a11y/control-has-associated-label",
"jsx-a11y/heading-has-content",
"jsx-a11y/html-has-lang",
"jsx-a11y/iframe-has-title",
"jsx-a11y/img-redundant-alt",
"jsx-a11y/interactive-supports-focus",
"jsx-a11y/label-has-associated-control",
"jsx-a11y/lang",
"jsx-a11y/media-has-caption",
"jsx-a11y/mouse-events-have-key-events",
"jsx-a11y/no-access-key",
"jsx-a11y/no-aria-hidden-on-focusable",
"jsx-a11y/no-autofocus",
"jsx-a11y/no-distracting-elements",
"jsx-a11y/no-interactive-element-to-noninteractive-role",
"jsx-a11y/no-noninteractive-element-interactions",
"jsx-a11y/no-noninteractive-element-to-interactive-role",
"jsx-a11y/no-noninteractive-tabindex",
"jsx-a11y/no-redundant-roles",
"jsx-a11y/no-static-element-interactions",
"jsx-a11y/prefer-tag-over-role",
"jsx-a11y/role-has-required-aria-props",
"jsx-a11y/role-supports-aria-props",
"jsx-a11y/scope",
"jsx-a11y/tabindex-no-positive",
"nextjs/google-font-display",
"nextjs/google-font-preconnect",
"nextjs/inline-script-id",
"nextjs/next-script-for-ga",
"nextjs/no-assign-module-variable",
"nextjs/no-async-client-component",
"nextjs/no-before-interactive-script-outside-document",
"nextjs/no-css-tags",
"nextjs/no-document-import-in-page",
"nextjs/no-duplicate-head",
"nextjs/no-head-element",
"nextjs/no-head-import-in-document",
"nextjs/no-html-link-for-pages",
"nextjs/no-img-element",
"nextjs/no-page-custom-font",
"nextjs/no-script-component-in-head",
"nextjs/no-styled-jsx-in-document",
"nextjs/no-sync-scripts",
"nextjs/no-title-in-document-head",
"nextjs/no-typos",
"nextjs/no-unwanted-polyfillio",
"promise/no-callback-in-promise",
"promise/no-new-statics",
"promise/valid-params",
"react/exhaustive-deps",
"react/forward-ref-uses-ref",
"react/jsx-key",
"react/jsx-no-duplicate-props",
"react/jsx-no-undef",
"react/jsx-props-no-spread-multi",
"react/no-children-prop",
"react/no-danger-with-children",
"react/no-did-mount-set-state",
"react/no-did-update-set-state",
"react/no-direct-mutation-state",
"react/no-find-dom-node",
"react/no-is-mounted",
"react/no-render-return-value",
"react/no-string-refs",
"react/no-this-in-sfc",
"react/no-unsafe",
"react/no-will-update-set-state",
"react/void-dom-elements-no-children",
"typescript/await-thenable",
"typescript/no-array-delete",
"typescript/no-base-to-string",
"typescript/no-duplicate-enum-values",
"typescript/no-duplicate-type-constituents",
"typescript/no-extra-non-null-assertion",
"typescript/no-floating-promises",
"typescript/no-for-in-array",
"typescript/no-implied-eval",
"typescript/no-meaningless-void-operator",
"typescript/no-misused-new",
"typescript/no-misused-spread",
"typescript/no-non-null-asserted-optional-chain",
"typescript/no-redundant-type-constituents",
"typescript/no-this-alias",
"typescript/no-unnecessary-parameter-property-assignment",
"typescript/no-unsafe-declaration-merging",
"typescript/no-unsafe-unary-minus",
"typescript/no-useless-default-assignment",
"typescript/no-useless-empty-export",
"typescript/no-wrapper-object-types",
"typescript/prefer-as-const",
"typescript/prefer-namespace-keyword",
"typescript/require-array-sort-compare",
"typescript/restrict-template-expressions",
"typescript/triple-slash-reference",
"typescript/unbound-method",
"unicorn/no-await-in-promise-methods",
"unicorn/no-empty-file",
"unicorn/no-invalid-fetch-options",
"unicorn/no-invalid-remove-event-listener",
"unicorn/no-new-array",
"unicorn/no-single-promise-in-promise-methods",
"unicorn/no-thenable",
"unicorn/no-unnecessary-await",
"unicorn/no-useless-fallback-in-spread",
"unicorn/no-useless-length-check",
"unicorn/no-useless-spread",
"unicorn/prefer-set-size",
"unicorn/prefer-string-starts-ends-with",
"vitest/expect-expect",
"vitest/hoisted-apis-on-top",
"vitest/no-conditional-expect",
"vitest/no-conditional-tests",
"vitest/no-disabled-tests",
"vitest/no-focused-tests",
"vitest/no-standalone-expect",
"vitest/prefer-snapshot-hint",
"vitest/require-awaited-expect-poll",
"vitest/require-local-test-context-for-concurrent-snapshots",
"vitest/require-mock-type-parameters",
"vitest/require-to-throw-message",
"vitest/valid-describe-callback",
"vitest/valid-expect",
"vitest/valid-expect-in-promise",
"vitest/valid-title",
"vitest/warn-todo",
"vue/no-arrow-functions-in-watch",
"vue/no-async-in-computed-properties",
"vue/no-computed-properties-in-data",
"vue/no-deprecated-data-object-declaration",
"vue/no-deprecated-delete-set",
"vue/no-deprecated-destroyed-lifecycle",
"vue/no-deprecated-events-api",
"vue/no-deprecated-model-definition",
"vue/no-deprecated-props-default-this",
"vue/no-deprecated-vue-config-keycodes",
"vue/no-dupe-keys",
"vue/no-export-in-script-setup",
"vue/no-expose-after-await",
"vue/no-lifecycle-after-await",
"vue/no-reserved-component-names",
"vue/no-reserved-keys",
"vue/no-reserved-props",
"vue/no-shared-component-data",
"vue/no-side-effects-in-computed-properties",
"vue/no-this-in-before-route-enter",
"vue/no-watch-after-await",
"vue/prefer-import-from-vue",
"vue/require-prop-type-constructor",
"vue/require-render-return",
"vue/require-slots-as-functions",
"vue/return-in-computed-property",
"vue/return-in-emits-validator",
"vue/valid-define-emits",
"vue/valid-define-options",
"vue/valid-define-props",
"vue/valid-next-tick",
"typescript/no-dupe-class-members",
"typescript/no-loss-of-precision",
"typescript/no-unused-expressions",
"typescript/no-unused-vars"
];
const perfRules = [
"no-await-in-loop",
"no-useless-call",
"react/jsx-no-constructed-context-values",
"react/no-array-index-key",
"react/no-object-type-as-default-prop",
"react-perf/jsx-no-jsx-as-prop",
"react-perf/jsx-no-new-array-as-prop",
"react-perf/jsx-no-new-function-as-prop",
"react-perf/jsx-no-new-object-as-prop",
"unicorn/prefer-array-find",
"unicorn/prefer-array-flat-map",
"unicorn/prefer-set-has"
];
const nurseryRules = [
"no-restricted-exports",
"no-undef",
"no-unreachable-loop",
"no-useless-assignment",
"import/export",
"import/named",
"promise/no-return-in-finally",
"react/react-compiler",
"react/require-render-return",
"typescript/no-unnecessary-condition",
"typescript/prefer-optional-chain",
"unicorn/no-useless-iterator-to-array"
];
const typeAwareRules = [
"typescript/await-thenable",
"typescript/consistent-return",
"typescript/consistent-type-exports",
"typescript/dot-notation",
"typescript/no-array-delete",
"typescript/no-base-to-string",
"typescript/no-confusing-void-expression",
"typescript/no-deprecated",
"typescript/no-duplicate-type-constituents",
"typescript/no-floating-promises",
"typescript/no-for-in-array",
"typescript/no-implied-eval",
"typescript/no-meaningless-void-operator",
"typescript/no-misused-promises",
"typescript/no-misused-spread",
"typescript/no-mixed-enums",
"typescript/no-redundant-type-constituents",
"typescript/no-unnecessary-boolean-literal-compare",
"typescript/no-unnecessary-condition",
"typescript/no-unnecessary-qualifier",
"typescript/no-unnecessary-template-expression",
"typescript/no-unnecessary-type-arguments",
"typescript/no-unnecessary-type-assertion",
"typescript/no-unnecessary-type-conversion",
"typescript/no-unnecessary-type-parameters",
"typescript/no-unsafe-argument",
"typescript/no-unsafe-assignment",
"typescript/no-unsafe-call",
"typescript/no-unsafe-enum-comparison",
"typescript/no-unsafe-member-access",
"typescript/no-unsafe-return",
"typescript/no-unsafe-type-assertion",
"typescript/no-unsafe-unary-minus",
"typescript/no-useless-default-assignment",
"typescript/non-nullable-type-assertion-style",
"typescript/only-throw-error",
"typescript/prefer-find",
"typescript/prefer-includes",
"typescript/prefer-nullish-coalescing",
"typescript/prefer-optional-chain",
"typescript/prefer-promise-reject-errors",
"typescript/prefer-readonly",
"typescript/prefer-readonly-parameter-types",
"typescript/prefer-reduce-type-parameter",
"typescript/prefer-regexp-exec",
"typescript/prefer-return-this-type",
"typescript/prefer-string-starts-ends-with",
"typescript/promise-function-async",
"typescript/related-getter-setter-pairs",
"typescript/require-array-sort-compare",
"typescript/require-await",
"typescript/restrict-plus-operands",
"typescript/restrict-template-expressions",
"typescript/return-await",
"typescript/strict-boolean-expressions",
"typescript/strict-void-return",
"typescript/switch-exhaustiveness-check",
"typescript/unbound-method",
"typescript/use-unknown-in-catch-callback-variable"
];
//#endregion
//#region src/generated/unsupported-rules.json
var unsupportedRules = {
"eslint/no-dupe-args": "Superseded by strict mode.",
"eslint/no-octal": "Superseded by strict mode.",
"eslint/no-octal-escape": "Superseded by strict mode.",
"eslint/no-new-symbol": "Deprecated as of ESLint v9, but for a while disable manually.",
"eslint/no-undef-init": "#6456, `unicorn/no-useless-undefined` covers this case.",
"import/no-unresolved": "Will always contain false positives due to module resolution complexity.",
"promise/no-native": "Handled by `eslint/no-undef`.",
"unicorn/no-for-loop": "This rule suggests using `Array.prototype.entries` which is slow https://github.com/oxc-project/oxc/issues/11311, furthermore, `typescript/prefer-for-of` covers most cases.",
"eslint/no-negated-in-lhs": "Replaced by `eslint/no-unsafe-negation`, which we support.",
"eslint/no-catch-shadow": "Replaced by `eslint/no-shadow`.",
"eslint/id-blacklist": "Replaced by `eslint/id-denylist`.",
"eslint/no-new-object": "Replaced by `eslint/no-object-constructor`, which we support.",
"eslint/no-native-reassign": "Replaced by `eslint/no-global-assign`, which we support.",
"n/shebang": "Replaced by `node/hashbang`.",
"n/no-hide-core-modules": "This rule is deprecated in eslint-plugin-n for being inherently incorrect, no need for us to implement it.",
"unicorn/no-array-push-push": "Replaced by `unicorn/prefer-single-call`.",
"import/imports-first": "Replaced by `import/first`, which we support.",
"eslint/dot-notation": "Use `typescript/dot-notation` instead, which we support as a type-aware rule.",
"eslint/consistent-return": "Use `typescript/consistent-return` instead, which we support as a type-aware rule.",
"eslint/no-useless-default-assignment": "Use `typescript/no-useless-default-assignment` instead, which will be supported as a type-aware rule.",
"react/jsx-sort-default-props": "Replaced by `react/sort-default-props`.",
"vitest/no-done-callback": "[Deprecated in eslint-plugin-vitest](https://github.com/vitest-dev/eslint-plugin-vitest/issues/158).",
"eslint/no-return-await": "Deprecated, not recommended anymore by ESLint.",
"eslint/prefer-reflect": "Deprecated, not recommended anymore by ESLint.",
"jsx-a11y/accessible-emoji": "Deprecated.",
"jsx-a11y/label-has-for": "Deprecated, replaced by `jsx-a11y/label-has-associated-control`.",
"jsx-a11y/no-onchange": "Deprecated, based on behavior of very old browsers, and so no longer necessary.",
"eslint/camelcase": "Superseded by `@typescript-eslint/naming-convention`, which accomplishes the same behavior with more flexibility.",
"eslint/no-invalid-this": "Superseded by TypeScript's [`noImplicitThis`](https://www.typescriptlang.org/tsconfig/#noImplicitThis) compiler option (enabled by `strict` mode).",
"react/jsx-uses-react": "It is unnecessary to import React for JSX/TSX files with React 17+ when using the new JSX transform. This rule is also not easy to implement in Oxlint as it modifies the behavior of another rule.",
"import/no-internal-modules": "Not necessary to implement this rule as we already have `eslint/no-restricted-imports`, which is able to cover the same use-cases.",
"n/prefer-node-protocol": "No need to implement, already implemented by `unicorn/prefer-node-protocol`.",
"n/no-process-exit": "No need to implement, already implemented by `unicorn/no-process-exit`.",
"n/file-extension-in-import": "No need to implement, already implemented by `import/extensions`.",
"n/no-callback-literal": "Use type-aware linting with `--type-aware --type-check` (or enable `options.typeAware` in config) and TypeScript callback typing (`err: Error | null | undefined`) to catch non-Error literals in error-first callbacks.",
"import/enforce-node-protocol-usage": "No need to implement, already implemented by `unicorn/prefer-node-protocol`.",
"import/no-deprecated": "No need to implement, already implemented by `typescript/no-deprecated` via tsgolint.",
"n/no-restricted-import": "No need to implement, already implemented by `no-restricted-imports` rule.",
"n/no-restricted-require": "No need to implement, already implemented by `no-restricted-imports` rule.",
"n/prefer-global/buffer": "No need to implement, the same policy can be enforced with generic restriction rules such as `no-restricted-imports` and `no-restricted-globals`.",
"n/prefer-global/console": "No need to implement, the same policy can be enforced with generic restriction rules such as `no-restricted-imports` and `no-restricted-globals`.",
"n/prefer-global/crypto": "No need to implement, the same policy can be enforced with generic restriction rules such as `no-restricted-imports` and `no-restricted-globals`.",
"n/prefer-global/process": "No need to implement, the same policy can be enforced with generic restriction rules such as `no-restricted-imports` and `no-restricted-globals`.",
"n/prefer-global/text-decoder": "No need to implement, the same policy can be enforced with generic restriction rules such as `no-restricted-imports` and `no-restricted-globals`.",
"n/prefer-global/text-encoder": "No need to implement, the same policy can be enforced with generic restriction rules such as `no-restricted-imports` and `no-restricted-globals`.",
"n/prefer-global/timers": "No need to implement, the same policy can be enforced with generic restriction rules such as `no-restricted-imports` and `no-restricted-globals`.",
"n/prefer-global