@fabdeh/eslint-config 0.6.4 → 0.7.0

package/dist/index.mjs

@@ -1,2069 +0,0 @@
-import { isPackageExists } from 'local-pkg';
-import tseslint from 'typescript-eslint';
-import { statSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { resolve, dirname, join } from 'node:path';
-import process from 'node:process';
-import eslint from '@eslint/js';
-import preferArrowFunctions from 'eslint-plugin-prefer-arrow-functions';
-import unusedImports from 'eslint-plugin-unused-imports';
-import globals from 'globals';
-import eslintComments from '@eslint-community/eslint-plugin-eslint-comments';
-import * as importX from 'eslint-plugin-import-x';
-import perfectionistPlugin from 'eslint-plugin-perfectionist';
-import jsdocPlugin from 'eslint-plugin-jsdoc';
-import unicornPlugin from 'eslint-plugin-unicorn';
-import { configs } from 'eslint-plugin-regexp';
-import { mergeProcessors, processorPassThrough } from 'eslint-merge-processors';
-
-const GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
-const GLOB_SRC = `**/*.${GLOB_SRC_EXT}`;
-const GLOB_JS = "**/*.?([cm])js?(x)";
-const GLOB_TS_EXT = "?([cm])ts?(x)";
-const GLOB_TS = `**/*.${GLOB_TS_EXT}`;
-const GLOB_CSS = "**/*.css";
-const GLOB_POSTCSS = "**/*.{p,post}css";
-const GLOB_LESS = "**/*.less";
-const GLOB_SCSS = "**/*.scss";
-const GLOB_JSON = "**/*.json";
-const GLOB_JSON5 = "**/*.json5";
-const GLOB_JSONC = "**/*.jsonc";
-const GLOB_MARKDOWN = "**/*.md";
-const GLOB_MARKDOWN_IN_MARKDOWN = "**/*.md/*.md";
-const GLOB_MARKDOWN_CODE = `${GLOB_MARKDOWN}/${GLOB_SRC}`;
-const GLOB_YAML = "**/*.y?(a)ml";
-const GLOB_TOML = "**/*.toml";
-const GLOB_XML = "**/*.xml";
-const GLOB_SVG = "**/*.svg";
-const GLOB_GRAPHQL = "**/*.{g,graph}ql";
-const GLOB_HTML = "**/*.htm?(l)";
-const GLOB_TESTS = [`**/*.spec.?([cm])[jt]s`, `**/*.test.?([cm])[jt]s`, `**/test-setup.?([cm])[jt]s`];
-const GLOB_EXCLUDE = [
-  "**/node_modules",
-  "**/dist",
-  "**/package-lock.json",
-  "**/yarn.lock",
-  "**/pnpm-lock.yaml",
-  "**/bun.lockb",
-  "**/output",
-  "**/coverage",
-  "**/temp",
-  "**/.temp",
-  "**/tmp",
-  "**/.tmp",
-  "**/.history",
-  "**/.vitepress/cache",
-  "**/.nuxt",
-  "**/.next",
-  "**/.svelte-kit",
-  "**/.vercel",
-  "**/.changeset",
-  "**/.idea",
-  "**/.cache",
-  "**/.output",
-  "**/.tsup",
-  "**/.vite-inspect",
-  "**/.yarn",
-  "**/vite.config.*.timestamp-*",
-  "**/CHANGELOG*.md",
-  "**/*.min.*",
-  "**/LICENSE*",
-  "**/__snapshots__",
-  "**/auto-import?(s).d.ts",
-  "**/components.d.ts",
-  "**/prettier-types.ts"
-];
-
-const SCOPE_URL = import.meta.dirname;
-const IS_CWD_IN_SCOPE = isPackageExists("@fabdeh/eslint-config");
-async function interopDefault(m) {
-  const resolved = await m;
-  return resolved.default ?? resolved;
-}
-function fileExists(path) {
-  try {
-    return statSync(path).isFile();
-  } catch {
-    return false;
-  }
-}
-function getWorkspaceRoot(dir, candidateRoot) {
-  if (process.env.NX_WORKSPACE_ROOT) {
-    return process.env.NX_WORKSPACE_ROOT;
-  }
-  if (dirname(dir) === dir) {
-    return candidateRoot;
-  }
-  const matches = [join(dir, "nx.json"), join(dir, "nx"), join(dir, "nx.bat")];
-  if (matches.some((x) => fileExists(x))) {
-    return dir;
-  } else if (fileExists(join(dir, "node_modules", "nx", "package.json"))) {
-    return getWorkspaceRoot(dirname(dir), dir);
-  } else {
-    return getWorkspaceRoot(dirname(dir), candidateRoot);
-  }
-}
-function getTsConfigFileName(dir) {
-  return ["tsconfig.base.json", "tsconfig.json"].map((filename) => ({ filename, path: join(dir, filename) })).filter(({ path }) => fileExists(path)).map(({ filename }) => filename).at(0);
-}
-function isPackageInScope(name) {
-  return isPackageExists(name, { paths: [SCOPE_URL] });
-}
-async function ensurePackages(packages) {
-  if (process.env.CI || !process.stdout.isTTY || !IS_CWD_IN_SCOPE) {
-    return;
-  }
-  const nonExistingPackages = packages.filter((i) => i && !isPackageInScope(i));
-  if (nonExistingPackages.length === 0) {
-    return;
-  }
-  const p = await import('@clack/prompts');
-  const result = await p.confirm({
-    message: `${nonExistingPackages.length === 1 ? "Package is" : "Packages are"} required for this config: ${nonExistingPackages.join(", ")}. Do you want to install them?`
-  });
-  if (result) {
-    await import('@antfu/install-pkg').then((i) => i.installPackage(nonExistingPackages, { dev: true }));
-  }
-}
-async function findNearestPackageJsonName(directoryPath = resolve()) {
-  try {
-    const packageJsonPath = join(directoryPath, "package.json");
-    const packageJsonData = JSON.parse(await readFile(packageJsonPath, "utf8"));
-    return packageJsonData.name;
-  } catch {
-    const parentDir = dirname(directoryPath);
-    if (directoryPath === parentDir) {
-      throw new Error("No package.json file found.");
-    }
-    return findNearestPackageJsonName(parentDir);
-  }
-}
-function resolveSubOptions(options, key) {
-  const option = options[key];
-  if (typeof option === "boolean") {
-    return void 0;
-  }
-  return option ?? {};
-}
-
-async function angular(options = {}) {
-  const angularEslint = await interopDefault(import('angular-eslint'));
-  const {
-    enableAccessibilityRules = true,
-    tsOverrides = {},
-    htmlOverrides = {},
-    prefix = "app",
-    ignoreClassNamePatternForInjectableProvidedIn: ignoreClassNamePattern,
-    componentStylesMode = "string",
-    preferOnPushOnly = true,
-    banExperimentalApi = true,
-    banDeveloperPreviewApi = true
-  } = options;
-  return tseslint.config(
-    {
-      name: "fabdeh/angular/rules",
-      plugins: {
-        "@angular-eslint": angularEslint.tsPlugin
-      },
-      processor: angularEslint.processInlineTemplates,
-      files: [GLOB_TS],
-      rules: {
-        "max-classes-per-file": ["error", 1],
-        "max-lines": ["error", 400],
-        "new-cap": [
-          "error",
-          {
-            capIsNewExceptions: [
-              "Attribute",
-              "Component",
-              "ContentChild",
-              "ContentChildren",
-              "Directive",
-              "Host",
-              "HostBinding",
-              "HostListener",
-              "Inject",
-              "Injectable",
-              "Input",
-              "NgModule",
-              "Optional",
-              "Output",
-              "Pipe",
-              "Self",
-              "SkipSelf",
-              "ViewChild",
-              "ViewChildren"
-            ]
-          }
-        ],
-        ...angularEslint.configs.tsRecommended.find((c) => c.name === "angular-eslint/ts-recommended")?.rules,
-        "@angular-eslint/component-max-inline-declarations": "error",
-        "@angular-eslint/component-selector": [
-          "error",
-          {
-            type: "element",
-            prefix,
-            style: "kebab-case"
-          }
-        ],
-        "@angular-eslint/consistent-component-styles": ["error", componentStylesMode],
-        "@angular-eslint/contextual-decorator": "error",
-        "@angular-eslint/directive-selector": [
-          "error",
-          {
-            type: "attribute",
-            prefix,
-            style: "camelCase"
-          }
-        ],
-        "@angular-eslint/no-async-lifecycle-method": "error",
-        "@angular-eslint/no-attribute-decorator": "error",
-        "@angular-eslint/no-conflicting-lifecycle": "error",
-        ...banDeveloperPreviewApi ? { "@angular-eslint/no-developer-preview": "error" } : {},
-        "@angular-eslint/no-duplicates-in-metadata-arrays": "error",
-        ...banExperimentalApi ? { "@angular-eslint/no-experimental": "error" } : {},
-        "@angular-eslint/no-forward-ref": "error",
-        "@angular-eslint/no-lifecycle-call": "error",
-        "@angular-eslint/no-pipe-impure": "error",
-        "@angular-eslint/no-queries-metadata-property": "error",
-        "@angular-eslint/no-uncalled-signals": "error",
-        "@angular-eslint/prefer-output-emitter-ref": "error",
-        "@angular-eslint/prefer-output-readonly": "error",
-        "@angular-eslint/prefer-signals": "error",
-        ...preferOnPushOnly ? { "@angular-eslint/prefer-on-push-component-change-detection": "error" } : {},
-        "@angular-eslint/relative-url-prefix": "error",
-        "@angular-eslint/require-lifecycle-on-prototype": "error",
-        "@angular-eslint/sort-keys-in-type-decorator": "error",
-        "@angular-eslint/sort-lifecycle-methods": "error",
-        "@angular-eslint/use-component-selector": "error",
-        "@angular-eslint/use-component-view-encapsulation": "error",
-        "@angular-eslint/use-injectable-provided-in": ignoreClassNamePattern ? ["error", { ignoreClassNamePattern }] : "error",
-        "@angular-eslint/use-lifecycle-interface": "error",
-        ...tsOverrides
-      }
-    },
-    {
-      name: "fabdeh/angular-template/rules",
-      plugins: {
-        "@angular-eslint/template": angularEslint.templatePlugin
-      },
-      languageOptions: {
-        parser: angularEslint.templateParser
-      },
-      files: [GLOB_HTML],
-      rules: {
-        ...angularEslint.configs.templateRecommended.find((c) => c.name === "angular-eslint/template-recommended")?.rules,
-        "@angular-eslint/template/attributes-order": ["error", { alphabetical: true }],
-        "@angular-eslint/template/button-has-type": "error",
-        "@angular-eslint/template/conditional-complexity": "error",
-        "@angular-eslint/template/eqeqeq": ["error", { allowNullOrUndefined: true }],
-        "@angular-eslint/template/no-any": "error",
-        "@angular-eslint/template/no-duplicate-attributes": "error",
-        "@angular-eslint/template/no-interpolation-in-attributes": "error",
-        "@angular-eslint/template/no-positive-tabindex": "error",
-        "@angular-eslint/template/prefer-control-flow": "error",
-        "@angular-eslint/template/prefer-ngsrc": "error",
-        "@angular-eslint/template/prefer-self-closing-tags": "error",
-        "@angular-eslint/template/prefer-static-string-properties": "error",
-        ...enableAccessibilityRules ? angularEslint.configs.templateAccessibility.find((c) => c.name === "angular-eslint/template-accessibility")?.rules : {},
-        ...htmlOverrides
-      }
-    }
-  );
-}
-
-function comments() {
-  return tseslint.config({
-    name: "fabdeh/comments/rules",
-    files: [GLOB_SRC],
-    plugins: {
-      "@eslint-community/eslint-comments": eslintComments
-    },
-    rules: {
-      "@eslint-community/eslint-comments/disable-enable-pair": ["error", { allowWholeFile: true }],
-      "@eslint-community/eslint-comments/no-aggregating-enable": "error",
-      "@eslint-community/eslint-comments/no-duplicate-disable": "error",
-      "@eslint-community/eslint-comments/no-unlimited-disable": "error",
-      "@eslint-community/eslint-comments/no-unused-disable": "error",
-      "@eslint-community/eslint-comments/no-unused-enable": "error"
-    }
-  });
-}
-
-function ignores(userIgnores = []) {
-  return tseslint.config({
-    name: "fabdeh/ignores",
-    ignores: [...GLOB_EXCLUDE, ...userIgnores]
-  });
-}
-
-function imports(options = {}) {
-  const { stylistic = true } = options;
-  return tseslint.config(
-    {
-      name: "fabdeh/imports/rules",
-      files: [GLOB_SRC],
-      plugins: {
-        "import-x": importX
-      },
-      rules: {
-        "import-x/consistent-type-specifier-style": ["error", "prefer-top-level"],
-        "import-x/default": "error",
-        "import-x/export": "error",
-        "import-x/first": "error",
-        "import-x/named": "error",
-        "import-x/no-absolute-path": "error",
-        "import-x/no-deprecated": "error",
-        "import-x/no-duplicates": "error",
-        "import-x/no-empty-named-blocks": "error",
-        "import-x/no-extraneous-dependencies": "error",
-        "import-x/no-mutable-exports": "error",
-        "import-x/no-named-as-default": "warn",
-        "import-x/no-named-as-default-member": "warn",
-        "import-x/no-named-default": "error",
-        "import-x/no-self-import": "error",
-        "import-x/no-useless-path-segments": "error",
-        "import-x/no-webpack-loader-syntax": "error",
-        ...stylistic ? {
-          "import-x/newline-after-import": ["error", { considerComments: true, count: 1 }]
-        } : {}
-      }
-    },
-    {
-      name: "fabdeh/imports/ts-disables",
-      files: [GLOB_TS],
-      rules: {
-        "import-x/named": "off",
-        "import-x/no-deprecated": "off"
-      }
-    }
-  );
-}
-
-function javascript(options = {}) {
-  const { overrides = {} } = options;
-  return tseslint.config(
-    {
-      name: "fabdeh/javascript/setup",
-      languageOptions: {
-        ecmaVersion: 2022,
-        globals: {
-          ...globals.browser,
-          ...globals.es2021,
-          ...globals.node,
-          document: "readonly",
-          navigator: "readonly",
-          window: "readonly"
-        },
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true
-          },
-          ecmaVersion: 2022,
-          sourceType: "module"
-        },
-        sourceType: "module"
-      },
-      linterOptions: {
-        reportUnusedDisableDirectives: "error"
-      }
-    },
-    {
-      name: "fabdeh/javascript/rules",
-      files: [GLOB_SRC],
-      plugins: {
-        "@typescript-eslint": tseslint.plugin,
-        "prefer-arrow-functions": preferArrowFunctions,
-        "unused-imports": unusedImports
-      },
-      rules: {
-        ...eslint.configs.recommended.rules,
-        "accessor-pairs": "error",
-        "array-callback-return": "error",
-        "block-scoped-var": "error",
-        "default-case-last": "error",
-        "dot-notation": "error",
-        eqeqeq: "error",
-        "id-denylist": [
-          "error",
-          "any",
-          "Number",
-          "number",
-          "String",
-          "string",
-          "Boolean",
-          "boolean",
-          "Undefined",
-          "undefined"
-        ],
-        "new-cap": "error",
-        "no-alert": "error",
-        "no-caller": "error",
-        "no-cond-assign": ["error", "always"],
-        "no-console": ["error", { allow: ["warn", "error"] }],
-        "no-empty": ["error", { allowEmptyCatch: true }],
-        "no-eval": "error",
-        "no-extend-native": "error",
-        "no-extra-bind": "error",
-        "no-implied-eval": "error",
-        "no-iterator": "error",
-        "no-labels": "error",
-        "no-lone-blocks": "error",
-        "no-lonely-if": "error",
-        "no-multi-str": "error",
-        "no-new": "error",
-        "no-new-func": "error",
-        "no-new-wrappers": "error",
-        "no-octal-escape": "error",
-        "no-plusplus": ["error", { allowForLoopAfterthoughts: true }],
-        "no-proto": "error",
-        /*
-        'no-restricted-syntax': [
-          'error',
-          {
-            selector: 'TSEnumDeclaration',
-            message: '',
-          },
-          {
-            selector: 'TSExportAssignment',
-            message: '',
-          },
-          {
-            selector: 'ForInStatement',
-            message: '',
-          },
-          {
-            selector: ':matches(PropertyDefinition, MethodDefinition)[accessibility="private"]',
-            message: 'Use `#private` members instead.',
-          },
-        ],
-        */
-        "no-self-compare": "error",
-        "no-sequences": "error",
-        "no-template-curly-in-string": "error",
-        "no-throw-literal": "error",
-        "no-undef-init": "error",
-        "no-unmodified-loop-condition": "error",
-        "no-unneeded-ternary": ["error", { defaultAssignment: false }],
-        "no-unreachable-loop": "error",
-        "no-unused-expressions": [
-          "error",
-          {
-            allowShortCircuit: true,
-            allowTaggedTemplates: true,
-            allowTernary: true
-          }
-        ],
-        "no-use-before-define": ["error", { classes: false, functions: false }],
-        "no-useless-call": "error",
-        "no-useless-computed-key": "error",
-        "no-useless-constructor": "error",
-        "no-useless-rename": "error",
-        "no-useless-return": "error",
-        "no-var": "error",
-        "object-shorthand": [
-          "error",
-          "always",
-          {
-            avoidQuotes: true,
-            ignoreConstructors: false
-          }
-        ],
-        "prefer-arrow-callback": "error",
-        "prefer-arrow-functions/prefer-arrow-functions": [
-          "error",
-          { singleReturnOnly: true, allowNamedFunctions: true }
-        ],
-        "prefer-const": "error",
-        "prefer-exponentiation-operator": "error",
-        "prefer-object-spread": "error",
-        "prefer-promise-reject-errors": "error",
-        "prefer-regex-literals": ["error", { disallowRedundantWrapping: true }],
-        "prefer-rest-params": "error",
-        "prefer-spread": "error",
-        "prefer-template": "error",
-        "symbol-description": "error",
-        "unicode-bom": ["error", "never"],
-        "unused-imports/no-unused-imports": "error",
-        "no-unused-vars": "off",
-        "unused-imports/no-unused-vars": [
-          "error",
-          {
-            args: "after-used",
-            argsIgnorePattern: "^_",
-            ignoreRestSiblings: true,
-            vars: "all",
-            varsIgnorePattern: "^_"
-          }
-        ],
-        "use-isnan": ["error", { enforceForIndexOf: true }],
-        "valid-typeof": ["error", { requireStringLiterals: true }],
-        "vars-on-top": "error",
-        yoda: ["error", "never", { exceptRange: true }],
-        "@typescript-eslint/ban-ts-comment": "error",
-        "@typescript-eslint/no-extra-non-null-assertion": "error",
-        "@typescript-eslint/no-misused-new": "error",
-        "@typescript-eslint/no-non-null-asserted-optional-chain": "error",
-        "@typescript-eslint/no-require-imports": ["error", { allowAsImport: true }],
-        "@typescript-eslint/no-this-alias": "error",
-        ...overrides
-      }
-    }
-  );
-}
-
-function getJsDocRules(level, stylistic, mode) {
-  return {
-    ...mode === "both" || mode === "jsOnly" ? {
-      "jsdoc/check-access": level,
-      "jsdoc/check-param-names": level,
-      "jsdoc/check-property-names": level,
-      "jsdoc/check-tag-names": level,
-      "jsdoc/check-types": level,
-      "jsdoc/check-values": level,
-      "jsdoc/empty-tags": level,
-      "jsdoc/implements-on-classes": level,
-      "jsdoc/no-defaults": level,
-      "jsdoc/no-undefined-types": level,
-      "jsdoc/require-jsdoc": level,
-      "jsdoc/require-param": level,
-      "jsdoc/require-param-description": level,
-      "jsdoc/require-param-name": level,
-      "jsdoc/require-param-type": level,
-      "jsdoc/require-property": level,
-      "jsdoc/require-property-description": level,
-      "jsdoc/require-property-name": level,
-      "jsdoc/require-property-type": level,
-      "jsdoc/require-returns": level,
-      "jsdoc/require-returns-check": level,
-      "jsdoc/require-returns-description": level,
-      "jsdoc/require-returns-type": level,
-      "jsdoc/require-yields": level,
-      "jsdoc/require-yields-check": level,
-      "jsdoc/valid-types": level,
-      ...stylistic ? {
-        "jsdoc/check-alignment": level,
-        "jsdoc/multiline-blocks": level,
-        "jsdoc/no-multi-asterisks": level,
-        "jsdoc/require-asterisk-prefix": level,
-        "jsdoc/require-hyphen-before-param-description": level,
-        "jsdoc/tag-lines": [level, "never", { startLines: 1 }]
-      } : {}
-    } : {},
-    ...mode === "both" || mode === "tsOnly" ? {
-      "jsdoc/check-tag-names": [level, { typed: true }],
-      "jsdoc/no-types": level,
-      "jsdoc/no-undefined-types": "off",
-      "jsdoc/require-param-type": "off",
-      "jsdoc/require-property-type": "off",
-      "jsdoc/require-returns-type": "off"
-    } : {}
-  };
-}
-function jsdoc(options = {}) {
-  const { stylistic = true } = options;
-  return tseslint.config(
-    {
-      name: "fabdeh/jsdoc/rules",
-      files: [GLOB_SRC],
-      plugins: { jsdoc: jsdocPlugin },
-      rules: getJsDocRules("warn", !!stylistic, "jsOnly")
-    },
-    {
-      name: "fabdeh/jsdoc/ts-only/rules",
-      files: [GLOB_TS],
-      rules: getJsDocRules("warn", !!stylistic, "tsOnly")
-    }
-  );
-}
-
-async function jsonc(options = {}) {
-  const {
-    files = [GLOB_JSON, GLOB_JSON5, GLOB_JSONC],
-    overrides = {},
-    stylistic = true
-  } = options;
-  const { indent = 2 } = typeof stylistic === "object" ? stylistic : {};
-  const [jsoncPlugin, jsoncParser] = await Promise.all([
-    interopDefault(import('eslint-plugin-jsonc')),
-    interopDefault(import('jsonc-eslint-parser'))
-  ]);
-  return tseslint.config(
-    {
-      name: "fabdeh/jsonc/setup",
-      plugins: {
-        jsonc: jsoncPlugin
-      }
-    },
-    {
-      name: "fabdeh/jsonc/rules",
-      languageOptions: {
-        parser: jsoncParser
-      },
-      files,
-      rules: {
-        "jsonc/no-bigint-literals": "error",
-        "jsonc/no-binary-expression": "error",
-        "jsonc/no-binary-numeric-literals": "error",
-        "jsonc/no-dupe-keys": "error",
-        "jsonc/no-escape-sequence-in-identifier": "error",
-        "jsonc/no-floating-decimal": "error",
-        "jsonc/no-hexadecimal-numeric-literals": "error",
-        "jsonc/no-infinity": "error",
-        "jsonc/no-multi-str": "error",
-        "jsonc/no-nan": "error",
-        "jsonc/no-number-props": "error",
-        "jsonc/no-numeric-separators": "error",
-        "jsonc/no-octal": "error",
-        "jsonc/no-octal-escape": "error",
-        "jsonc/no-octal-numeric-literals": "error",
-        "jsonc/no-parenthesized": "error",
-        "jsonc/no-plus-sign": "error",
-        "jsonc/no-regexp-literals": "error",
-        "jsonc/no-sparse-arrays": "error",
-        "jsonc/no-template-literals": "error",
-        "jsonc/no-undefined-value": "error",
-        "jsonc/no-unicode-codepoint-escapes": "error",
-        "jsonc/no-useless-escape": "error",
-        "jsonc/space-unary-ops": "error",
-        "jsonc/valid-json-number": "error",
-        "jsonc/vue-custom-block/no-parsing-error": "error",
-        ...stylistic ? {
-          "jsonc/array-bracket-spacing": ["error", "never"],
-          "jsonc/comma-dangle": ["error", "never"],
-          "jsonc/comma-style": ["error", "last"],
-          "jsonc/indent": ["error", indent],
-          "jsonc/key-spacing": ["error", { afterColon: true, beforeColon: false }],
-          "jsonc/object-curly-newline": ["error", { consistent: true, multiline: true }],
-          "jsonc/object-curly-spacing": ["error", "always"],
-          "jsonc/object-property-newline": ["error", { allowMultiplePropertiesPerLine: true }],
-          "jsonc/quote-props": "error",
-          "jsonc/quotes": "error"
-        } : {},
-        ...overrides
-      }
-    }
-  );
-}
-
-async function markdown(options = {}) {
-  const {
-    files = [GLOB_MARKDOWN],
-    overrides = {}
-  } = options;
-  const markdownPlugin = await interopDefault(import('@eslint/markdown'));
-  const parserPlain = {
-    meta: {
-      name: "parser-plain"
-    },
-    parseForESLint: (code) => ({
-      ast: {
-        body: [],
-        comments: [],
-        loc: { end: code.length, start: 0 },
-        range: [0, code.length],
-        tokens: [],
-        type: "Program"
-      },
-      // eslint-disable-next-line unicorn/no-null
-      scopeManager: null,
-      services: { isPlain: true },
-      visitorKeys: {
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        Program: []
-      }
-    })
-  };
-  return tseslint.config(
-    {
-      name: "fabdeh/markdown/setup",
-      plugins: {
-        markdown: markdownPlugin
-      }
-    },
-    {
-      name: "fabdeh/markdown/processor",
-      files,
-      ignores: [GLOB_MARKDOWN_IN_MARKDOWN],
-      processor: mergeProcessors([
-        markdownPlugin.processors.markdown,
-        processorPassThrough
-      ])
-    },
-    {
-      name: "fabdeh/markdown/parser",
-      files,
-      languageOptions: {
-        parser: parserPlain
-      }
-    },
-    {
-      name: "fabdeh/markdown/disables",
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            impliedStrict: true
-          }
-        }
-      },
-      files: [GLOB_MARKDOWN_CODE],
-      rules: {
-        ...tseslint.configs.disableTypeChecked.rules,
-        "import-x/newline-after-import": "off",
-        "no-alert": "off",
-        "no-console": "off",
-        "no-labels": "off",
-        "no-lone-blocks": "off",
-        "no-restricted-syntax": "off",
-        "no-undef": "off",
-        "no-unused-expressions": "off",
-        "no-unused-labels": "off",
-        "no-unused-vars": "off",
-        // 'node/prefer-global/process': 'off',
-        "@stylistic/comma-dangle": "off",
-        "@stylistic/eol-last": "off",
-        "@typescript-eslint/consistent-type-imports": "off",
-        "@typescript-eslint/explicit-function-return-type": "off",
-        "@typescript-eslint/no-namespace": "off",
-        "@typescript-eslint/no-redeclare": "off",
-        "@typescript-eslint/no-require-imports": "off",
-        "@typescript-eslint/no-unused-expressions": "off",
-        "@typescript-eslint/no-unused-vars": "off",
-        "@typescript-eslint/no-use-before-define": "off",
-        "unicode-bom": "off",
-        "unused-imports/no-unused-imports": "off",
-        "unused-imports/no-unused-vars": "off",
-        ...overrides
-      }
-    },
-    {
-      name: "fabdeh/markdown/rules",
-      files,
-      rules: {
-        ...markdownPlugin.configs.recommended.at(0)?.rules,
-        "markdown/no-duplicate-headings": "error"
-      }
-    }
-  );
-}
-
-const namingConvention = [
-  { selector: "default", format: ["camelCase"], leadingUnderscore: "forbid", trailingUnderscore: "forbid" },
-  { selector: ["variableLike", "memberLike"], format: ["camelCase"] },
-  // eslint-disable-next-line unicorn/no-null
-  { selector: "memberLike", modifiers: ["requiresQuotes"], format: null },
-  { selector: "typeLike", format: ["PascalCase"] },
-  { selector: "variable", modifiers: ["const", "global"], format: ["UPPER_CASE"] },
-  { selector: "enumMember", format: ["UPPER_CASE"] },
-  { selector: "parameter", modifiers: ["unused"], format: ["camelCase"], leadingUnderscore: "allow" },
-  { selector: "import", modifiers: ["default"], format: ["camelCase", "PascalCase"] },
-  { selector: "import", modifiers: ["namespace"], format: ["camelCase", "PascalCase"] }
-];
-
-const DEFAULT_STORE_GLOB = [
-  `**/*.actions.${GLOB_TS_EXT}`,
-  `**/*.feature.${GLOB_TS_EXT}`,
-  `**/*.reducer.${GLOB_TS_EXT}`,
-  `**/*.state.${GLOB_TS_EXT}`
-];
-const DEFAULT_EFFECTS_GLOB = [`**/*.effects.${GLOB_TS_EXT}`];
-const DEFAULT_SIGNALS_GLOB = [`**/*.store.${GLOB_TS_EXT}`];
-async function ngrx(options = {}) {
-  const ngrxPlugin = await interopDefault(import('@ngrx/eslint-plugin/v9'));
-  const {
-    store = isPackageExists("@ngrx/store"),
-    effects = isPackageExists("@ngrx/effects"),
-    signals = isPackageExists("@ngrx/signals")
-  } = options;
-  const configs = [];
-  let addOperatorsRules = false;
-  const ngrxOperatorsFiles = [];
-  if (store) {
-    const {
-      files = DEFAULT_STORE_GLOB,
-      enforceOperatorsRules = isPackageExists("@ngrx/operators"),
-      overrides = {}
-    } = typeof store === "object" ? store : {};
-    addOperatorsRules ||= enforceOperatorsRules;
-    ngrxOperatorsFiles.push(files);
-    configs.push({
-      name: "fabdeh/ngrx-store/rules",
-      files,
-      plugins: { "@ngrx": ngrxPlugin },
-      rules: {
-        ...ngrxPlugin.configs.store.find((c) => c.name === "ngrx/store")?.rules,
-        "@typescript-eslint/naming-convention": [
-          "error",
-          ...namingConvention,
-          {
-            selector: ["objectLiteralProperty"],
-            // eslint-disable-next-line unicorn/no-null
-            format: null,
-            custom: {
-              regex: String.raw`^(?:(?:[a-z]+(?:[A-Z][a-z]*)*)|[A-Z][a-z]*(?:\s[A-Z][a-z]*)*)$`,
-              match: true
-            }
-          },
-          {
-            selector: "variable",
-            modifiers: ["const", "global", "exported"],
-            format: ["camelCase", "PascalCase"],
-            leadingUnderscore: "forbid",
-            trailingUnderscore: "forbid"
-          }
-        ],
-        ...overrides
-      }
-    });
-  }
-  if (effects) {
-    const {
-      files = DEFAULT_EFFECTS_GLOB,
-      enforceOperatorsRules = isPackageExists("@ngrx/operators"),
-      overrides = {}
-    } = typeof effects === "object" ? effects : {};
-    addOperatorsRules ||= enforceOperatorsRules;
-    ngrxOperatorsFiles.push(files);
-    configs.push({
-      name: "fabdeh/ngrx-effects/rules",
-      files,
-      plugins: { "@ngrx": ngrxPlugin },
-      rules: {
-        ...ngrxPlugin.configs.effects.find((c) => c.name === "ngrx/effects")?.rules,
-        "@typescript-eslint/naming-convention": [
-          "error",
-          ...namingConvention,
-          {
-            selector: "variable",
-            modifiers: ["const", "global", "exported"],
-            format: ["camelCase"],
-            leadingUnderscore: "forbid",
-            trailingUnderscore: "forbid",
-            suffix: ["$"]
-          }
-        ],
-        ...overrides
-      }
-    });
-  }
-  if (signals) {
-    const {
-      files = DEFAULT_SIGNALS_GLOB,
-      enforceOperatorsRules = isPackageExists("@ngrx/operators"),
-      overrides = {}
-    } = typeof signals === "object" ? signals : {};
-    const allowLeadingUnderscoreOnMemberLike = (conventions) => [
-      ...conventions.filter((c) => !Array.isArray(c.selector)),
-      { selector: "variableLike", format: ["camelCase"] },
-      { selector: "memberLike", format: ["camelCase"], leadingUnderscore: "allow" }
-    ];
-    addOperatorsRules ||= enforceOperatorsRules;
-    ngrxOperatorsFiles.push(files);
-    configs.push({
-      name: "fabdeh/ngrx-signals/rules",
-      files,
-      plugins: { "@ngrx": ngrxPlugin },
-      rules: {
-        ...ngrxPlugin.configs.signals.find((c) => c.name === "ngrx/signals")?.rules,
-        "@typescript-eslint/naming-convention": [
-          "error",
-          ...allowLeadingUnderscoreOnMemberLike(namingConvention),
-          {
-            selector: "variable",
-            modifiers: ["const", "global", "exported"],
-            format: ["PascalCase"],
-            leadingUnderscore: "forbid",
-            trailingUnderscore: "forbid"
-          }
-        ],
-        ...overrides
-      }
-    });
-  }
-  if (addOperatorsRules) {
-    configs.push({
-      name: "fabdeh/ngrx-operators/rules",
-      files: [...ngrxOperatorsFiles],
-      plugins: { "@ngrx": ngrxPlugin },
-      rules: {
-        ...ngrxPlugin.configs.operators.find((c) => c.name === "ngrx/operators")?.rules
-      }
-    });
-  }
-  return tseslint.config(configs);
-}
-
-const SORT_IMPORT_GROUPS = [
-  "type",
-  { newlinesBetween: "never" },
-  "builtin-type",
-  { newlinesBetween: "never" },
-  "external-type",
-  { newlinesBetween: "never" },
-  "internal-type",
-  { newlinesBetween: "never" },
-  "parent-type",
-  { newlinesBetween: "never" },
-  "sibling-type",
-  { newlinesBetween: "never" },
-  "index-type",
-  { newlinesBetween: "always" },
-  "builtin",
-  { newlinesBetween: "always" },
-  "external",
-  { newlinesBetween: "always" },
-  "internal",
-  { newlinesBetween: "always" },
-  "parent",
-  { newlinesBetween: "never" },
-  "sibling",
-  { newlinesBetween: "never" },
-  "index",
-  { newlinesBetween: "always" },
-  "side-effect",
-  { newlinesBetween: "always" },
-  "object",
-  { newlinesBetween: "always" },
-  "unknown"
-];
-const SORT_UNION_OR_INTERSECTION_GROUPS = [
-  "named",
-  "keyword",
-  "operator",
-  "literal",
-  "function",
-  "import",
-  "conditional",
-  "object",
-  "tuple",
-  "intersection",
-  "union",
-  "nullish",
-  "unknown"
-];
-
-async function perfectionist() {
-  const rootDir = await findNearestPackageJsonName() === "@fabdeh/eslint-config" ? void 0 : getWorkspaceRoot(process.cwd(), process.cwd());
-  return tseslint.config({
-    name: "fabdeh/perfectionist/rules",
-    files: [GLOB_SRC],
-    plugins: {
-      perfectionist: perfectionistPlugin
-    },
-    rules: {
-      "perfectionist/sort-exports": ["error", { order: "asc", type: "natural" }],
-      "perfectionist/sort-imports": [
-        "error",
-        {
-          groups: SORT_IMPORT_GROUPS,
-          tsconfig: rootDir ? {
-            rootDir,
-            filename: getTsConfigFileName(rootDir)
-          } : void 0,
-          order: "asc",
-          type: "natural",
-          newlinesBetween: "never"
-        }
-      ],
-      "perfectionist/sort-intersection-types": [
-        "error",
-        {
-          groups: SORT_UNION_OR_INTERSECTION_GROUPS,
-          order: "asc",
-          type: "natural"
-        }
-      ],
-      "perfectionist/sort-named-exports": ["error", { order: "asc", type: "natural" }],
-      "perfectionist/sort-named-imports": ["error", { order: "asc", type: "natural" }],
-      "perfectionist/sort-switch-case": ["error", { order: "asc", type: "natural" }],
-      "perfectionist/sort-union-types": [
-        "error",
-        {
-          groups: SORT_UNION_OR_INTERSECTION_GROUPS,
-          order: "asc",
-          type: "natural"
-        }
-      ]
-    }
-  });
-}
-
-function regexp(options = {}) {
-  const { level, overrides } = options;
-  const config = configs["flat/recommended"];
-  const rules = Object.fromEntries(
-    Object.entries(config.rules).map(([ruleName, ruleLevel]) => [ruleName, level === "warn" ? level : ruleLevel])
-  );
-  return tseslint.config(
-    {
-      name: "fabdeh/regexp/rules",
-      files: [GLOB_SRC],
-      plugins: {
-        ...config.plugins
-      },
-      rules: {
-        ...rules,
-        ...overrides
-      }
-    }
-  );
-}
-
-function sortPackageJson() {
-  return tseslint.config({
-    name: "fabdeh/sort/package-json",
-    files: ["**/package.json"],
-    rules: {
-      "jsonc/sort-array-values": [
-        "error",
-        {
-          order: { type: "asc" },
-          pathPattern: "^files$"
-        }
-      ],
-      "jsonc/sort-keys": [
-        "error",
-        {
-          order: [
-            "publisher",
-            "name",
-            "displayName",
-            "type",
-            "version",
-            "private",
-            "packageManager",
-            "description",
-            "author",
-            "contributors",
-            "license",
-            "funding",
-            "homepage",
-            "repository",
-            "bugs",
-            "keywords",
-            "categories",
-            "sideEffects",
-            "exports",
-            "main",
-            "module",
-            "unpkg",
-            "jsdelivr",
-            "types",
-            "typesVersions",
-            "bin",
-            "icon",
-            "files",
-            "engines",
-            "activationEvents",
-            "contributes",
-            "scripts",
-            "peerDependencies",
-            "peerDependenciesMeta",
-            "dependencies",
-            "optionalDependencies",
-            "devDependencies",
-            "pnpm",
-            "overrides",
-            "resolutions",
-            "husky",
-            "simple-git-hooks",
-            "lint-staged",
-            "nano-staged",
-            "eslintConfig",
-            "config"
-          ],
-          pathPattern: "^$"
-        },
-        {
-          order: { type: "asc" },
-          pathPattern: "^(?:dev|peer|optional|bundled)?[Dd]ependencies(Meta)?$"
-        },
-        {
-          order: { type: "asc" },
-          pathPattern: "^(?:resolutions|overrides|pnpm.overrides)$"
-        },
-        {
-          order: [
-            "types",
-            "import",
-            "require",
-            "default"
-          ],
-          pathPattern: "^exports.*$"
-        },
-        {
-          order: [
-            // client hooks only
-            "pre-commit",
-            "prepare-commit-msg",
-            "commit-msg",
-            "post-commit",
-            "pre-rebase",
-            "post-rewrite",
-            "post-checkout",
-            "post-merge",
-            "pre-push",
-            "pre-auto-gc"
-          ],
-          pathPattern: "^(?:gitHooks|husky|simple-git-hooks)$"
-        }
-      ]
-    }
-  });
-}
-function sortTsConfig() {
-  return tseslint.config({
-    name: "fabdeh/sort/tsconfig-json",
-    files: ["**/tsconfig.json", "**/tsconfig.*.json"],
-    rules: {
-      "jsonc/sort-keys": [
-        "error",
-        {
-          order: [
-            "extends",
-            "compilerOptions",
-            "references",
-            "files",
-            "include",
-            "exclude"
-          ],
-          pathPattern: "^$"
-        },
-        {
-          order: [
-            /* Projects */
-            "incremental",
-            "composite",
-            "tsBuildInfoFile",
-            "disableSourceOfProjectReferenceRedirect",
-            "disableSolutionSearching",
-            "disableReferencedProjectLoad",
-            /* Language and Environment */
-            "target",
-            "jsx",
-            "jsxFactory",
-            "jsxFragmentFactory",
-            "jsxImportSource",
-            "lib",
-            "moduleDetection",
-            "noLib",
-            "reactNamespace",
-            "useDefineForClassFields",
-            "emitDecoratorMetadata",
-            "experimentalDecorators",
-            /* Modules */
-            "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",
-            /* Emit */
-            "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",
-            "isolatedDeclarations",
-            "isolatedModules",
-            "preserveSymlinks",
-            "verbatimModuleSyntax",
-            /* Completeness */
-            "skipDefaultLibCheck",
-            "skipLibCheck"
-          ],
-          pathPattern: "^compilerOptions$"
-        }
-      ]
-    }
-  });
-}
-
-const STYLISTIC_CONFIG_DEFAULT = {
-  semi: true,
-  arrowParens: true,
-  braceStyle: "1tbs",
-  quoteProps: "as-needed"
-};
-async function stylistic(options = {}) {
-  const stylisticOptions = {
-    ...STYLISTIC_CONFIG_DEFAULT,
-    ...typeof options.stylistic === "boolean" ? {} : options.stylistic
-  };
-  const stylisticPlugin = await interopDefault(import('@stylistic/eslint-plugin'));
-  const config = stylisticPlugin.configs.customize(stylisticOptions);
-  return tseslint.config({
-    name: "fabdeh/stylistic/rules",
-    files: [GLOB_SRC],
-    plugins: {
-      "@stylistic": stylisticPlugin
-    },
-    rules: {
-      ...config.rules,
-      "@stylistic/comma-dangle": ["error", { arrays: "always-multiline", objects: "always-multiline" }],
-      "@stylistic/no-extra-semi": "error",
-      "@stylistic/operator-linebreak": ["error", "after", { overrides: { "?": "before", ":": "before" } }]
-    }
-  });
-}
-
-async function tailwindcss(options = {}) {
-  await ensurePackages(["eslint-plugin-better-tailwindcss"]);
-  const betterTailwindcssPlugin = await interopDefault(import('eslint-plugin-better-tailwindcss'));
-  const { files: filesGlob, overrides, enableAllRules, parsers, ...settings } = options;
-  let files;
-  let parserConfigs;
-  if (parsers) {
-    files = { files: [...new Set(Object.keys(parsers))] };
-    parserConfigs = Object.entries(parsers).map(([glob, parser], index) => ({
-      name: `fabdeh/tailwindcss/parser-${index + 1}`,
-      files: [glob],
-      languageOptions: {
-        parser
-      }
-    }));
-  } else {
-    files = { files: filesGlob ?? [GLOB_SRC, GLOB_HTML] };
-    parserConfigs = [];
-  }
-  return tseslint.config(
-    ...parserConfigs,
-    {
-      name: "@fabdeh/tailwindcss/rules",
-      ...files,
-      plugins: {
-        "better-tailwindcss": betterTailwindcssPlugin
-      },
-      settings: {
-        "better-tailwindcss": settings
-      },
-      rules: {
-        ...betterTailwindcssPlugin.configs.recommended.rules,
-        ...enableAllRules ? {
-          "better-tailwindcss/enforce-consistent-variable-syntax": "warn",
-          "better-tailwindcss/no-conflicting-classes": "error",
-          "better-tailwindcss/no-restricted-classes": "error"
-        } : {}
-      }
-    }
-  );
-}
-
-async function toml(options = {}) {
-  const {
-    files = [GLOB_TOML],
-    overrides = {},
-    stylistic = true
-  } = options;
-  const { indent = 2 } = typeof stylistic === "object" ? stylistic : {};
-  const [tomlPlugin, tomlParser] = await Promise.all([
-    interopDefault(import('eslint-plugin-toml')),
-    interopDefault(import('toml-eslint-parser'))
-  ]);
-  return tseslint.config(
-    {
-      name: "fabdeh/toml/setup",
-      plugins: {
-        toml: tomlPlugin
-      }
-    },
-    {
-      name: "fabdeh/toml/rules",
-      languageOptions: {
-        parser: tomlParser
-      },
-      files,
-      rules: {
-        "@stylistic/spaced-comment": "off",
-        "toml/comma-style": "error",
-        "toml/keys-order": "error",
-        "toml/no-space-dots": "error",
-        "toml/no-unreadable-number-separator": "error",
-        "toml/precision-of-fractional-seconds": "error",
-        "toml/precision-of-integer": "error",
-        "toml/tables-order": "error",
-        "toml/vue-custom-block/no-parsing-error": "error",
-        ...stylistic ? {
-          "toml/array-bracket-newline": "error",
-          "toml/array-bracket-spacing": "error",
-          "toml/array-element-newline": "error",
-          "toml/indent": ["error", indent === "tab" ? 2 : indent],
-          "toml/inline-table-curly-spacing": "error",
-          "toml/key-spacing": "error",
-          "toml/padding-line-between-pairs": "error",
-          "toml/padding-line-between-tables": "error",
-          "toml/quoted-keys": "error",
-          "toml/spaced-comment": "error",
-          "toml/table-bracket-spacing": "error"
-        } : {},
-        ...overrides
-      }
-    }
-  );
-}
-
-const memberOrdering = {
-  default: [
-    "signature",
-    "#private-field",
-    "private-field",
-    "protected-field",
-    "public-field",
-    ["#private-accessor", "#private-get", "#private-set"],
-    ["private-accessor", "private-get", "private-set"],
-    ["protected-accessor", "protected-get", "protected-set"],
-    ["public-accessor", "public-get", "public-set"],
-    "static-initialization",
-    "constructor",
-    "call-signature",
-    "public-method",
-    "protected-method",
-    "private-method",
-    "#private-method"
-  ]
-};
-
-async function typescript(options = {}) {
-  const { stylistic = true, parserOptions = {}, overrides = {}, enableErasableSyntaxOnly = false, type = "app" } = options;
-  let erasableSyntaxOnlyPlugin;
-  let erasableSyntaxOnlyRules;
-  if (enableErasableSyntaxOnly) {
-    await ensurePackages(["eslint-plugin-erasable-syntax-only"]);
-    const erasableSyntaxOnly = await interopDefault(import('eslint-plugin-erasable-syntax-only'));
-    erasableSyntaxOnlyPlugin = erasableSyntaxOnly;
-    erasableSyntaxOnlyRules = erasableSyntaxOnly.configs.recommended.rules;
-  }
-  const tsconfigRootDir = getWorkspaceRoot(process.cwd(), process.cwd());
-  const defaultProject = getTsConfigFileName(tsconfigRootDir);
-  return tseslint.config(
-    {
-      name: "fabdeh/typescript/setup",
-      files: [GLOB_TS],
-      ignores: [`${GLOB_MARKDOWN}/**`],
-      languageOptions: {
-        parser: tseslint.parser,
-        parserOptions: {
-          sourceType: "module",
-          projectService: {
-            allowDefaultProject: ["*.js"],
-            defaultProject
-          },
-          tsconfigRootDir,
-          ...parserOptions
-        }
-      }
-    },
-    {
-      name: "fabdeh/typescript/rules",
-      files: [GLOB_TS],
-      ignores: [`${GLOB_MARKDOWN}/**`],
-      plugins: {
-        "@typescript-eslint": tseslint.plugin,
-        "unused-imports": unusedImports,
-        ...erasableSyntaxOnlyPlugin ? { "erasable-syntax-only": erasableSyntaxOnlyPlugin } : {}
-      },
-      rules: {
-        ...tseslint.configs.strictTypeChecked.find((c) => c.name === "typescript-eslint/eslint-recommended")?.rules,
-        ...tseslint.configs.strictTypeChecked.find((c) => c.name === "typescript-eslint/strict-type-checked")?.rules,
-        ...stylistic ? tseslint.configs.stylisticTypeChecked.find((c) => c.name === "typescript-eslint/stylistic-type-checked")?.rules : {},
-        "@typescript-eslint/array-type": ["error", { default: "array" }],
-        "@typescript-eslint/consistent-indexed-object-style": "error",
-        "@typescript-eslint/consistent-type-assertions": [
-          "error",
-          { assertionStyle: "as", objectLiteralTypeAssertions: "never" }
-        ],
-        "@typescript-eslint/consistent-type-definitions": ["error", "interface"],
-        "@typescript-eslint/consistent-type-exports": "error",
-        "@typescript-eslint/consistent-type-imports": ["error", {
-          disallowTypeAnnotations: false,
-          fixStyle: "separate-type-imports",
-          prefer: "type-imports"
-        }],
-        "@typescript-eslint/dot-notation": "error",
-        ...type === "lib" ? {
-          "@typescript-eslint/explicit-function-return-type": [
-            "error",
-            {
-              allowExpressions: true,
-              allowIIFEs: true
-            }
-          ]
-        } : { "@typescript-eslint/explicit-module-boundary-types": "error" },
-        "@typescript-eslint/explicit-member-accessibility": ["error", { accessibility: "no-public" }],
-        "@typescript-eslint/member-ordering": ["error", memberOrdering],
-        "@typescript-eslint/method-signature-style": "error",
-        "@typescript-eslint/naming-convention": ["error", ...namingConvention],
-        "@typescript-eslint/no-base-to-string": "error",
-        "@typescript-eslint/no-confusing-non-null-assertion": "error",
-        "@typescript-eslint/no-confusing-void-expression": ["error", { ignoreArrowShorthand: true }],
-        "@typescript-eslint/no-empty-interface": "off",
-        // deprecated but included in nx
-        "@typescript-eslint/no-extra-non-null-assertion": "error",
-        "@typescript-eslint/no-extraneous-class": ["error", { allowStaticOnly: true, allowWithDecorator: true }],
-        "@typescript-eslint/no-invalid-void-type": "error",
-        "@typescript-eslint/no-non-null-asserted-nullish-coalescing": "error",
-        "@typescript-eslint/only-throw-error": "error",
-        "@typescript-eslint/no-unnecessary-condition": "error",
-        "@typescript-eslint/no-unnecessary-type-arguments": "error",
-        "@typescript-eslint/no-unsafe-unary-minus": "error",
-        "@typescript-eslint/parameter-properties": "error",
-        "@typescript-eslint/prefer-enum-initializers": "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",
-        "@typescript-eslint/prefer-nullish-coalescing": "error",
-        "@typescript-eslint/prefer-optional-chain": "error",
-        "@typescript-eslint/prefer-readonly": "error",
-        "@typescript-eslint/prefer-reduce-type-parameter": "error",
-        "@typescript-eslint/prefer-return-this-type": "error",
-        "@typescript-eslint/prefer-string-starts-ends-with": "error",
-        "@typescript-eslint/require-array-sort-compare": "error",
-        "@typescript-eslint/restrict-plus-operands": ["error", { skipCompoundAssignments: true }],
-        "@typescript-eslint/restrict-template-expressions": "off",
-        "@typescript-eslint/switch-exhaustiveness-check": "error",
-        "@typescript-eslint/unbound-method": ["error", { ignoreStatic: true }],
-        "@typescript-eslint/unified-signatures": "error",
-        "@typescript-eslint/no-unused-vars": "off",
-        ...erasableSyntaxOnlyRules,
-        ...overrides
-      }
-    }
-  );
-}
-
-function unicorn(options = {}) {
-  return tseslint.config({
-    name: "fabdeh/unicorn/rules",
-    files: [GLOB_SRC],
-    plugins: { unicorn: unicornPlugin },
-    rules: {
-      ...options.allRecommended ? unicornPlugin.configs.recommended.rules : {
-        "unicorn/catch-error-name": "error",
-        "unicorn/consistent-date-clone": "error",
-        "unicorn/consistent-empty-array-spread": "error",
-        "unicorn/consistent-existence-index-check": "error",
-        "unicorn/consistent-function-scoping": ["error", { checkArrowFunctions: false }],
-        "unicorn/custom-error-definition": "error",
-        "unicorn/error-message": "error",
-        "unicorn/escape-case": "error",
-        "unicorn/explicit-length-check": "error",
-        "unicorn/filename-case": ["error", { case: "kebabCase", ignore: [/^[A-Z0-9_-]+\.md$/] }],
-        "unicorn/new-for-builtins": "error",
-        "unicorn/no-abusive-eslint-disable": "error",
-        "unicorn/no-anonymous-default-export": "error",
-        "unicorn/no-array-for-each": "error",
-        "unicorn/no-array-method-this-argument": "error",
-        "unicorn/no-array-reduce": "error",
-        "unicorn/no-await-expression-member": "error",
-        "unicorn/no-await-in-promise-methods": "error",
-        "unicorn/no-document-cookie": "error",
-        "unicorn/no-empty-file": "error",
-        "unicorn/no-for-loop": "error",
-        "unicorn/no-hex-escape": "error",
-        "unicorn/no-instanceof-builtins": "error",
-        "unicorn/no-invalid-fetch-options": "error",
-        "unicorn/no-invalid-remove-event-listener": "error",
-        "unicorn/no-lonely-if": "error",
-        "unicorn/no-magic-array-flat-depth": "error",
-        "unicorn/no-negated-condition": "error",
-        "unicorn/no-negation-in-equality-check": "error",
-        "unicorn/no-new-array": "error",
-        "unicorn/no-new-buffer": "error",
-        "unicorn/no-null": "error",
-        "unicorn/no-process-exit": "error",
-        "unicorn/no-single-promise-in-promise-methods": "error",
-        "unicorn/no-thenable": "error",
-        "unicorn/no-this-assignment": "error",
-        "unicorn/no-typeof-undefined": "error",
-        "unicorn/no-unnecessary-await": "error",
-        "unicorn/no-unnecessary-array-flat-depth": "error",
-        "unicorn/no-unnecessary-array-splice-count": "error",
-        "unicorn/no-unnecessary-slice-end": "error",
-        "unicorn/no-unused-properties": "warn",
-        "unicorn/no-useless-fallback-in-spread": "error",
-        "unicorn/no-useless-length-check": "error",
-        "unicorn/no-useless-promise-resolve-reject": "error",
-        "unicorn/no-useless-spread": "error",
-        "unicorn/no-useless-switch-case": "error",
-        "unicorn/no-zero-fractions": "error",
-        "unicorn/number-literal-case": "error",
-        "unicorn/numeric-separators-style": "error",
-        "unicorn/prefer-array-find": "error",
-        "unicorn/prefer-array-flat": "error",
-        "unicorn/prefer-array-flat-map": "error",
-        "unicorn/prefer-array-index-of": "error",
-        "unicorn/prefer-array-some": "error",
-        "unicorn/prefer-at": "error",
-        "unicorn/prefer-blob-reading-methods": "error",
-        "unicorn/prefer-code-point": "error",
-        "unicorn/prefer-date-now": "error",
-        "unicorn/prefer-default-parameters": "error",
-        "unicorn/prefer-export-from": "error",
-        "unicorn/prefer-import-meta-properties": "error",
-        "unicorn/prefer-includes": "error",
-        "unicorn/prefer-keyboard-event-key": "error",
-        "unicorn/prefer-logical-operator-over-ternary": "error",
-        "unicorn/prefer-math-min-max": "error",
-        "unicorn/prefer-math-trunc": "error",
-        "unicorn/prefer-modern-math-apis": "error",
-        "unicorn/prefer-negative-index": "error",
-        "unicorn/prefer-node-protocol": "error",
-        "unicorn/prefer-number-properties": "error",
-        "unicorn/prefer-object-from-entries": "error",
-        "unicorn/prefer-optional-catch-binding": "error",
-        "unicorn/prefer-query-selector": "error",
-        "unicorn/prefer-regexp-test": "error",
-        "unicorn/prefer-set-has": "error",
-        "unicorn/prefer-set-size": "error",
-        "unicorn/prefer-single-call": "error",
-        "unicorn/prefer-spread": "error",
-        "unicorn/prefer-string-raw": "error",
-        "unicorn/prefer-string-replace-all": "error",
-        "unicorn/prefer-string-slice": "error",
-        "unicorn/prefer-string-starts-ends-with": "error",
-        "unicorn/prefer-string-trim-start-end": "error",
-        "unicorn/prefer-structured-clone": "error",
-        "unicorn/prefer-switch": "error",
-        "unicorn/prefer-ternary": "error",
-        "unicorn/prefer-type-error": "error",
-        "unicorn/require-array-join-separator": "error",
-        "unicorn/require-number-to-fixed-digits-argument": "error",
-        "unicorn/require-post-message-target-origin": "error",
-        "unicorn/throw-new-error": "error"
-      }
-    }
-  });
-}
-
-async function vitest(options = {}) {
-  const {
-    overrides = {},
-    useJestDom = isPackageExists("@testing-library/jest-dom"),
-    useTestingLibrary = isPackageExists("@testing-library/angular")
-  } = options;
-  const [vitestPlugin, jestDomPlugin, testingLibraryPlugin] = await Promise.all([
-    interopDefault(import('@vitest/eslint-plugin')),
-    useJestDom ? interopDefault(import('eslint-plugin-jest-dom')) : Promise.resolve(void 0),
-    useTestingLibrary ? interopDefault(import('eslint-plugin-testing-library')) : Promise.resolve(void 0)
-  ]);
-  return tseslint.config({
-    name: "fabdeh/vitest/rules",
-    plugins: {
-      vitest: vitestPlugin,
-      ...jestDomPlugin ? { "jest-dom": jestDomPlugin } : {},
-      ...testingLibraryPlugin ? { "testing-library": testingLibraryPlugin } : {}
-    },
-    languageOptions: {
-      globals: {
-        ...globals.node,
-        ...globals.vitest,
-        ...vitestPlugin.environments.env.globals
-      }
-    },
-    settings: {
-      vitest: {
-        typecheck: true
-      }
-    },
-    files: [...GLOB_TESTS],
-    rules: {
-      ...vitestPlugin.configs.recommended.rules,
-      ...jestDomPlugin?.configs["flat/recommended"].rules,
-      ...testingLibraryPlugin?.configs["flat/angular"].rules,
-      "max-classes-per-file": "off",
-      "max-lines": "off",
-      "@typescript-eslint/consistent-type-assertions": "off",
-      "@typescript-eslint/no-empty-function": "off",
-      "@typescript-eslint/no-unsafe-assignment": "off",
-      "@typescript-eslint/no-unsafe-call": "off",
-      "@typescript-eslint/no-unsafe-member-access": "off",
-      "@typescript-eslint/unbound-method": "off",
-      "unicorn/no-null": "off",
-      "vitest/consistent-test-it": ["error", { fn: "test" }],
-      "vitest/no-standalone-expect": "error",
-      "vitest/no-test-return-statement": "error",
-      "vitest/prefer-hooks-in-order": "error",
-      "vitest/prefer-hooks-on-top": "error",
-      "vitest/prefer-lowercase-title": "error",
-      "vitest/prefer-spy-on": "error",
-      "vitest/prefer-to-be": "error",
-      "vitest/prefer-to-be-falsy": "error",
-      "vitest/prefer-to-be-object": "error",
-      "vitest/prefer-to-be-truthy": "error",
-      "vitest/prefer-to-contain": "error",
-      "vitest/prefer-to-have-length": "error",
-      "vitest/prefer-todo": "error",
-      "vitest/prefer-vi-mocked": "error",
-      "vitest/require-top-level-describe": "error",
-      ...getJsDocRules("off", true, "both"),
-      ...overrides
-    }
-  });
-}
-
-async function yaml(options = {}) {
-  const {
-    files = [GLOB_YAML],
-    overrides = {},
-    stylistic = true
-  } = options;
-  const {
-    indent = 2,
-    quotes = "single"
-  } = typeof stylistic === "object" ? stylistic : {};
-  const [yamlPlugin, yamlParser] = await Promise.all([
-    interopDefault(import('eslint-plugin-yml')),
-    interopDefault(import('yaml-eslint-parser'))
-  ]);
-  return tseslint.config(
-    {
-      name: "fabdeh/yaml/setup",
-      plugins: {
-        yaml: yamlPlugin
-      }
-    },
-    {
-      name: "fabdeh/yaml/rules",
-      languageOptions: {
-        parser: yamlParser
-      },
-      files,
-      rules: {
-        "@stylistic/spaced-comment": "off",
-        "yaml/block-mapping": "error",
-        "yaml/block-sequence": "error",
-        "yaml/no-empty-key": "error",
-        "yaml/no-empty-sequence-entry": "error",
-        "yaml/no-irregular-whitespace": "error",
-        "yaml/plain-scalar": "error",
-        "yaml/vue-custom-block/no-parsing-error": "error",
-        ...stylistic ? {
-          "yaml/block-mapping-question-indicator-newline": "error",
-          "yaml/block-sequence-hyphen-indicator-newline": "error",
-          "yaml/flow-mapping-curly-newline": "error",
-          "yaml/flow-mapping-curly-spacing": "error",
-          "yaml/flow-sequence-bracket-newline": "error",
-          "yaml/flow-sequence-bracket-spacing": "error",
-          "yaml/indent": ["error", indent === "tab" ? 2 : indent],
-          "yaml/key-spacing": "error",
-          "yaml/no-tab-indent": "error",
-          "yaml/quotes": ["error", { avoidEscape: true, prefer: quotes === "backtick" ? "single" : quotes }],
-          "yaml/spaced-comment": "error"
-        } : {},
-        ...overrides
-      }
-    }
-  );
-}
-
-function mergePrettierOptions(options, overrides = {}) {
-  return {
-    ...options,
-    ...overrides,
-    /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-    plugins: [
-      ...overrides.plugins ?? [],
-      ...options.plugins ?? []
-    ]
-    /* eslint-enable @typescript-eslint/no-unsafe-assignment */
-  };
-}
-async function formatters(options = {}, stylistic = {}, hasAngularTemplateParser = false) {
-  if (options === true) {
-    const isPrettierPluginXmlInScope = isPackageInScope("@prettier/plugin-xml");
-    options = {
-      css: true,
-      graphql: true,
-      html: true,
-      markdown: true,
-      slidev: isPackageExists("@slidev/cli"),
-      svg: isPrettierPluginXmlInScope,
-      xml: isPrettierPluginXmlInScope
-    };
-  }
-  await ensurePackages([
-    "eslint-plugin-format",
-    options.markdown && options.slidev ? "prettier-plugin-slidev" : void 0,
-    options.xml || options.svg ? "@prettier/plugin-xml" : void 0
-  ]);
-  const {
-    indent,
-    quotes,
-    semi
-  } = {
-    ...STYLISTIC_CONFIG_DEFAULT,
-    ...stylistic
-  };
-  const prettierOptions = {
-    endOfLine: "auto",
-    printWidth: 120,
-    semi,
-    singleQuote: quotes === "single",
-    tabWidth: typeof indent === "number" ? indent : 2,
-    trailingComma: "all",
-    useTabs: indent === "tab",
-    ...options.options
-  };
-  const prettierXmlOptions = {
-    xmlQuoteAttributes: "double",
-    xmlSelfClosingSpace: true,
-    xmlSortAttributesByKey: false,
-    xmlWhitespaceSensitivity: "ignore"
-  };
-  const formatPlugin = await interopDefault(import('eslint-plugin-format'));
-  const configs = [
-    {
-      name: "fabdeh/formatter/setup",
-      plugins: {
-        format: formatPlugin
-      }
-    }
-  ];
-  if (options.css) {
-    configs.push(
-      {
-        name: "fabdeh/formatter/css",
-        languageOptions: {
-          parser: formatPlugin.parserPlain
-        },
-        files: [GLOB_CSS, GLOB_POSTCSS],
-        rules: {
-          "format/prettier": [
-            "error",
-            mergePrettierOptions(prettierOptions, { parser: "css" })
-          ]
-        }
-      },
-      {
-        name: "fabdeh/formatter/scss",
-        languageOptions: {
-          parser: formatPlugin.parserPlain
-        },
-        files: [GLOB_SCSS],
-        rules: {
-          "format/prettier": [
-            "error",
-            mergePrettierOptions(prettierOptions, { parser: "scss" })
-          ]
-        }
-      },
-      {
-        name: "fabdeh/formatter/less",
-        languageOptions: {
-          parser: formatPlugin.parserPlain
-        },
-        files: [GLOB_LESS],
-        rules: {
-          "format/prettier": [
-            "error",
-            mergePrettierOptions(prettierOptions, { parser: "less" })
-          ]
-        }
-      }
-    );
-  }
-  if (options.html) {
-    configs.push({
-      name: "fabdeh/formatter/html",
-      ...hasAngularTemplateParser ? {} : {
-        languageOptions: {
-          parser: formatPlugin.parserPlain
-        }
-      },
-      files: [GLOB_HTML],
-      rules: {
-        "format/prettier": [
-          "error",
-          mergePrettierOptions(prettierOptions, { parser: "html" })
-        ]
-      }
-    });
-  }
-  if (options.xml) {
-    configs.push({
-      name: "fabdeh/formatter/xml",
-      languageOptions: {
-        parser: formatPlugin.parserPlain
-      },
-      files: [GLOB_XML],
-      rules: {
-        "format/prettier": [
-          "error",
-          mergePrettierOptions({ ...prettierXmlOptions, ...prettierOptions }, {
-            parser: "xml",
-            plugins: ["@prettier/plugin-xml"]
-          })
-        ]
-      }
-    });
-  }
-  if (options.svg) {
-    configs.push({
-      name: "fabdeh/formatter/svg",
-      languageOptions: {
-        parser: formatPlugin.parserPlain
-      },
-      files: [GLOB_SVG],
-      rules: {
-        "format/prettier": [
-          "error",
-          mergePrettierOptions({ ...prettierXmlOptions, ...prettierOptions }, {
-            parser: "xml",
-            plugins: ["@prettier/plugin-xml"]
-          })
-        ]
-      }
-    });
-  }
-  if (options.markdown) {
-    const GLOB_SLIDEV = options.slidev ? options.slidev === true ? ["**/.slides.md"] : options.slidev.files : [];
-    configs.push({
-      name: "fabdeh/formatter/markdown",
-      languageOptions: {
-        parser: formatPlugin.parserPlain
-      },
-      files: [GLOB_MARKDOWN],
-      ignores: GLOB_SLIDEV,
-      rules: {
-        "format/prettier": [
-          "error",
-          mergePrettierOptions(prettierOptions, {
-            parser: "markdown",
-            embeddedLanguageFormatting: "off"
-          })
-        ]
-      }
-    });
-    if (options.slidev) {
-      configs.push({
-        name: "fabdeh/formatter/slidev",
-        languageOptions: {
-          parser: formatPlugin.parserPlain
-        },
-        files: GLOB_SLIDEV,
-        rules: {
-          "format/prettier": [
-            "error",
-            mergePrettierOptions(prettierOptions, {
-              embeddedLanguageFormatting: "off",
-              parser: "slidev",
-              plugins: ["prettier-plugin-slidev"]
-            })
-          ]
-        }
-      });
-    }
-  }
-  if (options.graphql) {
-    configs.push({
-      name: "fabdeh/formatter/graphql",
-      languageOptions: {
-        parser: formatPlugin.parserPlain
-      },
-      files: [GLOB_GRAPHQL],
-      rules: {
-        "format/prettier": [
-          "error",
-          mergePrettierOptions(prettierOptions, { parser: "graphql" })
-        ]
-      }
-    });
-  }
-  return tseslint.config(configs);
-}
-
-const FLAT_CONFIG_PROPS = [
-  "name",
-  "languageOptions",
-  "linterOptions",
-  "processor",
-  "plugins",
-  "rules",
-  "settings",
-  "extends"
-];
-const NGRX_PACKAGES = ["@ngrx/store", "@ngrx/effects", "@ngrx/signals", "@ngrx/operators"];
-async function defineConfig(options = {}, ...userConfigs) {
-  const {
-    angular: enableAngular = isPackageExists("@angular/core"),
-    gitignore: enableGitignore = true,
-    jsdoc: enableJsdoc = true,
-    ngrx: enableNgrx = NGRX_PACKAGES.some((p) => isPackageExists(p)),
-    regexp: enableRegexp = true,
-    tailwindcss: enableTailwind = false,
-    typescript: enableTypescript = isPackageExists("typescript"),
-    unicorn: enableUnicorn = true,
-    vitest: enableVitest = isPackageExists("vitest")
-  } = options;
-  if (enableNgrx && !enableAngular) {
-    throw new Error("NgRx rules can only be enabled if Angular rules are also enabled.");
-  }
-  const stylisticOptions = options.stylistic === false ? false : typeof options.stylistic === "object" ? options.stylistic : {};
-  const configs = [];
-  if (enableGitignore) {
-    if (typeof enableGitignore === "object") {
-      configs.push(
-        interopDefault(import('eslint-config-flat-gitignore')).then(
-          (r) => tseslint.config(r({ name: "fabdeh/gitignore", ...enableGitignore }))
-        )
-      );
-    } else {
-      configs.push(
-        interopDefault(import('eslint-config-flat-gitignore')).then(
-          (r) => tseslint.config(r({ name: "fabdeh/gitignore", strict: true }))
-        )
-      );
-    }
-  }
-  configs.push(
-    ignores(options.ignores),
-    javascript({ overrides: options.javascript?.overrides }),
-    comments(),
-    imports({ stylistic: stylisticOptions }),
-    perfectionist()
-  );
-  if (enableJsdoc) {
-    configs.push(jsdoc({ stylistic: stylisticOptions }));
-  }
-  if (enableUnicorn) {
-    const unicornOptions = resolveSubOptions(options, "unicorn");
-    configs.push(unicorn(unicornOptions));
-  }
-  if (enableTypescript) {
-    const typescriptOptions = resolveSubOptions(options, "typescript");
-    configs.push(typescript({
-      ...typescriptOptions,
-      stylistic: stylisticOptions,
-      type: options.type
-    }));
-  }
-  if (stylisticOptions) {
-    configs.push(stylistic({ stylistic: stylisticOptions }));
-  }
-  if (enableRegexp) {
-    const regexpOptions = resolveSubOptions(options, "regexp");
-    configs.push(regexp(regexpOptions));
-  }
-  if (enableAngular) {
-    const angularOptions = resolveSubOptions(options, "angular");
-    configs.push(angular(angularOptions));
-  }
-  if (enableNgrx) {
-    const ngrxOptions = resolveSubOptions(options, "ngrx");
-    configs.push(ngrx(ngrxOptions));
-  }
-  if (enableVitest) {
-    const vitestOptions = resolveSubOptions(options, "vitest");
-    configs.push(vitest(vitestOptions));
-  }
-  if (enableTailwind) {
-    const tailwindcssOptions = resolveSubOptions(options, "tailwindcss");
-    configs.push(tailwindcss(tailwindcssOptions));
-  }
-  if (options.jsonc ?? true) {
-    const jsoncOptions = resolveSubOptions(options, "jsonc");
-    configs.push(
-      jsonc({
-        ...jsoncOptions,
-        stylistic: stylisticOptions
-      }),
-      sortPackageJson(),
-      sortTsConfig()
-    );
-  }
-  if (options.yaml ?? true) {
-    const yamlOptions = resolveSubOptions(options, "yaml");
-    configs.push(yaml({
-      ...yamlOptions,
-      stylistic: stylisticOptions
-    }));
-  }
-  if (options.toml ?? true) {
-    const tomlOptions = resolveSubOptions(options, "toml");
-    configs.push(toml({
-      ...tomlOptions,
-      stylistic: stylisticOptions
-    }));
-  }
-  if (options.markdown ?? true) {
-    const markdownOptions = resolveSubOptions(options, "markdown");
-    configs.push(markdown(markdownOptions));
-  }
-  if (options.formatters) {
-    configs.push(formatters(
-      options.formatters,
-      typeof stylisticOptions === "boolean" ? {} : stylisticOptions,
-      Boolean(enableAngular)
-    ));
-  }
-  if ("files" in options) {
-    throw new Error('[@fabdeh/eslint-config] The first argument should not contain the "files" property as the options are supposed to be global. Place it in the second or later config instead.');
-  }
-  const fusedConfig = Object.fromEntries(
-    Object.entries(options).filter(([k]) => FLAT_CONFIG_PROPS.includes(k))
-  );
-  if (Object.keys(fusedConfig).length > 0) {
-    configs.push([fusedConfig]);
-  }
-  return tseslint.config(...await Promise.all(configs), ...await Promise.all(userConfigs));
-}
-
-export { GLOB_HTML, GLOB_JS, GLOB_SRC, GLOB_TESTS, GLOB_TS, STYLISTIC_CONFIG_DEFAULT, angular, comments, defineConfig, ensurePackages, findNearestPackageJsonName, getTsConfigFileName, getWorkspaceRoot, ignores, imports, interopDefault, isPackageInScope, javascript, jsdoc, jsonc, markdown, ngrx, perfectionist, regexp, resolveSubOptions, sortPackageJson, sortTsConfig, stylistic, tailwindcss, toml, typescript, unicorn, vitest, yaml };