@will-stone/eslint-config 0.4.0 → 0.5.0

package/dist/index.cjs

@@ -0,0 +1,2089 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => factory
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/factory.ts
+var import_eslint_config_flat_gitignore = __toESM(require("eslint-config-flat-gitignore"), 1);
+
+// src/configs/astro.ts
+var import_parser = __toESM(require("@typescript-eslint/parser"), 1);
+var import_astro_eslint_parser = __toESM(require("astro-eslint-parser"), 1);
+var import_eslint_plugin_astro = __toESM(require("eslint-plugin-astro"), 1);
+function astro() {
+  return [
+    {
+      files: ["**/*.astro"],
+      languageOptions: {
+        // @ts-expect-error -- does not confirm to type
+        parser: import_astro_eslint_parser.default,
+        parserOptions: {
+          extraFileExtensions: [".astro"],
+          parser: import_parser.default
+        }
+      },
+      plugins: {
+        // @ts-expect-error -- does not confirm to type
+        astro: import_eslint_plugin_astro.default
+      },
+      // @ts-expect-error -- does not confirm to type
+      rules: import_eslint_plugin_astro.configs.recommended.rules
+    }
+  ];
+}
+
+// src/configs/base.ts
+var import_confusing_browser_globals = __toESM(require("confusing-browser-globals"), 1);
+var import_globals = __toESM(require("globals"), 1);
+function base() {
+  return [
+    {
+      languageOptions: {
+        globals: {
+          ...import_globals.default.browser,
+          ...import_globals.default.es2021
+        }
+      },
+      rules: {
+        /**
+         * Built-in rules
+         */
+        // Off for Prettier
+        // https://github.com/prettier/eslint-config-prettier/blob/main/index.js
+        // TODO move to prettier config
+        "array-bracket-newline": "off",
+        "array-bracket-spacing": "off",
+        "array-element-newline": "off",
+        "arrow-parens": "off",
+        "arrow-spacing": "off",
+        "block-spacing": "off",
+        "brace-style": "off",
+        "comma-dangle": "off",
+        "comma-spacing": "off",
+        "comma-style": "off",
+        "computed-property-spacing": "off",
+        "curly": 0,
+        "dot-location": "off",
+        "eol-last": "off",
+        "func-call-spacing": "off",
+        "function-call-argument-newline": "off",
+        "function-paren-newline": "off",
+        "generator-star": "off",
+        "generator-star-spacing": "off",
+        "implicit-arrow-linebreak": "off",
+        "indent": "off",
+        "jsx-quotes": "off",
+        "key-spacing": "off",
+        "keyword-spacing": "off",
+        "linebreak-style": "off",
+        "lines-around-comment": 0,
+        "max-len": 0,
+        "multiline-ternary": "off",
+        "new-parens": "off",
+        "newline-per-chained-call": "off",
+        "no-arrow-condition": "off",
+        "no-comma-dangle": "off",
+        "no-confusing-arrow": 0,
+        "no-extra-parens": "off",
+        "no-extra-semi": "off",
+        "no-floating-decimal": "off",
+        "no-mixed-operators": 0,
+        "no-mixed-spaces-and-tabs": "off",
+        "no-multi-spaces": "off",
+        "no-multiple-empty-lines": "off",
+        "no-reserved-keys": "off",
+        "no-space-before-semi": "off",
+        "no-tabs": 0,
+        "no-trailing-spaces": "off",
+        "no-unexpected-multiline": 0,
+        "no-whitespace-before-property": "off",
+        "no-wrap-func": "off",
+        "nonblock-statement-body-position": "off",
+        "object-curly-newline": "off",
+        "object-curly-spacing": "off",
+        "object-property-newline": "off",
+        "one-var-declaration-per-line": "off",
+        "operator-linebreak": "off",
+        "padded-blocks": "off",
+        "quote-props": "off",
+        "quotes": 0,
+        "rest-spread-spacing": "off",
+        "semi": "off",
+        "semi-spacing": "off",
+        "semi-style": "off",
+        "space-after-function-name": "off",
+        "space-after-keywords": "off",
+        "space-before-blocks": "off",
+        "space-before-function-paren": "off",
+        "space-before-function-parentheses": "off",
+        "space-before-keywords": "off",
+        "space-in-brackets": "off",
+        "space-in-parens": "off",
+        "space-infix-ops": "off",
+        "space-return-throw-case": "off",
+        "space-unary-ops": "off",
+        "space-unary-word-ops": "off",
+        "switch-colon-spacing": "off",
+        "template-curly-spacing": "off",
+        "template-tag-spacing": "off",
+        "unicode-bom": "off",
+        "wrap-iife": "off",
+        "wrap-regex": "off",
+        "yield-star-spacing": "off",
+        // Enforces getter/setter pairs in objects and classes
+        "accessor-pairs": "error",
+        // Enforces return statements in callbacks of array's methods
+        "array-callback-return": [
+          "error",
+          // To be compatible with unicorn/no-useless-undefined
+          { allowImplicit: true }
+        ],
+        // Can cause issues when Prettier is enabled
+        // TODO should this move to prettier config?
+        "arrow-body-style": "off",
+        // Generates warnings when variables are used outside of the
+        // block in which they were defined
+        "block-scoped-var": "error",
+        // camelCase vars
+        "camelcase": "error",
+        // Write comments however you like
+        "capitalized-comments": "off",
+        // If a class method does not use this,
+        // it can sometimes be made into a static function
+        "class-methods-use-this": "error",
+        // Measures the number of linearly independent paths through a program's
+        // source code. Rubbish. Use your own judgement on complexity.
+        "complexity": "off",
+        // Do not care how return statements specify values.
+        // When on, this rule gets annoying when combined with Unicorn's no-useless-* rules.
+        "consistent-return": "off",
+        // Not sure if required
+        "consistent-this": "error",
+        // Constructors of derived classes must call super().
+        // Constructors of non derived classes must not call super()
+        "constructor-super": "error",
+        // Require Default Case in Switch Statements
+        "default-case": "error",
+        // enforce default clauses in switch statements to be last
+        "default-case-last": "error",
+        // Putting default parameter at last allows function calls
+        // to omit optional tail arguments.
+        "default-param-last": "error",
+        // Access properties using the dot notation.
+        "dot-notation": "warn",
+        // Use === over ==
+        "eqeqeq": "warn",
+        // Enforce "for" loop update clause moving the counter in the right direction
+        "for-direction": "error",
+        // Require function names to match the name of the variable or property to
+        // which they are assigned.
+        "func-name-matching": "error",
+        // Requires function expressions to have a name,
+        // If the name cannot be assigned automatically
+        "func-names": ["error", "as-needed"],
+        // Declaration style: function name() {}
+        // Except arrow functions
+        "func-style": ["error", "declaration", { allowArrowFunctions: true }],
+        // Enforces that a return statement is present in property getters
+        "getter-return": "error",
+        // If a property has a getter and a setter, the setter should be defined
+        // right after the getter, or vice versa.
+        "grouped-accessor-pairs": "error",
+        // This rule is aimed at preventing unexpected behavior that could arise
+        // from using a for in loop without filtering the results in the loop.
+        "guard-for-in": "error",
+        // Disallows specified identifiers.
+        // Maybe turn this on when it's obvious which identifiers do not make sense.
+        // Rules like unicorn/catch-error-name look after some of these, anyway.
+        "id-denylist": "off",
+        // Allow variables named with as little chars as you like
+        "id-length": "off",
+        // Requires identifiers to match a specified regular expression.
+        // Mainly covered by rules like "camelcase". This could probably cause more
+        // trouble than it's worth.
+        "id-match": "off",
+        // Initialise vairables however you like
+        "init-declarations": "off",
+        // Enforces line comments positioned above code
+        "line-comment-position": "error",
+        // Require an empty line between class members
+        "lines-between-class-members": "warn",
+        "logical-assignment-operators": ["warn", "always"],
+        // Organise classes how you see fit
+        "max-classes-per-file": "off",
+        // This rule enforces a maximum depth that blocks can be nested to reduce
+        // code complexity. Just gets in the way too much.
+        "max-depth": "off",
+        // Files can contain as many lines as you like
+        "max-lines": "off",
+        // Functions can be as complicated as you like
+        "max-lines-per-function": "off",
+        // This rule enforces a maximum depth that callbacks can be nested to
+        // increase code clarity. Defaults to 10.
+        "max-nested-callbacks": "error",
+        // Enforces a maximum number of parameters allowed in function definitions.
+        // This is usually to help readability but TS self-documents this kind of thing.
+        "max-params": "off",
+        // Statements can be as complicated as you like
+        "max-statements": "off",
+        // Enforces maximum number of statements allowed per line to 1.
+        "max-statements-per-line": "error",
+        // Allow any style of multiline comments
+        "multiline-comment-style": "off",
+        // Require constructor names to begin with a capital letter
+        "new-cap": "error",
+        // alert is often used while debugging code, which should be removed before
+        // deployment to production.
+        "no-alert": "error",
+        // Use of the Array constructor to construct a new array is generally
+        // discouraged in favor of array literal notation because of the
+        // single-argument pitfall and because the Array global may be redefined.
+        // The exception is when the Array constructor is used to intentionally
+        // create sparse arrays of a specified size by giving the constructor a
+        // single numeric argument.
+        "no-array-constructor": "error",
+        // The executor function can also be an async function.
+        // However, this is usually a mistake:
+        // https://eslint.org/docs/rules/no-async-promise-executor#top
+        "no-async-promise-executor": "error",
+        // Use Promise.all() instead
+        "no-await-in-loop": "error",
+        // Use of bitwise operators in JavaScript is very rare and often & or | is
+        // simply a mistyped && or ||, which will lead to unexpected behavior.
+        "no-bitwise": "error",
+        // Use the producer methods Buffer.from, Buffer.alloc,
+        // and Buffer.allocUnsafe instead.
+        "no-buffer-constructor": "error",
+        // arguments.caller and arguments.callee ave been deprecated in future
+        // versions of JavaScript and their use is forbidden in ECMAScript 5 while
+        // in strict mode.
+        "no-caller": "error",
+        // Disallows lexical declarations (let, const, function and class) in
+        // case/default clauses. To ensure that the lexical declaration only applies
+        // to the current case clause wrap your clauses in blocks.
+        "no-case-declarations": "error",
+        // Disallow modifying variables of class declarations
+        "no-class-assign": "error",
+        // Disallow comparing against -0
+        "no-compare-neg-zero": "error",
+        // Disallow assignment operators in conditional statements. e.g.
+        // if (user.jobTitle = "manager") { }
+        "no-cond-assign": "error",
+        // Disallow the use of console
+        "no-console": "warn",
+        // Disallow modifying variables that are declared using const
+        "no-const-assign": "error",
+        // This rule identifies == and === comparisons which, based on the semantics
+        // of the JavaScript language, will always evaluate to true or false.
+        "no-constant-binary-expression": "error",
+        // Disallow constant expressions in conditions
+        // if (true) {}
+        "no-constant-condition": "error",
+        // Disallows return statements in the constructor of a class
+        "no-constructor-return": "error",
+        // Disallow continue statements.
+        // When used incorrectly it makes code less testable, less readable and less
+        // maintainable. Structured control flow statements such as if should be
+        // used instead.
+        "no-continue": "error",
+        // Control characters are special, invisible characters in the ASCII range
+        // 0-31. These characters are rarely used in JavaScript strings so a regular
+        // expression containing these characters is most likely a mistake.
+        "no-control-regex": "error",
+        // The debugger statement is used to tell the executing JavaScript
+        // environment to stop execution and start up a debugger at the current
+        // point in the code. This has fallen out of favor as a good practice with
+        // the advent of modern debugging and development tools.
+        "no-debugger": "error",
+        // The purpose of the delete operator is to remove a property from an
+        // object. Using the delete operator on a variable might lead to unexpected
+        // behavior.
+        "no-delete-var": "error",
+        // Require regex literals to escape division operators.
+        "no-div-regex": "warn",
+        // function foo(a, b, a) { } // duplicate "a" arg
+        "no-dupe-args": "error",
+        // class Foo {
+        //   bar() { console.log("hello") }
+        //   bar() { console.log("goodbye") } // duplicate class member
+        // }
+        "no-dupe-class-members": "error",
+        // if (isSomething(x)) {
+        //   foo()
+        // } else if (isSomething(x)) { // duplicate condition
+        //   bar()
+        // }
+        "no-dupe-else-if": "error",
+        // const foo = {
+        //   bar: "baz",
+        //   bar: "qux" // duplicate key
+        // }
+        "no-dupe-keys": "error",
+        // switch (a) {
+        //   case 1:
+        //     break
+        //   case 2:
+        //     break
+        //   case 1: // duplicate test expression
+        //     break
+        //   default:
+        //     break
+        // }
+        "no-duplicate-case": "error",
+        // Combine named imports in single statement.
+        "no-duplicate-imports": "error",
+        // If an `if` block contains a return statement, the else block becomes
+        // unnecessary. Its contents can be placed outside of the block.
+        "no-else-return": "warn",
+        // Disallow empty block statements.
+        "no-empty": "error",
+        // Disallow empty character classes in regular expressions.
+        "no-empty-character-class": "error",
+        // Disallow empty functions.
+        "no-empty-function": "error",
+        // Disallow empty destructuring patterns.
+        "no-empty-pattern": "error",
+        "no-empty-static-block": "error",
+        // Error: if (foo == null)
+        // Good: if (foo === null)
+        "no-eq-null": "error",
+        // Disallow eval()
+        "no-eval": "error",
+        // Disallow reassigning exceptions in catch clauses.
+        "no-ex-assign": "error",
+        // Disallow extending of native objects.
+        "no-extend-native": "error",
+        // Disallow unnecessary function binding
+        "no-extra-bind": "warn",
+        // In contexts such as an if statement's test where the result of the
+        // expression will already be coerced to a Boolean, casting to a Boolean via
+        // double negation (!!) or a Boolean call is unnecessary.
+        "no-extra-boolean-cast": "warn",
+        // If a loop contains no nested loops or switches, labeling the loop is unnecessary.
+        "no-extra-label": "warn",
+        // Disallow case statement fallthrough.
+        "no-fallthrough": "error",
+        // Disallow reassigning function declarations.
+        "no-func-assign": "error",
+        // Disallow assignment to native objects or read-only global variables.
+        "no-global-assign": "error",
+        // Disallow the type conversion with shorter notations.
+        "no-implicit-coercion": "warn",
+        // Disallow declarations in the global scope.
+        "no-implicit-globals": "error",
+        // There are some other ways to pass a string and have it interpreted as
+        // JavaScript code that have similar concerns.
+        // e.g. setTimeout("alert('Hi!');", 100);
+        "no-implied-eval": "error",
+        // Disallow assigning to imported bindings.
+        "no-import-assign": "error",
+        // Disallow inline comments after code.
+        "no-inline-comments": "error",
+        // Disallow variable or function declarations in nested blocks.
+        "no-inner-declarations": "error",
+        // Disallow invalid regular expression strings in RegExp constructors.
+        "no-invalid-regexp": "error",
+        // Disallow this keywords outside of classes or class-like objects.
+        "no-invalid-this": "error",
+        // Invalid or irregular whitespace causes issues with ECMAScript 5 parsers
+        // and also makes code harder to debug in a similar nature to mixed tabs and spaces.
+        "no-irregular-whitespace": "error",
+        // The __iterator__ property was a SpiderMonkey extension to JavaScript that
+        // could be used to create custom iterators that are compatible with
+        // JavaScript's for in and for each constructs. However, this property is
+        // now obsolete, so it should not be used.
+        "no-iterator": "error",
+        // Disallow labels that are variables names.
+        "no-label-var": "error",
+        // While convenient in some cases, labels tend to be used only rarely and
+        // are frowned upon by some as a remedial form of flow control that is more
+        // error prone and harder to understand.
+        "no-labels": "error",
+        // Disallow unnecessary nested blocks
+        "no-lone-blocks": "error",
+        // Disallow if statements as the only statement in else blocks.
+        "no-lonely-if": "warn",
+        // Writing functions within loops tends to result in errors due to the way
+        // the function creates a closure around the loop.
+        "no-loop-func": "error",
+        // Disallow the use of number literals that immediately lose precision at
+        // runtime when converted to a JS Number due to 64-bit floating-point rounding.
+        "no-loss-of-precision": "error",
+        // Disallowing magic numbers causes all sorts of problems
+        "no-magic-numbers": "off",
+        // Disallow characters which are made with multiple code points in character class syntax.
+        "no-misleading-character-class": "error",
+        // const foo = bar = "baz"
+        "no-multi-assign": "error",
+        // var x = "Line 1 \
+        //          Line 2"
+        "no-multi-str": "error",
+        // Negated conditions are more difficult to understand. Code can be made
+        // more readable by inverting the condition instead.
+        // This is handled by unicorn.
+        "no-negated-condition": "off",
+        // Disallow nested ternary expressions
+        "no-nested-ternary": "error",
+        // Disallows constructor calls using the new keyword that do not assign
+        // the resulting object to a variable.
+        "no-new": "error",
+        // ❌ Function()
+        // ✅ function()
+        "no-new-func": "error",
+        // ❌ new BigInt(12344555)
+        // ✅ BigInt(12344555)
+        "no-new-native-nonconstructor": "error",
+        // ❌ var myObject = new Object()
+        // ✅ var myObject = {}
+        "no-new-object": "error",
+        // Symbol is not intended to be used with the new operator, but to be called
+        //  as a function.
+        "no-new-symbol": "error",
+        // This rule aims to eliminate the use of String, Number, and Boolean with
+        // the new operator. As such, it warns whenever it sees new String,
+        // new Number, or new Boolean.
+        "no-new-wrappers": "error",
+        // Disallow \8 and \9 escape sequences in string literals
+        "no-nonoctal-decimal-escape": "error",
+        // This rule disallows calling the Math, JSON, Reflect and Atomics objects as functions.
+        "no-obj-calls": "error",
+        // the leading zero which identifies an octal literal has been a source of
+        // confusion and error in JavaScript code, ECMAScript 5 deprecates the use
+        // of octal numeric literals.
+        "no-octal": "error",
+        // As of the ECMAScript 5 specification, octal escape sequences in string
+        // literals are deprecated and should not be used. Unicode escape sequences
+        // should be used instead.
+        "no-octal-escape": "error",
+        // Assignment to variables declared as function parameters can be misleading
+        // and lead to confusing behavior, as modifying function parameters will
+        // also mutate the arguments object.
+        "no-param-reassign": "error",
+        // Because the unary ++ and -- operators are subject to automatic semicolon
+        // insertion, differences in whitespace can change semantics of source code.
+        "no-plusplus": "error",
+        // Disallow returning values from Promise executor functions
+        "no-promise-executor-return": "error",
+        // __proto__ property has been deprecated as of ECMAScript 3.1 and shouldn't
+        // be used in the code. Use Object.getPrototypeOf and Object.setPrototypeOf instead.
+        "no-proto": "error",
+        // Disallow use of Object.prototypes builtins directly.
+        "no-prototype-builtins": "error",
+        // Disallow variable redeclaration.
+        "no-redeclare": "error",
+        // Disallow multiple spaces in regular expression literals.
+        "no-regex-spaces": "warn",
+        // No export names are restricted
+        "no-restricted-exports": "off",
+        // Global variable names that are dangerous to use by mistake
+        "no-restricted-globals": ["error", ...import_confusing_browser_globals.default],
+        // No imports are restricted
+        "no-restricted-imports": "off",
+        // No properties are restricted
+        "no-restricted-properties": "off",
+        // No syntax is restricted
+        "no-restricted-syntax": "off",
+        // Disallow assignment in return statement
+        "no-return-assign": "error",
+        // Disallows unnecessary return await
+        "no-return-await": "error",
+        // ❌ location.href = "javascript:void(0)"
+        "no-script-url": "error",
+        // Self assignments have no effect.
+        // ❌ foo = foo
+        "no-self-assign": "error",
+        // Comparing a variable against itself is usually an error, either a typo or
+        // refactoring error.
+        "no-self-compare": "error",
+        // Disallow use of the comma operator.
+        "no-sequences": "error",
+        // Disallow returning values from setters.
+        "no-setter-return": "error",
+        // Disallow variable declarations from shadowing variables declared in the outer scope.
+        "no-shadow": "error",
+        // ES5 Value Properties of the Global Object (NaN, Infinity, undefined) as
+        // well as strict mode restricted identifiers eval and arguments are considered
+        // to be restricted names in JavaScript. Defining them to mean something
+        // else can have unintended consequences and confuse others reading the code.
+        "no-shadow-restricted-names": "error",
+        // This rule disallows sparse array literals which have "holes" where commas
+        //  are not preceded by elements. It does not apply to a trailing comma
+        // following the last element. Use ignored values instead.
+        "no-sparse-arrays": "error",
+        // Disallow template literal placeholder syntax in regular strings.
+        "no-template-curly-in-string": "error",
+        // Simple ternaries are okay
+        "no-ternary": "off",
+        // Disallow use of this/super before calling super() in constructors.
+        "no-this-before-super": "error",
+        // Maintain consistency when throwing exception by disallowing to throw
+        // literals and other expressions which cannot possibly be an Error object.
+        "no-throw-literal": "error",
+        // Disallow undeclared variables.
+        "no-undef": "error",
+        // Disallow initializing to undefined.
+        "no-undef-init": "warn",
+        // Allow undefined. Use no-global-assign and no-shadow-restricted-names
+        // rules to prevent undefined from being shadowed or assigned a different value.
+        "no-undefined": "off",
+        // Allow dangling underscores in identifiers.
+        "no-underscore-dangle": "off",
+        // Disallow unmodified conditions of loops
+        "no-unmodified-loop-condition": "error",
+        // Disallow ternary operators when simpler alternatives exist.
+        "no-unneeded-ternary": "warn",
+        // Disallow unreachable code after return, throw, continue, and break statements.
+        "no-unreachable": "error",
+        // Disallow loops with a body that allows only one iteration
+        "no-unreachable-loop": "error",
+        // Disallow control flow statements in finally blocks.
+        "no-unsafe-finally": "error",
+        // Disallow negating the left operand of relational operators.
+        "no-unsafe-negation": "error",
+        // Disallow use of optional chaining in contexts where the `undefined` value is not allowed
+        "no-unsafe-optional-chaining": "error",
+        // An unused expression which has no effect on the state of the program
+        // indicates a logic error.
+        "no-unused-expressions": "error",
+        // Labels that are declared and not used anywhere in the code are most
+        // likely an error due to incomplete refactoring.
+        "no-unused-labels": "warn",
+        "no-unused-private-class-members": "error",
+        // Variables must be used unless name starts with "ignored"
+        "no-unused-vars": [
+          "error",
+          {
+            // Useful for extracting args from props and ignoring them:
+            // { style: _style, ...restProps }
+            argsIgnorePattern: "^_",
+            varsIgnorePattern: "[iI]gnored"
+          }
+        ],
+        // It's possible to use identifiers before their formal declarations in code.
+        // This can be confusing and some believe it is best to always declare
+        // variables and functions before using them.
+        "no-use-before-define": "error",
+        // Do I need this? https://eslint.org/docs/rules/no-useless-backreference
+        "no-useless-backreference": "off",
+        // Function.prototype.call() and Function.prototype.apply() are slower than
+        // the normal function invocation.
+        "no-useless-call": "error",
+        // A catch clause that only rethrows the original error is redundant, and
+        // has no effect on the runtime behavior of the program.
+        "no-useless-catch": "error",
+        // ❌ var foo = {['a']: 'b'}
+        // ✅ var foo = {a: 'b'}
+        "no-useless-computed-key": "error",
+        // ❌ var foo = 'a' + 'b'
+        // ✅ var foo = 'ab'
+        "no-useless-concat": "error",
+        // ES2015 provides a default class constructor if one is not specified. As
+        // such, it isunnecessary to provide an empty constructor or one that simply
+        // delegates into its parent class.
+        "no-useless-constructor": "error",
+        // Escaping non-special characters in strings, template literals, and
+        // regular expressions doesn't have any effect.
+        "no-useless-escape": "error",
+        // Disallow renaming import, export, and destructured assignments to the same name.
+        "no-useless-rename": "warn",
+        // A return; statement with nothing after it is redundant, and has no effect
+        // on the runtime behavior of a function. This can be confusing, so it's
+        // better to disallow these redundant statements.
+        "no-useless-return": "warn",
+        // Require let or const instead of var.
+        "no-var": "warn",
+        // Disallow use of the void operator.
+        "no-void": "error",
+        // Allow TODOs and FIXMEs
+        "no-warning-comments": "off",
+        // The with statement is potentially problematic because it adds members of
+        // an object to the current scope, making it impossible to tell what a
+        // variable inside the block actually refers to.
+        "no-with": "error",
+        // Functions declared in object keys must conform to a certain style
+        // Capitalised functions are exempt as they are probably constructor functions
+        "object-shorthand": ["warn", "always", { ignoreConstructors: true }],
+        // Prevent combined variable declarations
+        "one-var": ["warn", "never"],
+        // Disallow assignment operator shorthand where possible.
+        "operator-assignment": ["warn", "never"],
+        "padding-line-between-statements": [
+          "warn",
+          { blankLine: "always", next: "*", prev: "multiline-block-like" },
+          { blankLine: "always", next: "multiline-block-like", prev: "*" },
+          { blankLine: "always", next: "*", prev: "multiline-const" },
+          { blankLine: "always", next: "multiline-const", prev: "*" },
+          { blankLine: "always", next: "*", prev: "multiline-let" },
+          { blankLine: "always", next: "multiline-let", prev: "*" },
+          { blankLine: "always", next: "*", prev: "multiline-var" },
+          { blankLine: "always", next: "multiline-var", prev: "*" }
+        ],
+        // Can cause issues when Prettier is enabled
+        "prefer-arrow-callback": "off",
+        // If a variable is never reassigned, using the const declaration is better.
+        "prefer-const": "warn",
+        // Make compatible with Unicorn's no-unreadable-array-destructuring
+        "prefer-destructuring": ["warn", { array: false, object: true }],
+        // Introduced in ES2016, the infix exponentiation operator ** is an
+        // alternative for the standard Math.pow function. Infix notation is
+        // considered to be more readable and thus more preferable than the function notation.
+        "prefer-exponentiation-operator": "warn",
+        // Allow regex to be left as-is
+        "prefer-named-capture-group": "off",
+        // This rule disallows calls to parseInt() or Number.parseInt() if called
+        // with two arguments: a string; and a radix option of 2 (binary), 8 (octal),
+        // or 16 (hexadecimal).
+        "prefer-numeric-literals": "warn",
+        // Not supported by Typescript yet
+        "prefer-object-has-own": "off",
+        // Prefer use of an object spread over Object.assign()
+        "prefer-object-spread": "warn",
+        // It is considered good practice to only pass instances of the built-in
+        // Error object to the reject() function for user-defined errors in Promises.
+        // Error objects automatically store a stack trace, which can be used to
+        // debug an error by determining where it came from. If a Promise is rejected
+        // with a non-Error value, it can be difficult to determine where the rejection occurred.
+        "prefer-promise-reject-errors": "error",
+        // Disallow use of the RegExp constructor in favor of regular expression literals.
+        "prefer-regex-literals": "error",
+        // Suggest using the rest parameters instead of `arguments`.
+        "prefer-rest-params": "error",
+        // Suggest using spread syntax instead of `.apply()`.
+        "prefer-spread": "error",
+        // Suggest using template literals instead of string concatenation.
+        "prefer-template": "warn",
+        // When using the parseInt() function it is common to omit the second argument,
+        // the radix, and let the function try to determine from the first argument
+        // what type of number it is. By default, parseInt() will autodetect decimal
+        // and hexadecimal (via 0x prefix). Prior to ECMAScript 5, parseInt() also
+        // autodetected octal literals, which caused problems because many developers
+        // assumed a leading 0 would be ignored.
+        "radix": "error",
+        // Disallow assignments that can lead to race conditions due to usage of await or yield.
+        "require-atomic-updates": "error",
+        // Disallow async functions which have no await expression.
+        "require-await": "error",
+        // Enforce the use of 'u' flag on RegExp.
+        "require-unicode-regexp": "error",
+        // Disallow generator functions that do not have yield.
+        "require-yield": "error",
+        // Sorting imports is handled by simple-import-sort
+        "sort-imports": "off",
+        "sort-keys": [
+          "error",
+          "asc",
+          {
+            allowLineSeparatedGroups: true,
+            caseSensitive: false,
+            natural: true
+          }
+        ],
+        // Not required as one-var rule is set to 'error' and so there will never be vars to sort.
+        "sort-vars": "off",
+        // All comments must have a space after the //
+        // This also allows /// reference comments
+        "spaced-comment": ["warn", "always", { markers: ["/"] }],
+        // Generally gets in the way as it's difficult to know when this may be required.
+        "strict": "off",
+        // Using description promotes easier debugging.
+        // ✅ var foo = Symbol("some description")
+        "symbol-description": "error",
+        // Require calls to isNaN() when checking for NaN.
+        "use-isnan": "error",
+        // Enforce comparing typeof expressions against valid strings.
+        "valid-typeof": ["error", { requireStringLiterals: true }],
+        // By default variable declarations are always moved (“hoisted”) invisibly
+        // to the top of their containing scope by the JavaScript interpreter.
+        // This rule forces the programmer to represent that behavior by manually
+        // moving the variable declaration to the top of its containing scope.
+        "vars-on-top": "error",
+        // ❌ if ('red' === color) {}
+        // ✅ if (color === 'red') {}
+        "yoda": "warn"
+      }
+    }
+  ];
+}
+
+// src/globs.ts
+var GLOB_EXCLUDE = [
+  "**/node_modules",
+  "**/dist",
+  "**/package-lock.json",
+  "**/yarn.lock",
+  "**/pnpm-lock.yaml",
+  "**/bun.lockb",
+  "**/output",
+  "**/coverage",
+  "**/temp",
+  "**/.vitepress/cache",
+  "**/.nuxt",
+  "**/.vercel",
+  "**/.changeset",
+  "**/.idea",
+  "**/.cache",
+  "**/.output",
+  "**/.vite-inspect",
+  "**/CHANGELOG*.md",
+  "**/*.min.*",
+  "**/LICENSE*",
+  "**/__snapshots__",
+  "**/auto-import?(s).d.ts",
+  "**/components.d.ts"
+];
+
+// src/configs/ignores.ts
+function ignores() {
+  return [
+    {
+      ignores: GLOB_EXCLUDE
+    }
+  ];
+}
+
+// src/configs/imports.ts
+var import_eslint_plugin_i = __toESM(require("eslint-plugin-i"), 1);
+var import_eslint_plugin_simple_import_sort = __toESM(require("eslint-plugin-simple-import-sort"), 1);
+function imports() {
+  return [
+    {
+      plugins: {
+        "import": import_eslint_plugin_i.default,
+        "simple-import-sort": import_eslint_plugin_simple_import_sort.default
+      },
+      rules: {
+        // Prefer inline types
+        "import/consistent-type-specifier-style": ["warn", "prefer-top-level"],
+        // Reports funny business with exports,
+        // like repeated exports of names or defaults
+        "import/export": "error",
+        // Stating exports at the end of the file can make refactoring a two-step process
+        "import/exports-last": "off",
+        // Same as import/exports-last
+        "import/group-exports": "off",
+        // There must be a line's space between imports and code
+        "import/newline-after-import": "warn",
+        // ❌ import {} from 'mod'
+        "import/no-empty-named-blocks": "warn",
+        // When there is only a single export from a module,
+        // this _would_ prefer using default export over named export, but it
+        // causes too many issues and it soon becomes tiresome with some tools
+        // requiring defaults and others forbidding them or requiring a certain
+        // named export.
+        "import/prefer-default-export": "off",
+        // Sort all the imports!
+        "simple-import-sort/exports": "warn",
+        "simple-import-sort/imports": "warn",
+        // The rest of the rules, off until required
+        "import/default": "off",
+        "import/dynamic-import-chunkname": "off",
+        "import/extensions": "off",
+        "import/first": "off",
+        "import/max-dependencies": "off",
+        "import/named": "off",
+        "import/namespace": "off",
+        "import/no-absolute-path": "off",
+        "import/no-amd": "off",
+        "import/no-anonymous-default-export": "off",
+        "import/no-commonjs": "off",
+        "import/no-cycle": "off",
+        "import/no-default-export": "off",
+        "import/no-deprecated": "off",
+        "import/no-duplicates": "off",
+        "import/no-dynamic-require": "off",
+        "import/no-extraneous-dependencies": "off",
+        "import/no-import-module-exports": "off",
+        "import/no-internal-modules": "off",
+        "import/no-mutable-exports": "off",
+        "import/no-named-as-default": "off",
+        "import/no-named-as-default-member": "off",
+        "import/no-named-default": "off",
+        "import/no-named-export": "off",
+        "import/no-namespace": "off",
+        "import/no-nodejs-modules": "off",
+        "import/no-relative-packages": "off",
+        "import/no-relative-parent-imports": "off",
+        "import/no-restricted-paths": "off",
+        "import/no-self-import": "off",
+        "import/no-unassigned-import": "off",
+        "import/no-unresolved": "off",
+        "import/no-unused-modules": "off",
+        "import/no-useless-path-segments": "off",
+        "import/no-webpack-loader-syntax": "off",
+        "import/order": "off",
+        "import/unambiguous": "off"
+      }
+    }
+  ];
+}
+
+// src/configs/jest.ts
+var import_eslint_plugin_jest = __toESM(require("eslint-plugin-jest"), 1);
+var import_globals2 = __toESM(require("globals"), 1);
+function jest() {
+  return [
+    {
+      files: ["**/__mocks__/**/*", "**/*.{spec,test}.{js,cjs,mjs,jsx,ts,tsx}"],
+      languageOptions: {
+        globals: import_globals2.default.jest
+      }
+    },
+    {
+      files: ["**/*.{spec,test}.{js,cjs,mjs,jsx,ts,tsx}"],
+      plugins: {
+        jest: import_eslint_plugin_jest.default
+      },
+      rules: {
+        // Consistent test function names
+        // test
+        // describe -> it
+        "jest/consistent-test-it": [
+          "error",
+          { fn: "test", withinDescribe: "it" }
+        ],
+        // Enforce assertion to be made in a test body
+        "jest/expect-expect": "error",
+        // Have as many expects as you like
+        "jest/max-expects": "off",
+        "jest/max-nested-describe": "off",
+        // Consistent expect methods
+        "jest/no-alias-methods": "error",
+        "jest/no-commented-out-tests": "error",
+        // Prevent calling expect conditionally
+        "jest/no-conditional-expect": "error",
+        "jest/no-conditional-in-test": "error",
+        "jest/no-deprecated-functions": "warn",
+        "jest/no-disabled-tests": "warn",
+        // Avoid using a callback in asynchronous tests and hooks
+        "jest/no-done-callback": "error",
+        // Do not allow multiple beforeEach, for example
+        "jest/no-duplicate-hooks": "error",
+        // Disallow using exports in files containing tests
+        "jest/no-export": "error",
+        "jest/no-focused-tests": "error",
+        "jest/no-hooks": "off",
+        "jest/no-identical-title": "error",
+        // Conditional logic in tests is usually an indication that a test is attempting to cover too much
+        "jest/no-if": "error",
+        // Disallow string interpolation inside snapshots
+        "jest/no-interpolation-in-snapshots": "error",
+        "jest/no-jasmine-globals": "warn",
+        "jest/no-large-snapshots": "off",
+        // Disallow manually importing from __mocks__
+        "jest/no-mocks-import": "error",
+        // No methods that need restricting
+        "jest/no-restricted-jest-methods": "off",
+        "jest/no-restricted-matchers": "off",
+        // No standalone expect in a describe block
+        "jest/no-standalone-expect": "error",
+        // Use .only and .skip over f and x
+        "jest/no-test-prefixes": "warn",
+        // Tests shouldn't return anything
+        "jest/no-test-return-statement": "error",
+        "jest/prefer-called-with": "off",
+        // https://github.com/jest-community/eslint-plugin-jest/blob/main/docs/rules/prefer-comparison-matcher.md
+        "jest/prefer-comparison-matcher": "warn",
+        "jest/prefer-each": "error",
+        // https://github.com/jest-community/eslint-plugin-jest/blob/main/docs/rules/prefer-equality-matcher.md
+        "jest/prefer-equality-matcher": "error",
+        "jest/prefer-expect-assertions": "off",
+        "jest/prefer-expect-resolves": "warn",
+        // Put lifecycle hooks in particular order
+        "jest/prefer-hooks-in-order": "error",
+        // beforeEach, beforeAll, afterEach etc. should be at top of test block
+        "jest/prefer-hooks-on-top": "error",
+        // Allow any case in test names
+        "jest/prefer-lowercase-title": "off",
+        // When working with mocks of functions that return promises, Jest provides
+        // some API sugar functions to reduce the amount of boilerplate you have to write.
+        "jest/prefer-mock-promise-shorthand": "warn",
+        "jest/prefer-snapshot-hint": "error",
+        // By overwriting a property with `jest.fn()` you have to manually restore
+        // the original implementation when cleaning up. When using jest.spyOn()
+        // Jest keeps track of changes, and they can be restored.
+        "jest/prefer-spy-on": "error",
+        "jest/prefer-strict-equal": "error",
+        "jest/prefer-to-be": "warn",
+        // expect(a.includes(b)).toBe(true) -> expect(a).toContain(b)
+        "jest/prefer-to-contain": "error",
+        // expect(files.length).toBe(1) -> expect(files).toHaveLength(1)
+        "jest/prefer-to-have-length": "error",
+        // When test cases are empty then it is better to mark them as test.todo
+        // as it will be highlighted in the summary output
+        "jest/prefer-todo": "error",
+        // Require setup and tear down code to be within lifecycle hooks
+        "jest/require-hook": "error",
+        // Requiring a message ensures that the intended error is thrown
+        "jest/require-to-throw-message": "error",
+        "jest/require-top-level-describe": "off",
+        "jest/unbound-method": "off",
+        "jest/valid-describe-callback": "error",
+        "jest/valid-expect": "error",
+        "jest/valid-expect-in-promise": "error",
+        // Titles are...
+        // - not empty
+        // - is a string
+        // - not prefixed with their block name
+        // - have no leading or trailing spaces
+        "jest/valid-title": "error"
+      }
+    },
+    {
+      files: ["**/*.{spec,test}.{ts,tsx}"],
+      rules: {
+        "jest/no-untyped-mock-factory": "warn"
+      }
+    }
+  ];
+}
+
+// src/configs/node.ts
+var import_eslint_plugin_n = __toESM(require("eslint-plugin-n"), 1);
+function node() {
+  return [
+    {
+      plugins: {
+        n: import_eslint_plugin_n.default
+      },
+      rules: {
+        // Enforces return statements in callbacks of array's methods
+        "n/callback-return": "error",
+        // require() should be called only in the top level of a module to make it
+        // easier to identify dependencies.
+        "n/global-require": "error",
+        // This rule expects that when you're using the callback pattern in Node.js
+        // you'll handle the error.
+        "n/handle-callback-err": "error",
+        // Disallow require calls to be mixed with regular variable declarations.
+        "n/no-mixed-requires": "error",
+        // ❌ var appHeader = new require('app-header')
+        // ✅ var AppHeader = require('app-header')
+        //    var appHeader = new AppHeader()
+        "n/no-new-require": "error",
+        // Disallow string concatenation when using __dirname and __filename.
+        // Use path.join() instead.
+        "n/no-path-concat": "error",
+        // Allow env vars in code
+        "n/no-process-env": "off",
+        // Handled by Unicorn
+        "n/no-process-exit": "off",
+        // No modules are restricted
+        "n/no-restricted-require": "off",
+        // I like synchronous functions
+        "n/no-sync": "off",
+        // Not sure I need this...?
+        // TODO check others' configs to see how they use this.
+        "n/shebang": "off",
+        // Turn these off until I work out if I need them
+        "n/exports-style": "off",
+        "n/file-extension-in-import": "off",
+        "n/no-callback-literal": "off",
+        "n/no-deprecated-api": "off",
+        "n/no-exports-assign": "off",
+        "n/no-extraneous-import": "off",
+        "n/no-extraneous-require": "off",
+        "n/no-missing-import": "off",
+        "n/no-missing-require": "off",
+        "n/no-restricted-import": "off",
+        "n/no-unpublished-bin": "off",
+        "n/no-unpublished-import": "off",
+        "n/no-unpublished-require": "off",
+        "n/no-unsupported-features/es-builtins": "off",
+        "n/no-unsupported-features/es-syntax": "off",
+        "n/no-unsupported-features/node-builtins": "off",
+        "n/prefer-global/buffer": "off",
+        "n/prefer-global/console": "off",
+        "n/prefer-global/process": "off",
+        "n/prefer-global/text-decoder": "off",
+        "n/prefer-global/text-encoder": "off",
+        "n/prefer-global/url": "off",
+        "n/prefer-global/url-search-params": "off",
+        "n/prefer-promises/dns": "off",
+        "n/prefer-promises/fs": "off",
+        "n/process-exit-as-throw": "off"
+      }
+    }
+  ];
+}
+
+// src/configs/prettier.ts
+var import_eslint_plugin_prettier = __toESM(require("eslint-plugin-prettier"), 1);
+function prettier() {
+  return [
+    {
+      plugins: {
+        prettier: import_eslint_plugin_prettier.default
+      },
+      rules: {
+        "prettier/prettier": "warn"
+      }
+    }
+  ];
+}
+
+// src/configs/react.ts
+var import_eslint_plugin_jsx_a11y = __toESM(require("eslint-plugin-jsx-a11y"), 1);
+var import_eslint_plugin_react = __toESM(require("eslint-plugin-react"), 1);
+var import_eslint_plugin_react_hooks = __toESM(require("eslint-plugin-react-hooks"), 1);
+var import_globals3 = __toESM(require("globals"), 1);
+function react() {
+  return [
+    {
+      files: ["**/*.{jsx,tsx}"],
+      languageOptions: {
+        globals: import_globals3.default.browser,
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          }
+        }
+      },
+      plugins: {
+        "jsx-a11y": import_eslint_plugin_jsx_a11y.default,
+        "react": import_eslint_plugin_react.default,
+        "react-hooks": import_eslint_plugin_react_hooks.default
+      },
+      rules: {
+        "jsx-a11y/alt-text": "error",
+        "jsx-a11y/anchor-ambiguous-text": "error",
+        "jsx-a11y/anchor-has-content": "error",
+        "jsx-a11y/anchor-is-valid": "error",
+        "jsx-a11y/aria-activedescendant-has-tabindex": "error",
+        "jsx-a11y/aria-props": "error",
+        "jsx-a11y/aria-proptypes": "error",
+        "jsx-a11y/aria-role": "error",
+        "jsx-a11y/aria-unsupported-elements": "error",
+        "jsx-a11y/autocomplete-valid": "error",
+        "jsx-a11y/click-events-have-key-events": "error",
+        "jsx-a11y/control-has-associated-label": [
+          "off",
+          {
+            ignoreElements: [
+              "audio",
+              "canvas",
+              "embed",
+              "input",
+              "textarea",
+              "tr",
+              "video"
+            ],
+            ignoreRoles: [
+              "grid",
+              "listbox",
+              "menu",
+              "menubar",
+              "radiogroup",
+              "row",
+              "tablist",
+              "toolbar",
+              "tree",
+              "treegrid"
+            ],
+            includeRoles: ["alert", "dialog"]
+          }
+        ],
+        "jsx-a11y/heading-has-content": "error",
+        "jsx-a11y/html-has-lang": "error",
+        "jsx-a11y/iframe-has-title": "error",
+        "jsx-a11y/img-redundant-alt": "error",
+        "jsx-a11y/interactive-supports-focus": [
+          "error",
+          {
+            tabbable: [
+              "button",
+              "checkbox",
+              "link",
+              "searchbox",
+              "spinbutton",
+              "switch",
+              "textbox"
+            ]
+          }
+        ],
+        "jsx-a11y/label-has-associated-control": "error",
+        "jsx-a11y/label-has-for": "off",
+        "jsx-a11y/lang": "error",
+        "jsx-a11y/media-has-caption": "error",
+        "jsx-a11y/mouse-events-have-key-events": "error",
+        "jsx-a11y/no-access-key": "error",
+        "jsx-a11y/no-aria-hidden-on-focusable": "error",
+        "jsx-a11y/no-autofocus": "error",
+        "jsx-a11y/no-distracting-elements": "error",
+        "jsx-a11y/no-interactive-element-to-noninteractive-role": [
+          "error",
+          {
+            canvas: ["img"],
+            tr: ["none", "presentation"]
+          }
+        ],
+        "jsx-a11y/no-noninteractive-element-interactions": [
+          "error",
+          {
+            alert: ["onKeyUp", "onKeyDown", "onKeyPress"],
+            body: ["onError", "onLoad"],
+            dialog: ["onKeyUp", "onKeyDown", "onKeyPress"],
+            handlers: [
+              "onClick",
+              "onError",
+              "onLoad",
+              "onMouseDown",
+              "onMouseUp",
+              "onKeyPress",
+              "onKeyDown",
+              "onKeyUp"
+            ],
+            iframe: ["onError", "onLoad"],
+            img: ["onError", "onLoad"]
+          }
+        ],
+        "jsx-a11y/no-noninteractive-element-to-interactive-role": [
+          "error",
+          {
+            fieldset: ["radiogroup", "presentation"],
+            li: ["menuitem", "option", "row", "tab", "treeitem"],
+            ol: [
+              "listbox",
+              "menu",
+              "menubar",
+              "radiogroup",
+              "tablist",
+              "tree",
+              "treegrid"
+            ],
+            table: ["grid"],
+            td: ["gridcell"],
+            ul: [
+              "listbox",
+              "menu",
+              "menubar",
+              "radiogroup",
+              "tablist",
+              "tree",
+              "treegrid"
+            ]
+          }
+        ],
+        "jsx-a11y/no-noninteractive-tabindex": [
+          "error",
+          {
+            allowExpressionValues: true,
+            roles: ["tabpanel"],
+            tags: []
+          }
+        ],
+        "jsx-a11y/no-redundant-roles": "error",
+        "jsx-a11y/no-static-element-interactions": [
+          "error",
+          {
+            allowExpressionValues: true,
+            handlers: [
+              "onClick",
+              "onMouseDown",
+              "onMouseUp",
+              "onKeyPress",
+              "onKeyDown",
+              "onKeyUp"
+            ]
+          }
+        ],
+        "jsx-a11y/prefer-tag-over-role": "error",
+        "jsx-a11y/role-has-required-aria-props": "error",
+        "jsx-a11y/role-supports-aria-props": "error",
+        "jsx-a11y/scope": "error",
+        "jsx-a11y/tabindex-no-positive": "error",
+        /**
+         * Off for Prettier
+         * https://github.com/prettier/eslint-config-prettier/blob/main/index.js
+         */
+        "react/jsx-child-element-spacing": "off",
+        "react/jsx-closing-bracket-location": "off",
+        "react/jsx-closing-tag-location": "off",
+        "react/jsx-curly-newline": "off",
+        "react/jsx-curly-spacing": "off",
+        "react/jsx-equals-spacing": "off",
+        "react/jsx-first-prop-new-line": "off",
+        "react/jsx-indent": "off",
+        "react/jsx-indent-props": "off",
+        "react/jsx-max-props-per-line": "off",
+        "react/jsx-newline": "off",
+        "react/jsx-one-expression-per-line": "off",
+        "react/jsx-props-no-multi-spaces": "off",
+        "react/jsx-tag-spacing": "off",
+        "react/jsx-wrap-multilines": "off",
+        // It is common to use these lifecycle methods without using "this".
+        "class-methods-use-this": [
+          "error",
+          {
+            exceptMethods: [
+              "render",
+              "getInitialState",
+              "getDefaultProps",
+              "getChildContext",
+              "componentWillMount",
+              "componentDidMount",
+              "componentWillReceiveProps",
+              "shouldComponentUpdate",
+              "componentWillUpdate",
+              "componentDidUpdate",
+              "componentWillUnmount",
+              "componentDidCatch"
+            ]
+          }
+        ],
+        "react/boolean-prop-naming": "error",
+        "react/button-has-type": "error",
+        "react/default-props-match-prop-types": "error",
+        "react/destructuring-assignment": "error",
+        "react/display-name": "error",
+        // Components can use any props.
+        "react/forbid-component-props": "off",
+        "react/forbid-dom-props": "error",
+        "react/forbid-elements": "error",
+        "react/forbid-foreign-prop-types": "error",
+        "react/forbid-prop-types": "error",
+        // Functional components can use any style.
+        "react/function-component-definition": "off",
+        "react/hook-use-state": "error",
+        "react/iframe-missing-sandbox": "error",
+        // ❌ <Hello personal={true} />
+        // ✅ <Hello personal />
+        "react/jsx-boolean-value": "warn",
+        // disallow unnecessary curly braces in JSX props and/or children.
+        "react/jsx-curly-brace-presence": "warn",
+        // Allow JSX in any files
+        "react/jsx-filename-extension": "off",
+        // Enforce shorthand for React fragments.
+        "react/jsx-fragments": "warn",
+        "react/jsx-handler-names": "error",
+        "react/jsx-key": "error",
+        // Unlimited JSX nesting.
+        "react/jsx-max-depth": "off",
+        // I haven't found any modern benchmarks for disallowing inline arrow
+        // functions, and quite frankly it feels like this "optimisation" is just
+        // people repeating sentiments from old blog posts.
+        "react/jsx-no-bind": [
+          "error",
+          {
+            allowArrowFunctions: true
+          }
+        ],
+        "react/jsx-no-comment-textnodes": "error",
+        "react/jsx-no-constructed-context-values": "error",
+        "react/jsx-no-duplicate-props": "error",
+        // In React, you might end up rendering unexpected values like 0 or NaN.
+        // https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/jsx-no-leaked-render.md
+        "react/jsx-no-leaked-render": "warn",
+        // ✅ <div>test</div>
+        // ✅ <div>{'test'}</div>
+        "react/jsx-no-literals": "off",
+        "react/jsx-no-script-url": "error",
+        "react/jsx-no-target-blank": "error",
+        "react/jsx-no-undef": "error",
+        "react/jsx-no-useless-fragment": "warn",
+        "react/jsx-pascal-case": "error",
+        // Allow prop spreading, you know the dangers!
+        "react/jsx-props-no-spreading": "off",
+        // Alphabetical sorting of props
+        // TODO there's other options in this one that could be useful.
+        "react/jsx-sort-props": ["warn", { reservedFirst: true }],
+        "react/jsx-uses-react": "error",
+        "react/jsx-uses-vars": "error",
+        "react/no-access-state-in-setstate": "error",
+        "react/no-adjacent-inline-elements": "error",
+        "react/no-array-index-key": "error",
+        "react/no-arrow-function-lifecycle": "error",
+        "react/no-children-prop": "error",
+        "react/no-danger": "error",
+        "react/no-danger-with-children": "error",
+        "react/no-deprecated": "error",
+        "react/no-did-mount-set-state": "error",
+        "react/no-did-update-set-state": "error",
+        "react/no-direct-mutation-state": "error",
+        "react/no-find-dom-node": "error",
+        "react/no-invalid-html-attribute": "error",
+        "react/no-is-mounted": "error",
+        // Allow as many components per file as you like
+        "react/no-multi-comp": "off",
+        "react/no-namespace": "error",
+        // Prevent potential unnecessary rerenders, and performance regressions
+        "react/no-object-type-as-default-prop": "error",
+        "react/no-redundant-should-component-update": "error",
+        "react/no-render-return-value": "error",
+        "react/no-set-state": "error",
+        "react/no-string-refs": "error",
+        "react/no-this-in-sfc": "error",
+        "react/no-typos": "error",
+        "react/no-unescaped-entities": "error",
+        // ❌ <div class="hello">Hello World</div>
+        // ✅ <div className="hello">Hello World</div>
+        "react/no-unknown-property": "warn",
+        "react/no-unsafe": "error",
+        "react/no-unstable-nested-components": "error",
+        "react/no-unused-class-component-methods": "error",
+        "react/no-unused-prop-types": "error",
+        "react/no-unused-state": "error",
+        "react/no-will-update-set-state": "error",
+        "react/prefer-es6-class": "error",
+        "react/prefer-exact-props": "error",
+        "react/prefer-read-only-props": "error",
+        "react/prefer-stateless-function": "error",
+        "react/prop-types": "off",
+        // React is no longer required to be imported to use JSX
+        "react/react-in-jsx-scope": "off",
+        // Enforce a defaultProps definition for every prop that is not a required prop
+        // TODO turn this back on and create a react-typescript rule set for disabling thing like this.
+        "react/require-default-props": "off",
+        // Do not enforce React components to have a shouldComponentUpdate method.
+        "react/require-optimization": "off",
+        "react/require-render-return": "error",
+        // Prevent extra closing tags for components without children.
+        "react/self-closing-comp": "warn",
+        "react/sort-comp": "error",
+        "react/sort-default-props": "error",
+        "react/sort-prop-types": "error",
+        "react/state-in-constructor": "error",
+        "react/static-property-placement": "error",
+        "react/style-prop-object": "error",
+        "react/void-dom-elements-no-children": "error",
+        // Checks effect dependencies
+        "react-hooks/exhaustive-deps": "warn",
+        // Checks rules of Hooks
+        "react-hooks/rules-of-hooks": "error"
+      },
+      settings: {
+        react: {
+          version: "detect"
+        }
+      }
+    }
+  ];
+}
+
+// src/configs/switch-case.ts
+var import_eslint_plugin_switch_case = __toESM(require("eslint-plugin-switch-case"), 1);
+function switchCase() {
+  return [
+    {
+      plugins: {
+        "switch-case": import_eslint_plugin_switch_case.default
+      },
+      rules: {
+        // Switches must have new lines between case groups
+        "switch-case/newline-between-switch-case": [
+          "warn",
+          "always",
+          { fallthrough: "never" }
+        ],
+        // It can be useful for switch cases to have their own scope.
+        "switch-case/no-case-curly": "off"
+      }
+    }
+  ];
+}
+
+// src/configs/typescript.ts
+var import_eslint_plugin = __toESM(require("@typescript-eslint/eslint-plugin"), 1);
+var import_parser2 = __toESM(require("@typescript-eslint/parser"), 1);
+function typescript() {
+  return [
+    {
+      files: ["**/*.{ts,tsx,astro}"],
+      languageOptions: {
+        // @ts-expect-error -- does not confirm to type
+        parser: import_parser2.default
+      },
+      plugins: {
+        // @ts-expect-error -- does not confirm to type
+        "@typescript-eslint": import_eslint_plugin.default
+      },
+      rules: {
+        /**
+         * Recommended to turn off these eslint built-in rules
+         * https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/src/configs/eslint-recommended.ts
+         */
+        // ts(2335) & ts(2377)
+        "constructor-super": "off",
+        // ts(2378)
+        "getter-return": "off",
+        // ts(2588)
+        "no-const-assign": "off",
+        // ts(2300)
+        "no-dupe-args": "off",
+        // ts(2393) & ts(2300)
+        "no-dupe-class-members": "off",
+        // ts(1117)
+        "no-dupe-keys": "off",
+        // ts(2539)
+        "no-func-assign": "off",
+        // ts(2539) & ts(2540)
+        "no-import-assign": "off",
+        // ts(2588)
+        "no-new-symbol": "off",
+        // ts(2349)
+        "no-obj-calls": "off",
+        // ts(2408)
+        "no-setter-return": "off",
+        // ts(2376)
+        "no-this-before-super": "off",
+        // ts(2304)
+        "no-undef": "off",
+        // ts(7027)
+        "no-unreachable": "off",
+        // ts(2365) & ts(2360) & ts(2358)
+        "no-unsafe-negation": "off",
+        // ts transpiles let/const to var, so no need for vars any more
+        "no-var": "error",
+        // ts provides better types with const
+        "prefer-const": "warn",
+        // ts provides better types with rest args over arguments
+        "prefer-rest-params": "error",
+        // ts transpiles spread to apply, so no need for manual apply
+        "prefer-spread": "error",
+        // ts(2367)
+        "valid-typeof": "off",
+        /**
+         * TS Recommended
+         * https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/src/configs/recommended.ts
+         */
+        "@typescript-eslint/adjacent-overload-signatures": "error",
+        "@typescript-eslint/ban-ts-comment": "error",
+        "@typescript-eslint/ban-types": "error",
+        "@typescript-eslint/explicit-module-boundary-types": "warn",
+        "@typescript-eslint/no-array-constructor": "error",
+        "@typescript-eslint/no-empty-function": "error",
+        "@typescript-eslint/no-empty-interface": "error",
+        "@typescript-eslint/no-explicit-any": "warn",
+        "@typescript-eslint/no-inferrable-types": "error",
+        "@typescript-eslint/no-misused-new": "error",
+        "@typescript-eslint/no-namespace": "error",
+        "@typescript-eslint/no-non-null-asserted-optional-chain": "error",
+        "@typescript-eslint/no-non-null-assertion": "warn",
+        "@typescript-eslint/no-this-alias": "error",
+        "@typescript-eslint/no-var-requires": "error",
+        "@typescript-eslint/prefer-as-const": "error",
+        "@typescript-eslint/prefer-namespace-keyword": "error",
+        "@typescript-eslint/triple-slash-reference": "error",
+        "no-array-constructor": "off",
+        "no-empty-function": "off",
+        "no-extra-semi": "off",
+        /**
+         * These are for type checking which I don't use eslint for
+         */
+        "@typescript-eslint/await-thenable": "off",
+        "@typescript-eslint/consistent-type-exports": "off",
+        "@typescript-eslint/dot-notation": "off",
+        "@typescript-eslint/naming-convention": "off",
+        "@typescript-eslint/no-base-to-string": "off",
+        "@typescript-eslint/no-confusing-void-expression": "off",
+        "@typescript-eslint/no-duplicate-type-constituents": "off",
+        "@typescript-eslint/no-floating-promises": "off",
+        "@typescript-eslint/no-for-in-array": "off",
+        "@typescript-eslint/no-implied-eval": "off",
+        "@typescript-eslint/no-meaningless-void-operator": "off",
+        "@typescript-eslint/no-misused-promises": "off",
+        "@typescript-eslint/no-mixed-enums": "off",
+        "@typescript-eslint/no-redundant-type-constituents": "off",
+        "@typescript-eslint/no-throw-literal": "off",
+        "@typescript-eslint/no-unnecessary-boolean-literal-compare": "off",
+        "@typescript-eslint/no-unnecessary-condition": "off",
+        "@typescript-eslint/no-unnecessary-qualifier": "off",
+        "@typescript-eslint/no-unnecessary-type-arguments": "off",
+        "@typescript-eslint/no-unnecessary-type-assertion": "off",
+        "@typescript-eslint/no-unsafe-argument": "off",
+        "@typescript-eslint/no-unsafe-assignment": "off",
+        "@typescript-eslint/no-unsafe-call": "off",
+        "@typescript-eslint/no-unsafe-enum-comparison": "off",
+        "@typescript-eslint/no-unsafe-member-access": "off",
+        "@typescript-eslint/no-unsafe-return": "off",
+        "@typescript-eslint/non-nullable-type-assertion-style": "off",
+        "@typescript-eslint/prefer-includes": "off",
+        "@typescript-eslint/prefer-nullish-coalescing": "off",
+        "@typescript-eslint/prefer-optional-chain": "off",
+        "@typescript-eslint/prefer-readonly": "off",
+        "@typescript-eslint/prefer-readonly-parameter-types": "off",
+        "@typescript-eslint/prefer-reduce-type-parameter": "off",
+        "@typescript-eslint/prefer-regexp-exec": "off",
+        "@typescript-eslint/prefer-return-this-type": "off",
+        "@typescript-eslint/prefer-string-starts-ends-with": "off",
+        "@typescript-eslint/promise-function-async": "off",
+        "@typescript-eslint/require-array-sort-compare": "off",
+        "@typescript-eslint/require-await": "off",
+        "@typescript-eslint/restrict-plus-operands": "off",
+        "@typescript-eslint/restrict-template-expressions": "off",
+        "@typescript-eslint/return-await": "off",
+        "@typescript-eslint/strict-boolean-expressions": "off",
+        "@typescript-eslint/switch-exhaustiveness-check": "off",
+        "@typescript-eslint/unbound-method": "off",
+        /**
+         * Off for Prettier
+         * https://github.com/prettier/eslint-config-prettier/blob/main/index.js
+         */
+        "@typescript-eslint/block-spacing": "off",
+        "@typescript-eslint/brace-style": "off",
+        "@typescript-eslint/comma-dangle": "off",
+        "@typescript-eslint/comma-spacing": "off",
+        "@typescript-eslint/func-call-spacing": "off",
+        "@typescript-eslint/indent": "off",
+        "@typescript-eslint/key-spacing": "off",
+        "@typescript-eslint/keyword-spacing": "off",
+        "@typescript-eslint/lines-around-comment": "off",
+        "@typescript-eslint/member-delimiter-style": "off",
+        "@typescript-eslint/no-extra-parens": "off",
+        "@typescript-eslint/no-extra-semi": "off",
+        "@typescript-eslint/object-curly-spacing": "off",
+        "@typescript-eslint/quotes": "off",
+        "@typescript-eslint/semi": "off",
+        "@typescript-eslint/space-before-blocks": "off",
+        "@typescript-eslint/space-before-function-paren": "off",
+        "@typescript-eslint/space-infix-ops": "off",
+        "@typescript-eslint/type-annotation-spacing": "off",
+        /**
+         * Superseded by TS rules below
+         */
+        "default-param-last": "off",
+        "lines-between-class-members": "off",
+        "no-duplicate-imports": "off",
+        "no-invalid-this": "off",
+        "no-loop-func": "off",
+        "no-loss-of-precision": "off",
+        "no-redeclare": "off",
+        "no-restricted-imports": "off",
+        "no-shadow": "off",
+        "no-unused-expressions": "off",
+        "no-unused-vars": "off",
+        "no-use-before-define": "off",
+        "no-useless-constructor": "off",
+        "padding-line-between-statements": "off",
+        /**
+         * The rest
+         */
+        // Requires using T[] over Array<T> for arrays
+        "@typescript-eslint/array-type": ["warn", { default: "array" }],
+        // Bans // tslint:<rule-flag> comments from being used
+        "@typescript-eslint/ban-tslint-comment": "warn",
+        // Ensures that literals on classes are exposed in a consistent style
+        "@typescript-eslint/class-literal-property-style": "warn",
+        // https://typescript-eslint.io/rules/consistent-generic-constructors/
+        "@typescript-eslint/consistent-generic-constructors": "warn",
+        // Enforce the use of the record type
+        "@typescript-eslint/consistent-indexed-object-style": "warn",
+        // Enforces consistent usage of type assertions
+        "@typescript-eslint/consistent-type-assertions": "error",
+        // Enforce using types for object type definitions
+        "@typescript-eslint/consistent-type-definitions": ["warn", "type"],
+        // Enforces consistent usage of type imports
+        "@typescript-eslint/consistent-type-imports": [
+          "warn",
+          {
+            fixStyle: "separate-type-imports",
+            prefer: "type-imports"
+          }
+        ],
+        // Enforce default parameters to be last
+        "@typescript-eslint/default-param-last": ["error"],
+        // Don't mind if functions do not have return types.
+        "@typescript-eslint/explicit-function-return-type": "off",
+        // Require explicit accessibility modifiers ("public") on class properties and methods
+        "@typescript-eslint/explicit-member-accessibility": "warn",
+        // Initialise vairables however you like
+        "@typescript-eslint/init-declarations": "off",
+        "@typescript-eslint/lines-between-class-members": [
+          "warn",
+          "always",
+          { exceptAfterOverload: true }
+        ],
+        // Require a consistent member declaration order
+        "@typescript-eslint/member-ordering": "error",
+        // ❌
+        // interface T1 {
+        //  func(arg: string): number;
+        // }
+        // ✅
+        // interface T1 {
+        //  func: (arg: string) => number;
+        // }
+        "@typescript-eslint/method-signature-style": "warn",
+        // Disallow non-null assertion in locations that may be confusing
+        "@typescript-eslint/no-confusing-non-null-assertion": "warn",
+        // Disallow duplicate class members
+        "@typescript-eslint/no-dupe-class-members": "error",
+        // ❌
+        // enum E {
+        //   A = 0,
+        //   B = 0,
+        // }
+        // ✅
+        // enum E {
+        //   A = 0,
+        //   B = 1,
+        // }
+        "@typescript-eslint/no-duplicate-enum-values": "error",
+        // Deleting missing key/value is safe
+        "@typescript-eslint/no-dynamic-delete": "off",
+        // ❌ const bar = foo!!!.bar
+        // ✅ const bar = foo!.bar
+        "@typescript-eslint/no-extra-non-null-assertion": "warn",
+        // Warns when a class is accidentally used as a namespace
+        "@typescript-eslint/no-extraneous-class": "error",
+        "@typescript-eslint/no-import-type-side-effects": "warn",
+        // Disallow this keywords outside of classes or class-like objects
+        "@typescript-eslint/no-invalid-this": "error",
+        // Disallows usage of void type outside of generic or return types
+        "@typescript-eslint/no-invalid-void-type": "error",
+        // Disallow function declarations that contain unsafe references inside loop statements
+        "@typescript-eslint/no-loop-func": "error",
+        // Disallow literal numbers that lose precision
+        "@typescript-eslint/no-loss-of-precision": ["error"],
+        // Disallowing magic numbers causes all sorts of problems
+        "@typescript-eslint/no-magic-numbers": "off",
+        "@typescript-eslint/no-non-null-asserted-nullish-coalescing": "error",
+        "@typescript-eslint/no-redeclare": "error",
+        "@typescript-eslint/no-require-imports": "error",
+        "@typescript-eslint/no-restricted-imports": "off",
+        // Disallow variable declarations from shadowing variables declared in the outer scope
+        "@typescript-eslint/no-shadow": ["error"],
+        // Aliasing can be useful
+        "@typescript-eslint/no-type-alias": "off",
+        // Disallows unnecessary constraints on generic types
+        "@typescript-eslint/no-unnecessary-type-constraint": "warn",
+        "@typescript-eslint/no-unsafe-declaration-merging": "error",
+        // Aims to eliminate unused expressions which have no effect on the state of the program.
+        "@typescript-eslint/no-unused-expressions": ["error"],
+        // Variables must be used unless name ends with "ignored"
+        "@typescript-eslint/no-unused-vars": [
+          "error",
+          {
+            // Useful for extracting args from props and ignoring them:
+            // { style: _style, ...restProps }
+            argsIgnorePattern: "^_",
+            varsIgnorePattern: "[iI]gnored"
+          }
+        ],
+        "@typescript-eslint/no-use-before-define": "error",
+        "@typescript-eslint/no-useless-constructor": "error",
+        // Disallow empty exports that don't change anything in a module file
+        "@typescript-eslint/no-useless-empty-export": "warn",
+        "@typescript-eslint/padding-line-between-statements": [
+          "error",
+          { blankLine: "always", next: "*", prev: "multiline-block-like" },
+          { blankLine: "always", next: "multiline-block-like", prev: "*" },
+          { blankLine: "always", next: "*", prev: "multiline-const" },
+          { blankLine: "always", next: "multiline-const", prev: "*" },
+          { blankLine: "always", next: "*", prev: "multiline-let" },
+          { blankLine: "always", next: "multiline-let", prev: "*" },
+          { blankLine: "always", next: "*", prev: "multiline-var" },
+          { blankLine: "always", next: "multiline-var", prev: "*" }
+        ],
+        // Not sure I need this, how many classes do I write?!
+        // https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/parameter-properties.md
+        "@typescript-eslint/parameter-properties": "off",
+        "@typescript-eslint/prefer-enum-initializers": "error",
+        // Unicorn does this better by providing a fixer
+        "@typescript-eslint/prefer-for-of": "off",
+        "@typescript-eslint/prefer-function-type": "warn",
+        // Require that all enum members be literal values to prevent unintended enum member name shadow issues.
+        "@typescript-eslint/prefer-literal-enum-member": "error",
+        // Recommends using // @ts-expect-error over // @ts-ignore
+        "@typescript-eslint/prefer-ts-expect-error": "warn",
+        "@typescript-eslint/sort-type-constituents": "warn",
+        // Not sure if required yet. Might be too strict and produce noist code.
+        "@typescript-eslint/typedef": "off",
+        "@typescript-eslint/unified-signatures": "error"
+      }
+    }
+  ];
+}
+
+// src/configs/unicorn.ts
+var import_eslint_plugin_unicorn = __toESM(require("eslint-plugin-unicorn"), 1);
+function unicorn() {
+  return [
+    {
+      plugins: {
+        unicorn: import_eslint_plugin_unicorn.default
+      },
+      rules: {
+        // This rule is superseded by the unicorn version below
+        "no-nested-ternary": "off",
+        // Improve regexes by making them shorter, consistent, and safer
+        "unicorn/better-regex": "warn",
+        // Catch error argument name should be "error"
+        "unicorn/catch-error-name": "error",
+        // Use destructured variables over properties
+        "unicorn/consistent-destructuring": "warn",
+        // Move function definitions to the highest possible scope
+        "unicorn/consistent-function-scoping": [
+          "error",
+          { checkArrowFunctions: false }
+        ],
+        // Custom Error classes must conform to standard
+        "unicorn/custom-error-definition": "warn",
+        // Enforce no spaces between braces
+        "unicorn/empty-brace-spaces": "warn",
+        // Enforces a message value to be passed in when throwing built-in Error
+        "unicorn/error-message": "error",
+        // Enforces defining escape sequence values with uppercase characters rather
+        // than lowercase ones. This promotes readability by making the escaped
+        // value more distinguishable from the identifier.
+        "unicorn/escape-case": "warn",
+        // Allows todo/fixme to be given expiry conditions and will error when met
+        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/master/docs/rules/expiring-todo-comments.md
+        "unicorn/expiring-todo-comments": "error",
+        // Don't care how if(blah.length) is checked
+        "unicorn/explicit-length-check": "off",
+        // Kebab-case only
+        "unicorn/filename-case": "error",
+        // Enforces requiring index file with . instead of ./, ./index or ./index.js
+        // Turned off for imports where this can mess with ESM.
+        "unicorn/import-index": ["warn", { ignoreImports: true }],
+        // Not sure if this is useful yet
+        "unicorn/import-style": "off",
+        // Enforce the use of new for all builtins, except String, Number and Boolean
+        "unicorn/new-for-builtins": "warn",
+        // Enforce specifying rules to disable in eslint-disable comments
+        "unicorn/no-abusive-eslint-disable": "error",
+        // Allow passing a function reference directly to iterator methods
+        "unicorn/no-array-callback-reference": "off",
+        // Prefer for…of over Array#forEach(…)
+        "unicorn/no-array-for-each": "warn",
+        // Disallow using the this argument in array methods
+        "unicorn/no-array-method-this-argument": "warn",
+        // Enforce combining multiple Array#push() into one call
+        "unicorn/no-array-push-push": "warn",
+        // for..of is much easier to read
+        "unicorn/no-array-reduce": "error",
+        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-await-expression-member.md
+        "unicorn/no-await-expression-member": "warn",
+        // Do not use leading/trailing space between console.log parameters
+        "unicorn/no-console-spaces": "warn",
+        // Do not use document.cookie directly
+        "unicorn/no-document-cookie": "error",
+        // Disallow empty files
+        // TODO turn back on when it can exclude files. As this warns about the
+        // auto-generated next-env.d.ts file.
+        "unicorn/no-empty-file": "off",
+        // Do not use a for loop that can be replaced with a for-of loop
+        "unicorn/no-for-loop": "warn",
+        // Enforce the use of Unicode escapes instead of hexadecimal escapes
+        "unicorn/no-hex-escape": "warn",
+        // Require Array.isArray() instead of instanceof Array
+        "unicorn/no-instanceof-array": "warn",
+        // The removeEventListener function must be called with a reference to the same
+        // function that was passed to addEventListener.
+        "unicorn/no-invalid-remove-event-listener": "error",
+        // Disallow identifiers (var names) starting with new.
+        // Do not check properties and allow "class" so that "className" is allowed.
+        "unicorn/no-keyword-prefix": [
+          "error",
+          { checkProperties: false, disallowedPrefixes: ["new"] }
+        ],
+        // This rule adds onto the built-in no-lonely-if rule, which only forbids if
+        // statements in else, not in if.
+        "unicorn/no-lonely-if": "warn",
+        // This is an improved version of the no-negated-condition ESLint rule that
+        // makes it automatically fixable. ESLint did not want to make it fixable.
+        "unicorn/no-negated-condition": "warn",
+        // Improved version of the no-nested-ternary ESLint rule, which allows cases
+        // where the nested ternary is only one level and wrapped in parens.
+        "unicorn/no-nested-ternary": "warn",
+        // Disallow new Array()
+        "unicorn/no-new-array": "warn",
+        // Enforce the use of Buffer.from() and Buffer.alloc() instead of the
+        // deprecated new Buffer()
+        "unicorn/no-new-buffer": "warn",
+        // Allow the use of the null literal, it useful for React components and empty JSON values.
+        "unicorn/no-null": "off",
+        // Disallow the use of objects as default parameters
+        "unicorn/no-object-as-default-parameter": "error",
+        // Extension to ESLint's no-process-exit rule, that allows process.exit() to
+        // be called in files that start with a hashbang → #!/usr/bin/env node
+        "unicorn/no-process-exit": "error",
+        // A class with only static members could just be an object instead
+        "unicorn/no-static-only-class": "error",
+        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-thenable.md
+        "unicorn/no-thenable": "error",
+        // Disallow assigning this to a variable
+        "unicorn/no-this-assignment": "error",
+        // Checking if a value is undefined by using typeof value === 'undefined' is needlessly verbose.
+        "unicorn/no-typeof-undefined": "warn",
+        // Disallow awaiting non-promise values
+        "unicorn/no-unnecessary-await": "warn",
+        // Disallow [,, foo], use ignored vars instead
+        "unicorn/no-unreadable-array-destructuring": "error",
+        // IIFE with parenthesized arrow function body is considered unreadable
+        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unreadable-iife.md
+        "unicorn/no-unreadable-iife": "error",
+        // Uses safe-regex to disallow potentially catastrophic exponential-time regular expressions.
+        // Turned off for now, even Sindre doesn't like it: https://github.com/sindresorhus/eslint-plugin-unicorn/issues/153
+        "unicorn/no-unsafe-regex": "off",
+        // Recommended config turned this off so I will too
+        "unicorn/no-unused-properties": "off",
+        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-fallback-in-spread.md
+        "unicorn/no-useless-fallback-in-spread": "warn",
+        // Disallow useless array length check
+        "unicorn/no-useless-length-check": "warn",
+        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-promise-resolve-reject.md
+        "unicorn/no-useless-promise-resolve-reject": "warn",
+        // Disallow useless spread
+        "unicorn/no-useless-spread": "warn",
+        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-switch-case.md
+        "unicorn/no-useless-switch-case": "error",
+        // ❌ let foo = undefined;
+        // ✅ let foo;
+        "unicorn/no-useless-undefined": "warn",
+        // Disallow number literals with zero fractions or dangling dots
+        "unicorn/no-zero-fractions": "warn",
+        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/number-literal-case.md
+        "unicorn/number-literal-case": "warn",
+        // Enforce the style of numeric separators by correctly grouping digits
+        "unicorn/numeric-separators-style": "warn",
+        // Prefer .addEventListener() and .removeEventListener() over on-functions
+        "unicorn/prefer-add-event-listener": "warn",
+        // Prefer .find(…) over the first element from .filter(…)
+        "unicorn/prefer-array-find": "warn",
+        // Prefer Array#flat() over legacy techniques to flatten arrays
+        "unicorn/prefer-array-flat": "warn",
+        // Prefer .flatMap(…) over .map(…).flat()
+        "unicorn/prefer-array-flat-map": "warn",
+        // Prefer Array#indexOf() over Array#findIndex() when looking for the index of an item
+        "unicorn/prefer-array-index-of": "warn",
+        // Prefer using Array#some over Array#find when ensuring at least one element
+        // in the array passes a given check.
+        "unicorn/prefer-array-some": "error",
+        // Prefer .at() method for index access and String#charAt()
+        "unicorn/prefer-at": "warn",
+        // Prefer Blob#arrayBuffer() over FileReader#readAsArrayBuffer(…) and Blob#text() over FileReader#readAsText(…)
+        "unicorn/prefer-blob-reading-methods": "error",
+        // Prefer String#codePointAt(…) over String#charCodeAt(…)
+        // and String.fromCodePoint(…) over String.fromCharCode(…)
+        "unicorn/prefer-code-point": "error",
+        // Prefer Date.now() to get the number of milliseconds since the Unix Epoch
+        "unicorn/prefer-date-now": "warn",
+        // Prefer default parameters over reassignment
+        "unicorn/prefer-default-parameters": "warn",
+        // Prefer Node#append() over Node#appendChild()
+        "unicorn/prefer-dom-node-append": "warn",
+        // Prefer using .dataset on DOM elements over .setAttribute(…)
+        "unicorn/prefer-dom-node-dataset": "warn",
+        // Prefer node.remove() over parentNode.removeChild(node) and parentElement.removeChild(node)
+        "unicorn/prefer-dom-node-remove": "warn",
+        // Prefer .textContent over .innerText
+        "unicorn/prefer-dom-node-text-content": "warn",
+        // Prefer EventTarget over EventEmitter.
+        "unicorn/prefer-event-target": "error",
+        // Prefer `export…from` when re-exporting
+        "unicorn/prefer-export-from": "warn",
+        // Prefer .includes() over .indexOf() when checking for existence or non-existence
+        "unicorn/prefer-includes": "warn",
+        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-json-parse-buffer.md
+        "unicorn/prefer-json-parse-buffer": "warn",
+        // Prefer KeyboardEvent#key over KeyboardEvent#keyCode
+        "unicorn/prefer-keyboard-event-key": "warn",
+        // Disallow ternary operators when simpler logical operator alternatives exist.
+        "unicorn/prefer-logical-operator-over-ternary": "warn",
+        // Enforce the use of Math.trunc instead of bitwise operators
+        "unicorn/prefer-math-trunc": "warn",
+        // e.g. foo.insertBefore(baz, bar) -> foo.before(bar, 'baz')
+        "unicorn/prefer-modern-dom-apis": "warn",
+        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-modern-math-apis.md
+        "unicorn/prefer-modern-math-apis": "warn",
+        // Not ready yet for ESM modules
+        // https://github.com/microsoft/TypeScript/issues/33079
+        "unicorn/prefer-module": "off",
+        // If a function is equivalent to String, Number, BigInt, Boolean, or Symbol,
+        // you should use the built-in one directly. Wrapping the built-in in a function is moot.
+        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-native-coercion-functions.md
+        "unicorn/prefer-native-coercion-functions": "warn",
+        // Prefer negative index over .length - index
+        // for {String,Array,TypedArray}#slice() and Array#splice()
+        "unicorn/prefer-negative-index": "warn",
+        // Prefer using the node: protocol when importing Node.js builtin modules
+        // TODO seems like this is not well supported by webpack yet
+        "unicorn/prefer-node-protocol": "off",
+        // Prefer Number static properties over global ones
+        "unicorn/prefer-number-properties": "warn",
+        // Prefer using Object.fromEntries(…) to transform a list of key-value pairs into an object
+        "unicorn/prefer-object-from-entries": "warn",
+        // Prefer Object.hasOwn(…) over Object.prototype.hasOwnProperty.call(…)
+        "unicorn/prefer-object-has-own": "warn",
+        // Prefer omitting the catch binding parameter
+        "unicorn/prefer-optional-catch-binding": "warn",
+        // Prefer borrowing methods from the prototype instead of methods from an instance
+        "unicorn/prefer-prototype-methods": "warn",
+        // Prefer .querySelector() over .getElementById(),
+        // .querySelectorAll() over .getElementsByClassName() and .getElementsByTagName()
+        "unicorn/prefer-query-selector": "warn",
+        // Prefer Reflect.apply() over Function#apply()
+        "unicorn/prefer-reflect-apply": "warn",
+        // Prefer RegExp#test() over String#match() and RegExp#exec()
+        "unicorn/prefer-regexp-test": "warn",
+        // Prefer Set#has() over Array#includes() when checking for existence or non-existence
+        // Set#has() is faster than Array#includes().
+        "unicorn/prefer-set-has": "warn",
+        // Prefer using Set#size instead of Array#length
+        "unicorn/prefer-set-size": "warn",
+        // Prefer the spread operator over Array.from()
+        "unicorn/prefer-spread": "warn",
+        // Prefer String#replaceAll() over regex searches with the global flag
+        "unicorn/prefer-string-replace-all": "warn",
+        // Prefer String#slice() over String#substr() and String#substring()
+        "unicorn/prefer-string-slice": "warn",
+        // Prefer String#startsWith() & String#endsWith() over more complex alternatives
+        "unicorn/prefer-string-starts-ends-with": "error",
+        // Prefer String#trimStart() / String#trimEnd() over String#trimLeft() / String#trimRight()
+        "unicorn/prefer-string-trim-start-end": "warn",
+        // Use whatever feels correct in the moment
+        "unicorn/prefer-switch": "off",
+        // Prefer ternary expressions over simple if-else statements
+        "unicorn/prefer-ternary": ["warn", "only-single-line"],
+        // Prefer top-level await over top-level promises and async function calls
+        "unicorn/prefer-top-level-await": "error",
+        // Enforce throwing TypeError in type checking conditions
+        "unicorn/prefer-type-error": "warn",
+        // Using complete words results in more readable code. Not everyone knows all your abbreviations.
+        // Code is written only once, but read many times.
+        "unicorn/prevent-abbreviations": [
+          "warn",
+          {
+            allowList: {
+              "next-env.d": true,
+              "react-app-env.d": true
+            },
+            replacements: {
+              props: false,
+              ref: false,
+              refs: false
+            }
+          }
+        ],
+        // Enforce the use of regex shorthands to improve readability
+        "unicorn/regex-shorthand": "warn",
+        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/relative-url-style.md
+        "unicorn/relative-url-style": "warn",
+        // Enforce using the separator argument with Array#join()
+        "unicorn/require-array-join-separator": "warn",
+        // Enforce using the digits argument with Number#toFixed()
+        "unicorn/require-number-to-fixed-digits-argument": "warn",
+        // Enforce using the targetOrigin argument with window.postMessage()
+        "unicorn/require-post-message-target-origin": "error",
+        // No swaps needed yet
+        "unicorn/string-content": "off",
+        // Only allow braces when there are variable declaration or function
+        // declaration which requires a scope.
+        "unicorn/switch-case-braces": ["warn", "avoid"],
+        // Fix whitespace-insensitive template indentation
+        "unicorn/template-indent": [
+          "warn",
+          {
+            indent: 2
+          }
+        ],
+        "unicorn/text-encoding-identifier-case": "error",
+        // Require new when throwing an error
+        "unicorn/throw-new-error": "warn"
+      }
+    }
+  ];
+}
+
+// src/utils.ts
+var import_node_fs = require("fs");
+var import_globby = require("globby");
+var import_load_json_file = require("load-json-file");
+function checkEnvironment() {
+  const isGitIgnore = (0, import_node_fs.existsSync)(".gitignore");
+  let isNodeEngine = false;
+  let isPrettier = false;
+  let isTailwind = false;
+  let testingFramework = null;
+  const allPackageJsonPaths = (0, import_globby.globbySync)([
+    "**/package.json",
+    // Could use the `gitIgnore` option but the negative pattern is about 8 times faster.
+    // https://github.com/sindresorhus/globby/issues/50
+    "!**/node_modules"
+  ]);
+  for (const packageJsonPath of allPackageJsonPaths) {
+    const packageJson = (0, import_load_json_file.loadJsonFileSync)(packageJsonPath);
+    if (!testingFramework && Boolean(
+      packageJson.dependencies?.jest || packageJson.devDependencies?.jest
+    ))
+      testingFramework = "jest";
+    if (!isNodeEngine && Boolean(packageJson.engines?.node))
+      isNodeEngine = true;
+    if (!isPrettier && Boolean(
+      packageJson.dependencies?.prettier || packageJson.devDependencies?.prettier
+    ))
+      isPrettier = true;
+    if (!isTailwind && Boolean(
+      packageJson.dependencies?.tailwindcss || packageJson.devDependencies?.tailwindcss
+    ))
+      isTailwind = true;
+  }
+  const isNode = isNodeEngine || (0, import_node_fs.existsSync)(".nvmrc") || (0, import_node_fs.existsSync)(".node-version");
+  return {
+    isGitIgnore,
+    isNode,
+    isPrettier,
+    isTailwind,
+    testingFramework
+  };
+}
+
+// src/factory.ts
+function factory() {
+  const { isGitIgnore, isNode, isPrettier, isTailwind, testingFramework } = checkEnvironment();
+  const configs = [];
+  if (isGitIgnore)
+    configs.push([(0, import_eslint_config_flat_gitignore.default)()]);
+  configs.push(
+    ignores(),
+    base(),
+    imports(),
+    switchCase(),
+    unicorn(),
+    typescript(),
+    astro(),
+    react()
+  );
+  if (isNode)
+    configs.push(node());
+  if (isTailwind)
+    configs.push(node());
+  if (testingFramework === "jest")
+    configs.push(jest());
+  if (isPrettier)
+    configs.push(prettier());
+  const merged = configs.flat();
+  return merged;
+}