@wondermarin/eslint-config 1.0.3 → 2.0.0

package/dist/main.js

@@ -0,0 +1,1583 @@
+import fs from 'node:fs';
+import path, { join } from 'node:path';
+import globals from 'globals';
+
+// node_modules/.pnpm/defu@6.1.4/node_modules/defu/dist/defu.mjs
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isPlainObject(value) && isPlainObject(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
+  );
+}
+var defu = createDefu();
+
+// src/configs/javascript.ts
+function javascriptConfig() {
+  return [
+    {
+      name: "wondermarin/eslint-config/javascript",
+      files: ["**/*.?([cm])js" /* JS */, "**/*.jsx" /* JSX */, "**/*.?([cm])ts" /* TS */, "**/*.tsx" /* TSX */, "**/*.vue" /* VUE */],
+      rules: {
+        "accessor-pairs": [
+          "error",
+          {
+            enforceForClassMembers: true,
+            getWithoutSet: false,
+            setWithoutGet: true
+          }
+        ],
+        "array-callback-return": [
+          "error",
+          {
+            allowImplicit: false,
+            allowVoid: false,
+            checkForEach: false
+          }
+        ],
+        "arrow-body-style": ["error", "as-needed", { requireReturnForObjectLiteral: false }],
+        "block-scoped-var": "error",
+        camelcase: [
+          "error",
+          {
+            ignoreDestructuring: false,
+            ignoreGlobals: false,
+            ignoreImports: false,
+            properties: "never"
+          }
+        ],
+        "capitalized-comments": "off",
+        "class-methods-use-this": "off",
+        complexity: "off",
+        "consistent-return": "off",
+        "consistent-this": "off",
+        "constructor-super": "error",
+        curly: "off",
+        "default-case": "error",
+        "default-case-last": "error",
+        "default-param-last": "error",
+        "dot-notation": ["error", { allowKeywords: true }],
+        eqeqeq: ["error", "always"],
+        "for-direction": "error",
+        "func-name-matching": "off",
+        "func-names": ["error", "as-needed"],
+        "func-style": ["error", "declaration", { allowArrowFunctions: true }],
+        "getter-return": ["error", { allowImplicit: false }],
+        "grouped-accessor-pairs": ["error", "getBeforeSet"],
+        "guard-for-in": "off",
+        "id-denylist": "off",
+        "id-length": "off",
+        "id-match": "off",
+        "init-declarations": "off",
+        "logical-assignment-operators": ["error", "always", { enforceForIfStatements: true }],
+        "max-classes-per-file": [
+          "error",
+          {
+            ignoreExpressions: false,
+            max: 1
+          }
+        ],
+        "max-depth": "off",
+        "max-lines": "off",
+        "max-lines-per-function": "off",
+        "max-nested-callbacks": "off",
+        "max-params": "off",
+        "max-statements": "off",
+        "new-cap": [
+          "error",
+          {
+            capIsNew: false,
+            newIsCap: true,
+            properties: false
+          }
+        ],
+        "no-alert": "error",
+        "no-array-constructor": "error",
+        "no-async-promise-executor": "error",
+        "no-await-in-loop": "off",
+        "no-bitwise": "off",
+        "no-caller": "error",
+        "no-case-declarations": "error",
+        "no-class-assign": "error",
+        "no-compare-neg-zero": "error",
+        "no-cond-assign": ["error", "always"],
+        "no-console": "off",
+        "no-const-assign": "error",
+        "no-constant-binary-expression": "error",
+        "no-constant-condition": ["error", { checkLoops: true }],
+        "no-constructor-return": "error",
+        "no-continue": "off",
+        "no-control-regex": "error",
+        "no-debugger": "error",
+        "no-delete-var": "error",
+        "no-div-regex": "error",
+        "no-dupe-args": "error",
+        "no-dupe-class-members": "error",
+        "no-dupe-else-if": "error",
+        "no-dupe-keys": "error",
+        "no-duplicate-case": "error",
+        "no-duplicate-imports": ["error", { includeExports: true }],
+        "no-else-return": ["error", { allowElseIf: false }],
+        "no-empty": ["error", { allowEmptyCatch: true }],
+        "no-empty-character-class": "error",
+        "no-empty-function": "error",
+        "no-empty-pattern": ["error", { allowObjectPatternsAsParameters: false }],
+        "no-empty-static-block": "error",
+        "no-eq-null": "error",
+        "no-eval": ["error", { allowIndirect: false }],
+        "no-ex-assign": "error",
+        "no-extend-native": "error",
+        "no-extra-bind": "error",
+        "no-extra-boolean-cast": ["error", { enforceForInnerExpressions: false }],
+        "no-extra-label": "error",
+        "no-fallthrough": ["error", { allowEmptyCase: true }],
+        "no-func-assign": "error",
+        "no-global-assign": "error",
+        "no-implicit-coercion": "off",
+        "no-implicit-globals": "off",
+        "no-implied-eval": "error",
+        "no-import-assign": "error",
+        "no-inline-comments": "error",
+        "no-inner-declarations": ["error", "functions"],
+        "no-invalid-regexp": "error",
+        "no-invalid-this": ["error", { capIsConstructor: true }],
+        "no-irregular-whitespace": [
+          "error",
+          {
+            skipComments: false,
+            skipJSXText: false,
+            skipRegExps: false,
+            skipStrings: true,
+            skipTemplates: true
+          }
+        ],
+        "no-iterator": "error",
+        "no-label-var": "error",
+        "no-labels": [
+          "error",
+          {
+            allowLoop: false,
+            allowSwitch: false
+          }
+        ],
+        "no-lone-blocks": "error",
+        "no-lonely-if": "off",
+        "no-loop-func": "error",
+        "no-loss-of-precision": "error",
+        "no-magic-numbers": "off",
+        "no-misleading-character-class": ["error", { allowEscape: false }],
+        "no-multi-assign": ["error", { ignoreNonDeclaration: false }],
+        "no-multi-str": "error",
+        "no-negated-condition": "error",
+        "no-nested-ternary": "off",
+        "no-new": "error",
+        "no-new-func": "error",
+        "no-new-native-nonconstructor": "error",
+        "no-new-wrappers": "error",
+        "no-nonoctal-decimal-escape": "error",
+        "no-obj-calls": "error",
+        "no-object-constructor": "error",
+        "no-octal": "error",
+        "no-octal-escape": "error",
+        "no-param-reassign": "off",
+        "no-plusplus": "off",
+        "no-promise-executor-return": ["error", { allowVoid: false }],
+        "no-proto": "error",
+        "no-prototype-builtins": "error",
+        "no-redeclare": ["error", { builtinGlobals: true }],
+        "no-regex-spaces": "error",
+        "no-restricted-exports": "off",
+        "no-restricted-globals": "off",
+        "no-restricted-imports": "off",
+        "no-restricted-properties": "off",
+        "no-restricted-syntax": "off",
+        "no-return-assign": ["error", "except-parens"],
+        "no-script-url": "error",
+        "no-self-assign": ["error", { props: true }],
+        "no-self-compare": "error",
+        "no-sequences": ["error", { allowInParentheses: true }],
+        "no-setter-return": "error",
+        "no-shadow": "off",
+        "no-shadow-restricted-names": "error",
+        "no-sparse-arrays": "error",
+        "no-template-curly-in-string": "error",
+        "no-ternary": "off",
+        "no-this-before-super": "error",
+        "no-throw-literal": "error",
+        "no-undef": ["error", { typeof: false }],
+        "no-undef-init": "error",
+        "no-undefined": "off",
+        "no-underscore-dangle": [
+          "error",
+          {
+            allowAfterSuper: false,
+            allowAfterThis: false,
+            allowAfterThisConstructor: false,
+            allowFunctionParams: false,
+            allowInArrayDestructuring: false,
+            allowInObjectDestructuring: false,
+            enforceInClassFields: false,
+            enforceInMethodNames: false
+          }
+        ],
+        "no-unexpected-multiline": "error",
+        "no-unmodified-loop-condition": "error",
+        "no-unneeded-ternary": ["error", { defaultAssignment: false }],
+        "no-unreachable": "error",
+        "no-unreachable-loop": "error",
+        "no-unsafe-finally": "error",
+        "no-unsafe-negation": ["error", { enforceForOrderingRelations: true }],
+        "no-unsafe-optional-chaining": ["error", { disallowArithmeticOperators: true }],
+        "no-unused-expressions": [
+          "error",
+          {
+            allowShortCircuit: false,
+            allowTaggedTemplates: false,
+            allowTernary: false,
+            enforceForJSX: false
+          }
+        ],
+        "no-unused-labels": "error",
+        "no-unused-private-class-members": "error",
+        "no-unused-vars": [
+          "error",
+          {
+            args: "after-used",
+            caughtErrors: "all",
+            ignoreRestSiblings: true,
+            vars: "all"
+          }
+        ],
+        "no-use-before-define": [
+          "error",
+          {
+            allowNamedExports: false,
+            classes: true,
+            functions: true,
+            variables: true
+          }
+        ],
+        "no-useless-assignment": "error",
+        "no-useless-backreference": "error",
+        "no-useless-call": "error",
+        "no-useless-catch": "error",
+        "no-useless-computed-key": ["error", { enforceForClassMembers: true }],
+        "no-useless-concat": "error",
+        "no-useless-constructor": "error",
+        "no-useless-escape": "error",
+        "no-useless-rename": [
+          "error",
+          {
+            ignoreDestructuring: false,
+            ignoreExport: false,
+            ignoreImport: false
+          }
+        ],
+        "no-useless-return": "error",
+        "no-var": "error",
+        "no-void": ["error", { allowAsStatement: true }],
+        "no-warning-comments": "off",
+        "no-with": "error",
+        "object-shorthand": [
+          "error",
+          "always",
+          {
+            avoidExplicitReturnArrows: false,
+            avoidQuotes: false,
+            ignoreConstructors: false
+          }
+        ],
+        "one-var": ["error", "never"],
+        "operator-assignment": ["error", "always"],
+        "prefer-arrow-callback": [
+          "error",
+          {
+            allowNamedFunctions: false,
+            allowUnboundThis: false
+          }
+        ],
+        "prefer-const": [
+          "error",
+          {
+            destructuring: "all",
+            ignoreReadBeforeAssign: false
+          }
+        ],
+        "prefer-destructuring": [
+          "error",
+          {
+            array: true,
+            object: true
+          },
+          {
+            enforceForRenamedProperties: false
+          }
+        ],
+        "prefer-exponentiation-operator": "error",
+        "prefer-named-capture-group": "off",
+        "prefer-numeric-literals": "off",
+        "prefer-object-has-own": "error",
+        "prefer-object-spread": "error",
+        "prefer-promise-reject-errors": "off",
+        "prefer-regex-literals": ["error", { disallowRedundantWrapping: true }],
+        "prefer-rest-params": "error",
+        "prefer-spread": "error",
+        "prefer-template": "error",
+        radix: ["error", "always"],
+        "require-atomic-updates": ["error", { allowProperties: false }],
+        "require-await": "error",
+        "require-unicode-regexp": ["error", { requireFlag: "v" }],
+        "require-yield": "error",
+        "sort-imports": "off",
+        "sort-keys": "off",
+        "sort-vars": "off",
+        strict: ["error", "never"],
+        "symbol-description": "error",
+        "unicode-bom": ["error", "never"],
+        "use-isnan": [
+          "error",
+          {
+            enforceForIndexOf: true,
+            enforceForSwitchCase: true
+          }
+        ],
+        "valid-typeof": ["error", { requireStringLiterals: true }],
+        "vars-on-top": "error",
+        yoda: [
+          "error",
+          "never",
+          {
+            exceptRange: false,
+            onlyEquality: false
+          }
+        ]
+      }
+    }
+  ];
+}
+
+// src/utils/interop-default.ts
+async function interopDefault(module) {
+  return Promise.resolve(module).then((v) => v.default ?? v);
+}
+
+// src/configs/typescript.ts
+async function typescriptConfig() {
+  const [typescriptParser, typescriptPlugin] = await Promise.all([
+    interopDefault(import('@typescript-eslint/parser')),
+    interopDefault(import('@typescript-eslint/eslint-plugin'))
+  ]);
+  return [
+    {
+      name: "wondermarin/eslint-config/typescript",
+      files: ["**/*.?([cm])ts" /* TS */, "**/*.tsx" /* TSX */, "**/*.vue" /* VUE */],
+      languageOptions: {
+        parser: typescriptParser,
+        parserOptions: {
+          project: true,
+          tsconfigRootDir: process.cwd()
+        }
+      },
+      plugins: {
+        "@typescript-eslint": typescriptPlugin
+      },
+      rules: {
+        "@typescript-eslint/adjacent-overload-signatures": "error",
+        "@typescript-eslint/array-type": ["error", { default: "array" }],
+        "@typescript-eslint/await-thenable": "error",
+        "@typescript-eslint/ban-ts-comment": [
+          "error",
+          {
+            minimumDescriptionLength: 3,
+            "ts-check": "allow-with-description",
+            "ts-expect-error": "allow-with-description",
+            "ts-ignore": "allow-with-description",
+            "ts-nocheck": "allow-with-description"
+          }
+        ],
+        "@typescript-eslint/ban-tslint-comment": "error",
+        "@typescript-eslint/class-literal-property-style": ["error", "fields"],
+        "@typescript-eslint/class-methods-use-this": "off",
+        "@typescript-eslint/consistent-generic-constructors": ["error", "constructor"],
+        "@typescript-eslint/consistent-indexed-object-style": ["error", "record"],
+        "@typescript-eslint/consistent-return": "off",
+        "@typescript-eslint/consistent-type-assertions": [
+          "error",
+          {
+            assertionStyle: "as",
+            objectLiteralTypeAssertions: "allow-as-parameter"
+          }
+        ],
+        "@typescript-eslint/consistent-type-definitions": ["error", "interface"],
+        "@typescript-eslint/consistent-type-exports": ["error", { fixMixedExportsWithInlineTypeSpecifier: true }],
+        "@typescript-eslint/consistent-type-imports": [
+          "error",
+          {
+            disallowTypeAnnotations: true,
+            fixStyle: "inline-type-imports",
+            prefer: "type-imports"
+          }
+        ],
+        "@typescript-eslint/default-param-last": "error",
+        "@typescript-eslint/dot-notation": [
+          "error",
+          {
+            allowIndexSignaturePropertyAccess: false,
+            allowKeywords: true,
+            allowPrivateClassPropertyAccess: false,
+            allowProtectedClassPropertyAccess: false
+          }
+        ],
+        "@typescript-eslint/explicit-function-return-type": "off",
+        "@typescript-eslint/explicit-member-accessibility": ["error", { accessibility: "explicit" }],
+        "@typescript-eslint/explicit-module-boundary-types": "off",
+        "@typescript-eslint/init-declarations": "off",
+        "@typescript-eslint/max-params": "off",
+        "@typescript-eslint/member-ordering": "off",
+        "@typescript-eslint/method-signature-style": ["error", "property"],
+        "@typescript-eslint/naming-convention": [
+          "error",
+          {
+            selector: "accessor",
+            format: ["strictCamelCase"],
+            leadingUnderscore: "forbid",
+            trailingUnderscore: "forbid"
+          },
+          {
+            selector: "classMethod",
+            format: ["strictCamelCase"],
+            leadingUnderscore: "forbid",
+            trailingUnderscore: "forbid"
+          },
+          {
+            selector: "objectLiteralMethod",
+            format: ["strictCamelCase", "StrictPascalCase"],
+            leadingUnderscore: "forbid",
+            trailingUnderscore: "forbid"
+          },
+          {
+            selector: "typeMethod",
+            format: ["strictCamelCase", "StrictPascalCase"],
+            leadingUnderscore: "forbid",
+            trailingUnderscore: "forbid"
+          },
+          {
+            selector: "classProperty",
+            format: ["strictCamelCase"],
+            leadingUnderscore: "forbid",
+            trailingUnderscore: "forbid"
+          },
+          {
+            selector: "class",
+            format: ["StrictPascalCase"],
+            leadingUnderscore: "forbid",
+            trailingUnderscore: "forbid"
+          },
+          {
+            selector: "enum",
+            format: ["StrictPascalCase"],
+            prefix: ["E"],
+            leadingUnderscore: "forbid",
+            trailingUnderscore: "forbid"
+          },
+          {
+            selector: "interface",
+            format: ["StrictPascalCase"],
+            prefix: ["I"],
+            leadingUnderscore: "forbid",
+            trailingUnderscore: "forbid"
+          },
+          {
+            selector: "typeAlias",
+            format: ["StrictPascalCase"],
+            prefix: ["T"],
+            leadingUnderscore: "forbid",
+            trailingUnderscore: "forbid"
+          },
+          {
+            selector: "typeParameter",
+            format: ["StrictPascalCase"],
+            leadingUnderscore: "forbid",
+            trailingUnderscore: "forbid"
+          },
+          {
+            selector: "function",
+            format: ["strictCamelCase", "StrictPascalCase"],
+            leadingUnderscore: "forbid",
+            trailingUnderscore: "forbid"
+          },
+          {
+            selector: "parameter",
+            format: ["strictCamelCase"],
+            leadingUnderscore: "forbid",
+            trailingUnderscore: "forbid"
+          },
+          {
+            selector: "variable",
+            format: ["strictCamelCase", "StrictPascalCase"],
+            leadingUnderscore: "forbid",
+            trailingUnderscore: "forbid"
+          },
+          {
+            selector: "enumMember",
+            format: ["StrictPascalCase", "UPPER_CASE"],
+            leadingUnderscore: "forbid",
+            trailingUnderscore: "forbid"
+          },
+          {
+            selector: "import",
+            format: ["strictCamelCase", "StrictPascalCase"],
+            leadingUnderscore: "forbid",
+            trailingUnderscore: "forbid"
+          },
+          {
+            selector: "parameterProperty",
+            format: ["strictCamelCase"],
+            leadingUnderscore: "forbid",
+            trailingUnderscore: "forbid"
+          }
+        ],
+        "@typescript-eslint/no-array-constructor": "error",
+        "@typescript-eslint/no-array-delete": "error",
+        "@typescript-eslint/no-base-to-string": "error",
+        "@typescript-eslint/no-confusing-non-null-assertion": "error",
+        "@typescript-eslint/no-confusing-void-expression": [
+          "error",
+          {
+            ignoreArrowShorthand: false,
+            ignoreVoidOperator: false
+          }
+        ],
+        "@typescript-eslint/no-dupe-class-members": "off",
+        "@typescript-eslint/no-duplicate-enum-values": "error",
+        "@typescript-eslint/no-duplicate-type-constituents": [
+          "error",
+          {
+            ignoreIntersections: false,
+            ignoreUnions: false
+          }
+        ],
+        "@typescript-eslint/no-dynamic-delete": "off",
+        "@typescript-eslint/no-empty-function": "error",
+        "@typescript-eslint/no-empty-object-type": [
+          "error",
+          {
+            allowInterfaces: "never",
+            allowObjectTypes: "never"
+          }
+        ],
+        "@typescript-eslint/no-explicit-any": "off",
+        "@typescript-eslint/no-extra-non-null-assertion": "error",
+        "@typescript-eslint/no-extraneous-class": [
+          "error",
+          {
+            allowConstructorOnly: false,
+            allowEmpty: false,
+            allowStaticOnly: false,
+            allowWithDecorator: true
+          }
+        ],
+        "@typescript-eslint/no-floating-promises": [
+          "error",
+          {
+            checkThenables: true,
+            ignoreIIFE: true,
+            ignoreVoid: true
+          }
+        ],
+        "@typescript-eslint/no-for-in-array": "error",
+        "@typescript-eslint/no-implied-eval": "error",
+        "@typescript-eslint/no-import-type-side-effects": "error",
+        "@typescript-eslint/no-inferrable-types": [
+          "error",
+          {
+            ignoreParameters: false,
+            ignoreProperties: false
+          }
+        ],
+        "@typescript-eslint/no-invalid-this": "off",
+        "@typescript-eslint/no-invalid-void-type": [
+          "error",
+          {
+            allowAsThisParameter: false,
+            allowInGenericTypeArguments: true
+          }
+        ],
+        "@typescript-eslint/no-loop-func": "off",
+        "@typescript-eslint/no-magic-numbers": "off",
+        "@typescript-eslint/no-meaningless-void-operator": ["error", { checkNever: false }],
+        "@typescript-eslint/no-misused-new": "error",
+        "@typescript-eslint/no-misused-promises": [
+          "error",
+          {
+            checksConditionals: true,
+            checksSpreads: true,
+            checksVoidReturn: {
+              attributes: false
+            }
+          }
+        ],
+        "@typescript-eslint/no-mixed-enums": "error",
+        "@typescript-eslint/no-namespace": [
+          "error",
+          {
+            allowDeclarations: false,
+            allowDefinitionFiles: true
+          }
+        ],
+        "@typescript-eslint/no-non-null-asserted-nullish-coalescing": "error",
+        "@typescript-eslint/no-non-null-asserted-optional-chain": "error",
+        "@typescript-eslint/no-non-null-assertion": "off",
+        "@typescript-eslint/no-redeclare": "off",
+        "@typescript-eslint/no-redundant-type-constituents": "error",
+        "@typescript-eslint/no-require-imports": "error",
+        "@typescript-eslint/no-restricted-imports": "off",
+        "@typescript-eslint/no-restricted-types": "off",
+        "@typescript-eslint/no-shadow": "off",
+        "@typescript-eslint/no-this-alias": ["error", { allowDestructuring: true }],
+        "@typescript-eslint/no-unnecessary-boolean-literal-compare": [
+          "error",
+          {
+            allowComparingNullableBooleansToFalse: false,
+            allowComparingNullableBooleansToTrue: false
+          }
+        ],
+        "@typescript-eslint/no-unnecessary-condition": [
+          "error",
+          {
+            allowConstantLoopConditions: false,
+            checkTypePredicates: true
+          }
+        ],
+        "@typescript-eslint/no-unnecessary-parameter-property-assignment": "error",
+        "@typescript-eslint/no-unnecessary-qualifier": "error",
+        "@typescript-eslint/no-unnecessary-template-expression": "error",
+        "@typescript-eslint/no-unnecessary-type-arguments": "error",
+        "@typescript-eslint/no-unnecessary-type-assertion": "error",
+        "@typescript-eslint/no-unnecessary-type-constraint": "error",
+        "@typescript-eslint/no-unnecessary-type-parameters": "error",
+        "@typescript-eslint/no-unsafe-argument": "error",
+        "@typescript-eslint/no-unsafe-assignment": "off",
+        "@typescript-eslint/no-unsafe-call": "off",
+        "@typescript-eslint/no-unsafe-declaration-merging": "error",
+        "@typescript-eslint/no-unsafe-enum-comparison": "error",
+        "@typescript-eslint/no-unsafe-function-type": "error",
+        "@typescript-eslint/no-unsafe-member-access": "off",
+        "@typescript-eslint/no-unsafe-return": "off",
+        "@typescript-eslint/no-unsafe-unary-minus": "error",
+        "@typescript-eslint/no-unused-expressions": [
+          "error",
+          {
+            allowShortCircuit: false,
+            allowTaggedTemplates: false,
+            allowTernary: false,
+            enforceForJSX: false
+          }
+        ],
+        "@typescript-eslint/no-unused-vars": [
+          "error",
+          {
+            args: "after-used",
+            caughtErrors: "all",
+            ignoreClassWithStaticInitBlock: false,
+            ignoreRestSiblings: true,
+            reportUsedIgnorePattern: true,
+            vars: "all"
+          }
+        ],
+        "@typescript-eslint/no-use-before-define": [
+          "error",
+          {
+            allowNamedExports: false,
+            classes: true,
+            enums: true,
+            functions: true,
+            ignoreTypeReferences: true,
+            typedefs: true,
+            variables: true
+          }
+        ],
+        "@typescript-eslint/no-useless-constructor": "error",
+        "@typescript-eslint/no-useless-empty-export": "error",
+        "@typescript-eslint/no-wrapper-object-types": "error",
+        "@typescript-eslint/non-nullable-type-assertion-style": "error",
+        "@typescript-eslint/only-throw-error": "off",
+        "@typescript-eslint/parameter-properties": "off",
+        "@typescript-eslint/prefer-as-const": "error",
+        "@typescript-eslint/prefer-destructuring": [
+          "error",
+          {
+            array: true,
+            object: true
+          },
+          {
+            enforceForDeclarationWithTypeAnnotation: false,
+            enforceForRenamedProperties: false
+          }
+        ],
+        "@typescript-eslint/prefer-enum-initializers": "error",
+        "@typescript-eslint/prefer-find": "error",
+        "@typescript-eslint/prefer-for-of": "error",
+        "@typescript-eslint/prefer-function-type": "error",
+        "@typescript-eslint/prefer-includes": "error",
+        "@typescript-eslint/prefer-literal-enum-member": ["error", { allowBitwiseExpressions: true }],
+        "@typescript-eslint/prefer-namespace-keyword": "error",
+        "@typescript-eslint/prefer-nullish-coalescing": [
+          "error",
+          {
+            allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+            ignoreConditionalTests: true,
+            ignoreMixedLogicalExpressions: true,
+            ignorePrimitives: {
+              bigint: false,
+              boolean: false,
+              number: false,
+              string: false
+            },
+            ignoreTernaryTests: false
+          }
+        ],
+        "@typescript-eslint/prefer-optional-chain": [
+          "error",
+          {
+            allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: false,
+            checkAny: true,
+            checkBigInt: true,
+            checkBoolean: true,
+            checkNumber: true,
+            checkString: true,
+            checkUnknown: true,
+            requireNullish: false
+          }
+        ],
+        "@typescript-eslint/prefer-promise-reject-errors": "off",
+        "@typescript-eslint/prefer-readonly": ["error", { onlyInlineLambdas: false }],
+        "@typescript-eslint/prefer-readonly-parameter-types": "off",
+        "@typescript-eslint/prefer-reduce-type-parameter": "error",
+        "@typescript-eslint/prefer-regexp-exec": "error",
+        "@typescript-eslint/prefer-return-this-type": "error",
+        "@typescript-eslint/prefer-string-starts-ends-with": ["error", { allowSingleElementEquality: "never" }],
+        "@typescript-eslint/promise-function-async": [
+          "error",
+          {
+            allowAny: true,
+            checkArrowFunctions: true,
+            checkFunctionDeclarations: true,
+            checkFunctionExpressions: true,
+            checkMethodDeclarations: true
+          }
+        ],
+        "@typescript-eslint/require-array-sort-compare": ["error", { ignoreStringArrays: true }],
+        "@typescript-eslint/require-await": "error",
+        "@typescript-eslint/restrict-plus-operands": [
+          "error",
+          {
+            allowAny: false,
+            allowBoolean: false,
+            allowNullish: false,
+            allowNumberAndString: false,
+            allowRegExp: false,
+            skipCompoundAssignments: false
+          }
+        ],
+        "@typescript-eslint/restrict-template-expressions": [
+          "error",
+          {
+            allowAny: true,
+            allowArray: true,
+            allowBoolean: true,
+            allowNullish: true,
+            allowNumber: true,
+            allowRegExp: true
+          }
+        ],
+        "@typescript-eslint/return-await": ["error", "in-try-catch"],
+        "@typescript-eslint/strict-boolean-expressions": "off",
+        "@typescript-eslint/switch-exhaustiveness-check": [
+          "error",
+          {
+            allowDefaultCaseForExhaustiveSwitch: true,
+            requireDefaultForNonUnion: false
+          }
+        ],
+        "@typescript-eslint/triple-slash-reference": [
+          "error",
+          {
+            lib: "always",
+            path: "never",
+            types: "prefer-import"
+          }
+        ],
+        "@typescript-eslint/typedef": "off",
+        "@typescript-eslint/unbound-method": ["error", { ignoreStatic: false }],
+        "@typescript-eslint/unified-signatures": ["error", { ignoreDifferentlyNamedParameters: false }],
+        "@typescript-eslint/use-unknown-in-catch-callback-variable": "error",
+        "@typescript-eslint/no-deprecated": "error",
+        "default-param-last": "off",
+        "dot-notation": "off",
+        "no-array-constructor": "off",
+        "no-dupe-class-members": "off",
+        "no-empty-function": "off",
+        "no-implied-eval": "off",
+        "no-invalid-this": "off",
+        "no-loop-func": "off",
+        "no-magic-numbers": "off",
+        "no-redeclare": "off",
+        "no-restricted-imports": "off",
+        "no-shadow": "off",
+        "no-throw-literal": "off",
+        "no-undef": "off",
+        "no-unused-expressions": "off",
+        "no-unused-vars": "off",
+        "no-use-before-define": "off",
+        "no-useless-constructor": "off",
+        "prefer-destructuring": "off",
+        "require-await": "off"
+      }
+    }
+  ];
+}
+
+// src/configs/stylistic.ts
+async function stylisticConfig() {
+  const [prettierConfig, prettierPlugin, stylisticPlugin, perfectionistPlugin] = await Promise.all([
+    interopDefault(import('eslint-config-prettier')),
+    interopDefault(import('eslint-plugin-prettier')),
+    interopDefault(import('@stylistic/eslint-plugin')),
+    interopDefault(import('eslint-plugin-perfectionist'))
+  ]);
+  return [
+    {
+      name: "wondermarin/eslint-config/prettier",
+      files: ["**/*.?([cm])js" /* JS */, "**/*.jsx" /* JSX */, "**/*.?([cm])ts" /* TS */, "**/*.tsx" /* TSX */, "**/*.vue" /* VUE */],
+      plugins: {
+        prettier: prettierPlugin
+      },
+      rules: {
+        "prettier/prettier": "error",
+        ...prettierConfig.rules
+      }
+    },
+    {
+      name: "wondermarin/eslint-config/stylistic",
+      files: ["**/*.?([cm])js" /* JS */, "**/*.jsx" /* JSX */, "**/*.?([cm])ts" /* TS */, "**/*.tsx" /* TSX */, "**/*.vue" /* VUE */],
+      plugins: {
+        "@stylistic": stylisticPlugin
+      },
+      rules: {
+        "@stylistic/array-bracket-newline": "off",
+        "@stylistic/array-bracket-spacing": "off",
+        "@stylistic/array-element-newline": "off",
+        "@stylistic/arrow-parens": "off",
+        "@stylistic/arrow-spacing": "off",
+        "@stylistic/block-spacing": "off",
+        "@stylistic/brace-style": "off",
+        "@stylistic/comma-dangle": "off",
+        "@stylistic/comma-spacing": "off",
+        "@stylistic/comma-style": "off",
+        "@stylistic/computed-property-spacing": "off",
+        "@stylistic/dot-location": "off",
+        "@stylistic/eol-last": "off",
+        "@stylistic/function-call-argument-newline": "off",
+        "@stylistic/function-call-spacing": "off",
+        "@stylistic/function-paren-newline": "off",
+        "@stylistic/generator-star-spacing": "off",
+        "@stylistic/implicit-arrow-linebreak": "off",
+        "@stylistic/indent": "off",
+        "@stylistic/indent-binary-ops": "off",
+        "@stylistic/jsx-child-element-spacing": "off",
+        "@stylistic/jsx-closing-bracket-location": "off",
+        "@stylistic/jsx-closing-tag-location": "off",
+        "@stylistic/jsx-curly-brace-presence": "off",
+        "@stylistic/jsx-curly-newline": "off",
+        "@stylistic/jsx-curly-spacing": "off",
+        "@stylistic/jsx-equals-spacing": "off",
+        "@stylistic/jsx-first-prop-new-line": "off",
+        "@stylistic/jsx-function-call-newline": "off",
+        "@stylistic/jsx-indent-props": "off",
+        "@stylistic/jsx-max-props-per-line": "off",
+        "@stylistic/jsx-newline": "off",
+        "@stylistic/jsx-one-expression-per-line": "off",
+        "@stylistic/jsx-pascal-case": "off",
+        "@stylistic/jsx-props-no-multi-spaces": "off",
+        "@stylistic/jsx-quotes": "off",
+        "@stylistic/jsx-self-closing-comp": "off",
+        "@stylistic/jsx-sort-props": "off",
+        "@stylistic/jsx-tag-spacing": "off",
+        "@stylistic/jsx-wrap-multilines": "off",
+        "@stylistic/key-spacing": "off",
+        "@stylistic/keyword-spacing": "off",
+        "@stylistic/line-comment-position": "off",
+        "@stylistic/linebreak-style": "off",
+        "@stylistic/lines-around-comment": "off",
+        "@stylistic/lines-between-class-members": "off",
+        "@stylistic/max-len": "off",
+        "@stylistic/max-statements-per-line": "off",
+        "@stylistic/member-delimiter-style": "off",
+        "@stylistic/multiline-comment-style": "off",
+        "@stylistic/multiline-ternary": "off",
+        "@stylistic/new-parens": "off",
+        "@stylistic/newline-per-chained-call": "off",
+        "@stylistic/no-confusing-arrow": "off",
+        "@stylistic/no-extra-parens": "off",
+        "@stylistic/no-extra-semi": "off",
+        "@stylistic/no-floating-decimal": "off",
+        "@stylistic/no-mixed-operators": "off",
+        "@stylistic/no-mixed-spaces-and-tabs": "off",
+        "@stylistic/no-multi-spaces": "off",
+        "@stylistic/no-multiple-empty-lines": "off",
+        "@stylistic/no-tabs": "off",
+        "@stylistic/no-trailing-spaces": "off",
+        "@stylistic/no-whitespace-before-property": "off",
+        "@stylistic/nonblock-statement-body-position": "off",
+        "@stylistic/object-curly-newline": "off",
+        "@stylistic/object-curly-spacing": "off",
+        "@stylistic/object-property-newline": "off",
+        "@stylistic/one-var-declaration-per-line": "off",
+        "@stylistic/operator-linebreak": "off",
+        "@stylistic/padded-blocks": "off",
+        "@stylistic/padding-line-between-statements": [
+          "error",
+          {
+            blankLine: "always",
+            next: "*",
+            prev: [
+              "block-like",
+              "case",
+              "class",
+              "debugger",
+              "default",
+              "directive",
+              "do",
+              "expression",
+              "for",
+              "function",
+              "if",
+              "iife",
+              "multiline-expression",
+              "multiline-const",
+              "multiline-let",
+              "switch",
+              "throw",
+              "try",
+              "while",
+              "with"
+            ]
+          },
+          {
+            blankLine: "always",
+            next: [
+              "block-like",
+              "break",
+              "case",
+              "class",
+              "continue",
+              "debugger",
+              "default",
+              "do",
+              "expression",
+              "for",
+              "function",
+              "if",
+              "iife",
+              "multiline-expression",
+              "multiline-const",
+              "multiline-let",
+              "return",
+              "singleline-const",
+              "singleline-let",
+              "switch",
+              "throw",
+              "try",
+              "while",
+              "with"
+            ],
+            prev: "*"
+          },
+          {
+            blankLine: "any",
+            next: "expression",
+            prev: "expression"
+          },
+          {
+            blankLine: "any",
+            next: ["singleline-const", "singleline-let"],
+            prev: ["singleline-const", "singleline-let"]
+          }
+        ],
+        "@stylistic/quote-props": "off",
+        "@stylistic/quotes": "off",
+        "@stylistic/rest-spread-spacing": "off",
+        "@stylistic/semi": "off",
+        "@stylistic/semi-spacing": "off",
+        "@stylistic/semi-style": "off",
+        "@stylistic/space-before-blocks": "off",
+        "@stylistic/space-before-function-paren": "off",
+        "@stylistic/space-in-parens": "off",
+        "@stylistic/space-infix-ops": "off",
+        "@stylistic/space-unary-ops": "off",
+        "@stylistic/spaced-comment": "off",
+        "@stylistic/switch-colon-spacing": "off",
+        "@stylistic/template-curly-spacing": "off",
+        "@stylistic/template-tag-spacing": "off",
+        "@stylistic/type-annotation-spacing": "off",
+        "@stylistic/type-generic-spacing": "off",
+        "@stylistic/type-named-tuple-spacing": "off",
+        "@stylistic/wrap-iife": "off",
+        "@stylistic/wrap-regex": "off",
+        "@stylistic/yield-star-spacing": "off"
+      }
+    },
+    {
+      name: "wondermarin/eslint-config/perfectionist",
+      files: ["**/*.?([cm])js" /* JS */, "**/*.jsx" /* JSX */, "**/*.?([cm])ts" /* TS */, "**/*.tsx" /* TSX */, "**/*.vue" /* VUE */],
+      plugins: {
+        perfectionist: perfectionistPlugin
+      },
+      rules: {
+        "perfectionist/sort-array-includes": "off",
+        "perfectionist/sort-astro-attributes": "off",
+        "perfectionist/sort-classes": "off",
+        "perfectionist/sort-enums": "off",
+        "perfectionist/sort-exports": [
+          "error",
+          {
+            type: "line-length",
+            order: "desc",
+            ignoreCase: true,
+            partitionByComment: false,
+            partitionByNewLine: true,
+            groupKind: "values-first",
+            matcher: "minimatch"
+          }
+        ],
+        "perfectionist/sort-imports": [
+          "error",
+          {
+            type: "line-length",
+            order: "desc",
+            ignoreCase: true,
+            internalPattern: ["@/**"],
+            sortSideEffects: false,
+            newlinesBetween: "always",
+            maxLineLength: 120,
+            groups: [
+              "builtin",
+              "builtin-type",
+              "external",
+              "external-type",
+              "internal",
+              "internal-type",
+              "parent",
+              "parent-type",
+              "sibling",
+              "sibling-type",
+              "index",
+              "index-type",
+              "side-effect",
+              "side-effect-style"
+            ],
+            customGroups: {},
+            matcher: "minimatch",
+            environment: "node"
+          }
+        ],
+        "perfectionist/sort-interfaces": "off",
+        "perfectionist/sort-intersection-types": "off",
+        "perfectionist/sort-jsx-props": "off",
+        "perfectionist/sort-maps": "off",
+        "perfectionist/sort-named-exports": [
+          "error",
+          {
+            type: "line-length",
+            order: "desc",
+            ignoreCase: true,
+            groupKind: "values-first",
+            partitionByComment: false,
+            partitionByNewLine: true,
+            matcher: "minimatch"
+          }
+        ],
+        "perfectionist/sort-named-imports": [
+          "error",
+          {
+            type: "line-length",
+            order: "desc",
+            ignoreCase: true,
+            ignoreAlias: false,
+            groupKind: "values-first",
+            partitionByComment: false,
+            partitionByNewLine: true,
+            matcher: "minimatch"
+          }
+        ],
+        "perfectionist/sort-object-types": "off",
+        "perfectionist/sort-objects": "off",
+        "perfectionist/sort-svelte-attributes": "off",
+        "perfectionist/sort-switch-case": "off",
+        "perfectionist/sort-union-types": "off",
+        "perfectionist/sort-variable-declarations": "off",
+        "perfectionist/sort-vue-attributes": "off"
+      }
+    }
+  ];
+}
+var removedMethodNames = /* @__PURE__ */ new Map([
+  ["getSource", "getText"],
+  ["getSourceLines", "getLines"],
+  ["getAllComments", "getAllComments"],
+  ["getDeclaredVariables", "getDeclaredVariables"],
+  ["getNodeByRangeIndex", "getNodeByRangeIndex"],
+  ["getCommentsBefore", "getCommentsBefore"],
+  ["getCommentsAfter", "getCommentsAfter"],
+  ["getCommentsInside", "getCommentsInside"],
+  ["getJSDocComment", "getJSDocComment"],
+  ["getFirstToken", "getFirstToken"],
+  ["getFirstTokens", "getFirstTokens"],
+  ["getLastToken", "getLastToken"],
+  ["getLastTokens", "getLastTokens"],
+  ["getTokenAfter", "getTokenAfter"],
+  ["getTokenBefore", "getTokenBefore"],
+  ["getTokenByRangeStart", "getTokenByRangeStart"],
+  ["getTokens", "getTokens"],
+  ["getTokensAfter", "getTokensAfter"],
+  ["getTokensBefore", "getTokensBefore"],
+  ["getTokensBetween", "getTokensBetween"]
+]);
+var fixedUpRuleReplacements = /* @__PURE__ */ new WeakMap();
+var fixedUpRules = /* @__PURE__ */ new WeakSet();
+var fixedUpPluginReplacements = /* @__PURE__ */ new WeakMap();
+var fixedUpPlugins = /* @__PURE__ */ new WeakSet();
+function fixupRule(ruleDefinition) {
+  if (fixedUpRuleReplacements.has(ruleDefinition)) {
+    return fixedUpRuleReplacements.get(ruleDefinition);
+  }
+  const isLegacyRule = typeof ruleDefinition === "function";
+  if (!isLegacyRule && fixedUpRules.has(ruleDefinition)) {
+    return ruleDefinition;
+  }
+  const originalCreate = isLegacyRule ? ruleDefinition : ruleDefinition.create.bind(ruleDefinition);
+  function ruleCreate(context) {
+    if ("getScope" in context) {
+      return originalCreate(context);
+    }
+    const sourceCode = context.sourceCode;
+    let currentNode = sourceCode.ast;
+    const newContext = Object.assign(Object.create(context), {
+      parserServices: sourceCode.parserServices,
+      /*
+       * The following methods rely on the current node in the traversal,
+       * so we need to add them manually.
+       */
+      getScope() {
+        return sourceCode.getScope(currentNode);
+      },
+      getAncestors() {
+        return sourceCode.getAncestors(currentNode);
+      },
+      markVariableAsUsed(variable) {
+        sourceCode.markVariableAsUsed(variable, currentNode);
+      }
+    });
+    for (const [
+      contextMethodName,
+      sourceCodeMethodName
+    ] of removedMethodNames) {
+      newContext[contextMethodName] = sourceCode[sourceCodeMethodName].bind(sourceCode);
+    }
+    Object.freeze(newContext);
+    const visitor = originalCreate(newContext);
+    for (const [methodName, method] of Object.entries(visitor)) {
+      if (methodName.startsWith("on")) {
+        visitor[methodName] = (...args) => {
+          currentNode = args[methodName === "onCodePathSegmentLoop" ? 2 : 1];
+          return method.call(visitor, ...args);
+        };
+        continue;
+      }
+      visitor[methodName] = (...args) => {
+        currentNode = args[0];
+        return method.call(visitor, ...args);
+      };
+    }
+    return visitor;
+  }
+  const newRuleDefinition = {
+    ...isLegacyRule ? void 0 : ruleDefinition,
+    create: ruleCreate
+  };
+  fixedUpRuleReplacements.set(ruleDefinition, newRuleDefinition);
+  fixedUpRules.add(newRuleDefinition);
+  return newRuleDefinition;
+}
+function fixupPluginRules(plugin) {
+  if (fixedUpPluginReplacements.has(plugin)) {
+    return fixedUpPluginReplacements.get(plugin);
+  }
+  if (fixedUpPlugins.has(plugin) || !plugin.rules) {
+    return plugin;
+  }
+  const newPlugin = {
+    ...plugin,
+    rules: Object.fromEntries(
+      Object.entries(plugin.rules).map(([ruleId, ruleDefinition]) => [
+        ruleId,
+        fixupRule(ruleDefinition)
+      ])
+    )
+  };
+  fixedUpPluginReplacements.set(plugin, newPlugin);
+  fixedUpPlugins.add(newPlugin);
+  return newPlugin;
+}
+function convertIgnorePatternToMinimatch(pattern) {
+  const isNegated = pattern.startsWith("!");
+  const negatedPrefix = isNegated ? "!" : "";
+  const patternToTest = (isNegated ? pattern.slice(1) : pattern).trimEnd();
+  if (["", "**", "/**", "**/"].includes(patternToTest)) {
+    return `${negatedPrefix}${patternToTest}`;
+  }
+  const firstIndexOfSlash = patternToTest.indexOf("/");
+  const matchEverywherePrefix = firstIndexOfSlash < 0 || firstIndexOfSlash === patternToTest.length - 1 ? "**/" : "";
+  const patternWithoutLeadingSlash = firstIndexOfSlash === 0 ? patternToTest.slice(1) : patternToTest;
+  const escapedPatternWithoutLeadingSlash = patternWithoutLeadingSlash.replaceAll(
+    /(?=((?:\\.|[^{(])*))\1([{(])/guy,
+    "$1\\$2"
+  );
+  const matchInsideSuffix = patternToTest.endsWith("/**") ? "/*" : "";
+  return `${negatedPrefix}${matchEverywherePrefix}${escapedPatternWithoutLeadingSlash}${matchInsideSuffix}`;
+}
+function includeIgnoreFile(ignoreFilePath) {
+  if (!path.isAbsolute(ignoreFilePath)) {
+    throw new Error("The ignore file location must be an absolute path.");
+  }
+  const ignoreFile = fs.readFileSync(ignoreFilePath, "utf8");
+  const lines = ignoreFile.split(/\r?\n/u);
+  return {
+    name: "Imported .gitignore patterns",
+    ignores: lines.map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map(convertIgnorePatternToMinimatch)
+  };
+}
+
+// src/configs/react.ts
+async function reactConfig() {
+  const [reactPlugin, reactHooksPlugin] = await Promise.all([
+    interopDefault(import('eslint-plugin-react')),
+    // @ts-expect-error missing types
+    interopDefault(import('eslint-plugin-react-hooks'))
+  ]);
+  return [
+    {
+      name: "wondermarin/eslint-config/react",
+      files: ["**/*.jsx" /* JSX */, "**/*.tsx" /* TSX */],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          }
+        }
+      },
+      settings: {
+        react: {
+          version: "detect"
+        }
+      },
+      plugins: {
+        react: reactPlugin,
+        "react-hooks": fixupPluginRules(reactHooksPlugin)
+      },
+      rules: {
+        "react-hooks/exhaustive-deps": "warn",
+        "react-hooks/rules-of-hooks": "error",
+        "react/boolean-prop-naming": "off",
+        "react/button-has-type": [
+          "error",
+          {
+            button: true,
+            reset: true,
+            submit: true
+          }
+        ],
+        "react/checked-requires-onchange-or-readonly": [
+          "error",
+          {
+            ignoreExclusiveCheckedAttribute: false,
+            ignoreMissingProperties: false
+          }
+        ],
+        "react/default-props-match-prop-types": "off",
+        "react/destructuring-assignment": [
+          "error",
+          "always",
+          {
+            destructureInSignature: "always",
+            ignoreClassFields: false
+          }
+        ],
+        "react/display-name": "off",
+        "react/forbid-component-props": "off",
+        "react/forbid-dom-props": "off",
+        "react/forbid-elements": "off",
+        "react/forbid-foreign-prop-types": "off",
+        "react/forbid-prop-types": "off",
+        "react/function-component-definition": [
+          "error",
+          {
+            namedComponents: "function-declaration",
+            unnamedComponents: "arrow-function"
+          }
+        ],
+        "react/hook-use-state": ["error", { allowDestructuredState: true }],
+        "react/iframe-missing-sandbox": "error",
+        "react/jsx-boolean-value": ["error", "never", { assumeUndefinedIsFalse: false }],
+        "react/jsx-curly-brace-presence": [
+          "error",
+          {
+            children: "never",
+            propElementValues: "always",
+            props: "never"
+          }
+        ],
+        "react/jsx-filename-extension": "off",
+        "react/jsx-fragments": ["error", "element"],
+        "react/jsx-handler-names": [
+          "error",
+          {
+            checkInlineFunction: true,
+            checkLocalVariables: true,
+            eventHandlerPrefix: "handle",
+            eventHandlerPropPrefix: "on"
+          }
+        ],
+        "react/jsx-key": [
+          "error",
+          {
+            checkFragmentShorthand: true,
+            checkKeyMustBeforeSpread: true,
+            warnOnDuplicates: true
+          }
+        ],
+        "react/jsx-max-depth": "off",
+        "react/jsx-no-bind": [
+          "error",
+          {
+            allowArrowFunctions: true,
+            allowBind: false,
+            allowFunctions: false,
+            ignoreDOMComponents: false,
+            ignoreRefs: false
+          }
+        ],
+        "react/jsx-no-comment-textnodes": "error",
+        "react/jsx-no-constructed-context-values": "error",
+        "react/jsx-no-duplicate-props": ["error", { ignoreCase: true }],
+        "react/jsx-no-leaked-render": ["error", { validStrategies: ["coerce", "ternary"] }],
+        "react/jsx-no-literals": "off",
+        "react/jsx-no-script-url": "error",
+        "react/jsx-no-target-blank": [
+          "error",
+          {
+            allowReferrer: false,
+            enforceDynamicLinks: "always",
+            forms: false,
+            links: true,
+            warnOnSpreadAttributes: false
+          }
+        ],
+        "react/jsx-no-undef": ["error", { allowGlobals: false }],
+        "react/jsx-no-useless-fragment": ["error", { allowExpressions: false }],
+        "react/jsx-pascal-case": [
+          "error",
+          {
+            allowAllCaps: false,
+            allowLeadingUnderscore: false,
+            allowNamespace: false
+          }
+        ],
+        "react/jsx-props-no-spread-multi": "error",
+        "react/jsx-props-no-spreading": "off",
+        "react/jsx-sort-props": "off",
+        "react/jsx-uses-react": "off",
+        "react/jsx-uses-vars": "error",
+        "react/no-access-state-in-setstate": "error",
+        "react/no-adjacent-inline-elements": "off",
+        "react/no-array-index-key": "off",
+        "react/no-arrow-function-lifecycle": "error",
+        "react/no-children-prop": ["error", { allowFunctions: false }],
+        "react/no-danger": "off",
+        "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",
+        "react/no-multi-comp": ["error", { ignoreStateless: false }],
+        "react/no-namespace": "error",
+        "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": "off",
+        "react/no-string-refs": ["error", { noTemplateLiterals: true }],
+        "react/no-this-in-sfc": "error",
+        "react/no-typos": "error",
+        "react/no-unescaped-entities": "error",
+        "react/no-unknown-property": ["error", { requireDataLowercase: true }],
+        "react/no-unsafe": ["error", { checkAliases: false }],
+        "react/no-unstable-nested-components": ["error", { allowAsProps: false }],
+        "react/no-unused-class-component-methods": "error",
+        "react/no-unused-prop-types": ["error", { skipShapeProps: true }],
+        "react/no-unused-state": "error",
+        "react/no-will-update-set-state": "error",
+        "react/prefer-es6-class": ["error", "always"],
+        "react/prefer-exact-props": "off",
+        "react/prefer-read-only-props": "error",
+        "react/prefer-stateless-function": ["error", { ignorePureComponents: false }],
+        "react/prop-types": ["error", { skipUndeclared: false }],
+        "react/react-in-jsx-scope": "off",
+        "react/require-default-props": "off",
+        "react/require-optimization": "error",
+        "react/require-render-return": "error",
+        "react/self-closing-comp": [
+          "error",
+          {
+            component: true,
+            html: true
+          }
+        ],
+        "react/sort-comp": "off",
+        "react/sort-default-props": "off",
+        "react/sort-prop-types": "off",
+        "react/state-in-constructor": ["error", "always"],
+        "react/static-property-placement": "off",
+        "react/style-prop-object": "error",
+        "react/void-dom-elements-no-children": "error",
+        "react/forward-ref-uses-ref": "error"
+      }
+    }
+  ];
+}
+function baseConfig() {
+  return [
+    {
+      name: "wondermarin/eslint-config",
+      files: ["**/*.?([cm])js" /* JS */, "**/*.jsx" /* JSX */, "**/*.?([cm])ts" /* TS */, "**/*.tsx" /* TSX */, "**/*.vue" /* VUE */],
+      languageOptions: {
+        ecmaVersion: 2024,
+        sourceType: "module",
+        parserOptions: {
+          ecmaVersion: 2024,
+          sourceType: "module"
+        },
+        globals: {
+          ...globals.node,
+          ...globals.browser
+        }
+      }
+    },
+    {
+      name: "wondermarin/eslint-config/ignores",
+      ignores: includeIgnoreFile(join(process.cwd(), ".gitignore")).ignores
+    }
+  ];
+}
+
+// src/configs/json.ts
+async function jsonConfig() {
+  const [jsoncParser, packageJsonPlugin] = await Promise.all([
+    interopDefault(import('jsonc-eslint-parser')),
+    interopDefault(import('eslint-plugin-package-json'))
+  ]);
+  return [
+    {
+      name: "wondermarin/eslint-config/package-json",
+      files: ["**/package.json" /* PACKAGE_JSON */],
+      languageOptions: {
+        parser: jsoncParser
+      },
+      plugins: {
+        "package-json": packageJsonPlugin
+      },
+      rules: {
+        "package-json/order-properties": ["error", { order: "sort-package-json" }],
+        "package-json/repository-shorthand": ["error", { form: "object" }],
+        "package-json/sort-collections": [
+          "error",
+          ["scripts", "config", "dependencies", "peerDependencies", "devDependencies"]
+        ],
+        "package-json/unique-dependencies": "error",
+        "package-json/valid-local-dependency": "error",
+        "package-json/valid-name": "error",
+        "package-json/valid-package-def": "error",
+        "package-json/valid-repository-directory": "error",
+        "package-json/valid-version": "error"
+      }
+    }
+  ];
+}
+
+// src/main.ts
+async function wondermarin(options) {
+  options = defu(options, {
+    javascript: true,
+    stylistic: true,
+    json: true
+  });
+  const config = [...baseConfig()];
+  if (options.javascript) config.push(...javascriptConfig());
+  if (options.typescript) config.push(...await typescriptConfig());
+  if (options.stylistic) config.push(...await stylisticConfig());
+  if (options.json) config.push(...await jsonConfig());
+  if (options.react) config.push(...await reactConfig());
+  return config;
+}
+var main_default = wondermarin;
+
+export { main_default as default };