@storm-software/eslint 0.122.8 → 0.123.0

package/dist/preset.js

@@ -1,988 +1,3645 @@
-import {
-  formatConfig
-} from "./chunk-FTXILLLE.js";
-import {
-  DEFAULT_IGNORES
-} from "./chunk-UAGSKXUP.js";
-import {
-  getStormRulesConfig
-} from "./chunk-VIASOXKK.js";
-import {
-  ts_docs_default
-} from "./chunk-723HQUNP.js";
 import {
   banner_plugin_default
-} from "./chunk-LSG5T3ZK.js";
-import "./chunk-Y67QTC5U.js";
+} from "./chunk-W6QEP5VE.js";
+import "./chunk-K6KBWFPU.js";
 import {
-  CODE_BLOCK,
-  CODE_FILE,
-  TS_FILE
-} from "./chunk-RTM5LCEB.js";
+  GLOB_ASTRO,
+  GLOB_ASTRO_TS,
+  GLOB_CSS,
+  GLOB_EXCLUDE,
+  GLOB_GRAPHQL,
+  GLOB_HTML,
+  GLOB_JSON,
+  GLOB_JSON5,
+  GLOB_JSONC,
+  GLOB_JSX,
+  GLOB_LESS,
+  GLOB_MARKDOWN,
+  GLOB_MARKDOWN_CODE,
+  GLOB_MARKDOWN_IN_MARKDOWN,
+  GLOB_POSTCSS,
+  GLOB_SCSS,
+  GLOB_SRC,
+  GLOB_SRC_EXT,
+  GLOB_SVG,
+  GLOB_TESTS,
+  GLOB_TOML,
+  GLOB_TS,
+  GLOB_TSX,
+  GLOB_XML,
+  GLOB_YAML
+} from "./chunk-X3L37QNE.js";
+import {
+  ensurePackages,
+  interopDefault,
+  isInEditorEnv,
+  isPackageInScope,
+  parserPlain,
+  renameRules
+} from "./chunk-7NZUDX62.js";
 import {
   __name
 } from "./chunk-SHUYVCID.js";
 
 // src/preset.ts
-import cspell from "@cspell/eslint-plugin/recommended";
-import eslint from "@eslint/js";
-import next from "@next/eslint-plugin-next";
-import nxPlugin from "@nx/eslint-plugin/nx.js";
-
-// ../config-tools/src/types.ts
-var LogLevel = {
-  SILENT: 0,
-  FATAL: 10,
-  ERROR: 20,
-  WARN: 30,
-  SUCCESS: 35,
-  INFO: 40,
-  DEBUG: 60,
-  TRACE: 70,
-  ALL: 100
-};
-var LogLevelLabel = {
-  SILENT: "silent",
-  FATAL: "fatal",
-  ERROR: "error",
-  WARN: "warn",
-  SUCCESS: "success",
-  INFO: "info",
-  DEBUG: "debug",
-  TRACE: "trace",
-  ALL: "all"
-};
+import { FlatConfigComposer } from "eslint-flat-config-utils";
+import { isPackageExists as isPackageExists2 } from "local-pkg";
 
