@unshared/eslint-config 0.0.1 → 0.0.2

package/dist/index.js

@@ -0,0 +1,1347 @@
+import vueParser from "vue-eslint-parser";
+import tslint from "typescript-eslint";
+import vueProcessorBlocks from "eslint-processor-vue-blocks";
+import vuePlugin from "eslint-plugin-vue";
+import { mergeProcessors } from "eslint-merge-processors";
+import { cwd } from "node:process";
+import perfectionist from "eslint-plugin-perfectionist";
+import { toArray } from "@unshared/collection/toArray";
+import stylistic from "@stylistic/eslint-plugin";
+import javascript from "@eslint/js";
+import vitestPlugin from "eslint-plugin-vitest";
+import unicornPlugin from "eslint-plugin-unicorn";
+import { FlatCompat } from "@eslint/eslintrc";
+import nodePlugin from "eslint-plugin-n";
+import jsonc from "eslint-plugin-jsonc";
+import pluginJsdoc from "eslint-plugin-jsdoc";
+import eslintCommentsPlugin from "eslint-plugin-eslint-comments";
+import pluginAntfu from "eslint-plugin-antfu";
+function getConfigRules(config) {
+  const rules = toArray(config).flat().map((x) => x.rules);
+  return Object.assign({}, ...rules);
+}
+function typescript(options) {
+  return [
+    javascript.configs.recommended,
+    {
+      languageOptions: {
+        // @ts-expect-error: ignore
+        parser: tslint.parser,
+        parserOptions: {
+          ecmaVersion: "latest",
+          sourceType: "module",
+          project: toArray(options.tsConfigPaths ?? "./tsconfig.json"),
+          tsconfigRootDir: cwd()
+        }
+      },
+      plugins: {
+        "@typescript-eslint": tslint.plugin,
+        "@stylistic": stylistic,
+        perfectionist
+      },
+      files: [
+        "**/*.{ts,tsx,cts,mts}",
+        "**/*.{js,jsx,cjs,mjs}"
+      ],
+      rules: {
+        /**
+         * Inherit all recommended rules from the `@eslint/js` plugin. This is the base
+         * configuration for JavaScript files.
+         */
+        ...getConfigRules(tslint.configs.recommendedTypeChecked),
+        ...getConfigRules(tslint.configs.stylisticTypeChecked),
+        /**
+         * Age-old debate over how to style braces. This rule aims to reduce the
+         * cognitive load of reasoning about code by enforcing a consistent style.
+         *
+         * @see https://eslint.style/rules/default/brace-style
+         */
+        "brace-style": "off",
+        "@typescript-eslint/brace-style": "off",
+        "@stylistic/brace-style": ["error", "stroustrup", {
+          allowSingleLine: !0
+        }],
+        /**
+         * Enforce an indent of 2 spaces. Aims to reduce visual noise and maintain
+         * readability of code when viewed on GitHub or GitLab.
+         *
+         * @see https://eslint.style/rules/default/no-tabs
+         * @see https://eslint.style/rules/default/indent
+         * @see https://eslint.style/rules/default/indent-binary-ops
+         */
+        "no-tabs": "off",
+        indent: "off",
+        "indent-binary-ops": "off",
+        "@typescript-eslint/no-tabs": "off",
+        "@typescript-eslint/indent": "off",
+        "@typescript-eslint/indent-binary-ops": "off",
+        "@stylistic/no-tabs": "error",
+        "@stylistic/indent": ["error", 2],
+        "@stylistic/indent-binary-ops": ["error", 2],
+        /**
+         * Enforce no semi-colons. This rule aims to maintain consistency around the
+         * use or omission of trailing semicolons. Helps reduce the visual noise in
+         * the codebase. Also helps to prevent errors when refactoring and adding
+         * new lines.
+         *
+         * @see https://eslint.style/rules/default/semi
+         */
+        semi: "off",
+        "@typescript-eslint/semi": "off",
+        "@stylistic/semi": ["error", "never"],
+        /**
+         * Enforce a consistent linebreak style and ensure no leading line breaks
+         * and a single trailing line break. This rule aims to maintain consistency
+         * around the use of line breaks in the codebase and reduce the amount of
+         * diff churn when making changes.
+         *
+         * @see https://eslint.style/rules/default/linebreak-style
+         */
+        "eol-last": "off",
+        "no-multiple-empty-lines": "off",
+        "@stylistic/eol-last": ["error", "always"],
+        "@stylistic/no-multiple-empty-lines": ["error", {
+          max: 1,
+          maxBOF: 0,
+          maxEOF: 1
+        }],
+        /**
+         * Enforce a trailing comma after the last element or property in a multiline
+         * list of properties or elements. This rule improves the clarity of diffs
+         * when an item is added or removed from an object or array.
+         *
+         * @see https://eslint.style/rules/default/comma-dangle
+         * @see https://eslint.style/rules/default/comma-spacing
+         */
+        "comma-dangle": "off",
+        "@typescript-eslint/comma-dangle": "off",
+        "@stylistic/comma-dangle": ["error", "always-multiline"],
+        /**
+         * This rule requires empty lines before and/or after comments. It is disabled
+         * however when in an object literal, array, or type literal.
+         *
+         * @see https://eslint.style/rules/default/lines-around-comment
+         */
+        /**
+         * Normalize type declaration and definition. This reduces the cognitive load
+         * of reasoning about code by enforcing a consistent style.
+         *
+         * @see https://typescript-eslint.io/rules/consistent-indexed-object-style
+         */
+        "@typescript-eslint/consistent-indexed-object-style": ["error", "record"],
+        "@typescript-eslint/consistent-type-definitions": ["error", "interface"],
+        "@typescript-eslint/member-delimiter-style": ["error", { multiline: { delimiter: "none" } }],
+        "@typescript-eslint/array-type": ["error", { default: "array-simple", readonly: "array-simple" }],
+        /**
+         * Enforce sequential declarations in the same block. This rule aims to
+         * enforce a top to bottom ordering of variable and type declarations.
+         * This reduces the likelihood of a developer skipping over a declaration
+         * when modifying code.
+         *
+         * @see https://typescript-eslint.io/rules/no-use-before-define
+         */
+        "no-use-before-define": "off",
+        "@typescript-eslint/no-use-before-define": ["error", {
+          enums: !0,
+          classes: !1,
+          typedefs: !0,
+          variables: !0,
+          functions: !1,
+          ignoreTypeReferences: !0
+        }],
+        /**
+         * Enforce a consistent spacing around various places where spaces are optional.
+         * This rule aims to maintain consistency around the use of spaces in the codebase
+         * and reduce the amount of diff churn when making changes.
+         *
+         * @see https://eslint.style/rules/default/key-spacing
+         * @see https://eslint.style/rules/default/comma-spacing
+         * @see https://eslint.style/rules/default/block-spacing
+         * @see https://eslint.style/rules/default/arrow-spacing
+         * @see https://eslint.style/rules/default/object-curly-spacing
+         */
+        "key-spacing": "off",
+        "comma-spacing": "off",
+        "block-spacing": "off",
+        "arrow-spacing": "off",
+        "spaced-comment": "off",
+        "no-multi-spaces": "off",
+        "space-before-blocks": "off",
+        "lines-around-comment": "off",
+        "object-curly-spacing": "off",
+        "array-bracket-spacing": "off",
+        "array-bracket-newline": "off",
+        "function-call-spacing": "off",
+        "generator-star-spacing": "off",
+        "template-curly-spacing": "off",
+        "newline-per-chained-call": "off",
+        "computed-property-spacing": "off",
+        "lines-between-class-members": "off",
+        "@typescript-eslint/comma-spacing": "off",
+        "@typescript-eslint/object-curly-spacing": "off",
+        "@typescript-eslint/type-annotation-spacing": "off",
+        "@typescript-eslint/lines-around-comment": "off",
+        "@stylistic/key-spacing": ["error", { afterColon: !0, beforeColon: !1 }],
+        "@stylistic/comma-spacing": ["error", { after: !0, before: !1 }],
+        "@stylistic/arrow-spacing": ["error", { before: !0, after: !0 }],
+        "@stylistic/type-generic-spacing": "error",
+        "@stylistic/type-named-tuple-spacing": "error",
+        "@stylistic/block-spacing": ["error", "always"],
+        "@stylistic/no-multi-spaces": "error",
+        "@stylistic/keyword-spacing": ["error", { before: !0, after: !0 }],
+        "@stylistic/space-before-blocks": ["error", "always"],
+        "@stylistic/object-curly-spacing": ["error", "always"],
+        "@stylistic/array-bracket-spacing": ["error", "never"],
+        "@stylistic/array-bracket-newline": ["error", "consistent"],
+        "@stylistic/function-call-spacing": ["error", "never"],
+        "@stylistic/template-curly-spacing": ["error", "never"],
+        "@stylistic/generator-star-spacing": ["error", { before: !0, after: !0 }],
+        "@stylistic/computed-property-spacing": ["error", "never"],
+        "@stylistic/multiline-ternary": ["error", "always-multiline"],
+        "@stylistic/lines-around-comment": ["error", {
+          beforeBlockComment: !0,
+          beforeLineComment: !0,
+          ignorePattern: "^(?! ?---|\\*)",
+          applyDefaultIgnorePatterns: !0,
+          afterHashbangComment: !0
+        }],
+        "@stylistic/spaced-comment": ["error", "always", {
+          block: { markers: ["!"], exceptions: ["*"], balanced: !0 },
+          line: { markers: ["/"], exceptions: ["/", "#"] }
+        }],
+        "@stylistic/lines-between-class-members": ["error", {
+          enforce: [{ blankLine: "always", prev: "method", next: "*" }]
+        }, {
+          exceptAfterSingleLine: !0
+        }],
+        "@stylistic/type-annotation-spacing": ["error", {
+          before: !1,
+          after: !0,
+          overrides: {
+            arrow: { before: !0, after: !0 },
+            colon: { before: !1, after: !0 },
+            variable: { before: !1, after: !0 },
+            property: { before: !1, after: !0 },
+            parameter: { before: !1, after: !0 },
+            returnType: { before: !1, after: !0 }
+          }
+        }],
+        /**
+         * Enforce the use of `@ts-expect-error` over `@ts-ignore` to silence TypeScript
+         * errors. This rule aims to ensure that TypeScript errors are never silenced
+         * without explanation or justification. When an error is fixed, the
+         * `@ts-expect-error` forces the developer to remove the comment.
+         *
+         * @see https://typescript-eslint.io/rules/prefer-ts-expect-error
+         * @see https://typescript-eslint.io/rules/ban-ts-comment
+         */
+        "@typescript-eslint/prefer-ts-expect-error": "error",
+        "@typescript-eslint/ban-ts-comment": ["error", {
+          "ts-check": !1,
+          "ts-expect-error": "allow-with-description",
+          "ts-ignore": !1,
+          "ts-nocheck": !1
+        }],
+        /**
+         * Disallow dangling expressions and promises. This rule aims to prevent
+         * dangling promises and expressions that are not assigned to a variable.
+         * This can lead to bugs and unexpected behavior in the codebase.
+         *
+         * @see https://eslint.org/docs/rules/no-void
+         * @see https://typescript-eslint.io/rules/no-floating-promises
+         */
+        "no-void": "off",
+        "no-unused-expressions": "off",
+        "@typescript-eslint/no-unused-expressions": "error",
+        "@typescript-eslint/no-floating-promises": ["error", {
+          ignoreVoid: !0,
+          ignoreIIFE: !0
+        }],
+        /**
+         * Sort imports alphabetically and group them without newlines. This rule
+         * aims to maintain consistency around the order of imports in JavaScript
+         * files. Helps reduce the visual noise in the codebase.
+         *
+         * @see https://eslint-plugin-perfectionist.azat.io/rules/sort-imports
+         */
+        "sort-imports": "off",
+        "@typescript-eslint/sort-type-constituents": "off",
+        "@typescript-eslint/consistent-type-imports": ["error", {
+          disallowTypeAnnotations: !1,
+          prefer: "no-type-imports"
+        }],
+        "perfectionist/sort-named-imports": ["error", { type: "natural" }],
+        "perfectionist/sort-imports": ["error", {
+          "newlines-between": "never",
+          order: "desc"
+        }],
+        /**
+         * Enforce no unused variables. Helps keep the codebase clean and reduces
+         * the chance of bugs from side-effects.
+         *
+         * @see https://typescript-eslint.io/rules/@typescript-eslint/no-unused-vars
+         */
+        "no-redeclare": "off",
+        "no-unused-vars": "off",
+        "@typescript-eslint/no-redeclare": "error",
+        "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
+        //////////////////////////////////////////////////////////////////////////////////////////
+        "perfectionist/sort-intersection-types": ["error", { type: "natural" }],
+        "perfectionist/sort-union-types": ["error", {
+          type: "natural",
+          "nullable-last": !0
+        }],
+        "no-useless-constructor": "off",
+        "@typescript-eslint/ban-types": "off",
+        "@typescript-eslint/camelcase": "off",
+        "@typescript-eslint/explicit-function-return-type": "off",
+        "@typescript-eslint/explicit-member-accessibility": "off",
+        "@typescript-eslint/explicit-module-boundary-types": "off",
+        "@typescript-eslint/no-empty-function": "off",
+        "@typescript-eslint/no-empty-interface": "off",
+        "@typescript-eslint/no-explicit-any": "off",
+        "@typescript-eslint/no-namespace": "off",
+        "@typescript-eslint/no-non-null-assertion": "off",
+        "@typescript-eslint/no-parameter-properties": "off",
+        "array-callback-return": "error",
+        "arrow-body-style": ["error", "as-needed"],
+        "arrow-parens": ["error", "as-needed", { requireForBlockBody: !0 }],
+        "block-scoped-var": "error",
+        camelcase: "off",
+        "comma-style": ["error", "last"],
+        complexity: ["off", 11],
+        "consistent-return": "off",
+        curly: ["error", "multi-or-nest", "consistent"],
+        eqeqeq: ["error", "smart"],
+        "no-alert": "error",
+        "no-case-declarations": "error",
+        "no-cond-assign": ["error", "always"],
+        "no-confusing-arrow": "error",
+        "no-console": ["warn", { allow: ["warn", "error"] }],
+        "no-constant-condition": "error",
+        "no-debugger": "error",
+        "no-eval": "error",
+        "no-implied-eval": "error",
+        "no-multi-str": "error",
+        "no-param-reassign": "off",
+        "no-restricted-syntax": ["error", "DebuggerStatement", "LabeledStatement", "WithStatement"],
+        "no-return-assign": "off",
+        "no-return-await": "off",
+        "no-trailing-spaces": "error",
+        "no-useless-escape": "off",
+        "no-var": "error",
+        "no-with": "error",
+        "object-shorthand": ["error", "always", { avoidQuotes: !0, ignoreConstructors: !1 }],
+        "one-var-declaration-per-line": "error",
+        "operator-linebreak": ["error", "before"],
+        "prefer-arrow-callback": ["error", { allowNamedFunctions: !1, allowUnboundThis: !0 }],
+        "prefer-const": ["error", { destructuring: "any", ignoreReadBeforeAssign: !0 }],
+        "prefer-rest-params": "error",
+        "prefer-spread": "error",
+        "prefer-template": "error",
+        "quote-props": ["error", "consistent-as-needed"],
+        quotes: ["error", "single"],
+        "require-await": "off",
+        "space-before-function-paren": ["error", "never"],
+        "vars-on-top": "error"
+      }
+    },
+    /**
+     * Ignore duplicate imports in declaration files as they are often used to re-export
+     * types from other packages into multiple namespaces. This is a common pattern
+     * in TypeScript declaration files.
+     */
+    {
+      files: ["*.d.ts"],
+      rules: {
+        "@typescript-eslint/no-use-before-define": "off",
+        "import/no-duplicates": "off"
+      }
+    },
+    /**
+     * Allow console statements in scripts and CLI files since they are not part of the
+     * library / production code and are useful for debugging, logging, and testing.
+     */
+    {
+      files: ["**/scripts/**/*", "cli.*"],
+      rules: {
+        "no-console": "off"
+      }
+    }
+  ];
+}
+const VUE_RECOMMENDED_RULES = vuePlugin.configs?.["flat/recommended"].rules, VUE_BASE_RULES = vuePlugin.configs?.base.rules;
+function vue(options) {
+  const TYPESCRIPT_CONFIG = typescript(options).at(1);
+  return [
+    {
+      plugins: {
+        vue: vuePlugin,
+        ...TYPESCRIPT_CONFIG.plugins
+      },
+      languageOptions: {
+        globals: {
+          computed: "readonly",
+          defineEmits: "readonly",
+          defineExpose: "readonly",
+          defineProps: "readonly",
+          onMounted: "readonly",
+          onUnmounted: "readonly",
+          reactive: "readonly",
+          ref: "readonly",
+          shallowReactive: "readonly",
+          shallowRef: "readonly",
+          toRef: "readonly",
+          toRefs: "readonly",
+          watch: "readonly",
+          watchEffect: "readonly"
+        },
+        parser: vueParser,
+        parserOptions: {
+          parser: tslint.parser,
+          extraFileExtensions: [".vue"],
+          ...TYPESCRIPT_CONFIG.languageOptions.parserOptions
+        }
+      },
+      processor: mergeProcessors([
+        // @ts-expect-error: ignore
+        vuePlugin.processors[".vue"],
+        vueProcessorBlocks()
+      ]),
+      files: [
+        "**/*.vue"
+      ],
+      rules: {
+        ...VUE_BASE_RULES,
+        ...VUE_RECOMMENDED_RULES,
+        ...TYPESCRIPT_CONFIG.rules,
+        "@typescript-eslint/no-unsafe-assignment": "off",
+        "@typescript-eslint/no-unsafe-call": "off",
+        /**
+         * Enforces consistent usage of type imports. This rule will enforce the use
+         * of `type` imports to make it easier for the Vue SFC compiler to analyze
+         * the code and infer the dependency graph correctly.
+         *
+         * @see https://typescript-eslint.io/rules/consistent-type-imports
+         * @see https://vuejs.github.io/vetur/guide/FAQ.html#why-does-vetur-show-cannot-find-module-xxx
+         */
+        "@typescript-eslint/consistent-type-imports": ["error", {
+          disallowTypeAnnotations: !1,
+          fixStyle: "inline-type-imports",
+          prefer: "type-imports"
+        }],
+        /**
+         * Enforce the order of the top-level properties in the component. This rule
+         * helps to maintain consistency and readability by enforcing a predictable
+         * order of the top-level properties in the component.
+         *
+         * @see https://eslint.vuejs.org/rules/ordered-component-elements.html
+         */
+        "vue/block-order": ["error", {
+          order: [
+            "docs",
+            "script",
+            "template",
+            "style"
+          ]
+        }],
+        /**
+         * Enforce use of the Composition API and TypeScript. This rule forbids the
+         * use of the Options API and JavaScript in Vue components for better
+         * consistency and maintainability.
+         *
+         * @see https://eslint.vuejs.org/rules/vue/prefer-define-options.html
+         */
+        "vue/component-api-style": ["error", ["script-setup"]],
+        /**
+         * Enforce the component name casing to be PascalCase. This rules helps identify
+         * and distinguish between components and HTML elements. It also helps to avoid
+         * conflicts with existing and future HTML elements.
+         *
+         * @see https://eslint.vuejs.org/rules/component-name-in-template-casing.html
+         */
+        "vue/component-name-in-template-casing": ["error", "PascalCase", {
+          ignores: ["/\\./"],
+          registeredComponentsOnly: !1
+        }],
+        /**
+         * Enforce consistent spacing between HTML comments and their content.
+         *
+         * @see https://eslint.vuejs.org/rules/html-comment-content-spacing.html
+         * @see https://eslint.vuejs.org/rules/html-comment-content-newline.html
+         */
+        "vue/html-comment-content-spacing": ["error", "always"],
+        /**
+         * Enforce consistent spacing between HTML / Component tags. This makes it
+         * easier to read and understand the structure of the component.
+         *
+         * @see https://eslint.vuejs.org/rules/padding-line-between-blocks.html
+         * @see https://eslint.vuejs.org/rules/padding-line-between-tags.html
+         */
+        "vue/html-comment-indent": ["error", 2],
+        "vue/padding-line-between-tags": ["error", [
+          { blankLine: "consistent", next: "*", prev: "*" },
+          { blankLine: "always", next: "*", prev: "comment" }
+        ]],
+        /**
+         * Enforce consistent spacing and newlines in the template. This rule helps
+         * to maintain consistency and readability by enforcing a predictable
+         *
+         * @see https://eslint.vuejs.org/rules/html-indent.html
+         * @see https://eslint.vuejs.org/rules/max-attributes-per-line.html
+         * @see https://eslint.vuejs.org/rules/html-closing-bracket-newline.html
+         */
+        "vue/html-indent": ["error", 2, {
+          alignAttributesVertically: !0,
+          attribute: 1,
+          baseIndent: 1,
+          closeBracket: 0,
+          ignores: []
+        }],
+        // 'vue/func-call-spacing': ['off', 'never'],
+        "vue/key-spacing": ["error", { afterColon: !0, beforeColon: !1 }],
+        "vue/keyword-spacing": ["error", { after: !0, before: !0 }],
+        "vue/max-attributes-per-line": ["error", {
+          multiline: { max: 1 },
+          singleline: { max: 5 }
+        }],
+        /**
+         * Allow single-word component names. This rule is disabled because we use
+         * pascal-casing to distinguish between components and HTML elements.
+         *
+         * @see https://eslint.vuejs.org/rules/multi-word-component-names.html
+         */
+        "vue/multi-word-component-names": "off",
+        "vue/multiline-html-element-content-newline": ["error", {
+          allowEmptyLines: !0,
+          ignores: [],
+          ignoreWhenEmpty: !0
+        }],
+        /**
+         * Reports the destructuring or member expression of props passed to setup
+         * causing the value to lose reactivity. This rule helps to avoid common
+         * pitfalls when using the Composition API.
+         *
+         * @see https://eslint.vuejs.org/rules/no-setup-props-reactivity-loss.html
+         */
+        "vue/no-setup-props-reactivity-loss": "error",
+        /**
+         * Disallow v-if in v-for. This rule helps to avoid common pitfalls when
+         * using v-if and v-for together in the same element.
+         *
+         * @see https://eslint.vuejs.org/rules/no-use-v-if-with-v-for.html
+         */
+        "vue/no-use-v-if-with-v-for": "error",
+        /**
+         * Enforce the declaration of emits in the setup function and warn on unused
+         * emits declarations. This rule helps reduce the risk stale code.
+         *
+         * @see https://eslint.vuejs.org/rules/require-explicit-emits.html
+         * @see https://eslint.vuejs.org/rules/no-unused-emit-declarations.html
+         */
+        "vue/require-explicit-emits": "error",
+        /**
+         * Enforce the `@` shorthand over `v-on:` and only allow inline callbacks.
+         * This rule helps to maintain consistency and readability by enforcing a
+         * predictable order of the event handlers in the component.
+         *
+         * @see https://eslint.vuejs.org/rules/v-on-style.html
+         * @see https://eslint.vuejs.org/rules/v-on-handler-style.html
+         */
+        "vue/v-on-style": ["error", "shorthand"],
+        "vue/no-sparse-arrays": "error",
+        "vue/no-unused-emit-declarations": "error",
+        "vue/no-use-v-else-with-v-for": "error",
+        "vue/no-useless-v-bind": "error",
+        "vue/no-v-html": "off",
+        "vue/no-v-text-v-html-on-component": "error",
+        "vue/object-curly-newline": ["error", { consistent: !0, multiline: !0 }],
+        "vue/object-curly-spacing": ["error", "always"],
+        "vue/object-shorthand": [
+          "error",
+          "always",
+          {
+            avoidQuotes: !0,
+            ignoreConstructors: !1
+          }
+        ],
+        "vue/operator-linebreak": ["error", "before"],
+        "vue/padding-line-between-blocks": ["error", "always"],
+        "vue/prefer-define-options": "error",
+        "vue/prefer-import-from-vue": "off",
+        "vue/prefer-separate-static-class": "error",
+        "vue/prefer-template": "error",
+        "vue/quote-props": ["error", "consistent-as-needed"],
+        "vue/require-default-prop": "off",
+        // reactivity transform
+        "vue/block-tag-newline": ["error", {
+          multiline: "always",
+          singleline: "always"
+        }],
+        // extensions
+        "vue/array-bracket-spacing": ["error", "never"],
+        "vue/arrow-spacing": ["error", { after: !0, before: !0 }],
+        "vue/block-lang": ["error", { script: { lang: "ts" } }],
+        "vue/block-spacing": ["error", "always"],
+        "vue/brace-style": ["error", "stroustrup", { allowSingleLine: !0 }],
+        "vue/comma-dangle": ["error", "always-multiline"],
+        "vue/comma-spacing": ["error", { after: !0, before: !1 }],
+        "vue/comma-style": ["error", "last"],
+        "vue/component-options-name-casing": ["error", "PascalCase"],
+        "vue/custom-event-name-casing": ["error", "camelCase"],
+        "vue/define-macros-order": ["error", {
+          order: ["defineProps", "defineEmits"]
+        }],
+        "vue/dot-location": ["error", "property"],
+        "vue/dot-notation": ["error", { allowKeywords: !0 }],
+        "vue/eqeqeq": ["error", "smart"],
+        "vue/first-attribute-linebreak": ["error", {
+          multiline: "below",
+          singleline: "beside"
+        }],
+        "vue/html-closing-bracket-newline": ["error", {
+          multiline: "never",
+          selfClosingTag: {
+            multiline: "always",
+            singleline: "never"
+          },
+          singleline: "never"
+        }],
+        "vue/html-comment-content-newline": ["error", {
+          multiline: "always",
+          singleline: "never"
+        }],
+        "vue/no-constant-condition": "warn",
+        "vue/no-empty-pattern": "error",
+        "vue/no-extra-parens": ["error", "functions"],
+        "vue/no-irregular-whitespace": "error",
+        "vue/no-loss-of-precision": "error",
+        "vue/no-restricted-syntax": [
+          "error",
+          "DebuggerStatement",
+          "LabeledStatement",
+          "WithStatement"
+        ],
+        "vue/no-restricted-v-bind": ["error", "/^v-/"],
+        "vue/require-prop-types": "off",
+        "vue/space-in-parens": ["error", "never"],
+        "vue/space-infix-ops": "error",
+        "vue/space-unary-ops": ["error", { nonwords: !1, words: !0 }],
+        "vue/template-curly-spacing": "error",
+        "vue/v-on-handler-style": ["error", "inline"]
+      }
+    }
+  ];
+}
+function vitest() {
+  return [
+    {
+      plugins: {
+        vitest: vitestPlugin
+      },
+      files: [
+        "**/*.{ts,mts,cts,tsx,d.ts}",
+        "**/*.{js,mjs,cjs,jsx}"
+      ],
+      settings: {
+        vitest: {
+          typecheck: !0
+        }
+      },
+      languageOptions: {
+        globals: {
+          ...vitestPlugin.environments.env.globals,
+          expectTypeOf: !0
+        }
+      },
+      rules: {
+        /**
+         * Inject all configuration from eslint-plugin-vitest.
+         *
+         * @see https://github.com/veritem/eslint-plugin-vitest/tree/main?tab=readme-ov-file#rules
+         */
+        ...vitestPlugin.configs.all.rules,
+        /**
+         * This rule aims to enforce having at least one expectation
+         * in test body to ensure that the test is actually testing something.
+         *
+         * @see https://github.com/veritem/eslint-plugin-vitest/blob/main/docs/rules/expect-expect.md
+         */
+        "vitest/expect-expect": ["error", {
+          assertFunctionNames: [
+            "expect",
+            "expectTypeOf"
+          ]
+        }],
+        /**
+         * Disable the conditional test rule as it is prevent's us to use in-source
+         * testing when using the `if (import.meta.vitest)` condition. Also disable
+         * the rule that prevents the use of if-else statements in tests as we want
+         * to use it to test type predicates.
+         *
+         * @see https://github.com/veritem/eslint-plugin-vitest/blob/main/docs/rules/no-conditional-in-test.md
+         */
+        "vitest/no-conditional-in-test": "off",
+        "vitest/no-conditional-tests": "off",
+        /**
+         * Since we use in-source testing, we need to disable the rule as it may prevent
+         * us from using top level evaluation that are not part of the test suite.
+         *
+         * @see https://github.com/veritem/eslint-plugin-vitest/blob/main/docs/rules/no-hooks.md
+         */
+        "vitest/require-hook": "off",
+        "vitest/no-hooks": "off",
+        /**
+         * Disable the rule that enforces the use of `expect.assertions` in tests.
+         * As much as this rule enforces a best-practice, it is not always necessary.
+         *
+         * @see https://github.com/veritem/eslint-plugin-vitest/blob/main/docs/rules/prefer-expect-assertions.md
+         */
+        "vitest/prefer-expect-assertions": "off",
+        /**
+         * Some functions may have a single test case, and it is not necessary
+         * to wrap them in a describe block.
+         *
+         * @see https://github.com/veritem/eslint-plugin-vitest/blob/main/docs/rules/require-top-level-describe.md
+         */
+        "vitest/require-top-level-describe": "off",
+        /**
+         * Enforce rule titles starts with 'should'. This is a convention
+         * to force the developer to write the test in a way that it reads
+         * like a sentence.
+         *
+         * @see https://github.com/veritem/eslint-plugin-vitest/blob/main/docs/rules/valid-title.md
+         */
+        "vitest/valid-title": ["error", {
+          ignoreTypeOfDescribeName: !0,
+          mustMatch: {
+            test: ["^should"]
+          }
+        }]
+      }
+    }
+  ];
+}
+const UNICORN_RECOMMENDED_RULES = unicornPlugin.configs.recommended.rules;
+function unicorn() {
+  return [
+    {
+      plugins: {
+        unicorn: unicornPlugin
+      },
+      rules: {
+        ...UNICORN_RECOMMENDED_RULES,
+        /**
+         * Improve regexes by making them shorter, consistent, and safer. This rule
+         * aims to improve readability and consistency of regexes while also
+         * mitigating regex denial of service attacks by disallowing potentially
+         * catastrophic backtracking.
+         *
+         * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/better-regex.md
+         */
+        "unicorn/better-regex": "error",
+        /**
+         * Enforce the catch clause parameter name to be named `error`. This rule
+         * aims to enforce a consistent parameter name in catch clauses. The name
+         * `error` is the most commonly used name for the parameter that is passed
+         * to the catch clause.
+         *
+         * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/catch-error-name.md
+         */
+        "unicorn/catch-error-name": ["error", {
+          name: "error"
+        }],
+        /**
+         * Enforce the use of camelCase or PascalCase when naming folders, files and
+         * variables. This rule aims to enforce a consistent naming convention for
+         * filenames, directory names, and variable names.
+         *
+         * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/filename-case.md
+         */
+        "unicorn/filename-case": ["error", {
+          cases: {
+            camelCase: !0,
+            pascalCase: !0
+          },
+          ignore: [
+            "^[A-Z]+(.md)?$"
+          ]
+        }],
+        /**
+         * Disable the recommended import style rules. We want to be able to use both
+         * named and default imports in our codebase.
+         *
+         * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/import-style.md
+         */
+        "unicorn/import-style": "off",
+        /**
+         * Disallow unsafe regular expressions. Regular expressions can be unsafe
+         * when they are too complex and can cause catastrophic backtracking. This
+         * rule disallows regular expressions that can lead to catastrophic
+         *
+         * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unsafe-regex.md
+         */
+        "unicorn/no-unsafe-regex": "error",
+        /**
+         * Enforces a convention of grouping digits using numeric separators.
+         * Long numbers can become really hard to read, so cutting it into groups
+         * of digits, separated with a _, is important to keep your code clear.
+         *
+         * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/numeric-separators-style.md
+         */
+        "unicorn/numeric-separators-style": ["error", {
+          onlyIfContainsSeparator: !0
+        }],
+        "unicorn/number-literal-case": "error",
+        "unicorn/consistent-function-scoping": "off",
+        "unicorn/error-message": "error",
+        "unicorn/escape-case": "error",
+        "unicorn/no-array-callback-reference": "off",
+        "unicorn/no-array-for-each": "off",
+        "unicorn/no-array-instanceof": "error",
+        "unicorn/no-new-buffer": "error",
+        "unicorn/no-static-only-class": "off",
+        "unicorn/prefer-code-point": "off",
+        "unicorn/prefer-exponentiation-operator": "error",
+        "unicorn/prefer-includes": "error",
+        "unicorn/prefer-module": "off",
+        "unicorn/prefer-starts-ends-with": "error",
+        "unicorn/prefer-switch": "off",
+        "unicorn/prefer-text-content": "error",
+        "unicorn/prefer-type-error": "error",
+        "unicorn/prevent-abbreviations": ["error", {
+          allowList: {
+            args: !0,
+            dir: !0,
+            fn: !0,
+            i: !0,
+            j: !0,
+            k: !0,
+            props: !0,
+            Props: !0,
+            ref: !0,
+            v: !0,
+            x: !0,
+            y: !0,
+            z: !0
+          }
+        }],
+        "unicorn/throw-new-error": "error"
+      }
+    }
+  ];
+}
+function sonarjs() {
+  return new FlatCompat().config({
+    extends: [
+      "plugin:sonarjs/recommended"
+    ],
+    plugins: [
+      "sonarjs"
+    ],
+    rules: {
+      /**
+       * Cognitive Complexity is a measure of how hard the control flow of a function
+       * is to understand. Functions with high Cognitive Complexity will be difficult
+       * to maintain.
+       *
+       * @see https://github.com/SonarSource/eslint-plugin-sonarjs/blob/master/docs/rules/cognitive-complexity.md
+       */
+      "sonarjs/cognitive-complexity": ["error", 30],
+      /**
+       * Duplicated string literals make the process of refactoring error-prone,
+       * since you must be sure to update all occurrences. On the other hand,
+       * constants can be referenced from many places, but only need to be
+       * updated in a single place.
+       *
+       * @see https://github.com/SonarSource/eslint-plugin-sonarjs/blob/master/docs/rules/no-duplicate-string.md
+       */
+      "sonarjs/no-duplicate-string": ["error", {
+        threshold: 10
+      }],
+      /**
+       * Those rules are crashing ESLint at startup, so they are disabled for now.
+       */
+      "sonarjs/no-empty-collection": "off",
+      "sonarjs/no-extra-arguments": "off",
+      "sonarjs/no-gratuitous-expressions": "off",
+      "sonarjs/no-one-iteration-loop": "off",
+      "sonarjs/no-redundant-jump": "off",
+      "sonarjs/no-unused-collection": "off",
+      "sonarjs/no-use-of-empty-return-value": "off"
+    }
+  });
+}
+function node() {
+  return [
+    {
+      plugins: {
+        n: nodePlugin
+      },
+      rules: {
+        ...nodePlugin.configs.recommended.rules,
+        /**
+         * Disallow the use of extraneous imports. This rule helps prevent the
+         * use of third-party modules that are not listed in the project's
+         * dependencies.
+         *
+         * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-extraneous-import.md
+         */
+        "n/no-extraneous-import": "error",
+        /**
+         * Disable the no-missing-import as module resolution is already checked
+         * by other tools and IDEs extensively. This rule is redundant.
+         *
+         * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-missing-import.md
+         */
+        "n/no-missing-import": "off",
+        "n/no-missing-require": "off",
+        /**
+         * Enfore the use of the asyncrounous version of the `fs` and `dns` APIs.
+         *
+         * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-sync.md
+         * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-promises/fs.md
+         * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-promises/dns.md
+         */
+        "n/no-sync": "off",
+        "n/prefer-promises/fs": "error",
+        "n/prefer-promises/dns": "error",
+        /**
+         * Allow the use of features up to Node.js version 20. This will allow
+         * the use of newer ECMAScript features and Node.js APIs.
+         *
+         * @see https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules
+         */
+        "n/no-unsupported-features/es-syntax": "error",
+        "n/no-unsupported-features/es-builtins": "error",
+        "n/no-unsupported-features/node-builtins": "error",
+        /**
+         * Prepend the `node:` prefix to all Node.js core modules. This helps
+         * identify the module as a Node.js core module and not a third-party
+         * module.
+         *
+         * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-node-protocol.md
+         */
+        "n/prefer-node-protocol": "error"
+      },
+      settings: {
+        node: {
+          version: ">=20.0.0"
+        }
+      }
+    }
+  ];
+}
+function jsonTsconfig() {
+  return [
+    {
+      files: [
+        "**/tsconfig.json",
+        "**/tsconfig.*.json"
+      ],
+      rules: {
+        "jsonc/sort-array-values": [
+          "error",
+          {
+            order: { type: "asc" },
+            pathPattern: "^(includes|excludes)$"
+          }
+        ],
+        "jsonc/sort-keys": [
+          "error",
+          {
+            order: [
+              "extends",
+              "compilerOptions",
+              "references",
+              "files",
+              "include",
+              "exclude"
+            ],
+            pathPattern: "^$"
+          },
+          {
+            order: [
+              // --- Project Structure
+              "incremental",
+              "composite",
+              "tsBuildInfoFile",
+              "disableSourceOfProjectReferenceRedirect",
+              "disableSolutionSearching",
+              "disableReferencedProjectLoad",
+              // --- Language and Environment
+              "target",
+              "jsx",
+              "jsxFactory",
+              "jsxFragmentFactory",
+              "jsxImportSource",
+              "lib",
+              "moduleDetection",
+              "noLib",
+              "reactNamespace",
+              "useDefineForClassFields",
+              "emitDecoratorMetadata",
+              "experimentalDecorators",
+              // --- Module Resolution
+              "baseUrl",
+              "rootDir",
+              "rootDirs",
+              "customConditions",
+              "module",
+              "moduleResolution",
+              "moduleSuffixes",
+              "noResolve",
+              "paths",
+              "resolveJsonModule",
+              "resolvePackageJsonExports",
+              "resolvePackageJsonImports",
+              "typeRoots",
+              "types",
+              "allowArbitraryExtensions",
+              "allowImportingTsExtensions",
+              "allowUmdGlobalAccess",
+              // --- JavaScript Support
+              "allowJs",
+              "checkJs",
+              "maxNodeModuleJsDepth",
+              // --- Type Checking
+              "strict",
+              "strictBindCallApply",
+              "strictFunctionTypes",
+              "strictNullChecks",
+              "strictPropertyInitialization",
+              "allowUnreachableCode",
+              "allowUnusedLabels",
+              "alwaysStrict",
+              "exactOptionalPropertyTypes",
+              "noFallthroughCasesInSwitch",
+              "noImplicitAny",
+              "noImplicitOverride",
+              "noImplicitReturns",
+              "noImplicitThis",
+              "noPropertyAccessFromIndexSignature",
+              "noUncheckedIndexedAccess",
+              "noUnusedLocals",
+              "noUnusedParameters",
+              "useUnknownInCatchVariables",
+              // --- Emitting
+              "declaration",
+              "declarationDir",
+              "declarationMap",
+              "downlevelIteration",
+              "emitBOM",
+              "emitDeclarationOnly",
+              "importHelpers",
+              "importsNotUsedAsValues",
+              "inlineSourceMap",
+              "inlineSources",
+              "mapRoot",
+              "newLine",
+              "noEmit",
+              "noEmitHelpers",
+              "noEmitOnError",
+              "outDir",
+              "outFile",
+              "preserveConstEnums",
+              "preserveValueImports",
+              "removeComments",
+              "sourceMap",
+              "sourceRoot",
+              "stripInternal",
+              // --- Interop Constraints
+              "allowSyntheticDefaultImports",
+              "esModuleInterop",
+              "forceConsistentCasingInFileNames",
+              "isolatedModules",
+              "preserveSymlinks",
+              "verbatimModuleSyntax",
+              // --- Completeness
+              "skipDefaultLibCheck",
+              "skipLibCheck"
+            ],
+            pathPattern: "^compilerOptions$"
+          },
+          {
+            order: { type: "asc" },
+            pathPattern: "^compilerOptions\\.paths$"
+          }
+        ]
+      }
+    }
+  ];
+}
+function jsonPackage() {
+  return [
+    {
+      files: [
+        "**/package.json"
+      ],
+      rules: {
+        "jsonc/sort-keys": [
+          "error",
+          {
+            order: [
+              "name",
+              "type",
+              "version",
+              "license",
+              "private",
+              "sideEffects",
+              // --- Publishing
+              "description",
+              "author",
+              "keywords",
+              "bugs",
+              "funding",
+              "homepage",
+              "repository",
+              // --- Distribution
+              "bin",
+              "main",
+              "module",
+              "types",
+              "typings",
+              "browser",
+              "exports",
+              "files",
+              // --- Package Manager
+              "packageManager",
+              "pnpm",
+              // --- Scripts
+              "scripts",
+              // --- Dependencies
+              "peerDependencies",
+              "peerDependenciesMeta",
+              "optionalDependencies",
+              "dependencies",
+              "devDependencies",
+              "bundledDependencies",
+              "bundleDependencies",
+              // --- Config
+              "tsup",
+              "husky",
+              "lint-staged",
+              "eslintConfig"
+            ],
+            pathPattern: "^$"
+          },
+          {
+            order: { type: "asc" },
+            pathPattern: "^(?:dev|peer|optional|bundled)?[Dd]ependencies$"
+          }
+        ]
+      }
+    }
+  ];
+}
+function configJson() {
+  return [
+    ...jsonc.configs["flat/recommended-with-json"],
+    {
+      files: [
+        "**/*.json",
+        "**/*.json5"
+      ],
+      rules: {
+        /**
+         * Automatically apply jsonc rules similar to your configured ESLint core rules to JSON.
+         *
+         * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/auto.html
+         */
+        "jsonc/auto": "error"
+      }
+    }
+  ];
+}
+function jsdoc() {
+  return [
+    pluginJsdoc.configs["flat/recommended-typescript-flavor-error"],
+    {
+      files: [
+        "**/*.{ts,mts,cts,tsx,d.ts}",
+        "**/*.{js,mjs,cjs,jsx}",
+        "**/*.vue"
+      ],
+      rules: {
+        /**
+         * Enforce a consistent padding of the block description.
+         *
+         * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/HEAD/docs/rules/check-alignment.md#readme
+         */
+        "jsdoc/check-alignment": "error",
+        /**
+         * Normalize the indentation in the JSdoc comment to improve readability.
+         *
+         * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-indentation.md#readme
+         */
+        "jsdoc/check-indentation": "error",
+        /**
+         * Enforce a strict set of tags for the JSDoc comment. This rule also includes
+         * some custom tags that are used in our projects.
+         *
+         * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/.README/rules/check-tag-names.md
+         */
+        "jsdoc/require-jsdoc": "off",
+        "jsdoc/require-param-type": "off",
+        "jsdoc/check-tag-names": ["error", {
+          definedTags: [
+            "category"
+          ]
+        }],
+        /**
+         * Checks for multi-line-style comments which fail to meet the criteria of a jsdoc block,
+         * namely that it should begin with two and only two asterisks.
+         *
+         * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/no-bad-blocks.md
+         */
+        "jsdoc/no-bad-blocks": "error",
+        /**
+         * It is common practice to prefix a hyphen to parameters in JSDoc. But this
+         * is sometimes forgotten and has no real purpose. This rule aims to enforce
+         * that no hyphen is used.
+         *
+         * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-hyphen-before-param-description
+         */
+        "jsdoc/require-hyphen-before-param-description": ["error", "never"],
+        /**
+         * Since we are using TypeScript, we don't need to enforce types in JSDoc.
+         *
+         * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-param-type.md
+         */
+        "jsdoc/require-returns-type": "off",
+        /**
+         * Enforce a new-line between the JSDoc summary and tags. Aims to improve
+         * readability by separating the summary and tags.
+         *
+         * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/tag-lines.md
+         */
+        "jsdoc/tag-lines": ["error", "any", { startLines: 1 }]
+      }
+    }
+  ];
+}
+function eslintComments() {
+  return [
+    {
+      plugins: {
+        "eslint-comments": eslintCommentsPlugin
+      },
+      rules: {
+        /**
+         * Allow multiple rules directive in a single comment. This
+         * reduces the number of comments in the code.
+         *
+         * @see https://mysticatea.github.io/eslint-plugin-eslint-comments/rules/disable-enable-pair
+         */
+        "eslint-comments/disable-enable-pair": "off",
+        /**
+         * `eslint-enable` directive-comments can enable rules which are disabled by different
+         * eslint-disable directive-comments. It can enable a rule unintentionally. This rule
+         * will report such cases.
+         *
+         * @see https://mysticatea.github.io/eslint-plugin-eslint-comments/rules/no-aggregating-enable
+         */
+        "eslint-comments/no-aggregating-enable": "error",
+        /**
+         * Disallow duplicate eslint-disable comments. This rule will report when there are
+         * multiple eslint-disable comments for the same rule, either in the same line or enabled
+         * by different eslint-disable comments.
+         *
+         * @see https://mysticatea.github.io/eslint-plugin-eslint-comments/rules/no-duplicate-disable
+         */
+        "eslint-comments/no-duplicate-disable": "error",
+        /**
+         * Disallow eslint-disable comments without rule names. This ensures that we cannot
+         * disable all rules in a file using eslint-disable comment.
+         *
+         * @see https://mysticatea.github.io/eslint-plugin-eslint-comments/rules/no-unlimited-disable
+         */
+        "eslint-comments/no-unlimited-disable": "error",
+        /**
+         * Errors when an eslint-disable comment has no effect. This is useful
+         * to prevent unnecessary comments in the code.
+         *
+         * @see https://mysticatea.github.io/eslint-plugin-eslint-comments/rules/no-unused-disable
+         */
+        "eslint-comments/no-unused-disable": "error"
+      }
+    }
+  ];
+}
+function antfu() {
+  return [
+    {
+      plugins: {
+        antfu: pluginAntfu
+      },
+      rules: {
+        "antfu/consistent-list-newline": "error",
+        /**
+         * Auto-fix import duplication. The TypeScript compiler already detects and removes
+         * duplicate imports, but this rule can be used to fix the issue automatically in the editor.
+         *
+         * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/import-dedupe.md
+         */
+        "antfu/import-dedupe": "error",
+        /**
+         * Enforce top-level function to be declared using function instead of arrow function. This
+         * rule helps when you want to add additional overload signatures to a function without
+         * having to transform the arrow function into a function declaration manually.
+         *
+         * On top of that, it mitigates the risk of accidentally using the `this` instance from
+         * an outer scope.
+         *
+         * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/top-level-function.md
+         */
+        "antfu/top-level-function": "error",
+        /**
+         * Enforce consistent line breaks inside braces of object/array/named imports/exports and
+         * function parameters. Reduces the cognitive load of reasoning about code style.
+         *
+         * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/consistent-list-newline.md
+         */
+        "object-curly-newline": "off"
+      }
+    }
+  ];
+}
+function all(options = {}) {
+  return [
+    ...antfu(),
+    ...eslintComments(),
+    ...jsdoc(),
+    ...configJson(),
+    ...jsonPackage(),
+    ...jsonTsconfig(),
+    ...node(),
+    ...sonarjs(),
+    ...typescript(options),
+    ...unicorn(),
+    ...vitest(),
+    ...vue(options),
+    // ...promise(),
+    // ...markdown(),
+    {
+      ignores: [
+        "**/dist",
+        "**/bin",
+        "**/node_modules",
+        "**/.nuxt",
+        "**/output",
+        "**/coverage",
+        "**/public",
+        "**/__wip__",
+        "**/__snapshots__",
+        "**/LICENSE*",
+        "**/CHANGELOG*",
+        "packages-lock.json",
+        "pnpm-lock.yaml",
+        "yarn.lock"
+      ]
+    }
+  ];
+}
+export {
+  all as default
+};
+//# sourceMappingURL=index.js.map