-// ../config/src/constants.ts
-var STORM_DEFAULT_DOCS = "https://docs.stormsoftware.com";
-var STORM_DEFAULT_HOMEPAGE = "https://stormsoftware.com";
-var STORM_DEFAULT_LICENSING = "https://license.stormsoftware.com";
-
-// ../config/src/schema.ts
-import z from "zod";
-var DarkColorSchema = z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#1d1e22").describe("The dark background color of the workspace");
-var LightColorSchema = z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#f4f4f5").describe("The light background color of the workspace");
-var BrandColorSchema = z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#1fb2a6").describe("The primary brand specific color of the workspace");
-var AlternateColorSchema = z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).optional().describe("The alternate brand specific color of the workspace");
-var AccentColorSchema = z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).optional().describe("The secondary brand specific color of the workspace");
-var LinkColorSchema = z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).optional().describe("The color used to display hyperlink text");
-var HelpColorSchema = z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#8256D0").describe("The second brand specific color of the workspace");
-var SuccessColorSchema = z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#12B66A").describe("The success color of the workspace");
-var InfoColorSchema = z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#0070E0").describe("The informational color of the workspace");
-var WarningColorSchema = z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#fcc419").describe("The warning color of the workspace");
-var DangerColorSchema = z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#D8314A").describe("The danger color of the workspace");
-var FatalColorSchema = z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).optional().describe("The fatal color of the workspace");
-var PositiveColorSchema = z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#4ade80").describe("The positive number color of the workspace");
-var NegativeColorSchema = z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#ef4444").describe("The negative number color of the workspace");
-var DarkThemeColorConfigSchema = z.object({
-  foreground: LightColorSchema,
-  background: DarkColorSchema,
-  brand: BrandColorSchema,
-  alternate: AlternateColorSchema,
-  accent: AccentColorSchema,
-  link: LinkColorSchema,
-  help: HelpColorSchema,
-  success: SuccessColorSchema,
-  info: InfoColorSchema,
-  warning: WarningColorSchema,
-  danger: DangerColorSchema,
-  fatal: FatalColorSchema,
-  positive: PositiveColorSchema,
-  negative: NegativeColorSchema
-});
-var LightThemeColorConfigSchema = z.object({
-  foreground: DarkColorSchema,
-  background: LightColorSchema,
-  brand: BrandColorSchema,
-  alternate: AlternateColorSchema,
-  accent: AccentColorSchema,
-  link: LinkColorSchema,
-  help: HelpColorSchema,
-  success: SuccessColorSchema,
-  info: InfoColorSchema,
-  warning: WarningColorSchema,
-  danger: DangerColorSchema,
-  fatal: FatalColorSchema,
-  positive: PositiveColorSchema,
-  negative: NegativeColorSchema
-});
-var MultiThemeColorConfigSchema = z.object({
-  dark: DarkThemeColorConfigSchema,
-  light: LightThemeColorConfigSchema
-});
-var SingleThemeColorConfigSchema = z.object({
-  dark: DarkColorSchema,
-  light: LightColorSchema,
-  brand: BrandColorSchema,
-  alternate: AlternateColorSchema,
-  accent: AccentColorSchema,
-  link: LinkColorSchema,
-  help: HelpColorSchema,
-  success: SuccessColorSchema,
-  info: InfoColorSchema,
-  warning: WarningColorSchema,
-  danger: DangerColorSchema,
-  fatal: FatalColorSchema,
-  positive: PositiveColorSchema,
-  negative: NegativeColorSchema
-});
-var RegistryUrlConfigSchema = z.string().trim().toLowerCase().url().optional().describe("A remote registry URL used to publish distributable packages");
-var RegistryConfigSchema = z.object({
-  github: RegistryUrlConfigSchema,
-  npm: RegistryUrlConfigSchema,
-  cargo: RegistryUrlConfigSchema,
-  cyclone: RegistryUrlConfigSchema,
-  container: RegistryUrlConfigSchema
-}).default({}).describe("A list of remote registry URLs used by Storm Software");
-var ColorConfigSchema = SingleThemeColorConfigSchema.or(MultiThemeColorConfigSchema).describe("Colors used for various workspace elements");
-var ColorConfigMapSchema = z.union([
-  z.object({
-    base: ColorConfigSchema
-  }),
-  z.record(z.string(), ColorConfigSchema)
-]);
-var ExtendsItemSchema = z.string().trim().describe("The path to a base config file to use as a configuration preset file. Documentation can be found at https://github.com/unjs/c12#extending-configuration.");
-var ExtendsSchema = ExtendsItemSchema.or(z.array(ExtendsItemSchema)).describe("The path to a base config file to use as a configuration preset file. Documentation can be found at https://github.com/unjs/c12#extending-configuration.");
-var WorkspaceBotConfigSchema = z.object({
-  name: z.string().trim().default("Stormie-Bot").describe("The workspace bot user's name (this is the bot that will be used to perform various tasks)"),
-  email: z.string().trim().email().default("bot@stormsoftware.com").describe("The email of the workspace bot")
-}).describe("The workspace's bot user's config used to automated various operations tasks");
-var WorkspaceDirectoryConfigSchema = z.object({
-  cache: z.string().trim().optional().describe("The directory used to store the environment's cached file data"),
-  data: z.string().trim().optional().describe("The directory used to store the environment's data files"),
-  config: z.string().trim().optional().describe("The directory used to store the environment's configuration files"),
-  temp: z.string().trim().optional().describe("The directory used to store the environment's temp files"),
-  log: z.string().trim().optional().describe("The directory used to store the environment's temp files"),
-  build: z.string().trim().default("dist").describe("The directory used to store the workspace's distributable files after a build (relative to the workspace root)")
-}).describe("Various directories used by the workspace to store data, cache, and configuration files");
-var StormConfigSchema = z.object({
-  $schema: z.string().trim().default("https://cdn.jsdelivr.net/npm/@storm-software/config/schemas/storm-workspace.schema.json").optional().nullish().describe("The URL to the JSON schema file that describes the Storm configuration file"),
-  extends: ExtendsSchema.optional(),
-  name: z.string().trim().toLowerCase().optional().describe("The name of the service/package/scope using this configuration"),
-  namespace: z.string().trim().toLowerCase().optional().describe("The namespace of the package"),
-  organization: z.string().trim().default("storm-software").describe("The organization of the workspace"),
-  repository: z.string().trim().optional().describe("The repo URL of the workspace (i.e. GitHub)"),
-  license: z.string().trim().default("Apache-2.0").describe("The license type of the package"),
-  homepage: z.string().trim().url().default(STORM_DEFAULT_HOMEPAGE).describe("The homepage of the workspace"),
-  docs: z.string().trim().url().default(STORM_DEFAULT_DOCS).describe("The base documentation site for the workspace"),
-  licensing: z.string().trim().url().default(STORM_DEFAULT_LICENSING).describe("The base licensing site for the workspace"),
-  branch: z.string().trim().default("main").describe("The branch of the workspace"),
-  preid: z.string().optional().describe("A tag specifying the version pre-release identifier"),
-  owner: z.string().trim().default("@storm-software/admin").describe("The owner of the package"),
-  bot: WorkspaceBotConfigSchema,
-  mode: z.enum([
-    "development",
-    "staging",
-    "production"
-  ]).default("production").describe("The current runtime environment mode for the package"),
-  workspaceRoot: z.string().trim().default("").describe("The root directory of the workspace"),
-  externalPackagePatterns: z.array(z.string()).default([]).describe("The build will use these package patterns to determine if they should be external to the bundle"),
-  skipCache: z.boolean().default(false).describe("Should all known types of workspace caching be skipped?"),
-  directories: WorkspaceDirectoryConfigSchema,
-  packageManager: z.enum([
-    "npm",
-    "yarn",
-    "pnpm",
-    "bun"
-  ]).default("npm").describe("The JavaScript/TypeScript package manager used by the repository"),
-  timezone: z.string().trim().default("America/New_York").describe("The default timezone of the workspace"),
-  locale: z.string().trim().default("en-US").describe("The default locale of the workspace"),
-  logLevel: z.enum([
-    "silent",
-    "fatal",
-    "error",
-    "warn",
-    "success",
-    "info",
-    "debug",
-    "trace",
-    "all"
-  ]).default("info").describe("The log level used to filter out lower priority log messages. If not provided, this is defaulted using the `environment` config value (if `environment` is set to `production` then `level` is `error`, else `level` is `debug`)."),
-  skipConfigLogging: z.boolean().optional().describe("Should the logging of the current Storm Workspace configuration be skipped?"),
-  registry: RegistryConfigSchema,
-  configFile: z.string().trim().nullable().default(null).describe("The filepath of the Storm config. When this field is null, no config file was found in the current workspace."),
-  colors: ColorConfigSchema.or(ColorConfigMapSchema).describe("Storm theme config values used for styling various package elements"),
-  extensions: z.record(z.any()).optional().default({}).describe("Configuration of each used extension")
-}).describe("Storm Workspace config values used during various dev-ops processes. This type is a combination of the StormPackageConfig and StormProject types. It represents the config of the entire monorepo.");
-
-// ../config-tools/src/utilities/get-default-config.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { join as join2 } from "node:path";
-
-// ../config-tools/src/utilities/correct-paths.ts
-var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
-function normalizeWindowsPath(input = "") {
-  if (!input) {
-    return input;
-  }
-  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
-}
-__name(normalizeWindowsPath, "normalizeWindowsPath");
-var _UNC_REGEX = /^[/\\]{2}/;
-var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
-var _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
-var correctPaths = /* @__PURE__ */ __name(function(path) {
-  if (!path || path.length === 0) {
-    return ".";
-  }
-  path = normalizeWindowsPath(path);
-  const isUNCPath = path.match(_UNC_REGEX);
-  const isPathAbsolute = isAbsolute(path);
-  const trailingSeparator = path[path.length - 1] === "/";
-  path = normalizeString(path, !isPathAbsolute);
-  if (path.length === 0) {
-    if (isPathAbsolute) {
-      return "/";
-    }
-    return trailingSeparator ? "./" : ".";
-  }
-  if (trailingSeparator) {
-    path += "/";
-  }
-  if (_DRIVE_LETTER_RE.test(path)) {
-    path += "/";
-  }
-  if (isUNCPath) {
-    if (!isPathAbsolute) {
-      return `//./${path}`;
-    }
-    return `//${path}`;
-  }
-  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
-}, "correctPaths");
-var joinPaths = /* @__PURE__ */ __name(function(...segments) {
-  let path = "";
-  for (const seg of segments) {
-    if (!seg) {
-      continue;
-    }
-    if (path.length > 0) {
-      const pathTrailing = path[path.length - 1] === "/";
-      const segLeading = seg[0] === "/";
-      const both = pathTrailing && segLeading;
-      if (both) {
-        path += seg.slice(1);
-      } else {
-        path += pathTrailing || segLeading ? seg : `/${seg}`;
+// src/configs/astro.ts
+async function astro(options = {}) {
+  const { files = [
+    GLOB_ASTRO
+  ], overrides = {}, stylistic: stylistic2 = true } = options;
+  const [pluginAstro, parserAstro, parserTs] = await Promise.all([
+    interopDefault(import("eslint-plugin-astro")),
+    interopDefault(import("astro-eslint-parser")),
+    interopDefault(import("@typescript-eslint/parser"))
+  ]);
+  return [
+    {
+      name: "storm/astro/setup",
+      plugins: {
+        astro: pluginAstro
       }
-    } else {
-      path += seg;
-    }
-  }
-  return correctPaths(path);
-}, "joinPaths");
-function normalizeString(path, allowAboveRoot) {
-  let res = "";
-  let lastSegmentLength = 0;
-  let lastSlash = -1;
-  let dots = 0;
-  let char = null;
-  for (let index = 0; index <= path.length; ++index) {
-    if (index < path.length) {
-      char = path[index];
-    } else if (char === "/") {
-      break;
-    } else {
-      char = "/";
-    }
-    if (char === "/") {
-      if (lastSlash === index - 1 || dots === 1) {
-      } else if (dots === 2) {
-        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
-          if (res.length > 2) {
-            const lastSlashIndex = res.lastIndexOf("/");
-            if (lastSlashIndex === -1) {
-              res = "";
-              lastSegmentLength = 0;
-            } else {
-              res = res.slice(0, lastSlashIndex);
-              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-            }
-            lastSlash = index;
-            dots = 0;
-            continue;
-          } else if (res.length > 0) {
-            res = "";
-            lastSegmentLength = 0;
-            lastSlash = index;
-            dots = 0;
-            continue;
-          }
-        }
-        if (allowAboveRoot) {
-          res += res.length > 0 ? "/.." : "..";
-          lastSegmentLength = 2;
-        }
-      } else {
-        if (res.length > 0) {
-          res += `/${path.slice(lastSlash + 1, index)}`;
-        } else {
-          res = path.slice(lastSlash + 1, index);
-        }
-        lastSegmentLength = index - lastSlash - 1;
+    },
+    {
+      files,
+      languageOptions: {
+        globals: pluginAstro.environments.astro.globals,
+        parser: parserAstro,
+        parserOptions: {
+          extraFileExtensions: [
+            ".astro"
+          ],
+          parser: parserTs
+        },
+        sourceType: "module"
+      },
+      name: "storm/astro/rules",
+      processor: "astro/client-side-ts",
+      rules: {
+        // use recommended rules
+        "astro/missing-client-only-directive-value": "error",
+        "astro/no-conflict-set-directives": "error",
+        "astro/no-deprecated-astro-canonicalurl": "error",
+        "astro/no-deprecated-astro-fetchcontent": "error",
+        "astro/no-deprecated-astro-resolve": "error",
+        "astro/no-deprecated-getentrybyslug": "error",
+        "astro/no-set-html-directive": "off",
+        "astro/no-unused-define-vars-in-style": "error",
+        "astro/semi": "off",
+        "astro/valid-compile": "error",
+        ...stylistic2 ? {
+          "style/indent": "off",
+          "style/jsx-closing-tag-location": "off",
+          "style/jsx-one-expression-per-line": "off",
+          "style/no-multiple-empty-lines": "off"
+        } : {},
+        ...overrides
       }
-      lastSlash = index;
-      dots = 0;
-    } else if (char === "." && dots !== -1) {
-      ++dots;
-    } else {
-      dots = -1;
     }
-  }
-  return res;
+  ];
 }
-__name(normalizeString, "normalizeString");
-var isAbsolute = /* @__PURE__ */ __name(function(p) {
-  return _IS_ABSOLUTE_RE.test(p);
-}, "isAbsolute");
+__name(astro, "astro");
 
-// ../config-tools/src/utilities/find-up.ts
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-var MAX_PATH_SEARCH_DEPTH = 30;
-var depth = 0;
-function findFolderUp(startPath, endFileNames = [], endDirectoryNames = []) {
-  const _startPath = startPath ?? process.cwd();
-  if (endDirectoryNames.some((endDirName) => existsSync(join(_startPath, endDirName)))) {
-    return _startPath;
-  }
-  if (endFileNames.some((endFileName) => existsSync(join(_startPath, endFileName)))) {
-    return _startPath;
-  }
-  if (_startPath !== "/" && depth++ < MAX_PATH_SEARCH_DEPTH) {
-    const parent = join(_startPath, "..");
-    return findFolderUp(parent, endFileNames, endDirectoryNames);
-  }
-  return void 0;
-}
-__name(findFolderUp, "findFolderUp");
-
-// ../config-tools/src/utilities/find-workspace-root.ts
-var rootFiles = [
-  "storm-workspace.json",
-  "storm-workspace.json",
-  "storm-workspace.yaml",
-  "storm-workspace.yml",
-  "storm-workspace.js",
-  "storm-workspace.ts",
-  ".storm-workspace.json",
-  ".storm-workspace.yaml",
-  ".storm-workspace.yml",
-  ".storm-workspace.js",
-  ".storm-workspace.ts",
-  "lerna.json",
-  "nx.json",
-  "turbo.json",
-  "npm-workspace.json",
-  "yarn-workspace.json",
-  "pnpm-workspace.json",
-  "npm-workspace.yaml",
-  "yarn-workspace.yaml",
-  "pnpm-workspace.yaml",
-  "npm-workspace.yml",
-  "yarn-workspace.yml",
-  "pnpm-workspace.yml",
-  "npm-lock.json",
-  "yarn-lock.json",
-  "pnpm-lock.json",
-  "npm-lock.yaml",
-  "yarn-lock.yaml",
-  "pnpm-lock.yaml",
-  "npm-lock.yml",
-  "yarn-lock.yml",
-  "pnpm-lock.yml",
-  "bun.lockb"
-];
-var rootDirectories = [
-  ".storm-workspace",
-  ".nx",
-  ".github",
-  ".vscode",
-  ".verdaccio"
-];
-function findWorkspaceRootSafe(pathInsideMonorepo) {
-  if (process.env.STORM_WORKSPACE_ROOT || process.env.NX_WORKSPACE_ROOT_PATH) {
-    return correctPaths(process.env.STORM_WORKSPACE_ROOT ?? process.env.NX_WORKSPACE_ROOT_PATH);
-  }
-  return correctPaths(findFolderUp(pathInsideMonorepo ?? process.cwd(), rootFiles, rootDirectories));
-}
-__name(findWorkspaceRootSafe, "findWorkspaceRootSafe");
-function findWorkspaceRoot(pathInsideMonorepo) {
-  const result = findWorkspaceRootSafe(pathInsideMonorepo);
-  if (!result) {
-    throw new Error(`Cannot find workspace root upwards from known path. Files search list includes: 
-${rootFiles.join("\n")}
-Path: ${pathInsideMonorepo ? pathInsideMonorepo : process.cwd()}`);
-  }
-  return result;
+// src/configs/disables.ts
+async function disables() {
+  return [
+    {
+      files: [
+        `**/scripts/${GLOB_SRC}`
+      ],
+      name: "storm/disables/scripts",
+      rules: {
+        "no-console": "off",
+        "ts/explicit-function-return-type": "off"
+      }
+    },
+    {
+      files: [
+        `**/cli/${GLOB_SRC}`,
+        `**/cli.${GLOB_SRC_EXT}`
+      ],
+      name: "storm/disables/cli",
+      rules: {
+        "no-console": "off"
+      }
+    },
+    {
+      files: [
+        "**/*.d.?([cm])ts"
+      ],
+      name: "storm/disables/dts",
+      rules: {
+        "eslint-comments/no-unlimited-disable": "off",
+        "import/no-duplicates": "off",
+        "no-restricted-syntax": "off",
+        "unused-imports/no-unused-vars": "off"
+      }
+    },
+    {
+      files: [
+        "**/*.js",
+        "**/*.cjs"
+      ],
+      name: "storm/disables/cjs",
+      rules: {
+        "ts/no-require-imports": "off"
+      }
+    },
+    {
+      files: [
+        `**/*.config.${GLOB_SRC_EXT}`,
+        `**/*.config.*.${GLOB_SRC_EXT}`
+      ],
+      name: "storm/disables/config-files",
+      rules: {
+        "no-console": "off",
+        "ts/explicit-function-return-type": "off"
+      }
+    }
+  ];
 }
-__name(findWorkspaceRoot, "findWorkspaceRoot");
-
-// ../config-tools/src/utilities/get-default-config.ts
-var DEFAULT_COLOR_CONFIG = {
-  light: {
-    background: "#fafafa",
-    foreground: "#1d1e22",
-    brand: "#1fb2a6",
-    alternate: "#db2777",
-    help: "#5C4EE5",
-    success: "#087f5b",
-    info: "#0550ae",
-    warning: "#e3b341",
-    danger: "#D8314A",
-    positive: "#22c55e",
-    negative: "#dc2626"
-  },
-  dark: {
-    background: "#1d1e22",
-    foreground: "#cbd5e1",
-    brand: "#2dd4bf",
-    alternate: "#db2777",
-    help: "#818cf8",
-    success: "#10b981",
-    info: "#58a6ff",
-    warning: "#f3d371",
-    danger: "#D8314A",
-    positive: "#22c55e",
-    negative: "#dc2626"
-  }
-};
+__name(disables, "disables");
 
-// ../config-tools/src/logger/chalk.ts
-import chalk from "chalk";
-var chalkDefault = {
-  hex: /* @__PURE__ */ __name((_) => (message) => message, "hex"),
-  bgHex: /* @__PURE__ */ __name((_) => ({
-    whiteBright: /* @__PURE__ */ __name((message) => message, "whiteBright")
-  }), "bgHex"),
-  whiteBright: /* @__PURE__ */ __name((message) => message, "whiteBright"),
-  gray: /* @__PURE__ */ __name((message) => message, "gray"),
-  bold: {
-    hex: /* @__PURE__ */ __name((_) => (message) => message, "hex"),
-    bgHex: /* @__PURE__ */ __name((_) => ({
-      whiteBright: /* @__PURE__ */ __name((message) => message, "whiteBright")
-    }), "bgHex"),
-    whiteBright: /* @__PURE__ */ __name((message) => message, "whiteBright")
-  },
-  dim: {
-    hex: /* @__PURE__ */ __name((_) => (message) => message, "hex"),
-    gray: /* @__PURE__ */ __name((message) => message, "gray")
-  }
+// src/configs/stylistic.ts
+var StylisticConfigDefaults = {
+  indent: 2,
+  jsx: true,
+  quotes: "single",
+  semi: false
 };
-var getChalk = /* @__PURE__ */ __name(() => {
-  let _chalk = chalk;
-  if (!_chalk?.hex || !_chalk?.bold?.hex || !_chalk?.bgHex || !_chalk?.whiteBright) {
-    _chalk = chalkDefault;
-  }
-  return _chalk;
-}, "getChalk");
-
-// ../config-tools/src/logger/is-unicode-supported.ts
-function isUnicodeSupported() {
-  if (process.platform !== "win32") {
-    return process.env.TERM !== "linux";
-  }
-  return Boolean(process.env.WT_SESSION) || // Windows Terminal
-  Boolean(process.env.TERMINUS_SUBLIME) || // Terminus (<0.2.27)
-  process.env.ConEmuTask === "{cmd::Cmder}" || // ConEmu and cmder
-  process.env.TERM_PROGRAM === "Terminus-Sublime" || process.env.TERM_PROGRAM === "vscode" || process.env.TERM === "xterm-256color" || process.env.TERM === "alacritty" || process.env.TERM === "rxvt-unicode" || process.env.TERM === "rxvt-unicode-256color" || process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+async function stylistic(options = {}) {
+  const { indent, jsx: jsx2, overrides = {}, quotes, semi } = {
+    ...StylisticConfigDefaults,
+    ...options
+  };
+  const pluginStylistic = await interopDefault(import("@stylistic/eslint-plugin"));
+  const config = pluginStylistic.configs.customize({
+    indent,
+    jsx: jsx2,
+    pluginName: "style",
+    quotes,
+    semi
+  });
+  return [
+    {
+      name: "storm/stylistic/rules",
+      plugins: {
+        style: pluginStylistic
+      },
+      rules: {
+        ...config.rules,
+        ...overrides
+      }
+    }
+  ];
 }
-__name(isUnicodeSupported, "isUnicodeSupported");
+__name(stylistic, "stylistic");
 
-// ../config-tools/src/logger/console-icons.ts
-var useIcon = /* @__PURE__ */ __name((c, fallback) => isUnicodeSupported() ? c : fallback, "useIcon");
-var CONSOLE_ICONS = {
-  [LogLevelLabel.ERROR]: useIcon("\u2718", "\xD7"),
-  [LogLevelLabel.FATAL]: useIcon("\u{1F480}", "\xD7"),
-  [LogLevelLabel.WARN]: useIcon("\u26A0", "\u203C"),
-  [LogLevelLabel.INFO]: useIcon("\u2139", "i"),
-  [LogLevelLabel.SUCCESS]: useIcon("\u2714", "\u221A"),
-  [LogLevelLabel.DEBUG]: useIcon("\u{1F6E0}", "D"),
-  [LogLevelLabel.TRACE]: useIcon("\u{1F6E0}", "T"),
-  [LogLevelLabel.ALL]: useIcon("\u2709", "\u2192")
-};
-
-// ../config-tools/src/logger/format-timestamp.ts
-var formatTimestamp = /* @__PURE__ */ __name((date = /* @__PURE__ */ new Date()) => {
-  return `${date.toLocaleDateString()} ${date.toLocaleTimeString()}`;
-}, "formatTimestamp");
-
-// ../config-tools/src/logger/get-log-level.ts
-var getLogLevel = /* @__PURE__ */ __name((label) => {
-  switch (label) {
-    case "all":
-      return LogLevel.ALL;
-    case "trace":
-      return LogLevel.TRACE;
-    case "debug":
-      return LogLevel.DEBUG;
-    case "info":
-      return LogLevel.INFO;
-    case "warn":
-      return LogLevel.WARN;
-    case "error":
-      return LogLevel.ERROR;
-    case "fatal":
-      return LogLevel.FATAL;
-    case "silent":
-      return LogLevel.SILENT;
-    default:
-      return LogLevel.INFO;
-  }
-}, "getLogLevel");
-
-// ../config-tools/src/logger/console.ts
-var getLogFn = /* @__PURE__ */ __name((logLevel = LogLevel.INFO, config = {}, _chalk = getChalk()) => {
-  const colors = !config.colors?.dark && !config.colors?.["base"] && !config.colors?.["base"]?.dark ? DEFAULT_COLOR_CONFIG : config.colors?.dark && typeof config.colors.dark === "string" ? config.colors : config.colors?.["base"]?.dark && typeof config.colors["base"].dark === "string" ? config.colors["base"].dark : config.colors?.["base"] ? config.colors?.["base"] : DEFAULT_COLOR_CONFIG;
-  const configLogLevel = config.logLevel || process.env.STORM_LOG_LEVEL || LogLevelLabel.INFO;
-  if (logLevel > getLogLevel(configLogLevel) || logLevel <= LogLevel.SILENT || getLogLevel(configLogLevel) <= LogLevel.SILENT) {
-    return (_) => {
-    };
-  }
-  if (typeof logLevel === "number" && LogLevel.FATAL >= logLevel) {
-    return (message) => {
-      console.error(`
-${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors.fatal ?? "#7d1a1a")(`[${CONSOLE_ICONS[LogLevelLabel.FATAL]} Fatal] `)}${_chalk.bold.whiteBright(formatLogMessage(message))}
-`);
-    };
-  }
-  if (typeof logLevel === "number" && LogLevel.ERROR >= logLevel) {
-    return (message) => {
-      console.error(`
-${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors.danger ?? "#f85149")(`[${CONSOLE_ICONS[LogLevelLabel.ERROR]} Error] `)}${_chalk.bold.whiteBright(formatLogMessage(message))}
-`);
-    };
-  }
-  if (typeof logLevel === "number" && LogLevel.WARN >= logLevel) {
-    return (message) => {
-      console.warn(`
-${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors.warning ?? "#e3b341")(`[${CONSOLE_ICONS[LogLevelLabel.WARN]} Warn] `)}${_chalk.bold.whiteBright(formatLogMessage(message))}
-`);
-    };
-  }
-  if (typeof logLevel === "number" && LogLevel.SUCCESS >= logLevel) {
-    return (message) => {
-      console.info(`
-${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors.success ?? "#56d364")(`[${CONSOLE_ICONS[LogLevelLabel.SUCCESS]} Success] `)}${_chalk.bold.whiteBright(formatLogMessage(message))}
-`);
-    };
-  }
-  if (typeof logLevel === "number" && LogLevel.INFO >= logLevel) {
-    return (message) => {
-      console.info(`
-${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors.info ?? "#58a6ff")(`[${CONSOLE_ICONS[LogLevelLabel.INFO]} Info] `)}${_chalk.bold.whiteBright(formatLogMessage(message))}
-`);
-    };
-  }
-  if (typeof logLevel === "number" && LogLevel.DEBUG >= logLevel) {
-    return (message) => {
-      console.debug(`
-${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors.brand ?? "#1fb2a6")(`[${CONSOLE_ICONS[LogLevelLabel.DEBUG]}  Debug] `)}${_chalk.bold.whiteBright(formatLogMessage(message))}
-`);
-    };
-  }
-  if (typeof logLevel === "number" && LogLevel.TRACE >= logLevel) {
-    return (message) => {
-      console.debug(`
-${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors.brand ?? "#1fb2a6")(`[${CONSOLE_ICONS[LogLevelLabel.TRACE]}  Trace] `)}${_chalk.bold.whiteBright(formatLogMessage(message))}
-`);
+// src/configs/formatters.ts
+function mergePrettierOptions(options, overrides = {}) {
+  return {
+    ...options,
+    ...overrides,
+    plugins: [
+      ...overrides.plugins || [],
+      ...options.plugins || []
+    ]
+  };
+}
+__name(mergePrettierOptions, "mergePrettierOptions");
+async function formatters(options = {}, stylistic2 = {}) {
+  if (options === true) {
+    const isPrettierPluginXmlInScope = isPackageInScope("@prettier/plugin-xml");
+    options = {
+      astro: isPackageInScope("prettier-plugin-astro"),
+      css: true,
+      graphql: true,
+      html: true,
+      markdown: true,
+      svg: isPrettierPluginXmlInScope,
+      xml: isPrettierPluginXmlInScope
     };
   }
-  return (message) => {
-    console.log(`
-${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors.brand ?? "#1fb2a6")(`[${CONSOLE_ICONS[LogLevelLabel.ALL]}  System] `)}${_chalk.bold.whiteBright(formatLogMessage(message))}
-`);
+  await ensurePackages([
+    "eslint-plugin-format",
+    options.astro ? "prettier-plugin-astro" : void 0,
+    options.xml || options.svg ? "@prettier/plugin-xml" : void 0
+  ]);
+  const { indent, quotes, semi } = {
+    ...StylisticConfigDefaults,
+    ...stylistic2
   };
-}, "getLogFn");
-var writeFatal = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.FATAL, config)(message), "writeFatal");
-var writeError = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.ERROR, config)(message), "writeError");
-var writeInfo = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.INFO, config)(message), "writeInfo");
-var writeDebug = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.DEBUG, config)(message), "writeDebug");
-var writeTrace = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.TRACE, config)(message), "writeTrace");
-var MAX_DEPTH = 4;
-var formatLogMessage = /* @__PURE__ */ __name((message, options = {}, depth2 = 0) => {
-  if (depth2 > MAX_DEPTH) {
-    return "<max depth>";
-  }
-  const prefix = options.prefix ?? "-";
-  const skip = options.skip ?? [];
-  return typeof message === "undefined" || message === null || !message && typeof message !== "boolean" ? "<none>" : typeof message === "string" ? message : Array.isArray(message) ? `
-${message.map((item, index) => ` ${prefix}> #${index} = ${formatLogMessage(item, {
-    prefix: `${prefix}-`,
-    skip
-  }, depth2 + 1)}`).join("\n")}` : typeof message === "object" ? `
-${Object.keys(message).filter((key) => !skip.includes(key)).map((key) => ` ${prefix}> ${key} = ${_isFunction(message[key]) ? "<function>" : typeof message[key] === "object" ? formatLogMessage(message[key], {
-    prefix: `${prefix}-`,
-    skip
-  }, depth2 + 1) : message[key]}`).join("\n")}` : message;
-}, "formatLogMessage");
-var _isFunction = /* @__PURE__ */ __name((value) => {
-  try {
-    return value instanceof Function || typeof value === "function" || !!(value?.constructor && value?.call && value?.apply);
-  } catch (e) {
-    return false;
-  }
-}, "_isFunction");
-
-// src/preset.ts
-import { defu } from "defu";
-import json from "eslint-plugin-json";
-import markdown from "eslint-plugin-markdown";
-import prettierConfig from "eslint-plugin-prettier/recommended";
-import reactPlugin from "eslint-plugin-react";
-import reactCompiler from "eslint-plugin-react-compiler";
-import reactHooks from "eslint-plugin-react-hooks";
-import storybook from "eslint-plugin-storybook";
-import tsdoc from "eslint-plugin-tsdoc";
-import unicorn from "eslint-plugin-unicorn";
-import yml from "eslint-plugin-yml";
-import globalsObj from "globals";
-import tsEslint from "typescript-eslint";
-function getStormConfig(options = {
-  rules: {},
-  ignores: [],
-  globals: {},
-  useUnicorn: true,
-  markdown: {},
-  react: {},
-  nx: {},
-  useReactCompiler: false,
-  logLevel: "info",
-  cspellConfigFile: "./.vscode/cspell.json"
-}, ...userConfigs) {
-  const tsconfig = options.tsconfig;
-  const parserOptions = options.parserOptions;
-  const typescriptEslintConfigType = options.typescriptEslintConfigType || "eslintRecommended";
-  const useUnicorn = options.useUnicorn ?? true;
-  const react = options.react ?? {};
-  const nx = options.nx ?? {};
-  const useReactCompiler = options.useReactCompiler ?? false;
-  const logLevel = options.logLevel ?? "info";
-  const globals = options.globals ?? {};
-  const cspellConfigFile = options.cspellConfigFile || "./.vscode/cspell.json";
-  try {
-    const ignoredFiles = [
-      ...DEFAULT_IGNORES,
-      ...options.ignores || []
-    ].filter(Boolean);
-    const configs = [
-      // Prettier
-      prettierConfig,
-      // Import
-      // https://www.npmjs.com/package/eslint-plugin-import
-      // { plugins: { import: importEslint } },
-      // {
-      //   files: [CODE_FILE],
-      //   rules: importRules
-      // },
-      // Json
-      // https://www.npmjs.com/package/eslint-plugin-json
-      {
-        files: [
-          "**/*.json"
-        ],
-        ...json.configs["recommended"],
-        rules: {
-          "json/json": [
-            "warn",
-            {
-              allowComments: true
-            }
-          ]
-        }
-      },
-      {
-        files: [
-          "**/executors/**/schema.json",
-          "**/generators/**/schema.json"
-        ],
-        rules: nx !== false ? {
-          "@nx/workspace/valid-schema-description": "error"
-        } : {}
+  const prettierOptions = Object.assign({
+    endOfLine: "auto",
+    printWidth: 120,
+    semi,
+    singleQuote: quotes === "single",
+    tabWidth: typeof indent === "number" ? indent : 2,
+    trailingComma: "all",
+    useTabs: indent === "tab"
+  }, options.prettierOptions || {});
+  const prettierXmlOptions = {
+    xmlQuoteAttributes: "double",
+    xmlSelfClosingSpace: true,
+    xmlSortAttributesByKey: false,
+    xmlWhitespaceSensitivity: "ignore"
+  };
+  const dprintOptions = Object.assign({
+    indentWidth: typeof indent === "number" ? indent : 2,
+    quoteStyle: quotes === "single" ? "preferSingle" : "preferDouble",
+    useTabs: indent === "tab"
+  }, options.dprintOptions || {});
+  const pluginFormat = await interopDefault(import("eslint-plugin-format"));
+  const configs2 = [
+    {
+      name: "storm/formatter/setup",
+      plugins: {
+        format: pluginFormat
+      }
+    }
+  ];
+  if (options.css) {
+    configs2.push({
+      files: [
+        GLOB_CSS,
+        GLOB_POSTCSS
+      ],
+      languageOptions: {
+        parser: parserPlain
       },
-      {
-        files: [
-          "**/package.json"
-        ],
-        rules: nx !== false ? {
-          "@nx/dependency-checks": [
-            "error",
-            {
-              buildTargets: [
-                "build-base",
-                "build"
-              ],
-              ignoredDependencies: [
-                "typescript"
-              ],
-              checkMissingDependencies: true,
-              checkObsoleteDependencies: true,
-              checkVersionMismatches: false,
-              includeTransitiveDependencies: true,
-              useLocalPathsForWorkspaceDependencies: true
-            }
-          ]
-        } : {}
+      name: "storm/formatter/css",
+      rules: {
+        "format/prettier": [
+          "error",
+          mergePrettierOptions(prettierOptions, {
+            parser: "css"
+          })
+        ]
+      }
+    }, {
+      files: [
+        GLOB_SCSS
+      ],
+      languageOptions: {
+        parser: parserPlain
       },
-      // YML
-      // https://www.npmjs.com/package/eslint-plugin-yml
-      ...yml.configs["flat/recommended"],
-      ...yml.configs["flat/prettier"],
-      // CSpell
-      {
-        ...cspell,
-        rules: {
-          ...cspell.rules,
-          "@cspell/spellchecker": [
-            "warn",
-            {
-              configFile: joinPaths(findWorkspaceRoot(), cspellConfigFile),
-              autoFix: true
-            }
-          ]
-        }
+      name: "storm/formatter/scss",
+      rules: {
+        "format/prettier": [
+          "error",
+          mergePrettierOptions(prettierOptions, {
+            parser: "scss"
+          })
+        ]
+      }
+    }, {
+      files: [
+        GLOB_LESS
+      ],
+      languageOptions: {
+        parser: parserPlain
       },
-      // User overrides
-      ...userConfigs
-    ].filter(Boolean);
-    if (nx) {
-      configs.push({
-        plugins: {
-          "@nx": nxPlugin
-        }
-      });
-    }
-    configs.push(eslint.configs.recommended);
-    if (typescriptEslintConfigType !== "none") {
-      if (!(typescriptEslintConfigType in tsEslint.configs)) {
-        console.warn("Invalid TypeScript ESLint configuration type:", typescriptEslintConfigType);
-      } else {
-        configs.push(...Array.isArray(tsEslint.configs[typescriptEslintConfigType]) ? tsEslint.configs[typescriptEslintConfigType] : [
-          tsEslint.configs[typescriptEslintConfigType]
-        ]);
+      name: "storm/formatter/less",
+      rules: {
+        "format/prettier": [
+          "error",
+          mergePrettierOptions(prettierOptions, {
+            parser: "less"
+          })
+        ]
       }
-    }
-    if (useUnicorn) {
-      configs.push({
-        files: [
-          TS_FILE
-        ],
-        plugins: {
-          unicorn
-        },
-        rules: {
-          ...unicorn.configs["flat/recommended"].rules
-        }
-      });
-    }
-    configs.push({
+    });
+  }
+  if (options.html) {
+    configs2.push({
       files: [
-        TS_FILE
+        GLOB_HTML
       ],
-      plugins: {
-        tsdoc
+      languageOptions: {
+        parser: parserPlain
       },
-      rules: ts_docs_default
+      name: "storm/formatter/html",
+      rules: {
+        "format/prettier": [
+          "error",
+          mergePrettierOptions(prettierOptions, {
+            parser: "html"
+          })
+        ]
+      }
     });
-    configs.push({
-      ...banner_plugin_default.configs["recommended"],
-      name: "banner",
-      plugins: {
-        banner: banner_plugin_default
+  }
+  if (options.xml) {
+    configs2.push({
+      files: [
+        GLOB_XML
+      ],
+      languageOptions: {
+        parser: parserPlain
       },
+      name: "storm/formatter/xml",
+      rules: {
+        "format/prettier": [
+          "error",
+          mergePrettierOptions({
+            ...prettierXmlOptions,
+            ...prettierOptions
+          }, {
+            parser: "xml",
+            plugins: [
+              "@prettier/plugin-xml"
+            ]
+          })
+        ]
+      }
+    });
+  }
+  if (options.svg) {
+    configs2.push({
       files: [
-        CODE_FILE
+        GLOB_SVG
       ],
+      languageOptions: {
+        parser: parserPlain
+      },
+      name: "storm/formatter/svg",
       rules: {
-        "banner/banner": [
+        "format/prettier": [
           "error",
-          {
-            commentType: "block",
-            numNewlines: 2,
-            repositoryName: options.name
-          }
+          mergePrettierOptions({
+            ...prettierXmlOptions,
+            ...prettierOptions
+          }, {
+            parser: "xml",
+            plugins: [
+              "@prettier/plugin-xml"
+            ]
+          })
         ]
       }
     });
-    if (react) {
-      const reactConfigs = [
-        {
-          ...reactPlugin.configs?.recommended,
-          plugins: {
-            react: reactPlugin
-          },
-          files: [
-            "**/*.tsx"
-          ],
-          ...react
-        },
-        {
-          ...reactHooks.configs?.recommended,
-          plugins: {
-            "react-hooks": reactHooks
-          },
-          files: [
-            TS_FILE
-          ]
-        }
-      ];
-      if (useReactCompiler) {
-        reactConfigs.push({
-          files: [
-            "**/*.tsx"
-          ],
-          plugins: {
-            "react-compiler": reactCompiler
-          },
-          rules: {
-            "react-compiler/react-compiler": "error"
+  }
+  if (options.markdown) {
+    const formater = options.markdown === true ? "prettier" : options.markdown;
+    configs2.push({
+      files: [
+        GLOB_MARKDOWN
+      ],
+      languageOptions: {
+        parser: parserPlain
+      },
+      name: "storm/formatter/markdown",
+      rules: {
+        [`format/${formater}`]: [
+          "error",
+          formater === "prettier" ? mergePrettierOptions(prettierOptions, {
+            embeddedLanguageFormatting: "off",
+            parser: "markdown"
+          }) : {
+            ...dprintOptions,
+            language: "markdown"
           }
-        });
+        ]
       }
-      reactConfigs.push(storybook.configs["flat/recommended"]);
-      configs.push(...reactConfigs);
-    }
-    if (options.nextFiles && options.nextFiles.length > 0) {
-      configs.push({
-        ...next.configs["core-web-vitals"],
-        files: options.nextFiles
-      });
-    }
-    const typescriptConfig = {
+    });
+  }
+  if (options.astro) {
+    configs2.push({
       files: [
-        TS_FILE
+        GLOB_ASTRO
       ],
       languageOptions: {
-        globals: {
-          ...Object.fromEntries(Object.keys(globalsObj).flatMap((group) => Object.keys(globalsObj[group]).map((key) => [
-            key,
-            "readonly"
-          ]))),
-          ...globalsObj.browser,
-          ...globalsObj.node,
-          ...globals,
-          window: "readonly"
-        },
-        parserOptions: {
-          projectService: true,
-          ecmaFeatures: {
-            jsx: react !== false
-          }
-        }
+        parser: parserPlain
       },
+      name: "storm/formatter/astro",
       rules: {
-        ...getStormRulesConfig({
-          ...options,
-          typescriptEslintConfigType,
-          useUnicorn,
-          useNx: nx !== false
-        }),
-        ...Object.keys(options.rules ?? {}).filter((ruleId) => !useUnicorn || !ruleId.startsWith("unicorn/") || !react || !ruleId.startsWith("react/") && !ruleId.startsWith("react-hooks/")).reduce((ret, ruleId) => {
-          ret[ruleId] = options.rules[ruleId];
-          return ret;
-        }, {})
+        "format/prettier": [
+          "error",
+          mergePrettierOptions(prettierOptions, {
+            parser: "astro",
+            plugins: [
+              "prettier-plugin-astro"
+            ]
+          })
+        ]
       }
-    };
-    if (parserOptions) {
-      typescriptConfig.languageOptions ??= {};
-      typescriptConfig.languageOptions.parserOptions = parserOptions;
-    }
-    if (tsconfig) {
-      typescriptConfig.languageOptions ??= {};
-      typescriptConfig.languageOptions.parserOptions ??= {};
-      typescriptConfig.languageOptions.parserOptions.project = tsconfig;
-    }
-    configs.push(typescriptConfig);
-    if (options.markdown) {
-      configs.push(...markdown.configs.recommended);
-      configs.push({
-        files: [
-          CODE_BLOCK
-        ],
-        processor: "markdown/markdown",
-        rules: {
-          "unicorn/filename-case": "off",
-          "no-undef": "off",
-          "no-unused-expressions": "off",
-          "padded-blocks": "off",
-          "no-empty-pattern": "off",
-          "no-redeclare": "off",
-          "no-import-assign": "off",
-          ...options.markdown
-        }
-      });
-      configs.push({
-        files: [
-          "**/*.md/*.js",
-          "**/*.md/*.ts"
-        ],
-        rules: {
-          "unicorn/filename-case": "off",
-          "no-undef": "off",
-          "no-unused-expressions": "off",
-          "padded-blocks": "off",
-          "no-empty-pattern": "off",
-          "no-redeclare": "off",
-          "no-import-assign": "off",
-          ...options.markdown
-        }
-      });
-    }
-    writeTrace(formatLogMessage(configs, {
-      skip: [
-        "globals"
-      ]
-    }), {
-      logLevel
-    });
-    const result = formatConfig("Preset", configs.reduce((ret, config) => {
-      delete config.parserOptions;
-      const existingIndex = ret.findIndex((existing) => areFilesEqual(existing.files, config.files));
-      if (existingIndex >= 0) {
-        ret[existingIndex] = defu(ret[existingIndex], config);
-      } else {
-        ret.push(config);
-      }
-      return ret;
-    }, []));
-    result.unshift({
-      ignores: ignoredFiles
     });
-    writeInfo("\u2699\uFE0F  Completed generated Storm ESLint configuration objects", {
-      logLevel
-    });
-    writeDebug(formatLogMessage(result, {
-      skip: [
-        "globals"
-      ]
-    }), {
-      logLevel
+    configs2.push({
+      files: [
+        GLOB_ASTRO,
+        GLOB_ASTRO_TS
+      ],
+      name: "storm/formatter/astro/disables",
+      rules: {
+        "style/arrow-parens": "off",
+        "style/block-spacing": "off",
+        "style/comma-dangle": "off",
+        "style/indent": "off",
+        "style/no-multi-spaces": "off",
+        "style/quotes": "off",
+        "style/semi": "off"
+      }
     });
-    return result;
-  } catch (error) {
-    writeFatal("Error generating Storm ESLint configuration objects", {
-      logLevel
+  }
+  if (options.graphql) {
+    configs2.push({
+      files: [
+        GLOB_GRAPHQL
+      ],
+      languageOptions: {
+        parser: parserPlain
+      },
+      name: "storm/formatter/graphql",
+      rules: {
+        "format/prettier": [
+          "error",
+          mergePrettierOptions(prettierOptions, {
+            parser: "graphql"
+          })
+        ]
+      }
     });
-    writeError(error, {
-      logLevel
+  }
+  return configs2;
+}
+__name(formatters, "formatters");
+
+// src/configs/graphql.ts
+import { FlatCompat } from "@eslint/eslintrc";
+var compat = new FlatCompat({
+  // import.meta.dirname is available after Node.js v20.11.0
+  baseDirectory: import.meta.dirname
+});
+async function graphql(options = {}) {
+  const { relay = true, operations = true, schema = true } = options;
+  await ensurePackages([
+    "@graphql-eslint/eslint-plugin",
+    "eslint-plugin-relay"
+  ]);
+  const [pluginGraphQL] = await Promise.all([
+    interopDefault(import("@graphql-eslint/eslint-plugin"))
+  ]);
+  return [
+    {
+      name: "storm/graphql/setup",
+      files: [
+        "**/*.graphql",
+        "**/*.gql"
+      ],
+      languageOptions: {
+        parser: pluginGraphQL.parser
+      },
+      plugins: {
+        "@graphql-eslint": pluginGraphQL
+      }
+    },
+    {
+      name: "storm/graphql/rules",
+      plugins: {
+        graphql: pluginGraphQL
+      },
+      rules: {
+        ...schema ? {
+          "@graphql-eslint/description-style": "error",
+          "@graphql-eslint/known-argument-names": "error",
+          "@graphql-eslint/known-directives": "error",
+          "@graphql-eslint/known-type-names": "error",
+          "@graphql-eslint/lone-schema-definition": "error",
+          "@graphql-eslint/naming-convention": [
+            "error",
+            {
+              types: "PascalCase",
+              FieldDefinition: "camelCase",
+              InputValueDefinition: "camelCase",
+              Argument: "camelCase",
+              DirectiveDefinition: "camelCase",
+              EnumValueDefinition: "UPPER_CASE",
+              "FieldDefinition[parent.name.value=Query]": {
+                forbiddenPrefixes: [
+                  "query",
+                  "get"
+                ],
+                forbiddenSuffixes: [
+                  "Query"
+                ]
+              },
+              "FieldDefinition[parent.name.value=Mutation]": {
+                forbiddenPrefixes: [
+                  "mutation"
+                ],
+                forbiddenSuffixes: [
+                  "Mutation"
+                ]
+              },
+              "FieldDefinition[parent.name.value=Subscription]": {
+                forbiddenPrefixes: [
+                  "subscription"
+                ],
+                forbiddenSuffixes: [
+                  "Subscription"
+                ]
+              },
+              "EnumTypeDefinition,EnumTypeExtension": {
+                forbiddenPrefixes: [
+                  "Enum"
+                ],
+                forbiddenSuffixes: [
+                  "Enum"
+                ]
+              },
+              "InterfaceTypeDefinition,InterfaceTypeExtension": {
+                forbiddenPrefixes: [
+                  "Interface"
+                ],
+                forbiddenSuffixes: [
+                  "Interface"
+                ]
+              },
+              "UnionTypeDefinition,UnionTypeExtension": {
+                forbiddenPrefixes: [
+                  "Union"
+                ],
+                forbiddenSuffixes: [
+                  "Union"
+                ]
+              },
+              "ObjectTypeDefinition,ObjectTypeExtension": {
+                forbiddenPrefixes: [
+                  "Type"
+                ],
+                forbiddenSuffixes: [
+                  "Type"
+                ]
+              }
+            }
+          ],
+          "@graphql-eslint/no-hashtag-description": "error",
+          "@graphql-eslint/no-typename-prefix": "error",
+          "@graphql-eslint/no-unreachable-types": "error",
+          "@graphql-eslint/possible-type-extension": "error",
+          "@graphql-eslint/provided-required-arguments": "error",
+          "@graphql-eslint/require-deprecation-reason": "error",
+          "@graphql-eslint/require-description": [
+            "error",
+            {
+              types: true,
+              DirectiveDefinition: true,
+              rootField: true
+            }
+          ],
+          "@graphql-eslint/strict-id-in-types": "error",
+          "@graphql-eslint/unique-directive-names": "error",
+          "@graphql-eslint/unique-directive-names-per-location": "error",
+          "@graphql-eslint/unique-enum-value-names": "error",
+          "@graphql-eslint/unique-field-definition-names": "error",
+          "@graphql-eslint/unique-operation-types": "error",
+          "@graphql-eslint/unique-type-names": "error"
+        } : {},
+        ...operations ? {
+          "@graphql-eslint/executable-definitions": "error",
+          "@graphql-eslint/fields-on-correct-type": "error",
+          "@graphql-eslint/fragments-on-composite-type": "error",
+          "@graphql-eslint/known-argument-names": "error",
+          "@graphql-eslint/known-directives": "error",
+          "@graphql-eslint/known-fragment-names": "error",
+          "@graphql-eslint/known-type-names": "error",
+          "@graphql-eslint/lone-anonymous-operation": "error",
+          "@graphql-eslint/naming-convention": [
+            "error",
+            {
+              VariableDefinition: "camelCase",
+              OperationDefinition: {
+                style: "PascalCase",
+                forbiddenPrefixes: [
+                  "Query",
+                  "Mutation",
+                  "Subscription",
+                  "Get"
+                ],
+                forbiddenSuffixes: [
+                  "Query",
+                  "Mutation",
+                  "Subscription"
+                ]
+              },
+              FragmentDefinition: {
+                style: "PascalCase",
+                forbiddenPrefixes: [
+                  "Fragment"
+                ],
+                forbiddenSuffixes: [
+                  "Fragment"
+                ]
+              }
+            }
+          ],
+          "@graphql-eslint/no-anonymous-operations": "error",
+          "@graphql-eslint/no-deprecated": "error",
+          "@graphql-eslint/no-duplicate-fields": "error",
+          "@graphql-eslint/no-fragment-cycles": "error",
+          "@graphql-eslint/no-undefined-variables": "error",
+          "@graphql-eslint/no-unused-fragments": "error",
+          "@graphql-eslint/no-unused-variables": "error",
+          "@graphql-eslint/one-field-subscriptions": "error",
+          "@graphql-eslint/overlapping-fields-can-be-merged": "error",
+          "@graphql-eslint/possible-fragment-spread": "error",
+          "@graphql-eslint/provided-required-arguments": "error",
+          "@graphql-eslint/require-selections": "error",
+          "@graphql-eslint/scalar-leafs": "error",
+          "@graphql-eslint/selection-set-depth": [
+            "error",
+            {
+              maxDepth: 7
+            }
+          ],
+          "@graphql-eslint/unique-argument-names": "error",
+          "@graphql-eslint/unique-directive-names-per-location": "error",
+          "@graphql-eslint/unique-fragment-name": "error",
+          "@graphql-eslint/unique-input-field-names": "error",
+          "@graphql-eslint/unique-operation-name": "error",
+          "@graphql-eslint/unique-variable-names": "error",
+          "@graphql-eslint/value-literals-of-correct-type": "error",
+          "@graphql-eslint/variables-are-input-types": "error",
+          "@graphql-eslint/variables-in-allowed-position": "error"
+        } : {}
+      }
+    },
+    ...relay ? compat.config({
+      name: "storm/graphql/relay",
+      plugins: [
+        "relay"
+      ],
+      extends: [
+        "plugin:relay/ts-recommended"
+      ],
+      rules: {
+        // errors
+        "relay/graphql-syntax": "error",
+        "relay/graphql-naming": "error",
+        // warnings
+        "relay/compat-uses-vars": "warn",
+        "relay/generated-typescript-types": "warn",
+        "relay/no-future-added-value": "warn",
+        "relay/unused-fields": "warn",
+        "relay/must-colocate-fragment-spreads": "warn",
+        "relay/function-required-argument": "warn",
+        "relay/hook-required-argument": "warn",
+        // @graphql-eslint rules
+        "@graphql-eslint/relay-arguments": "error",
+        "@graphql-eslint/relay-connection-types": "error",
+        "@graphql-eslint/relay-edge-types": "error",
+        "@graphql-eslint/relay-page-info": "error"
+      }
+    }) : []
+  ];
+}
+__name(graphql, "graphql");
+
+// src/configs/ignores.ts
+async function ignores(userIgnores = []) {
+  return [
+    {
+      ignores: [
+        ...GLOB_EXCLUDE,
+        ...userIgnores
+      ],
+      name: "storm/ignores"
+    }
+  ];
+}
+__name(ignores, "ignores");
+
+// src/plugins.ts
+import { default as default2 } from "@cspell/eslint-plugin";
+import { default as default3 } from "@nx/eslint-plugin/nx.js";
+import * as pluginImport from "eslint-plugin-import-x";
+import { default as default4 } from "eslint-plugin-n";
+import { default as default5 } from "eslint-plugin-perfectionist";
+import { default as default6 } from "eslint-plugin-unicorn";
+import { default as default7 } from "eslint-plugin-unused-imports";
+
+// src/configs/imports.ts
+async function imports(options = {}) {
+  const { stylistic: stylistic2 = true } = options;
+  return [
+    {
+      name: "storm/imports/rules",
+      plugins: {
+        import: pluginImport
+      },
+      rules: {
+        "import/consistent-type-specifier-style": [
+          "error",
+          "prefer-top-level"
+        ],
+        "import/first": "error",
+        "import/no-duplicates": "error",
+        "import/no-mutable-exports": "error",
+        "import/no-named-default": "error",
+        "import/no-self-import": "error",
+        "import/no-webpack-loader-syntax": "error",
+        ...stylistic2 ? {
+          "import/newline-after-import": [
+            "error",
+            {
+              count: 1
+            }
+          ]
+        } : {}
+      }
+    }
+  ];
+}
+__name(imports, "imports");
+
+// src/configs/javascript.ts
+import defu from "defu";
+import globalsLib from "globals";
+async function javascript(options = {}) {
+  const { isInEditor = false, overrides = {}, name = "storm", globals = {} } = options;
+  return [
+    {
+      name: "storm/javascript/setup",
+      languageOptions: {
+        ecmaVersion: 2022,
+        globals: defu(globals, {
+          ...globalsLib.browser,
+          ...globalsLib.es2021,
+          ...globalsLib.node,
+          document: "readonly",
+          navigator: "readonly",
+          window: "readonly"
+        }),
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          },
+          ecmaVersion: 2022,
+          sourceType: "module"
+        },
+        sourceType: "module"
+      },
+      linterOptions: {
+        reportUnusedDisableDirectives: true
+      }
+    },
+    {
+      // Banner
+      ...banner_plugin_default.configs["recommended"],
+      name: "storm/javascript/banner",
+      plugins: {
+        banner: banner_plugin_default
+      },
+      rules: {
+        "banner/banner": [
+          "error",
+          {
+            commentType: "block",
+            numNewlines: 2,
+            repositoryName: name
+          }
+        ]
+      }
+    },
+    {
+      name: "storm/javascript/rules",
+      plugins: {
+        "unused-imports": default7
+      },
+      rules: {
+        // disallow use of console
+        "no-console": "error",
+        // Disallows expressions where the operation doesn't affect the value
+        // https://eslint.org/docs/rules/no-constant-binary-expression
+        // TODO: semver-major, enable
+        "no-constant-binary-expression": "off",
+        // disallow use of constant expressions in conditions
+        "no-constant-condition": "warn",
+        // disallow control characters in regular expressions
+        "no-control-regex": "error",
+        // disallow use of debugger
+        "no-debugger": "warn",
+        // disallow duplicate arguments in functions
+        "no-dupe-args": "error",
+        // Disallow duplicate conditions in if-else-if chains
+        // https://eslint.org/docs/rules/no-dupe-else-if
+        "no-dupe-else-if": "error",
+        // disallow duplicate keys when creating object literals
+        "no-dupe-keys": "error",
+        // disallow a duplicate case label.
+        "no-duplicate-case": "error",
+        // disallow empty statements
+        "no-empty": "error",
+        // disallow the use of empty character classes in regular expressions
+        "no-empty-character-class": "error",
+        // disallow assigning to the exception in a catch block
+        "no-ex-assign": "error",
+        // disallow double-negation boolean casts in a boolean context
+        // https://eslint.org/docs/rules/no-extra-boolean-cast
+        "no-extra-boolean-cast": "error",
+        // disallow unnecessary parentheses
+        // https://eslint.org/docs/rules/no-extra-parens
+        "no-extra-parens": [
+          "off",
+          "all",
+          {
+            conditionalAssign: true,
+            nestedBinaryExpressions: false,
+            returnAssign: false,
+            ignoreJSX: "all",
+            enforceForArrowConditionals: false
+          }
+        ],
+        // disallow unnecessary semicolons
+        "no-extra-semi": "error",
+        // disallow overwriting functions written as function declarations
+        "no-func-assign": "off",
+        // https://eslint.org/docs/rules/no-import-assign
+        "no-import-assign": "error",
+        // disallow function or variable declarations in nested blocks
+        "no-inner-declarations": "warn",
+        // disallow invalid regular expression strings in the RegExp constructor
+        "no-invalid-regexp": "error",
+        // disallow irregular whitespace outside of strings and comments
+        "no-irregular-whitespace": "error",
+        // Disallow Number Literals That Lose Precision
+        // https://eslint.org/docs/rules/no-loss-of-precision
+        "no-loss-of-precision": "error",
+        // Disallow characters which are made with multiple code points in character class syntax
+        // https://eslint.org/docs/rules/no-misleading-character-class
+        "no-misleading-character-class": "error",
+        // disallow the use of object properties of the global object (Math and JSON) as functions
+        "no-obj-calls": "error",
+        // Disallow new operators with global non-constructor functions
+        // https://eslint.org/docs/latest/rules/no-new-native-nonconstructor
+        // TODO: semver-major, enable
+        "no-new-native-nonconstructor": "off",
+        // Disallow returning values from Promise executor functions
+        // https://eslint.org/docs/rules/no-promise-executor-return
+        "no-promise-executor-return": "error",
+        // disallow use of Object.prototypes builtins directly
+        // https://eslint.org/docs/rules/no-prototype-builtins
+        "no-prototype-builtins": "error",
+        // disallow multiple spaces in a regular expression literal
+        "no-regex-spaces": "error",
+        // Disallow returning values from setters
+        // https://eslint.org/docs/rules/no-setter-return
+        "no-setter-return": "error",
+        // disallow sparse arrays
+        "no-sparse-arrays": "error",
+        // Disallow template literal placeholder syntax in regular strings
+        // https://eslint.org/docs/rules/no-template-curly-in-string
+        "no-template-curly-in-string": "error",
+        // Avoid code that looks like two expressions but is actually one
+        // https://eslint.org/docs/rules/no-unexpected-multiline
+        "no-unexpected-multiline": "error",
+        // disallow unreachable statements after a return, throw, continue, or break statement
+        "no-unreachable": "error",
+        // Disallow loops with a body that allows only one iteration
+        // https://eslint.org/docs/rules/no-unreachable-loop
+        "no-unreachable-loop": [
+          "error",
+          {
+            ignore: []
+            // WhileStatement, DoWhileStatement, ForStatement, ForInStatement, ForOfStatement
+          }
+        ],
+        // disallow return/throw/break/continue inside finally blocks
+        // https://eslint.org/docs/rules/no-unsafe-finally
+        "no-unsafe-finally": "error",
+        // disallow negating the left operand of relational operators
+        // https://eslint.org/docs/rules/no-unsafe-negation
+        "no-unsafe-negation": "error",
+        // disallow use of optional chaining in contexts where the undefined value is not allowed
+        // https://eslint.org/docs/rules/no-unsafe-optional-chaining
+        "no-unsafe-optional-chaining": [
+          "error",
+          {
+            disallowArithmeticOperators: true
+          }
+        ],
+        // Disallow Unused Private Class Members
+        // https://eslint.org/docs/rules/no-unused-private-class-members
+        // TODO: enable once eslint 7 is dropped (which is semver-major)
+        "no-unused-private-class-members": "off",
+        // Disallow useless backreferences in regular expressions
+        // https://eslint.org/docs/rules/no-useless-backreference
+        "no-useless-backreference": "error",
+        // disallow negation of the left operand of an in expression
+        // deprecated in favor of no-unsafe-negation
+        "no-negated-in-lhs": "off",
+        // Disallow assignments that can lead to race conditions due to usage of await or yield
+        // https://eslint.org/docs/rules/require-atomic-updates
+        // note: not enabled because it is very buggy
+        "require-atomic-updates": "off",
+        // disallow comparisons with the value NaN
+        "use-isnan": "error",
+        // ensure JSDoc comments are valid
+        // https://eslint.org/docs/rules/valid-jsdoc
+        "valid-jsdoc": "off",
+        // ensure that the results of typeof are compared against a valid string
+        // https://eslint.org/docs/rules/valid-typeof
+        "valid-typeof": [
+          "error",
+          {
+            requireStringLiterals: true
+          }
+        ],
+        /*************************************************************
+        *
+        *    Stylistic Rules - These rules relate to style guidelines
+        *
+        **************************************************************/
+        // enforce line breaks after opening and before closing array brackets
+        // https://eslint.org/docs/rules/array-bracket-newline
+        // TODO: enable? semver-major
+        "array-bracket-newline": [
+          "off",
+          "consistent"
+        ],
+        // enforce line breaks between array elements
+        // https://eslint.org/docs/rules/array-element-newline
+        // TODO: enable? semver-major
+        "array-element-newline": [
+          "off",
+          {
+            multiline: true,
+            minItems: 3
+          }
+        ],
+        // enforce spacing inside array brackets
+        "array-bracket-spacing": [
+          "error",
+          "never"
+        ],
+        // enforce spacing inside single-line blocks
+        // https://eslint.org/docs/rules/block-spacing
+        "block-spacing": [
+          "error",
+          "always"
+        ],
+        // enforce one true brace style
+        "brace-style": [
+          "error",
+          "1tbs",
+          {
+            allowSingleLine: true
+          }
+        ],
+        // require camel case names
+        camelcase: [
+          "error",
+          {
+            properties: "never",
+            ignoreDestructuring: false
+          }
+        ],
+        // enforce or disallow capitalization of the first letter of a comment
+        // https://eslint.org/docs/rules/capitalized-comments
+        "capitalized-comments": [
+          "off",
+          "never",
+          {
+            line: {
+              ignorePattern: ".*",
+              ignoreInlineComments: true,
+              ignoreConsecutiveComments: true
+            },
+            block: {
+              ignorePattern: ".*",
+              ignoreInlineComments: true,
+              ignoreConsecutiveComments: true
+            }
+          }
+        ],
+        // require trailing commas in multiline object literals
+        "comma-dangle": [
+          "error",
+          "never"
+        ],
+        // enforce spacing before and after comma
+        "comma-spacing": [
+          "error",
+          {
+            before: false,
+            after: true
+          }
+        ],
+        // enforce one true comma style
+        "comma-style": [
+          "error",
+          "last",
+          {
+            exceptions: {
+              ArrayExpression: false,
+              ArrayPattern: false,
+              ArrowFunctionExpression: false,
+              CallExpression: false,
+              FunctionDeclaration: false,
+              FunctionExpression: false,
+              ImportDeclaration: false,
+              ObjectExpression: false,
+              ObjectPattern: false,
+              VariableDeclaration: false,
+              NewExpression: false
+            }
+          }
+        ],
+        // disallow padding inside computed properties
+        "computed-property-spacing": [
+          "error",
+          "never"
+        ],
+        // enforces consistent naming when capturing the current execution context
+        "consistent-this": "off",
+        // enforce newline at the end of file, with no multiple empty lines
+        "eol-last": [
+          "error",
+          "always"
+        ],
+        // https://eslint.org/docs/rules/function-call-argument-newline
+        "function-call-argument-newline": [
+          "error",
+          "consistent"
+        ],
+        // enforce spacing between functions and their invocations
+        // https://eslint.org/docs/rules/func-call-spacing
+        "func-call-spacing": [
+          "error",
+          "never"
+        ],
+        // requires function names to match the name of the variable or property to which they are
+        // assigned
+        // https://eslint.org/docs/rules/func-name-matching
+        "func-name-matching": [
+          "off",
+          "always",
+          {
+            includeCommonJSModuleExports: false,
+            considerPropertyDescriptor: true
+          }
+        ],
+        // require function expressions to have a name
+        // https://eslint.org/docs/rules/func-names
+        "func-names": "warn",
+        // enforces use of function declarations or expressions
+        // https://eslint.org/docs/rules/func-style
+        // TODO: enable
+        "func-style": [
+          "off",
+          "expression"
+        ],
+        // require line breaks inside function parentheses if there are line breaks between parameters
+        // https://eslint.org/docs/rules/function-paren-newline
+        "function-paren-newline": "off",
+        // disallow specified identifiers
+        // https://eslint.org/docs/rules/id-denylist
+        "id-denylist": "off",
+        // this option enforces minimum and maximum identifier lengths
+        // (variable names, property names etc.)
+        "id-length": "off",
+        // require identifiers to match the provided regular expression
+        "id-match": "off",
+        // Enforce the location of arrow function bodies with implicit returns
+        // https://eslint.org/docs/rules/implicit-arrow-linebreak
+        "implicit-arrow-linebreak": "off",
+        // this option sets a specific tab width for your code
+        // https://eslint.org/docs/rules/indent
+        indent: "off",
+        //   "error",
+        //   2,
+        //   {
+        //     SwitchCase: 1,
+        //     VariableDeclarator: 1,
+        //     outerIIFEBody: 1,
+        //     // MemberExpression: null,
+        //     FunctionDeclaration: {
+        //       parameters: 1,
+        //       body: 1
+        //     },
+        //     FunctionExpression: {
+        //       parameters: 1,
+        //       body: 1
+        //     },
+        //     CallExpression: {
+        //       arguments: 1
+        //     },
+        //     ArrayExpression: 1,
+        //     ObjectExpression: 1,
+        //     ImportDeclaration: 1,
+        //     flatTernaryExpressions: false,
+        //     // list derived from https://github.com/benjamn/ast-types/blob/HEAD/def/jsx.js
+        //     ignoredNodes: [
+        //       "JSXElement",
+        //       "JSXElement > *",
+        //       "JSXAttribute",
+        //       "JSXIdentifier",
+        //       "JSXNamespacedName",
+        //       "JSXMemberExpression",
+        //       "JSXSpreadAttribute",
+        //       "JSXExpressionContainer",
+        //       "JSXOpeningElement",
+        //       "JSXClosingElement",
+        //       "JSXFragment",
+        //       "JSXOpeningFragment",
+        //       "JSXClosingFragment",
+        //       "JSXText",
+        //       "JSXEmptyExpression",
+        //       "JSXSpreadChild"
+        //     ],
+        //     ignoreComments: false
+        //   }
+        // ],
+        // specify whether double or single quotes should be used in JSX attributes
+        // https://eslint.org/docs/rules/jsx-quotes
+        "jsx-quotes": [
+          "off",
+          "prefer-double"
+        ],
+        // enforces spacing between keys and values in object literal properties
+        "key-spacing": [
+          "error",
+          {
+            beforeColon: false,
+            afterColon: true
+          }
+        ],
+        // require a space before & after certain keywords
+        "keyword-spacing": [
+          "error",
+          {
+            before: true,
+            after: true,
+            overrides: {
+              return: {
+                after: true
+              },
+              throw: {
+                after: true
+              },
+              case: {
+                after: true
+              }
+            }
+          }
+        ],
+        // enforce position of line comments
+        // https://eslint.org/docs/rules/line-comment-position
+        // TODO: enable?
+        "line-comment-position": [
+          "off",
+          {
+            position: "above",
+            ignorePattern: "",
+            applyDefaultPatterns: true
+          }
+        ],
+        // disallow mixed 'LF' and 'CRLF' as linebreaks
+        // https://eslint.org/docs/rules/linebreak-style
+        "linebreak-style": [
+          "error",
+          "unix"
+        ],
+        // require or disallow an empty line between class members
+        // https://eslint.org/docs/rules/lines-between-class-members
+        "lines-between-class-members": [
+          "error",
+          "always",
+          {
+            exceptAfterSingleLine: false
+          }
+        ],
+        // enforces empty lines around comments
+        "lines-around-comment": "off",
+        // require or disallow newlines around directives
+        // https://eslint.org/docs/rules/lines-around-directive
+        "lines-around-directive": [
+          "error",
+          {
+            before: "always",
+            after: "always"
+          }
+        ],
+        // Require or disallow logical assignment logical operator shorthand
+        // https://eslint.org/docs/latest/rules/logical-assignment-operators
+        // TODO, semver-major: enable
+        "logical-assignment-operators": [
+          "off",
+          "always",
+          {
+            enforceForIfStatements: true
+          }
+        ],
+        // specify the maximum depth that blocks can be nested
+        "max-depth": [
+          "off",
+          4
+        ],
+        // specify the maximum length of a line in your program
+        // https://eslint.org/docs/rules/max-len
+        "max-len": [
+          "error",
+          100,
+          2,
+          {
+            ignoreUrls: true,
+            ignoreComments: true,
+            ignoreRegExpLiterals: true,
+            ignoreStrings: true,
+            ignoreTemplateLiterals: true
+          }
+        ],
+        // specify the max number of lines in a file
+        // https://eslint.org/docs/rules/max-lines
+        "max-lines": [
+          "off",
+          {
+            max: 300,
+            skipBlankLines: true,
+            skipComments: true
+          }
+        ],
+        // enforce a maximum function length
+        // https://eslint.org/docs/rules/max-lines-per-function
+        "max-lines-per-function": [
+          "off",
+          {
+            max: 50,
+            skipBlankLines: true,
+            skipComments: true,
+            IIFEs: true
+          }
+        ],
+        // specify the maximum depth callbacks can be nested
+        "max-nested-callbacks": "off",
+        // limits the number of parameters that can be used in the function declaration.
+        "max-params": [
+          "off",
+          3
+        ],
+        // specify the maximum number of statement allowed in a function
+        "max-statements": [
+          "off",
+          10
+        ],
+        // restrict the number of statements per line
+        // https://eslint.org/docs/rules/max-statements-per-line
+        "max-statements-per-line": [
+          "off",
+          {
+            max: 1
+          }
+        ],
+        // enforce a particular style for multiline comments
+        // https://eslint.org/docs/rules/multiline-comment-style
+        "multiline-comment-style": [
+          "off",
+          "starred-block"
+        ],
+        // require multiline ternary
+        // https://eslint.org/docs/rules/multiline-ternary
+        // TODO: enable?
+        "multiline-ternary": [
+          "off",
+          "never"
+        ],
+        // require a capital letter for constructors
+        "new-cap": [
+          "error",
+          {
+            newIsCap: true,
+            newIsCapExceptions: [],
+            capIsNew: false,
+            capIsNewExceptions: [
+              "Immutable.Map",
+              "Immutable.Set",
+              "Immutable.List"
+            ]
+          }
+        ],
+        "no-unused-vars": [
+          "error",
+          {
+            args: "none",
+            caughtErrors: "none",
+            ignoreRestSiblings: true,
+            vars: "all"
+          }
+        ],
+        // disallow the omission of parentheses when invoking a constructor with no arguments
+        // https://eslint.org/docs/rules/new-parens
+        "new-parens": "error",
+        // allow/disallow an empty newline after var statement
+        "newline-after-var": "off",
+        // Require or disallow padding lines between statements
+        // https://eslint.org/docs/rules/padding-line-between-statements
+        "padding-line-between-statements": [
+          "error",
+          {
+            blankLine: "always",
+            prev: [
+              "const",
+              "let",
+              "var"
+            ],
+            next: "return"
+          }
+        ],
+        // enforces new line after each method call in the chain to make it
+        // more readable and easy to maintain
+        // https://eslint.org/docs/rules/newline-per-chained-call
+        "newline-per-chained-call": [
+          "error",
+          {
+            ignoreChainWithDepth: 5
+          }
+        ],
+        // disallow use of the Array constructor
+        "no-array-constructor": "error",
+        // disallow use of bitwise operators
+        // https://eslint.org/docs/rules/no-bitwise
+        "no-bitwise": "off",
+        // disallow use of the continue statement
+        // https://eslint.org/docs/rules/no-continue
+        "no-continue": "off",
+        // disallow comments inline after code
+        "no-inline-comments": "off",
+        // disallow if as the only statement in an else block
+        // https://eslint.org/docs/rules/no-lonely-if
+        "no-lonely-if": "error",
+        // disallow un-paren'd mixes of different operators
+        // https://eslint.org/docs/rules/no-mixed-operators
+        "no-mixed-operators": [
+          "error",
+          {
+            // the list of arithmetic groups disallows mixing `%` and `**`
+            // with other arithmetic operators.
+            groups: [
+              [
+                "%",
+                "**"
+              ],
+              [
+                "%",
+                "+"
+              ],
+              [
+                "%",
+                "-"
+              ],
+              [
+                "%",
+                "*"
+              ],
+              [
+                "%",
+                "/"
+              ],
+              [
+                "/",
+                "*"
+              ],
+              [
+                "&",
+                "|",
+                "<<",
+                ">>",
+                ">>>"
+              ],
+              [
+                "==",
+                "!=",
+                "===",
+                "!=="
+              ],
+              [
+                "&&",
+                "||"
+              ]
+            ],
+            allowSamePrecedence: false
+          }
+        ],
+        // disallow mixed spaces and tabs for indentation
+        "no-mixed-spaces-and-tabs": "error",
+        // disallow use of chained assignment expressions
+        // https://eslint.org/docs/rules/no-multi-assign
+        "no-multi-assign": [
+          "error"
+        ],
+        // disallow multiple empty lines, only one newline at the end, and no new lines at the beginning
+        // https://eslint.org/docs/rules/no-multiple-empty-lines
+        "no-multiple-empty-lines": [
+          "error",
+          {
+            max: 1,
+            maxBOF: 0,
+            maxEOF: 0
+          }
+        ],
+        // disallow negated conditions
+        // https://eslint.org/docs/rules/no-negated-condition
+        "no-negated-condition": "off",
+        // disallow nested ternary expressions
+        "no-nested-ternary": "off",
+        // disallow use of the Object constructor
+        "no-new-object": "error",
+        // disallow use of unary operators, ++ and --
+        // https://eslint.org/docs/rules/no-plusplus
+        "no-plusplus": "off",
+        // disallow certain syntax forms
+        // https://eslint.org/docs/rules/no-restricted-syntax
+        "no-restricted-syntax": [
+          "error",
+          // {
+          //   selector: "ForInStatement",
+          //   message:
+          //     "for..in loops iterate over the entire prototype chain, which is virtually never what you want. Use Object.{keys,values,entries}, and iterate over the resulting array."
+          // },
+          // {
+          //   selector: "ForOfStatement",
+          //   message:
+          //     "iterators/generators require regenerator-runtime, which is too heavyweight for this guide to allow them. Separately, loops should be avoided in favor of array iterations."
+          // },
+          "TSEnumDeclaration[const=true]",
+          "TSExportAssignment",
+          {
+            selector: "LabeledStatement",
+            message: "Labels are a form of GOTO; using them makes code confusing and hard to maintain and understand."
+          },
+          {
+            selector: "WithStatement",
+            message: "`with` is disallowed in strict mode because it makes code impossible to predict and optimize."
+          }
+        ],
+        // disallow space between function identifier and application
+        // deprecated in favor of func-call-spacing
+        "no-spaced-func": "off",
+        // disallow tab characters entirely
+        "no-tabs": "error",
+        // disallow the use of ternary operators
+        "no-ternary": "off",
+        // disallow trailing whitespace at the end of lines
+        "no-trailing-spaces": [
+          "error",
+          {
+            skipBlankLines: false,
+            ignoreComments: false
+          }
+        ],
+        // disallow dangling underscores in identifiers
+        // https://eslint.org/docs/rules/no-underscore-dangle
+        "no-underscore-dangle": [
+          "off",
+          {
+            allow: [],
+            allowAfterThis: false,
+            allowAfterSuper: false,
+            enforceInMethodNames: true
+          }
+        ],
+        // disallow the use of Boolean literals in conditional expressions
+        // also, prefer `a || b` over `a ? a : b`
+        // https://eslint.org/docs/rules/no-unneeded-ternary
+        "no-unneeded-ternary": [
+          "error",
+          {
+            defaultAssignment: false
+          }
+        ],
+        // disallow whitespace before properties
+        // https://eslint.org/docs/rules/no-whitespace-before-property
+        "no-whitespace-before-property": "error",
+        // enforce the location of single-line statements
+        // https://eslint.org/docs/rules/nonblock-statement-body-position
+        "nonblock-statement-body-position": [
+          "error",
+          "beside",
+          {
+            overrides: {}
+          }
+        ],
+        // require padding inside curly braces
+        "object-curly-spacing": [
+          "error",
+          "always"
+        ],
+        // enforce line breaks between braces
+        // https://eslint.org/docs/rules/object-curly-newline
+        "object-curly-newline": [
+          "error",
+          {
+            ObjectExpression: {
+              minProperties: 5,
+              multiline: true,
+              consistent: true
+            },
+            ObjectPattern: {
+              minProperties: 5,
+              multiline: true,
+              consistent: true
+            },
+            ImportDeclaration: {
+              minProperties: 5,
+              multiline: true,
+              consistent: true
+            },
+            ExportDeclaration: {
+              minProperties: 5,
+              multiline: true,
+              consistent: true
+            }
+          }
+        ],
+        // enforce "same line" or "multiple line" on object properties.
+        // https://eslint.org/docs/rules/object-property-newline
+        "object-property-newline": [
+          "error",
+          {
+            allowAllPropertiesOnSameLine: false
+          }
+        ],
+        // allow just one var statement per function
+        "one-var": [
+          "error",
+          "never"
+        ],
+        // require a newline around variable declaration
+        // https://eslint.org/docs/rules/one-var-declaration-per-line
+        "one-var-declaration-per-line": [
+          "error",
+          "always"
+        ],
+        // require assignment operator shorthand where possible or prohibit it entirely
+        // https://eslint.org/docs/rules/operator-assignment
+        "operator-assignment": [
+          "error",
+          "always"
+        ],
+        // Requires operator at the beginning of the line in multiline statements
+        // https://eslint.org/docs/rules/operator-linebreak
+        "operator-linebreak": [
+          "error",
+          "after",
+          {
+            overrides: {
+              "=": "none"
+            }
+          }
+        ],
+        // disallow padding within blocks
+        "padded-blocks": [
+          "error",
+          {
+            blocks: "never",
+            classes: "never",
+            switches: "never"
+          },
+          {
+            allowSingleLineBlocks: true
+          }
+        ],
+        // Disallow the use of Math.pow in favor of the ** operator
+        // https://eslint.org/docs/rules/prefer-exponentiation-operator
+        "prefer-exponentiation-operator": "error",
+        // Prefer use of an object spread over Object.assign
+        // https://eslint.org/docs/rules/prefer-object-spread
+        "prefer-object-spread": "error",
+        // require quotes around object literal property names
+        // https://eslint.org/docs/rules/quote-props.html
+        "quote-props": [
+          "error",
+          "as-needed",
+          {
+            keywords: false,
+            unnecessary: true,
+            numbers: false
+          }
+        ],
+        // specify whether double or single quotes should be used
+        quotes: [
+          "error",
+          "double",
+          {
+            avoidEscape: true
+          }
+        ],
+        // do not require jsdoc
+        // https://eslint.org/docs/rules/require-jsdoc
+        "require-jsdoc": "off",
+        // require or disallow use of semicolons instead of ASI
+        semi: [
+          "error",
+          "always"
+        ],
+        // enforce spacing before and after semicolons
+        "semi-spacing": [
+          "error",
+          {
+            before: false,
+            after: true
+          }
+        ],
+        // Enforce location of semicolons
+        // https://eslint.org/docs/rules/semi-style
+        "semi-style": [
+          "error",
+          "last"
+        ],
+        // requires object keys to be sorted
+        "sort-keys": [
+          "off",
+          "asc",
+          {
+            caseSensitive: false,
+            natural: true
+          }
+        ],
+        // sort variables within the same declaration block
+        "sort-vars": "off",
+        // require or disallow space before blocks
+        "space-before-blocks": "error",
+        // require or disallow space before function opening parenthesis
+        // https://eslint.org/docs/rules/space-before-function-paren
+        "space-before-function-paren": "off",
+        //   "error",
+        //   {
+        //     anonymous: "always",
+        //     named: "never",
+        //     asyncArrow: "always"
+        //   }
+        // ],
+        // require or disallow spaces inside parentheses
+        "space-in-parens": [
+          "error",
+          "never"
+        ],
+        // require spaces around operators
+        "space-infix-ops": "error",
+        // Require or disallow spaces before/after unary operators
+        // https://eslint.org/docs/rules/space-unary-ops
+        "space-unary-ops": [
+          "error",
+          {
+            words: true,
+            nonwords: false,
+            overrides: {}
+          }
+        ],
+        // require or disallow a space immediately following the // or /* in a comment
+        // https://eslint.org/docs/rules/spaced-comment
+        "spaced-comment": [
+          "error",
+          "always",
+          {
+            line: {
+              exceptions: [
+                "-",
+                "+"
+              ],
+              markers: [
+                "=",
+                "!",
+                "/"
+              ]
+              // space here to support sprockets directives, slash for TS /// comments
+            },
+            block: {
+              exceptions: [
+                "-",
+                "+"
+              ],
+              markers: [
+                "=",
+                "!",
+                ":",
+                "::"
+              ],
+              balanced: true
+            }
+          }
+        ],
+        // Enforce spacing around colons of switch statements
+        // https://eslint.org/docs/rules/switch-colon-spacing
+        "switch-colon-spacing": [
+          "error",
+          {
+            after: true,
+            before: false
+          }
+        ],
+        // Require or disallow spacing between template tags and their literals
+        // https://eslint.org/docs/rules/template-tag-spacing
+        "template-tag-spacing": [
+          "error",
+          "never"
+        ],
+        // require or disallow the Unicode Byte Order Mark
+        // https://eslint.org/docs/rules/unicode-bom
+        "unicode-bom": [
+          "error",
+          "never"
+        ],
+        // require regex literals to be wrapped in parentheses
+        "wrap-regex": "off",
+        "class-methods-use-this": "off",
+        "accessor-pairs": [
+          "error",
+          {
+            enforceForClassMembers: true,
+            setWithoutGet: true
+          }
+        ],
+        "constructor-super": "error",
+        "dot-notation": [
+          "error",
+          {
+            allowKeywords: true
+          }
+        ],
+        "no-case-declarations": "error",
+        "no-class-assign": "error",
+        "no-const-assign": "error",
+        "no-delete-var": "error",
+        "no-dupe-class-members": "error",
+        "no-empty-pattern": "error",
+        "no-eval": "error",
+        "no-extend-native": "error",
+        "no-extra-bind": "error",
+        "no-fallthrough": "error",
+        "no-global-assign": "error",
+        "no-implied-eval": "error",
+        "no-iterator": "error",
+        "no-labels": [
+          "error",
+          {
+            allowLoop: false,
+            allowSwitch: false
+          }
+        ],
+        "no-lone-blocks": "error",
+        "no-multi-str": "error",
+        "no-new": "error",
+        "no-new-func": "error",
+        "no-new-wrappers": "error",
+        "no-octal": "error",
+        "no-octal-escape": "error",
+        "no-proto": "error",
+        "no-redeclare": [
+          "error",
+          {
+            builtinGlobals: false
+          }
+        ],
+        "no-restricted-globals": [
+          "error",
+          {
+            message: "Use `globalThis` instead.",
+            name: "global"
+          },
+          {
+            message: "Use `globalThis` instead.",
+            name: "self"
+          }
+        ],
+        "no-restricted-properties": [
+          "error",
+          {
+            message: "Use `Object.getPrototypeOf` or `Object.setPrototypeOf` instead.",
+            property: "__proto__"
+          },
+          {
+            message: "Use `Object.defineProperty` instead.",
+            property: "__defineGetter__"
+          },
+          {
+            message: "Use `Object.defineProperty` instead.",
+            property: "__defineSetter__"
+          },
+          {
+            message: "Use `Object.getOwnPropertyDescriptor` instead.",
+            property: "__lookupGetter__"
+          },
+          {
+            message: "Use `Object.getOwnPropertyDescriptor` instead.",
+            property: "__lookupSetter__"
+          }
+        ],
+        "no-self-assign": [
+          "error",
+          {
+            props: true
+          }
+        ],
+        "no-self-compare": "error",
+        "no-sequences": "error",
+        "no-shadow-restricted-names": "error",
+        "no-this-before-super": "error",
+        "no-throw-literal": "error",
+        "no-undef": "error",
+        "no-undef-init": "error",
+        "no-unmodified-loop-condition": "error",
+        "no-unused-expressions": [
+          "error",
+          {
+            allowShortCircuit: true,
+            allowTaggedTemplates: true,
+            allowTernary: true
+          }
+        ],
+        "no-use-before-define": [
+          "error",
+          {
+            classes: false,
+            functions: false,
+            variables: true
+          }
+        ],
+        "no-useless-call": "error",
+        "no-useless-catch": "error",
+        "no-useless-computed-key": "error",
+        "no-useless-constructor": "error",
+        "no-useless-rename": "error",
+        "no-useless-return": "error",
+        "no-var": "error",
+        "no-with": "error",
+        "object-shorthand": [
+          "error",
+          "always",
+          {
+            avoidQuotes: true,
+            ignoreConstructors: false
+          }
+        ],
+        "prefer-arrow-callback": [
+          "error",
+          {
+            allowNamedFunctions: false,
+            allowUnboundThis: true
+          }
+        ],
+        "prefer-const": [
+          isInEditor ? "warn" : "error",
+          {
+            destructuring: "all",
+            ignoreReadBeforeAssign: true
+          }
+        ],
+        "prefer-promise-reject-errors": "error",
+        "prefer-regex-literals": [
+          "error",
+          {
+            disallowRedundantWrapping: true
+          }
+        ],
+        "prefer-rest-params": "error",
+        "prefer-spread": "error",
+        "prefer-template": "error",
+        "symbol-description": "error",
+        "unused-imports/no-unused-imports": isInEditor ? "warn" : "error",
+        "unused-imports/no-unused-vars": [
+          "error",
+          {
+            args: "after-used",
+            argsIgnorePattern: "^_",
+            ignoreRestSiblings: true,
+            vars: "all",
+            varsIgnorePattern: "^_"
+          }
+        ],
+        "vars-on-top": "error",
+        "yoda": [
+          "error",
+          "never"
+        ],
+        ...overrides
+      }
+    }
+  ];
+}
+__name(javascript, "javascript");
+
+// src/configs/jsdoc.ts
+async function jsdoc(options = {}) {
+  const { stylistic: stylistic2 = true } = options;
+  return [
+    {
+      name: "storm/jsdoc/rules",
+      plugins: {
+        jsdoc: await interopDefault(import("eslint-plugin-jsdoc"))
+      },
+      rules: {
+        "jsdoc/check-access": "warn",
+        "jsdoc/check-param-names": "warn",
+        "jsdoc/check-property-names": "warn",
+        "jsdoc/check-types": "off",
+        "jsdoc/empty-tags": "warn",
+        "jsdoc/implements-on-classes": "warn",
+        "jsdoc/no-defaults": "warn",
+        "jsdoc/no-multi-asterisks": "warn",
+        "jsdoc/require-param-name": "warn",
+        "jsdoc/require-property": "warn",
+        "jsdoc/require-property-description": "warn",
+        "jsdoc/require-property-name": "warn",
+        "jsdoc/require-returns-check": "warn",
+        "jsdoc/require-returns-description": "warn",
+        "jsdoc/require-yields-check": "warn",
+        ...stylistic2 ? {
+          "jsdoc/check-alignment": "warn",
+          "jsdoc/multiline-blocks": "warn"
+        } : {}
+      }
+    }
+  ];
+}
+__name(jsdoc, "jsdoc");
+
+// src/configs/jsonc.ts
+async function jsonc(options = {}) {
+  const { files = [
+    GLOB_JSON,
+    GLOB_JSON5,
+    GLOB_JSONC
+  ], overrides = {}, stylistic: stylistic2 = true } = options;
+  const { indent = 2 } = typeof stylistic2 === "boolean" ? {} : stylistic2;
+  const [pluginJsonc, parserJsonc] = await Promise.all([
+    interopDefault(import("eslint-plugin-jsonc")),
+    interopDefault(import("jsonc-eslint-parser"))
+  ]);
+  return [
+    {
+      name: "storm/jsonc/setup",
+      plugins: {
+        jsonc: pluginJsonc
+      }
+    },
+    {
+      files,
+      languageOptions: {
+        parser: parserJsonc
+      },
+      name: "storm/jsonc/rules",
+      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",
+        ...stylistic2 ? {
+          "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
+      }
+    }
+  ];
+}
+__name(jsonc, "jsonc");
+
+// src/configs/jsx.ts
+async function jsx() {
+  return [
+    {
+      files: [
+        GLOB_JSX,
+        GLOB_TSX
+      ],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          }
+        }
+      },
+      name: "antfu/jsx/setup"
+    }
+  ];
+}
+__name(jsx, "jsx");
+
+// src/configs/markdown.ts
+import { mergeProcessors, processorPassThrough } from "eslint-merge-processors";
+async function markdown(options = {}) {
+  const { componentExts = [], files = [
+    GLOB_MARKDOWN
+  ], overrides = {} } = options;
+  const markdown1 = await interopDefault(import("@eslint/markdown"));
+  return [
+    {
+      name: "storm/markdown/setup",
+      plugins: {
+        markdown: markdown1
+      }
+    },
+    {
+      files,
+      ignores: [
+        GLOB_MARKDOWN_IN_MARKDOWN
+      ],
+      name: "storm/markdown/processor",
+      // `eslint-plugin-markdown` only creates virtual files for code blocks,
+      // but not the markdown file itself. We use `eslint-merge-processors` to
+      // add a pass-through processor for the markdown file itself.
+      processor: mergeProcessors([
+        markdown1.processors.markdown,
+        processorPassThrough
+      ])
+    },
+    {
+      files,
+      languageOptions: {
+        parser: parserPlain
+      },
+      name: "storm/markdown/parser"
+    },
+    {
+      files: [
+        GLOB_MARKDOWN_CODE,
+        ...componentExts.map((ext) => `${GLOB_MARKDOWN}/**/*.${ext}`)
+      ],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            impliedStrict: true
+          }
+        }
+      },
+      name: "storm/markdown/disables",
+      rules: {
+        "import/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",
+        "style/comma-dangle": "off",
+        "style/eol-last": "off",
+        "ts/consistent-type-imports": "off",
+        "ts/explicit-function-return-type": "off",
+        "ts/no-namespace": "off",
+        "ts/no-redeclare": "off",
+        "ts/no-require-imports": "off",
+        "ts/no-unused-expressions": "off",
+        "ts/no-unused-vars": "off",
+        "ts/no-use-before-define": "off",
+        "unicode-bom": "off",
+        "unused-imports/no-unused-imports": "off",
+        "unused-imports/no-unused-vars": "off",
+        ...overrides
+      }
+    }
+  ];
+}
+__name(markdown, "markdown");
+
+// src/configs/next.ts
+import { FlatCompat as FlatCompat2 } from "@eslint/eslintrc";
+var compat2 = new FlatCompat2({
+  // import.meta.dirname is available after Node.js v20.11.0
+  baseDirectory: import.meta.dirname
+});
+async function next(options = {}) {
+  const { coreWebVitals = true, rootDir } = options;
+  await ensurePackages([
+    "@next/eslint-plugin-next"
+  ]);
+  return [
+    ...compat2.config({
+      name: "storm/next",
+      extends: [
+        "next"
+      ],
+      settings: {
+        next: {
+          rootDir
+        }
+      },
+      rules: {
+        // warnings
+        "@next/next/google-font-display": "warn",
+        "@next/next/google-font-preconnect": "warn",
+        "@next/next/next-script-for-ga": "warn",
+        "@next/next/no-async-client-component": "warn",
+        "@next/next/no-before-interactive-script-outside-document": "warn",
+        "@next/next/no-css-tags": "warn",
+        "@next/next/no-head-element": "warn",
+        "@next/next/no-html-link-for-pages": "warn",
+        "@next/next/no-img-element": "warn",
+        "@next/next/no-page-custom-font": "warn",
+        "@next/next/no-styled-jsx-in-document": "warn",
+        "@next/next/no-sync-scripts": "warn",
+        "@next/next/no-title-in-document-head": "warn",
+        "@next/next/no-typos": "warn",
+        "@next/next/no-unwanted-polyfillio": "warn",
+        // errors
+        "@next/next/inline-script-id": "error",
+        "@next/next/no-assign-module-variable": "error",
+        "@next/next/no-document-import-in-page": "error",
+        "@next/next/no-duplicate-head": "error",
+        "@next/next/no-head-import-in-document": "error",
+        "@next/next/no-script-component-in-head": "error",
+        // core web vitals
+        ...coreWebVitals ? {
+          "@next/next/no-html-link-for-pages": "error",
+          "@next/next/no-sync-scripts": "error"
+        } : {}
+      }
+    })
+  ];
+}
+__name(next, "next");
+
+// src/configs/node.ts
+async function node() {
+  return [
+    {
+      name: "storm/node/rules",
+      plugins: {
+        node: default4
+      },
+      rules: {
+        "node/handle-callback-err": [
+          "error",
+          "^(err|error)$"
+        ],
+        "node/no-deprecated-api": "error",
+        "node/no-exports-assign": "error",
+        "node/no-new-require": "error",
+        "node/no-path-concat": "error",
+        "node/prefer-global/buffer": [
+          "error",
+          "never"
+        ],
+        "node/prefer-global/process": [
+          "error",
+          "never"
+        ],
+        "node/process-exit-as-throw": "error"
+      }
+    }
+  ];
+}
+__name(node, "node");
+
+// src/configs/nx.ts
+import defu2 from "defu";
+async function nx(options = {}) {
+  const { depsCheck, moduleBoundaries } = options;
+  return [
+    {
+      name: "storm/nx/setup",
+      plugins: {
+        "@nx": default3
+      }
+    },
+    {
+      name: "storm/nx/schema",
+      files: [
+        "**/executors/**/schema.json",
+        "**/generators/**/schema.json"
+      ],
+      rules: {
+        "@nx/workspace/valid-schema-description": "error"
+      }
+    },
+    {
+      name: "storm/nx/dependency-check",
+      files: [
+        "**/package.json"
+      ],
+      rules: {
+        "@nx/dependency-checks": [
+          "error",
+          defu2(depsCheck ?? {}, {
+            buildTargets: [
+              "build-base",
+              "build"
+            ],
+            ignoredDependencies: [],
+            ignoredFiles: [],
+            checkMissingDependencies: true,
+            checkObsoleteDependencies: true,
+            checkVersionMismatches: false,
+            includeTransitiveDependencies: true,
+            useLocalPathsForWorkspaceDependencies: true
+          })
+        ]
+      }
+    },
+    {
+      name: "storm/nx/module-boundaries",
+      files: [
+        "**/nx.json",
+        "**/*.ts",
+        "**/*.tsx",
+        "**/*.js",
+        "**/*.jsx"
+      ],
+      rules: {
+        "@nx/enforce-module-boundaries": [
+          "error",
+          moduleBoundaries ?? {
+            enforceBuildableLibDependency: true,
+            checkDynamicDependenciesExceptions: [
+              ".*"
+            ],
+            allow: [],
+            depConstraints: [
+              {
+                sourceTag: "*",
+                onlyDependOnLibsWithTags: [
+                  "*"
+                ]
+              }
+            ]
+          }
+        ]
+      }
+    }
+  ];
+}
+__name(nx, "nx");
+
+// src/configs/perfectionist.ts
+async function perfectionist() {
+  return [
+    {
+      name: "storm/perfectionist/setup",
+      plugins: {
+        perfectionist: default5
+      },
+      rules: {
+        "perfectionist/sort-exports": [
+          "error",
+          {
+            order: "asc",
+            type: "natural"
+          }
+        ],
+        "perfectionist/sort-imports": [
+          "error",
+          {
+            groups: [
+              "type",
+              [
+                "parent-type",
+                "sibling-type",
+                "index-type",
+                "internal-type"
+              ],
+              "builtin",
+              "external",
+              "internal",
+              [
+                "parent",
+                "sibling",
+                "index"
+              ],
+              "side-effect",
+              "object",
+              "unknown"
+            ],
+            newlinesBetween: "ignore",
+            order: "asc",
+            type: "natural"
+          }
+        ],
+        "perfectionist/sort-named-exports": [
+          "error",
+          {
+            order: "asc",
+            type: "natural"
+          }
+        ],
+        "perfectionist/sort-named-imports": [
+          "error",
+          {
+            order: "asc",
+            type: "natural"
+          }
+        ]
+      }
+    }
+  ];
+}
+__name(perfectionist, "perfectionist");
+
+// src/configs/react.ts
+import { isPackageExists } from "local-pkg";
+var ReactRefreshAllowConstantExportPackages = [
+  "vite"
+];
+var ReactRouterPackages = [
+  "@react-router/node",
+  "@react-router/react",
+  "@react-router/serve",
+  "@react-router/dev"
+];
+var NextJsPackages = [
+  "next"
+];
+async function react(options = {}) {
+  const { files = [
+    GLOB_SRC
+  ], filesTypeAware = [
+    GLOB_TS,
+    GLOB_TSX
+  ], ignoresTypeAware = [
+    `${GLOB_MARKDOWN}/**`,
+    GLOB_ASTRO_TS
+  ], overrides = {}, tsconfigPath } = options;
+  await ensurePackages([
+    "@eslint-react/eslint-plugin",
+    "eslint-plugin-react-hooks",
+    "eslint-plugin-react-refresh",
+    "eslint-plugin-react-compiler"
+  ]);
+  const isTypeAware = !!tsconfigPath;
+  const typeAwareRules = {
+    "react/no-leaked-conditional-rendering": "warn"
+  };
+  const [pluginReact, pluginReactHooks, pluginReactRefresh, pluginReactCompiler] = await Promise.all([
+    interopDefault(import("@eslint-react/eslint-plugin")),
+    interopDefault(import("eslint-plugin-react-hooks")),
+    interopDefault(import("eslint-plugin-react-refresh")),
+    interopDefault(import("eslint-plugin-react-compiler"))
+  ]);
+  const isAllowConstantExport = ReactRefreshAllowConstantExportPackages.some((i) => isPackageExists(i));
+  const isUsingReactRouter = ReactRouterPackages.some((i) => isPackageExists(i));
+  const isUsingNext = NextJsPackages.some((i) => isPackageExists(i));
+  const plugins = pluginReact.configs.all.plugins;
+  return [
+    {
+      name: "storm/react/setup",
+      plugins: {
+        "react": plugins["@eslint-react"],
+        "react-dom": plugins["@eslint-react/dom"],
+        "react-hooks": pluginReactHooks,
+        "react-hooks-extra": plugins["@eslint-react/hooks-extra"],
+        "react-naming-convention": plugins["@eslint-react/naming-convention"],
+        "react-refresh": pluginReactRefresh,
+        "react-web-api": plugins["@eslint-react/web-api"],
+        "react-compiler": pluginReactCompiler
+      }
+    },
+    {
+      files,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          }
+        },
+        sourceType: "module"
+      },
+      name: "storm/react/rules",
+      rules: {
+        // recommended rules from @eslint-react/dom
+        "react-dom/no-children-in-void-dom-elements": "warn",
+        "react-dom/no-dangerously-set-innerhtml": "warn",
+        "react-dom/no-dangerously-set-innerhtml-with-children": "error",
+        "react-dom/no-find-dom-node": "error",
+        "react-dom/no-missing-button-type": "warn",
+        "react-dom/no-missing-iframe-sandbox": "warn",
+        "react-dom/no-namespace": "error",
+        "react-dom/no-render-return-value": "error",
+        "react-dom/no-script-url": "warn",
+        "react-dom/no-unsafe-iframe-sandbox": "warn",
+        "react-dom/no-unsafe-target-blank": "warn",
+        // recommended rules react-hooks
+        "react-hooks/exhaustive-deps": "warn",
+        "react-hooks/rules-of-hooks": "error",
+        // react refresh
+        "react-refresh/only-export-components": [
+          "warn",
+          {
+            allowConstantExport: isAllowConstantExport,
+            allowExportNames: [
+              ...isUsingNext ? [
+                "dynamic",
+                "dynamicParams",
+                "revalidate",
+                "fetchCache",
+                "runtime",
+                "preferredRegion",
+                "maxDuration",
+                "config",
+                "generateStaticParams",
+                "metadata",
+                "generateMetadata",
+                "viewport",
+                "generateViewport"
+              ] : [],
+              ...isUsingReactRouter ? [
+                "meta",
+                "links",
+                "headers",
+                "loader",
+                "action"
+              ] : []
+            ]
+          }
+        ],
+        // recommended rules from @eslint-react/web-api
+        "react-web-api/no-leaked-event-listener": "warn",
+        "react-web-api/no-leaked-interval": "warn",
+        "react-web-api/no-leaked-resize-observer": "warn",
+        "react-web-api/no-leaked-timeout": "warn",
+        // recommended rules from @eslint-react
+        "react/ensure-forward-ref-using-ref": "warn",
+        "react/jsx-no-duplicate-props": "warn",
+        "react/jsx-uses-vars": "warn",
+        "react/no-access-state-in-setstate": "error",
+        "react/no-array-index-key": "warn",
+        "react/no-children-count": "warn",
+        "react/no-children-for-each": "warn",
+        "react/no-children-map": "warn",
+        "react/no-children-only": "warn",
+        "react/no-children-to-array": "warn",
+        "react/no-clone-element": "warn",
+        "react/no-comment-textnodes": "warn",
+        "react/no-component-will-mount": "error",
+        "react/no-component-will-receive-props": "error",
+        "react/no-component-will-update": "error",
+        "react/no-context-provider": "warn",
+        "react/no-create-ref": "error",
+        "react/no-default-props": "error",
+        "react/no-direct-mutation-state": "error",
+        "react/no-duplicate-key": "error",
+        "react/no-forward-ref": "warn",
+        "react/no-implicit-key": "warn",
+        "react/no-missing-key": "error",
+        "react/no-nested-components": "error",
+        "react/no-prop-types": "error",
+        "react/no-redundant-should-component-update": "error",
+        "react/no-set-state-in-component-did-mount": "warn",
+        "react/no-set-state-in-component-did-update": "warn",
+        "react/no-set-state-in-component-will-update": "warn",
+        "react/no-string-refs": "error",
+        "react/no-unsafe-component-will-mount": "warn",
+        "react/no-unsafe-component-will-receive-props": "warn",
+        "react/no-unsafe-component-will-update": "warn",
+        "react/no-unstable-context-value": "warn",
+        "react/no-unstable-default-props": "warn",
+        "react/no-unused-class-component-members": "warn",
+        "react/no-unused-state": "warn",
+        "react/prefer-destructuring-assignment": "warn",
+        "react/prefer-shorthand-boolean": "warn",
+        "react/prefer-shorthand-fragment": "warn",
+        // recommended rules from eslint-plugin-react-compiler
+        "react-compiler/react-compiler": "error",
+        // overrides
+        ...overrides
+      }
+    },
+    ...isTypeAware ? [
+      {
+        files: filesTypeAware,
+        ignores: ignoresTypeAware,
+        name: "storm/react/type-aware-rules",
+        rules: {
+          ...typeAwareRules
+        }
+      }
+    ] : []
+  ];
+}
+__name(react, "react");
+
+// src/configs/regexp.ts
+import { configs } from "eslint-plugin-regexp";
+async function regexp(options = {}) {
+  const config = configs["flat/recommended"];
+  const rules = {
+    ...config.rules
+  };
+  if (options.level === "warn") {
+    for (const key in rules) {
+      if (rules[key] === "error") rules[key] = "warn";
+    }
+  }
+  return [
+    {
+      ...config,
+      name: "storm/regexp/rules",
+      rules: {
+        ...rules,
+        ...options.overrides
+      }
+    }
+  ];
+}
+__name(regexp, "regexp");
+
+// src/configs/sort.ts
+async function sortPackageJson() {
+  return [
+    {
+      files: [
+        "**/package.json"
+      ],
+      name: "storm/sort/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",
+              "eslintConfig"
+            ],
+            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)$"
+          }
+        ]
+      }
+    }
+  ];
+}
+__name(sortPackageJson, "sortPackageJson");
+function sortTsconfig() {
+  return [
+    {
+      files: [
+        "**/tsconfig.json",
+        "**/tsconfig.*.json"
+      ],
+      name: "storm/sort/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$"
+          }
+        ]
+      }
+    }
+  ];
+}
+__name(sortTsconfig, "sortTsconfig");
+
+// src/configs/storybook.ts
+async function storybook(options = {}) {
+  const { csf = "loose" } = options;
+  await ensurePackages([
+    "eslint-plugin-storybook"
+  ]);
+  const [pluginStorybook] = await Promise.all([
+    interopDefault(import("eslint-plugin-storybook"))
+  ]);
+  return [
+    {
+      name: "storm/storybook/setup",
+      plugins: {
+        storybook: pluginStorybook
+      },
+      ignores: [
+        "!.storybook"
+      ]
+    },
+    {
+      name: "storm/storybook/rules",
+      files: [
+        "**/*.stories.@(ts|tsx|js|jsx|mjs|cjs)",
+        "**/*.story.@(ts|tsx|js|jsx|mjs|cjs)"
+      ],
+      rules: {
+        ...csf !== "none" ? csf === "strict" ? {
+          "storybook/csf-component": "error",
+          "storybook/no-title-property-in-meta": "error"
+        } : {
+          "storybook/csf-component": "warn",
+          "storybook/no-title-property-in-meta": "warn"
+        } : {},
+        // errors
+        "storybook/await-interactions": "error",
+        "storybook/context-in-play-function": "error",
+        "storybook/default-exports": "error",
+        "storybook/story-exports": "error",
+        "storybook/use-storybook-expect": "error",
+        "storybook/use-storybook-testing-library": "error",
+        // warnings
+        "storybook/hierarchy-separator": "warn",
+        "storybook/no-redundant-story-name": "warn",
+        "storybook/prefer-pascal-case": "warn",
+        // off
+        "react-hooks/rules-of-hooks": "off",
+        "import/no-anonymous-default-export": "off"
+      }
+    },
+    {
+      name: "storm/storybook/main",
+      files: [
+        "**/.storybook/main.@(js|cjs|mjs|ts)"
+      ],
+      rules: {
+        "storybook/no-uninstalled-addons": "error"
+      }
+    }
+  ];
+}
+__name(storybook, "storybook");
+
+// src/configs/test.ts
+var _pluginTest;
+async function test(options = {}) {
+  const { files = GLOB_TESTS, isInEditor = false, overrides = {} } = options;
+  const [pluginVitest, pluginNoOnlyTests] = await Promise.all([
+    interopDefault(import("@vitest/eslint-plugin")),
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-plugin-no-only-tests"))
+  ]);
+  _pluginTest = _pluginTest || {
+    ...pluginVitest,
+    rules: {
+      ...pluginVitest.rules,
+      // extend `test/no-only-tests` rule
+      ...pluginNoOnlyTests.rules
+    }
+  };
+  return [
+    {
+      name: "storm/test/setup",
+      plugins: {
+        test: _pluginTest
+      }
+    },
+    {
+      files,
+      name: "storm/test/rules",
+      rules: {
+        "test/consistent-test-it": [
+          "error",
+          {
+            fn: "it",
+            withinDescribe: "it"
+          }
+        ],
+        "test/no-identical-title": "error",
+        "test/no-import-node-test": "error",
+        "test/no-only-tests": isInEditor ? "warn" : "error",
+        "test/prefer-hooks-in-order": "error",
+        "test/prefer-lowercase-title": "error",
+        // Disables
+        ...{
+          "no-unused-expressions": "off",
+          "node/prefer-global/process": "off",
+          "ts/explicit-function-return-type": "off"
+        },
+        ...overrides
+      }
+    }
+  ];
+}
+__name(test, "test");
+
+// src/configs/toml.ts
+async function toml(options = {}) {
+  const { files = [
+    GLOB_TOML
+  ], overrides = {}, stylistic: stylistic2 = true } = options;
+  const { indent = 2 } = typeof stylistic2 === "boolean" ? {} : stylistic2;
+  const [pluginToml, parserToml] = await Promise.all([
+    interopDefault(import("eslint-plugin-toml")),
+    interopDefault(import("toml-eslint-parser"))
+  ]);
+  return [
+    {
+      name: "storm/toml/setup",
+      plugins: {
+        toml: pluginToml
+      }
+    },
+    {
+      files,
+      languageOptions: {
+        parser: parserToml
+      },
+      name: "storm/toml/rules",
+      rules: {
+        "style/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",
+        ...stylistic2 ? {
+          "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
+      }
+    }
+  ];
+}
+__name(toml, "toml");
+
+// src/configs/typescript.ts
+import process from "node:process";
+async function typescript(options = {}) {
+  const { componentExts = [], overrides = {}, overridesTypeAware = {}, parserOptions = {}, type = "app" } = options;
+  const files = options.files ?? [
+    GLOB_TS,
+    GLOB_TSX,
+    ...componentExts.map((ext) => `**/*.${ext}`)
+  ];
+  const filesTypeAware = options.filesTypeAware ?? [
+    GLOB_TS,
+    GLOB_TSX
+  ];
+  const ignoresTypeAware = options.ignoresTypeAware ?? [
+    `${GLOB_MARKDOWN}/**`,
+    GLOB_ASTRO_TS
+  ];
+  const tsconfigPath = options?.tsconfigPath ? options.tsconfigPath : void 0;
+  const isTypeAware = !!tsconfigPath;
+  const typeAwareRules = {
+    "dot-notation": "off",
+    "no-implied-eval": "off",
+    "ts/await-thenable": "error",
+    "ts/dot-notation": [
+      "error",
+      {
+        allowKeywords: true
+      }
+    ],
+    "ts/no-floating-promises": "error",
+    "ts/no-for-in-array": "error",
+    "ts/no-implied-eval": "error",
+    "ts/no-misused-promises": "error",
+    "ts/no-unnecessary-type-assertion": "error",
+    "ts/no-unsafe-argument": "error",
+    "ts/no-unsafe-assignment": "error",
+    "ts/no-unsafe-call": "error",
+    "ts/no-unsafe-member-access": "error",
+    "ts/no-unsafe-return": "error",
+    "ts/promise-function-async": "error",
+    "ts/restrict-plus-operands": "error",
+    "ts/restrict-template-expressions": "error",
+    "ts/return-await": [
+      "error",
+      "in-try-catch"
+    ],
+    "ts/strict-boolean-expressions": [
+      "error",
+      {
+        allowNullableBoolean: true,
+        allowNullableObject: true
+      }
+    ],
+    "ts/switch-exhaustiveness-check": "error",
+    "ts/unbound-method": "error"
+  };
+  const [pluginTs, parserTs] = await Promise.all([
+    interopDefault(import("@typescript-eslint/eslint-plugin")),
+    interopDefault(import("@typescript-eslint/parser"))
+  ]);
+  function makeParser(typeAware, files2, ignores2) {
+    return {
+      files: files2,
+      ...ignores2 ? {
+        ignores: ignores2
+      } : {},
+      languageOptions: {
+        parser: parserTs,
+        parserOptions: {
+          extraFileExtensions: componentExts.map((ext) => `.${ext}`),
+          sourceType: "module",
+          ...typeAware ? {
+            projectService: {
+              allowDefaultProject: [
+                "./*.js"
+              ],
+              defaultProject: tsconfigPath
+            },
+            tsconfigRootDir: process.cwd()
+          } : {},
+          ...parserOptions
+        }
+      },
+      name: `storm/typescript/${typeAware ? "type-aware-parser" : "parser"}`
+    };
+  }
+  __name(makeParser, "makeParser");
+  return [
+    {
+      // Install the plugins without globs, so they can be configured separately.
+      name: "storm/typescript/setup",
+      plugins: {
+        ts: pluginTs
+      }
+    },
+    // assign type-aware parser for type-aware files and type-unaware parser for the rest
+    ...isTypeAware ? [
+      makeParser(false, files),
+      makeParser(true, filesTypeAware, ignoresTypeAware)
+    ] : [
+      makeParser(false, files)
+    ],
+    {
+      files,
+      name: "storm/typescript/rules",
+      rules: {
+        ...renameRules(pluginTs.configs["eslint-recommended"].overrides[0].rules, {
+          "@typescript-eslint": "ts"
+        }),
+        ...renameRules(pluginTs.configs.strict.rules, {
+          "@typescript-eslint": "ts"
+        }),
+        /*************************************************************
+        *
+        *   TypeScript Rules - The following rules are specific to the TypeScript plugin
+        *
+        **************************************************************/
+        "ts/no-explicit-any": "off",
+        "ts/no-empty-function": "off",
+        "ts/no-var-requires": "off",
+        "ts/ban-ts-comment": "off",
+        "ts/no-empty-interface": "off",
+        "ts/explicit-module-boundary-types": "off",
+        "ts/explicit-function-return-type": "off",
+        "ts/no-unused-vars": [
+          "error",
+          {
+            args: "none",
+            varsIgnorePattern: "^_"
+          }
+        ],
+        "ts/prefer-nullish-coalescing": [
+          "error",
+          {
+            ignorePrimitives: {
+              string: true
+            }
+          }
+        ],
+        "ts/no-restricted-imports": [
+          "error",
+          {
+            patterns: [
+              {
+                group: [
+                  "nx/src/plugins/js*"
+                ],
+                message: "Imports from 'nx/src/plugins/js' are not allowed. Use '@nx/js' instead"
+              },
+              {
+                group: [
+                  "**/native-bindings",
+                  "**/native-bindings.js"
+                ],
+                message: "Direct imports from native-bindings.js are not allowed. Import from index.js instead."
+              },
+              {
+                group: [
+                  "create-storm-workspace"
+                ],
+                message: "Direct imports from `create-storm-workspace` are not allowed. Instead install this package globally (example: 'npm i create-storm-workspace -g')."
+              },
+              {
+                group: [
+                  "create-nx-workspace"
+                ],
+                message: "Direct imports from `create-nx-workspace` are not allowed. Instead install this package globally (example: 'npm i create-nx-workspace -g')."
+              }
+            ]
+          }
+        ],
+        "no-dupe-class-members": "off",
+        "no-redeclare": "off",
+        "no-use-before-define": "off",
+        "no-useless-constructor": "off",
+        "ts/consistent-type-definitions": [
+          "error",
+          "interface"
+        ],
+        "ts/consistent-type-imports": [
+          "error",
+          {
+            disallowTypeAnnotations: false,
+            fixStyle: "separate-type-imports",
+            prefer: "type-imports"
+          }
+        ],
+        "ts/method-signature-style": [
+          "error",
+          "property"
+        ],
+        "ts/no-dupe-class-members": "error",
+        "ts/no-dynamic-delete": "off",
+        "ts/no-empty-object-type": [
+          "error",
+          {
+            allowInterfaces: "always"
+          }
+        ],
+        "ts/no-extraneous-class": "off",
+        "ts/no-import-type-side-effects": "error",
+        "ts/no-invalid-void-type": "off",
+        "ts/no-non-null-assertion": "off",
+        "ts/no-redeclare": [
+          "error",
+          {
+            builtinGlobals: false
+          }
+        ],
+        "ts/no-require-imports": "error",
+        "ts/no-unused-expressions": [
+          "error",
+          {
+            allowShortCircuit: true,
+            allowTaggedTemplates: true,
+            allowTernary: true
+          }
+        ],
+        "ts/no-use-before-define": [
+          "error",
+          {
+            classes: false,
+            functions: false,
+            variables: true
+          }
+        ],
+        "ts/no-useless-constructor": "off",
+        "ts/no-wrapper-object-types": "error",
+        "ts/triple-slash-reference": "off",
+        "ts/unified-signatures": "off",
+        ...type === "lib" ? {
+          "ts/explicit-function-return-type": [
+            "error",
+            {
+              allowExpressions: true,
+              allowHigherOrderFunctions: true,
+              allowIIFEs: true
+            }
+          ]
+        } : {},
+        ...overrides
+      }
+    },
+    ...isTypeAware ? [
+      {
+        files: filesTypeAware,
+        ignores: ignoresTypeAware,
+        name: "storm/typescript/rules-type-aware",
+        rules: {
+          ...typeAwareRules,
+          ...overridesTypeAware
+        }
+      }
+    ] : []
+  ];
+}
+__name(typescript, "typescript");
+
+// src/configs/unicorn.ts
+async function unicorn(options = {}) {
+  return [
+    {
+      name: "storm/unicorn/rules",
+      plugins: {
+        unicorn: default6
+      },
+      rules: {
+        ...options.allRecommended ? default6.configs["recommended"].rules : {
+          "unicorn/consistent-empty-array-spread": "error",
+          "unicorn/error-message": "error",
+          "unicorn/escape-case": "error",
+          "unicorn/new-for-builtins": "error",
+          "unicorn/no-instanceof-array": "error",
+          "unicorn/no-new-array": "error",
+          "unicorn/no-new-buffer": "error",
+          "unicorn/number-literal-case": "error",
+          "unicorn/prefer-dom-node-text-content": "error",
+          "unicorn/prefer-includes": "error",
+          "unicorn/prefer-node-protocol": "error",
+          "unicorn/prefer-number-properties": "error",
+          "unicorn/prefer-string-starts-ends-with": "error",
+          "unicorn/prefer-type-error": "error",
+          "unicorn/throw-new-error": "error"
+        },
+        /*************************************************************
+        *
+        *  Unicorn Rules - The following rules are specific to the Unicorn plugin
+        *
+        **************************************************************/
+        "unicorn/number-literal-case": "off",
+        "unicorn/template-indent": "off",
+        "unicorn/prevent-abbreviations": "off",
+        "unicorn/no-await-expression-member": "off",
+        "unicorn/no-useless-undefined": "off",
+        "unicorn/no-array-push-push": "off",
+        "unicorn/no-array-reduce": "off",
+        "unicorn/no-useless-switch-case": "off",
+        "unicorn/prefer-string-replace-all": "off",
+        "unicorn/no-abusive-eslint-disable": "off",
+        "unicorn/import-style": "off",
+        "unicorn/prefer-module": "off",
+        "unicorn/consistent-function-scoping": "off",
+        "unicorn/no-nested-ternary": "off"
+      }
+    }
+  ];
+}
+__name(unicorn, "unicorn");
+
+// src/configs/unocss.ts
+async function unocss(options = {}) {
+  const { attributify = true, strict = false } = options;
+  await ensurePackages([
+    "@unocss/eslint-plugin"
+  ]);
+  const [pluginUnoCSS] = await Promise.all([
+    interopDefault(import("@unocss/eslint-plugin"))
+  ]);
+  return [
+    {
+      name: "storm/unocss",
+      plugins: {
+        unocss: pluginUnoCSS
+      },
+      rules: {
+        "unocss/order": "warn",
+        ...attributify ? {
+          "unocss/order-attributify": "warn"
+        } : {},
+        ...strict ? {
+          "unocss/blocklist": "error"
+        } : {}
+      }
+    }
+  ];
+}
+__name(unocss, "unocss");
+
+// src/configs/yaml.ts
+async function yaml(options = {}) {
+  const { files = [
+    GLOB_YAML
+  ], overrides = {}, stylistic: stylistic2 = true } = options;
+  const { indent = 2, quotes = "single" } = typeof stylistic2 === "boolean" ? {} : stylistic2;
+  const [pluginYaml, parserYaml] = await Promise.all([
+    interopDefault(import("eslint-plugin-yml")),
+    interopDefault(import("yaml-eslint-parser"))
+  ]);
+  return [
+    {
+      name: "storm/yaml/setup",
+      plugins: {
+        yaml: pluginYaml
+      }
+    },
+    // YML
+    // https://www.npmjs.com/package/eslint-plugin-yml
+    ...pluginYaml.configs["flat/recommended"],
+    {
+      files,
+      languageOptions: {
+        parser: parserYaml
+      },
+      name: "storm/yaml/rules",
+      rules: {
+        "style/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",
+        ...stylistic2 ? {
+          "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
+      }
+    }
+  ];
+}
+__name(yaml, "yaml");
+
+// src/configs/cspell.ts
+import cspellConfig from "@cspell/eslint-plugin/recommended";
+import { findWorkspaceRoot, joinPaths } from "@storm-software/config-tools";
+async function cspell(options = {}) {
+  const { configFile = "./.vscode/cspell.json" } = options;
+  return [
+    {
+      name: "storm/cspell/setup",
+      plugins: {
+        "@cspell": default2
+      }
+    },
+    {
+      name: "storm/cspell/rules",
+      ...cspellConfig,
+      rules: {
+        ...cspellConfig.rules,
+        "@cspell/spellchecker": [
+          "warn",
+          {
+            configFile: joinPaths(findWorkspaceRoot(), configFile),
+            autoFix: true
+          }
+        ]
+      }
+    }
+  ];
+}
+__name(cspell, "cspell");
+
+// src/preset.ts
+var flatConfigProps = [
+  "name",
+  "languageOptions",
+  "linterOptions",
+  "processor",
+  "plugins",
+  "rules",
+  "settings"
+];
+var defaultPluginRenaming = {
+  "@eslint-react": "react",
+  "@eslint-react/dom": "react-dom",
+  "@eslint-react/hooks-extra": "react-hooks-extra",
+  "@eslint-react/naming-convention": "react-naming-convention",
+  "@stylistic": "style",
+  "@typescript-eslint": "ts",
+  "import-x": "import",
+  "n": "node",
+  "vitest": "test",
+  "yml": "yaml"
+};
+function resolveSubOptions(options, key) {
+  return typeof options[key] === "boolean" ? {} : options[key] || {};
+}
+__name(resolveSubOptions, "resolveSubOptions");
+function getOverrides(options, key) {
+  const sub = resolveSubOptions(options, key);
+  return "overrides" in sub ? sub.overrides : {};
+}
+__name(getOverrides, "getOverrides");
+function getStormConfig(options, ...userConfigs) {
+  const { name, globals = {}, astro: enableAstro = false, autoRenamePlugins = true, componentExts = [], gitignore: enableGitignore = true, jsx: enableJsx = true, cspell: enableCSpell = true, react: enableReact = false, regexp: enableRegexp = true, next: enableNext = false, graphql: enableGraphQL = false, storybook: enableStorybook = false, typescript: enableTypeScript = isPackageExists2("typescript"), unicorn: enableUnicorn = true, unocss: enableUnoCSS = false } = options;
+  let isInEditor = options.isInEditor;
+  if (isInEditor == null) {
+    isInEditor = isInEditorEnv();
+    if (isInEditor)
+      console.log("[@antfu/eslint-config] Detected running in editor, some rules are disabled.");
+  }
+  const stylisticOptions = options.stylistic === false ? false : typeof options.stylistic === "object" ? options.stylistic : {};
+  if (stylisticOptions && !("jsx" in stylisticOptions)) stylisticOptions.jsx = enableJsx;
+  const configs2 = [];
+  if (enableGitignore) {
+    if (typeof enableGitignore !== "boolean") {
+      configs2.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => [
+        r({
+          name: "storm/gitignore",
+          ...enableGitignore
+        })
+      ]));
+    } else {
+      configs2.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => [
+        r({
+          name: "storm/gitignore",
+          strict: false
+        })
+      ]));
+    }
+  }
+  const typescriptOptions = resolveSubOptions(options, "typescript");
+  const tsconfigPath = "tsconfigPath" in typescriptOptions ? typescriptOptions.tsconfigPath : void 0;
+  configs2.push(ignores(options.ignores), javascript({
+    name,
+    globals,
+    isInEditor,
+    overrides: getOverrides(options, "javascript")
+  }), node(), jsdoc({
+    stylistic: stylisticOptions
+  }), imports({
+    stylistic: stylisticOptions
+  }), nx(resolveSubOptions(options, "nx")), perfectionist());
+  if (enableCSpell) {
+    configs2.push(cspell(resolveSubOptions(options, "cspell")));
+  }
+  if (enableUnicorn) {
+    configs2.push(unicorn(enableUnicorn === true ? {} : enableUnicorn));
+  }
+  if (enableJsx) {
+    configs2.push(jsx());
+  }
+  if (enableTypeScript) {
+    configs2.push(typescript({
+      ...typescriptOptions,
+      componentExts,
+      overrides: getOverrides(options, "typescript"),
+      type: options.type
+    }));
+  }
+  if (stylisticOptions) {
+    configs2.push(stylistic({
+      ...stylisticOptions,
+      lessOpinionated: options.lessOpinionated,
+      overrides: getOverrides(options, "stylistic")
+    }));
+  }
+  if (enableRegexp) {
+    configs2.push(regexp(typeof enableRegexp === "boolean" ? {} : enableRegexp));
+  }
+  if (options.test ?? true) {
+    configs2.push(test({
+      isInEditor,
+      overrides: getOverrides(options, "test")
+    }));
+  }
+  if (enableGraphQL) {
+    configs2.push(graphql(resolveSubOptions(options, "graphql")));
+  }
+  if (enableReact) {
+    configs2.push(react({
+      ...typescriptOptions,
+      overrides: getOverrides(options, "react"),
+      tsconfigPath
+    }));
+  }
+  if (enableNext) {
+    configs2.push(next(resolveSubOptions(options, "next")));
+  }
+  if (enableStorybook) {
+    configs2.push(storybook(resolveSubOptions(options, "storybook")));
+  }
+  if (enableUnoCSS) {
+    configs2.push(unocss({
+      ...resolveSubOptions(options, "unocss"),
+      overrides: getOverrides(options, "unocss")
+    }));
+  }
+  if (enableAstro) {
+    configs2.push(astro({
+      overrides: getOverrides(options, "astro"),
+      stylistic: stylisticOptions
+    }));
+  }
+  if (options.jsonc ?? true) {
+    configs2.push(jsonc({
+      overrides: getOverrides(options, "jsonc"),
+      stylistic: stylisticOptions
+    }), sortPackageJson(), sortTsconfig());
+  }
+  if (options.yaml ?? true) {
+    configs2.push(yaml({
+      overrides: getOverrides(options, "yaml"),
+      stylistic: stylisticOptions
+    }));
+  }
+  if (options.toml ?? true) {
+    configs2.push(toml({
+      overrides: getOverrides(options, "toml"),
+      stylistic: stylisticOptions
+    }));
+  }
+  if (options.markdown ?? true) {
+    configs2.push(markdown({
+      componentExts,
+      overrides: getOverrides(options, "markdown")
+    }));
+  }
+  if (options.formatters) {
+    configs2.push(formatters(options.formatters, typeof stylisticOptions === "boolean" ? {} : stylisticOptions));
+  }
+  configs2.push(disables());
+  if ("files" in options) {
+    throw new Error('[@storm-software/eslint] 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 = flatConfigProps.reduce((acc, key) => {
+    if (key in options) acc[key] = options[key];
+    return acc;
+  }, {});
+  if (Object.keys(fusedConfig).length) configs2.push([
+    fusedConfig
+  ]);
+  let composer = new FlatConfigComposer();
+  composer = composer.append(...configs2, ...userConfigs);
+  if (autoRenamePlugins) {
+    composer = composer.renamePlugins(defaultPluginRenaming);
+  }
+  if (isInEditor) {
+    composer = composer.disableRulesFix([
+      "unused-imports/no-unused-imports",
+      "test/no-only-tests",
+      "prefer-const"
+    ], {
+      builtinRules: /* @__PURE__ */ __name(() => import([
+        "eslint",
+        "use-at-your-own-risk"
+      ].join("/")).then((r) => r.builtinRules), "builtinRules")
     });
-    throw error;
   }
+  return composer;
 }
 __name(getStormConfig, "getStormConfig");
-var areFilesEqual = /* @__PURE__ */ __name((files1, files2) => {
-  if (files1 === files2) {
-    return true;
-  } else if (!files1 || !files2) {
-    return false;
-  } else if (typeof files1 === "string" && typeof files2 !== "string" || typeof files1 !== "string" && typeof files2 === "string" || Array.isArray(files1) && !Array.isArray(files2) || !Array.isArray(files1) && Array.isArray(files2)) {
-    return false;
-  } else if (files1.length !== files2.length) {
-    return false;
-  }
-  return files1.every((file, index) => Array.isArray(file) && Array.isArray(files2?.[index]) ? areFilesEqual(file, files2?.[index]) : !Array.isArray(file) && !Array.isArray(files2?.[index]) ? file?.toLowerCase() === files2?.[index]?.toLowerCase() : file === files2);
-}, "areFilesEqual");
+var preset_default = getStormConfig;
 export {
-  getStormConfig
+  preset_default as default,
+  defaultPluginRenaming,
+  getOverrides,
+  getStormConfig,
+  resolveSubOptions
 };