@jsse/eslint-config 0.2.19 → 0.2.21

package/dist/index.js

@@ -24,9 +24,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/.pnpm/globals@15.10.0/node_modules/globals/globals.json
+// node_modules/.pnpm/globals@15.11.0/node_modules/globals/globals.json
 var require_globals = __commonJS({
-  "node_modules/.pnpm/globals@15.10.0/node_modules/globals/globals.json"(exports, module) {
+  "node_modules/.pnpm/globals@15.11.0/node_modules/globals/globals.json"(exports, module) {
     module.exports = {
       amd: {
         define: false,
@@ -1954,6 +1954,38 @@ var require_globals = __commonJS({
         WeakRef: false,
         WeakSet: false
       },
+      es3: {
+        Array: false,
+        Boolean: false,
+        Date: false,
+        decodeURI: false,
+        decodeURIComponent: false,
+        encodeURI: false,
+        encodeURIComponent: false,
+        Error: false,
+        escape: false,
+        eval: false,
+        EvalError: false,
+        Function: false,
+        Infinity: false,
+        isFinite: false,
+        isNaN: false,
+        Math: false,
+        NaN: false,
+        Number: false,
+        Object: false,
+        parseFloat: false,
+        parseInt: false,
+        RangeError: false,
+        ReferenceError: false,
+        RegExp: false,
+        String: false,
+        SyntaxError: false,
+        TypeError: false,
+        undefined: false,
+        unescape: false,
+        URIError: false
+      },
       es5: {
         Array: false,
         Boolean: false,
@@ -2968,9 +3000,9 @@ var require_globals = __commonJS({
   }
 });
 
-// node_modules/.pnpm/globals@15.10.0/node_modules/globals/index.js
+// node_modules/.pnpm/globals@15.11.0/node_modules/globals/index.js
 var require_globals2 = __commonJS({
-  "node_modules/.pnpm/globals@15.10.0/node_modules/globals/index.js"(exports, module) {
+  "node_modules/.pnpm/globals@15.11.0/node_modules/globals/index.js"(exports, module) {
     "use strict";
     module.exports = require_globals();
   }
@@ -2986,7 +3018,7 @@ var SLOW_RULES = [
   "unicorn/no-unnecessary-polyfills"
 ];
 
-// src/factory.ts
+// src/define-config.ts
 import fs2 from "node:fs";
 import process6 from "node:process";
 
@@ -6097,11 +6129,11 @@ var pp$4 = Parser.prototype;
 pp$4.raise = function(pos, message) {
   var loc = getLineInfo(this.input, pos);
   message += " (" + loc.line + ":" + loc.column + ")";
-  var err = new SyntaxError(message);
-  err.pos = pos;
-  err.loc = loc;
-  err.raisedAt = this.pos;
-  throw err;
+  var err2 = new SyntaxError(message);
+  err2.pos = pos;
+  err2.loc = loc;
+  err2.raisedAt = this.pos;
+  throw err2;
 };
 pp$4.raiseRecoverable = pp$4.raise;
 pp$4.curPosition = function() {
@@ -8171,11 +8203,11 @@ pp.tryReadTemplateToken = function() {
   this.inTemplateElement = true;
   try {
     this.readTmplToken();
-  } catch (err) {
-    if (err === INVALID_TEMPLATE_ESCAPE_ERROR) {
+  } catch (err2) {
+    if (err2 === INVALID_TEMPLATE_ESCAPE_ERROR) {
       this.readInvalidTemplateToken();
     } else {
-      throw err;
+      throw err2;
     }
   }
   this.inTemplateElement = false;
@@ -8414,11 +8446,11 @@ Parser.acorn = {
   nonASCIIwhitespace
 };
 
-// node_modules/.pnpm/mlly@1.7.1/node_modules/mlly/dist/index.mjs
+// node_modules/.pnpm/mlly@1.7.2/node_modules/mlly/dist/index.mjs
 import { builtinModules, createRequire } from "node:module";
 import fs, { realpathSync, statSync, promises } from "node:fs";
 
-// node_modules/.pnpm/ufo@1.5.3/node_modules/ufo/dist/index.mjs
+// node_modules/.pnpm/ufo@1.5.4/node_modules/ufo/dist/index.mjs
 var r = String.fromCharCode;
 var TRAILING_SLASH_RE = /\/$|\/\?|\/#/;
 var JOIN_LEADING_SLASH_RE = /^\.?\//;
@@ -8471,7 +8503,7 @@ var isAbsolute = function(p) {
   return _IS_ABSOLUTE_RE.test(p);
 };
 
-// node_modules/.pnpm/mlly@1.7.1/node_modules/mlly/dist/index.mjs
+// node_modules/.pnpm/mlly@1.7.2/node_modules/mlly/dist/index.mjs
 import { fileURLToPath as fileURLToPath$1, URL as URL$1, pathToFileURL as pathToFileURL$1 } from "node:url";
 import assert from "node:assert";
 import process$1 from "node:process";
@@ -9786,7 +9818,7 @@ function _resolve(id, options = {}) {
     for (const prefix of ["", "/index"]) {
       for (const extension of options.extensions || DEFAULT_EXTENSIONS) {
         resolved = _tryModuleResolve(
-          id + prefix + extension,
+          joinURL(id, prefix) + extension,
           url,
           conditionsSet
         );
@@ -9847,138 +9879,651 @@ function resolvePackage(name, options = {}) {
   }
 }
 
-// src/globs.ts
-var GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
-var GLOB_JS_SRC_EXT = "?([cm])js?(x)";
-var GLOB_SRC = "**/*.?([cm])[jt]s?(x)";
-var GLOB_JS = "**/*.?([cm])js";
-var GLOB_JSX = "**/*.?([cm])jsx";
-var GLOB_TS = "**/*.?([cm])ts";
-var GLOB_TSX = "**/*.?([cm])tsx";
-var GLOB_STYLE = "**/*.{c,le,sc}ss";
-var GLOB_CSS = "**/*.css";
-var GLOB_LESS = "**/*.less";
-var GLOB_SCSS = "**/*.scss";
-var GLOB_JSON = "**/*.json";
-var GLOB_JSON5 = "**/*.json5";
-var GLOB_JSONC = "**/*.jsonc";
-var GLOB_TOML = "**/*.toml";
-var GLOB_MARKDOWN = "**/*.md";
-var GLOB_GRAPHQL = ["**/*.graphql", "**/*.gql"];
-var GLOB_YAML = "**/*.y?(a)ml";
-var GLOB_HTML = "**/*.htm?(l)";
-var GLOB_TSCONFIG = ["**/tsconfig.json", "**/tsconfig.*.json"];
-var GLOB_MARKDOWN_CODE = `${GLOB_MARKDOWN}/${GLOB_SRC}`;
-var GLOB_TESTS = [
-  `**/__tests__/**/*.${GLOB_SRC_EXT}`,
-  `**/*.spec.${GLOB_SRC_EXT}`,
-  `**/*.test.${GLOB_SRC_EXT}`,
-  `**/*.bench.${GLOB_SRC_EXT}`,
-  `**/*.benchmark.${GLOB_SRC_EXT}`
-];
-var GLOB_ALL_SRC = [
-  GLOB_SRC,
-  GLOB_STYLE,
-  GLOB_JSON,
-  GLOB_JSON5,
-  GLOB_MARKDOWN,
-  GLOB_YAML,
-  GLOB_HTML
-];
-var GLOB_EXCLUDE = [
-  "**/__snapshots__",
-  "**/.cache",
-  "**/.changeset",
-  "**/.history",
-  "**/.idea",
-  "**/.next",
-  "**/.nuxt",
-  "**/.output",
-  "**/.temp",
-  "**/.tmp",
-  "**/.vercel",
-  "**/.vite-inspect",
-  "**/.vitepress/cache",
-  "**/*.bak",
-  "**/*.min.*",
-  "**/.yarn",
-  "**/.pnp.*",
-  "**/auto-import?(s).d.ts",
-  "**/bun.lockb",
-  "**/CHANGELOG*.md",
-  "**/components.d.ts",
-  "**/coverage",
-  "**/dist",
-  "**/LICENSE*",
-  "**/node_modules",
-  "**/out",
-  "**/output",
-  "**/package-lock.json",
-  "**/pnpm-lock.yaml",
-  "**/scratch",
-  "**/temp",
-  "**/tmp",
-  "**/yarn.lock"
-];
-
-// src/utils.ts
-import process3 from "node:process";
-async function combine(...configs) {
-  const resolved = await Promise.all(configs);
-  return resolved.flat();
-}
-async function combineAsync(...configs) {
-  const resolved = await Promise.all(configs);
-  return resolved.flatMap(
-    (config) => Array.isArray(config) ? config : [config]
-  );
-}
-function renameRules(rules, from, to) {
-  if (from === to) {
-    return rules;
+// node_modules/.pnpm/neverthrow@8.0.0/node_modules/neverthrow/dist/index.es.js
+var defaultErrorConfig = {
+  withStackTrace: false
+};
+var createNeverThrowError = (message, result, config = defaultErrorConfig) => {
+  const data2 = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
+  const maybeStack = config.withStackTrace ? new Error().stack : void 0;
+  return {
+    data: data2,
+    message,
+    stack: maybeStack
+  };
+};
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve2) {
+      resolve2(value);
+    });
   }
-  return Object.fromEntries(
-    Object.entries(rules).map(([key, value]) => {
-      if (key.startsWith(from)) {
-        return [to + key.slice(from.length), value];
+  return new (P || (P = Promise))(function(resolve2, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
       }
-      return [key, value];
-    })
-  );
-}
-async function interopDefault2(m) {
-  const resolved = await m;
-  return resolved.default || resolved;
-}
-function isCI() {
-  return !!process3.env.CI;
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, [])).next());
+  });
 }
-function isInEditor() {
-  return !!((process3.env.VSCODE_PID || process3.env.JETBRAINS_IDE) && !isCI());
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function verb(n2) {
+    if (g[n2]) i[n2] = function(v) {
+      return new Promise(function(a, b) {
+        q.push([n2, v, a, b]) > 1 || resume(n2, v);
+      });
+    };
+  }
+  function resume(n2, v) {
+    try {
+      step(g[n2](v));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+  function step(r2) {
+    r2.value instanceof __await ? Promise.resolve(r2.value.v).then(fulfill, reject) : settle(q[0][2], r2);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
+}
+function __asyncDelegator(o) {
+  var i, p;
+  return i = {}, verb("next"), verb("throw", function(e) {
+    throw e;
+  }), verb("return"), i[Symbol.iterator] = function() {
+    return this;
+  }, i;
+  function verb(n2, f) {
+    i[n2] = o[n2] ? function(v) {
+      return (p = !p) ? { value: __await(o[n2](v)), done: n2 === "return" } : f ? f(v) : v;
+    } : f;
+  }
+}
+function __asyncValues(o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i);
+  function verb(n2) {
+    i[n2] = o[n2] && function(v) {
+      return new Promise(function(resolve2, reject) {
+        v = o[n2](v), settle(resolve2, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve2, reject, d, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve2({ value: v2, done: d });
+    }, reject);
+  }
 }
-function uniqueStrings(...strings) {
-  const set = /* @__PURE__ */ new Set();
-  for (const item of strings) {
-    if (typeof item === "string") {
-      set.add(item);
-    } else {
-      for (const str of item) {
-        set.add(str);
+var ResultAsync = class _ResultAsync {
+  constructor(res) {
+    this._promise = res;
+  }
+  static fromSafePromise(promise) {
+    const newPromise = promise.then((value) => new Ok(value));
+    return new _ResultAsync(newPromise);
+  }
+  static fromPromise(promise, errorFn) {
+    const newPromise = promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e)));
+    return new _ResultAsync(newPromise);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromThrowable(fn, errorFn) {
+    return (...args) => {
+      return new _ResultAsync((() => __awaiter(this, void 0, void 0, function* () {
+        try {
+          return new Ok(yield fn(...args));
+        } catch (error) {
+          return new Err(errorFn ? errorFn(error) : error);
+        }
+      }))());
+    };
+  }
+  static combine(asyncResultList) {
+    return combineResultAsyncList(asyncResultList);
+  }
+  static combineWithAllErrors(asyncResultList) {
+    return combineResultAsyncListWithAllErrors(asyncResultList);
+  }
+  map(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      return new Ok(yield f(res.value));
+    })));
+  }
+  andThrough(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
       }
+      const newRes = yield f(res.value);
+      if (newRes.isErr()) {
+        return new Err(newRes.error);
+      }
+      return new Ok(res.value);
+    })));
+  }
+  andTee(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      try {
+        yield f(res.value);
+      } catch (e) {
+      }
+      return new Ok(res.value);
+    })));
+  }
+  mapErr(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isOk()) {
+        return new Ok(res.value);
+      }
+      return new Err(yield f(res.error));
+    })));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(f) {
+    return new _ResultAsync(this._promise.then((res) => {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      const newValue = f(res.value);
+      return newValue instanceof _ResultAsync ? newValue._promise : newValue;
+    }));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return f(res.error);
+      }
+      return new Ok(res.value);
+    })));
+  }
+  match(ok2, _err) {
+    return this._promise.then((res) => res.match(ok2, _err));
+  }
+  unwrapOr(t) {
+    return this._promise.then((res) => res.unwrapOr(t));
+  }
+  /**
+   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+   */
+  safeUnwrap() {
+    return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
+      return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
+    });
+  }
+  // Makes ResultAsync implement PromiseLike<Result>
+  then(successCallback, failureCallback) {
+    return this._promise.then(successCallback, failureCallback);
+  }
+};
+var errAsync = (err2) => new ResultAsync(Promise.resolve(new Err(err2)));
+var fromPromise = ResultAsync.fromPromise;
+var fromSafePromise = ResultAsync.fromSafePromise;
+var fromAsyncThrowable = ResultAsync.fromThrowable;
+var combineResultList = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr()) {
+      acc = err(result.error);
+      break;
+    } else {
+      acc.map((list) => list.push(result.value));
     }
   }
-  return [...set];
+  return acc;
+};
+var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
+var combineResultListWithAllErrors = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr() && acc.isErr()) {
+      acc.error.push(result.error);
+    } else if (result.isErr() && acc.isOk()) {
+      acc = err([result.error]);
+    } else if (result.isOk() && acc.isOk()) {
+      acc.value.push(result.value);
+    }
+  }
+  return acc;
+};
+var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
+var Result;
+(function(Result2) {
+  function fromThrowable2(fn, errorFn) {
+    return (...args) => {
+      try {
+        const result = fn(...args);
+        return ok(result);
+      } catch (e) {
+        return err(errorFn ? errorFn(e) : e);
+      }
+    };
+  }
+  Result2.fromThrowable = fromThrowable2;
+  function combine2(resultList) {
+    return combineResultList(resultList);
+  }
+  Result2.combine = combine2;
+  function combineWithAllErrors(resultList) {
+    return combineResultListWithAllErrors(resultList);
+  }
+  Result2.combineWithAllErrors = combineWithAllErrors;
+})(Result || (Result = {}));
+var ok = (value) => new Ok(value);
+function err(err2) {
+  return new Err(err2);
 }
+var Ok = class {
+  constructor(value) {
+    this.value = value;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+  map(f) {
+    return ok(f(this.value));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  mapErr(_f) {
+    return ok(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(f) {
+    return f(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThrough(f) {
+    return f(this.value).map((_value) => this.value);
+  }
+  andTee(f) {
+    try {
+      f(this.value);
+    } catch (e) {
+    }
+    return ok(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(_f) {
+    return ok(this.value);
+  }
+  asyncAndThen(f) {
+    return f(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  asyncAndThrough(f) {
+    return f(this.value).map(() => this.value);
+  }
+  asyncMap(f) {
+    return ResultAsync.fromSafePromise(f(this.value));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  unwrapOr(_v) {
+    return this.value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  match(ok2, _err) {
+    return ok2(this.value);
+  }
+  safeUnwrap() {
+    const value = this.value;
+    return function* () {
+      return value;
+    }();
+  }
+  _unsafeUnwrap(_) {
+    return this.value;
+  }
+  _unsafeUnwrapErr(config) {
+    throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config);
+  }
+};
+var Err = class {
+  constructor(error) {
+    this.error = error;
+  }
+  isOk() {
+    return false;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  map(_f) {
+    return err(this.error);
+  }
+  mapErr(f) {
+    return err(f(this.error));
+  }
+  andThrough(_f) {
+    return err(this.error);
+  }
+  andTee(_f) {
+    return err(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(_f) {
+    return err(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(f) {
+    return f(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  asyncAndThen(_f) {
+    return errAsync(this.error);
+  }
+  asyncAndThrough(_f) {
+    return errAsync(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  asyncMap(_f) {
+    return errAsync(this.error);
+  }
+  unwrapOr(v) {
+    return v;
+  }
+  match(_ok, err2) {
+    return err2(this.error);
+  }
+  safeUnwrap() {
+    const error = this.error;
+    return function* () {
+      yield err(error);
+      throw new Error("Do not use this generator out of `safeTry`");
+    }();
+  }
+  _unsafeUnwrap(config) {
+    throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
+  }
+  _unsafeUnwrapErr(_) {
+    return this.error;
+  }
+};
+var fromThrowable = Result.fromThrowable;
 
-// src/plugins.ts
-import { default as default2 } from "@typescript-eslint/eslint-plugin";
-import * as parserTs from "@typescript-eslint/parser";
-import { default as default3 } from "eslint-plugin-antfu";
-import { default as default4 } from "eslint-plugin-eslint-comments";
-import * as pluginImport from "eslint-plugin-import-x";
-import { default as default5 } from "eslint-plugin-n";
-import { default as default6 } from "eslint-plugin-perfectionist";
-import { default as default7 } from "eslint-plugin-unicorn";
+// src/utils.ts
+import process3 from "node:process";
+
+// src/lager.ts
+var LAGER_LEVELS = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60
+};
+function isLagerLevel(level) {
+  return level === "trace" || level === "debug" || level === "info" || level === "warn" || level === "error" || level === "fatal";
+}
+var Lager = class {
+  _level = "info";
+  id = "lager";
+  levelNo = LAGER_LEVELS[this._level];
+  prefix = "";
+  constructor(options) {
+    const { level, id, prefix } = {
+      level: "info",
+      id: "lager",
+      prefix: "@jsse/eslint-config",
+      ...options
+    };
+    this.id = id;
+    this._level = isLagerLevel(level) ? level : "info";
+    this.levelNo = LAGER_LEVELS[this._level];
+    this.prefix = prefix;
+    this.log = this.log.bind(this);
+    this.debug = this.debug.bind(this);
+  }
+  get level() {
+    return this._level;
+  }
+  set level(level) {
+    this._level = level;
+    this.levelNo = LAGER_LEVELS[level];
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  log(...args) {
+    console.log(this.prefix, ...args);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  trace(...args) {
+    if (this.levelNo <= LAGER_LEVELS.trace) {
+      console.trace(this.prefix, ...args);
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  debug(...args) {
+    if (this.levelNo <= LAGER_LEVELS.debug) {
+      console.debug(this.prefix, ...args);
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  info(...args) {
+    if (this.levelNo <= LAGER_LEVELS.info) {
+      console.info(this.prefix, ...args);
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  warn(...args) {
+    if (this.levelNo <= LAGER_LEVELS.warn) {
+      console.warn(this.prefix, ...args);
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  error(...args) {
+    if (this.levelNo <= LAGER_LEVELS.error) {
+      console.error(this.prefix, ...args);
+    }
+  }
+};
+var log = new Lager();
+
+// src/utils.ts
+async function combine(...configs) {
+  const resolved = await Promise.all(configs);
+  return resolved.flat();
+}
+async function combineAsync(...configs) {
+  const resolved = await Promise.all(configs);
+  return resolved.flatMap(
+    (config) => Array.isArray(config) ? config : [config]
+  );
+}
+function renameRules(rules, from, to) {
+  if (from === to) {
+    return rules;
+  }
+  return Object.fromEntries(
+    Object.entries(rules).map(([key, value]) => {
+      if (key.startsWith(from)) {
+        return [to + key.slice(from.length), value];
+      }
+      return [key, value];
+    })
+  );
+}
+async function interopDefault2(m) {
+  const resolved = await m;
+  return resolved.default || resolved;
+}
+function isCI() {
+  return !!process3.env.CI;
+}
+function isInEditor() {
+  return !!((process3.env.VSCODE_PID || process3.env.JETBRAINS_IDE) && !isCI());
+}
+function uniqueStrings(...strings) {
+  const set = /* @__PURE__ */ new Set();
+  for (const item of strings) {
+    if (typeof item === "string") {
+      set.add(item);
+    } else {
+      for (const str of item) {
+        set.add(str);
+      }
+    }
+  }
+  return [...set];
+}
+var parserPlain = {
+  meta: {
+    name: "parser-plain"
+  },
+  parseForESLint: (code) => ({
+    ast: {
+      body: [],
+      comments: [],
+      loc: { end: code.length, start: 0 },
+      range: [0, code.length],
+      tokens: [],
+      type: "Program"
+    },
+    scopeManager: void 0,
+    services: { isPlain: true },
+    visitorKeys: {
+      Program: []
+    }
+  })
+};
+function turnOffRules(configs, off) {
+  if (off && off.length > 0) {
+    for (const rule of off) {
+      log.debug(`turning-off: ${rule}`);
+    }
+    const currentlyActiveRules = /* @__PURE__ */ new Set();
+    for (const config of configs) {
+      for (const rule of Object.keys(config.rules ?? {}))
+        currentlyActiveRules.add(rule);
+    }
+    for (const rule of off) {
+      if (!currentlyActiveRules.has(rule)) {
+        log.info(
+          `Rule \`${rule}\` is not active in the current config, you can remove it from the off list`
+        );
+      }
+    }
+    for (const config of configs) {
+      const cfgRules = config.rules;
+      if (cfgRules) {
+        for (const rule of off) {
+          if (cfgRules[rule] !== void 0 && cfgRules[rule] !== "off" && cfgRules[rule] !== 0) {
+            cfgRules[rule] = "off";
+          }
+        }
+      }
+    }
+  }
+  return configs;
+}
+function changeRuleEntrySeverity(ruleConfig, level) {
+  if (Array.isArray(ruleConfig)) {
+    if (ruleConfig[0] !== level) {
+      ruleConfig[0] = level;
+    }
+    return ruleConfig;
+  }
+  return level;
+}
+function error2warn(configs) {
+  for (const config of configs) {
+    if (config.rules) {
+      config.rules = Object.fromEntries(
+        Object.entries(config.rules).map(([key, value]) => {
+          if (value === "error" || value === 2) {
+            return [key, changeRuleEntrySeverity(value, "warn")];
+          }
+          if (Array.isArray(value) && (value[0] === "error" || value[0] === 2)) {
+            return [key, changeRuleEntrySeverity(value, "warn")];
+          }
+          return [key, value];
+        })
+      );
+    }
+  }
+  return configs;
+}
+function warn2error(configs) {
+  for (const config of configs) {
+    if (config.rules) {
+      config.rules = Object.fromEntries(
+        Object.entries(config.rules).map(([key, value]) => {
+          if (value === "warn" || value === 1) {
+            return [key, changeRuleEntrySeverity(value, "error")];
+          }
+          if (Array.isArray(value) && (value[0] === "warn" || value[0] === 1)) {
+            return [key, changeRuleEntrySeverity(value, "error")];
+          }
+          return [key, value];
+        })
+      );
+    }
+  }
+  return configs;
+}
+
+// src/plugins.ts
+import { default as default2 } from "@eslint-community/eslint-plugin-eslint-comments";
+import { default as default3 } from "@typescript-eslint/eslint-plugin";
+import * as parserTs from "@typescript-eslint/parser";
+import { default as default4 } from "eslint-plugin-antfu";
+import * as pluginImport from "eslint-plugin-import-x";
+import { default as default5 } from "eslint-plugin-n";
+import { default as default6 } from "eslint-plugin-perfectionist";
+import { default as default7 } from "eslint-plugin-unicorn";
 import { default as default8 } from "eslint-plugin-unused-imports";
 async function importPluginReact() {
   const pluginReact = await interopDefault2(import("eslint-plugin-react"));
@@ -9988,6 +10533,7 @@ async function importPluginReact() {
 }
 async function importPluginReactHooks() {
   const pluginReactHooks = await interopDefault2(
+    // @ts-expect-error - bad types
     import("eslint-plugin-react-hooks")
   );
   return {
@@ -9996,6 +10542,7 @@ async function importPluginReactHooks() {
 }
 async function importPluginReactRefresh() {
   const pluginReactRefresh = await interopDefault2(
+    // @ts-expect-error - bad types
     import("eslint-plugin-react-refresh")
   );
   return {
@@ -10006,7 +10553,9 @@ async function importReactPlugins() {
   const [pluginReact, pluginReactHooks, pluginReactRefresh] = await Promise.all(
     [
       interopDefault2(import("eslint-plugin-react")),
+      // @ts-expect-error - bad types
       interopDefault2(import("eslint-plugin-react-hooks")),
+      // @ts-expect-error - bad types
       interopDefault2(import("eslint-plugin-react-refresh"))
     ]
   );
@@ -10039,7 +10588,7 @@ async function importYmlLibs() {
   return { parserYaml, pluginYaml };
 }
 async function importPluginMarkdown() {
-  const pluginMarkdown = await interopDefault2(import("eslint-plugin-markdown"));
+  const pluginMarkdown = await interopDefault2(import("@eslint/markdown"));
   return {
     pluginMarkdown
   };
@@ -10064,41 +10613,52 @@ async function importPluginStylistic() {
 }
 async function importPluginTailwind() {
   const pluginTailwind = await interopDefault2(
+    // @ts-expect-error - bad types
     import("eslint-plugin-tailwindcss")
   );
   return { pluginTailwind };
 }
+async function safeImportPluginTailwind() {
+  try {
+    const plugin = await importPluginTailwind();
+    return ok(plugin);
+  } catch (e) {
+    return err(
+      new Error(
+        `Failed to import \`eslint-plugin-tailwindcss\`. You might need to install it. ${e}`
+      )
+    );
+  }
+}
 
 // src/configs/antfu.ts
-var antfu = async () => {
+var antfu = async (options) => {
   return [
     {
       name: "jsse/antfu",
       plugins: {
-        antfu: default3
+        antfu: default4
       },
-      // @ts-expect-error - antfu plugin types err
-      rules: {
-        "antfu/no-import-node-modules-by-path": "error",
-        "antfu/top-level-function": "error"
-      }
-    },
-    {
-      files: ["**/src/**/*"],
-      name: "jsse/antfu/src",
-      // @ts-expect-error - antfu plugin types err
-      rules: {
-        "antfu/no-import-dist": "error"
-      }
-    },
-    {
-      files: ["**/bin/**/*", `**/bin.${GLOB_SRC_EXT}`],
-      name: "jsse/antfu/bin",
       rules: {
-        "antfu/no-import-dist": "off",
-        "antfu/no-import-node-modules-by-path": "off"
+        // used to like the following rule, but now find it annoying
+        "antfu/top-level-function": options?.topLevelFunction ?? "off"
       }
     }
+    // {
+    //   files: ["**/src/**/*"],
+    //   name: "jsse/antfu/src",
+    //   rules: {
+    //     "antfu/no-import-dist": "error",
+    //   },
+    // },
+    // {
+    //   files: ["**/bin/**/*", `**/bin.${GLOB_SRC_EXT}`],
+    //   name: "jsse/antfu/bin",
+    //   rules: {
+    //     "antfu/no-import-dist": "off",
+    //     "antfu/no-import-node-modules-by-path": "off",
+    //   },
+    // },
   ];
 };
 
@@ -10108,7 +10668,7 @@ var comments = async () => [
     name: "jsse/eslint-comments",
     plugins: {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      "eslint-comments": default4
+      "eslint-comments": default2
     },
     rules: {
       "eslint-comments/no-aggregating-enable": "error",
@@ -10119,6 +10679,81 @@ var comments = async () => [
   }
 ];
 
+// src/globs.ts
+var GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
+var GLOB_JS_SRC_EXT = "?([cm])js?(x)";
+var GLOB_SRC = "**/*.?([cm])[jt]s?(x)";
+var GLOB_JS = "**/*.?([cm])js";
+var GLOB_JSX = "**/*.?([cm])jsx";
+var GLOB_TS = "**/*.?([cm])ts";
+var GLOB_TSX = "**/*.?([cm])tsx";
+var GLOB_STYLE = "**/*.{c,le,sc}ss";
+var GLOB_CSS = "**/*.css";
+var GLOB_LESS = "**/*.less";
+var GLOB_SCSS = "**/*.scss";
+var GLOB_JSON = "**/*.json";
+var GLOB_JSON5 = "**/*.json5";
+var GLOB_JSONC = "**/*.jsonc";
+var GLOB_TOML = "**/*.toml";
+var GLOB_MARKDOWN = "**/*.md";
+var GLOB_MARKDOWN_IN_MARKDOWN = "**/*.md/*.md";
+var GLOB_GRAPHQL = ["**/*.graphql", "**/*.gql"];
+var GLOB_YAML = "**/*.y?(a)ml";
+var GLOB_HTML = "**/*.htm?(l)";
+var GLOB_TSCONFIG = ["**/tsconfig.json", "**/tsconfig.*.json"];
+var GLOB_MARKDOWN_CODE = `${GLOB_MARKDOWN}/${GLOB_SRC}`;
+var GLOB_TESTS = [
+  `**/__tests__/**/*.${GLOB_SRC_EXT}`,
+  `**/*.spec.${GLOB_SRC_EXT}`,
+  `**/*.test.${GLOB_SRC_EXT}`,
+  `**/*.bench.${GLOB_SRC_EXT}`,
+  `**/*.benchmark.${GLOB_SRC_EXT}`
+];
+var GLOB_ALL_SRC = [
+  GLOB_SRC,
+  GLOB_STYLE,
+  GLOB_JSON,
+  GLOB_JSON5,
+  GLOB_MARKDOWN,
+  GLOB_YAML,
+  GLOB_HTML
+];
+var GLOB_EXCLUDE = [
+  "**/__snapshots__",
+  "**/.cache",
+  "**/.changeset",
+  "**/.history",
+  "**/.idea",
+  "**/.next",
+  "**/.nuxt",
+  "**/.output",
+  "**/.temp",
+  "**/.tmp",
+  "**/.vercel",
+  "**/.vite-inspect",
+  "**/.vitepress/cache",
+  "**/*.bak",
+  "**/*.min.*",
+  "**/.yarn",
+  "**/.pnp.*",
+  "**/auto-import?(s).d.ts",
+  "**/bun.lockb",
+  "**/CHANGELOG*.md",
+  "**/components.d.ts",
+  "**/coverage",
+  "**/dist",
+  "**/LICENSE*",
+  "**/node_modules",
+  "**/out",
+  "**/output",
+  "**/package-lock.json",
+  "**/pnpm-lock.yaml",
+  "**/scratch",
+  "**/temp",
+  "**/tmp",
+  "**/yarn.lock"
+];
+
 // src/configs/ignores.ts
 var ignores = async () => {
   return [
@@ -10530,6 +11165,9 @@ var jsonc = async (options) => {
   ];
 };
 
+// src/configs/markdown.ts
+import { mergeProcessors, processorPassThrough } from "eslint-merge-processors";
+
 // src/configs/ts/typescript-rules.ts
 function typescriptRulesTypeAware() {
   return {
@@ -10951,6 +11589,7 @@ function typescriptRules(props) {
 // src/configs/markdown.ts
 var markdown = async (options) => {
   const { componentExts = [], overrides = {} } = options ?? {};
+  const files = [GLOB_MARKDOWN];
   const { pluginMarkdown } = await importPluginMarkdown();
   const tsRulesOff = Object.fromEntries(
     // @ts-expect-error - undefined
@@ -10959,6 +11598,13 @@ var markdown = async (options) => {
       "off"
     ])
   );
+  const processor = mergeProcessors(
+    [
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      pluginMarkdown.processors.markdown,
+      processorPassThrough
+    ].filter((processor2) => processor2 !== void 0)
+  );
   return [
     {
       name: "jsse/markdown/setup",
@@ -10967,10 +11613,26 @@ var markdown = async (options) => {
         markdown: pluginMarkdown
       }
     },
+    // {
+    //   files: [GLOB_MARKDOWN],
+    //   name: "jsse/markdown/processor",
+    //   processor: "markdown/markdown",
+    // },
     {
-      files: [GLOB_MARKDOWN],
+      files,
+      ignores: [GLOB_MARKDOWN_IN_MARKDOWN],
       name: "jsse/markdown/processor",
-      processor: "markdown/markdown"
+      // `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
+    },
+    {
+      files,
+      languageOptions: {
+        parser: parserPlain
+      },
+      name: "jsse/markdown/parser"
     },
     {
       files: [
@@ -11009,22 +11671,38 @@ var markdown = async (options) => {
         "@typescript-eslint/restrict-plus-operands": "off",
         "@typescript-eslint/restrict-template-expressions": "off",
         "@typescript-eslint/unbound-method": "off",
+        "n/prefer-global/buffer": "off",
+        "n/prefer-global/process": "off",
         "no-alert": "off",
         "no-console": "off",
         "no-undef": "off",
         "no-unused-expressions": "off",
         "no-unused-vars": "off",
-        "node/prefer-global/process": "off",
-        // Type aware rules
         "object-curly-newline": "off",
         "style/comma-dangle": "off",
         "style/eol-last": "off",
         "unicode-bom": "off",
         "unused-imports/no-unused-imports": "off",
         "unused-imports/no-unused-vars": "off",
+        // Type aware rules
         ...tsRulesOff,
         ...overrides
       }
+    },
+    {
+      files: ["**/README.md", "**/README.md/**"],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            impliedStrict: true
+          }
+        }
+      },
+      name: "jsse/markdown/rules/readme",
+      rules: {
+        "unicorn/filename-case": "off",
+        "unicorn/no-null": "off"
+      }
     }
   ];
 };
@@ -11853,25 +12531,33 @@ function tailwindSettings(options) {
   return { ...TAILWIND_ESLINT_SETTINGS_DEFAULT, ...options };
 }
 var tailwind = async (options) => {
-  const { pluginTailwind } = await importPluginTailwind();
-  return [
-    {
-      files: [GLOB_SRC],
-      name: "jsse/tailwind/rules",
-      plugins: {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        tailwindcss: pluginTailwind
-      },
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      rules: {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        ...pluginTailwind.configs.recommended.rules
-      },
-      settings: {
-        tailwindcss: tailwindSettings(options)
-      }
+  const importResult = await safeImportPluginTailwind();
+  return importResult.match(
+    ({ pluginTailwind }) => {
+      return [
+        {
+          files: [GLOB_SRC],
+          name: "jsse/tailwind/rules",
+          plugins: {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            tailwindcss: pluginTailwind
+          },
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          rules: {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            ...pluginTailwind.configs.recommended.rules
+          },
+          settings: {
+            tailwindcss: tailwindSettings(options)
+          }
+        }
+      ];
+    },
+    (error) => {
+      log.error(error.message);
+      return [];
     }
-  ];
+  );
 };
 
 // src/configs/ts/parser.ts
@@ -11983,9 +12669,9 @@ var typescript = async (options) => {
   const tsPrefixTo = prefix?.to ?? "@typescript-eslint";
   const tsRules = {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    ...(default2.configs["eslint-recommended"]?.overrides ?? [])[0]?.rules,
+    ...(default3.configs["eslint-recommended"]?.overrides ?? [])[0]?.rules,
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    ...default2.configs.strict?.rules,
+    ...default3.configs.strict?.rules,
     "no-invalid-this": "off",
     ...typescriptRules({
       typeAware: false
@@ -11998,7 +12684,7 @@ var typescript = async (options) => {
       name: "jsse/typescript/setup",
       plugins: {
         import: pluginImport,
-        [tsPrefixTo]: default2
+        [tsPrefixTo]: default3
       }
     },
     ...parserConfigs,
@@ -12270,87 +12956,7 @@ var yml = async (options) => {
   ];
 };
 
-// src/lager.ts
-var levels = {
-  trace: 10,
-  debug: 20,
-  info: 30,
-  warn: 40,
-  error: 50,
-  fatal: 60
-};
-function isLagerLevel(level) {
-  return level === "trace" || level === "debug" || level === "info" || level === "warn" || level === "error" || level === "fatal";
-}
-var Lager = class {
-  _level = "info";
-  id = "lager";
-  levelNo = levels[this._level];
-  prefix = "";
-  constructor(options) {
-    const { level, id, prefix } = {
-      level: "info",
-      id: "lager",
-      prefix: "@jsse/eslint-config",
-      ...options
-    };
-    this.id = id;
-    this._level = isLagerLevel(level) ? level : "info";
-    this.levelNo = levels[this._level];
-    this.prefix = prefix;
-    this.log = this.log.bind(this);
-    this.debug = this.debug.bind(this);
-  }
-  get level() {
-    return this._level;
-  }
-  set level(level) {
-    this._level = level;
-    this.levelNo = levels[level];
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  log(...args) {
-    console.log(...args);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  trace(...args) {
-    if (this.levelNo > levels.trace) {
-      return;
-    }
-    console.trace(...args);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  debug(...args) {
-    if (this.levelNo > levels.debug) {
-      return;
-    }
-    console.debug(...args);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  info(...args) {
-    if (this.levelNo > levels.info) {
-      return;
-    }
-    console.info("[@jsse/eslint-config]", ...args);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  warn(...args) {
-    if (this.levelNo > levels.warn) {
-      return;
-    }
-    console.warn(...args);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  error(...args) {
-    if (this.levelNo > levels.error) {
-      return;
-    }
-    console.error(...args);
-  }
-};
-var log = new Lager();
-
-// src/factory.ts
+// src/define-config.ts
 var flatConfigProps = [
   "files",
   "ignores",
@@ -12361,7 +12967,9 @@ var flatConfigProps = [
   "rules",
   "settings"
 ];
-var DEBUG = !!(process6.env.DEBUG?.toLowerCase() === "true" || process6.env.DEBUG === "1");
+var DEBUG = ["1", "true", "t", "on", "yes", "y"].includes(
+  process6.env.DEBUG ?? ""
+);
 function defaultOptions2() {
   return {
     componentExts: [],
@@ -12552,37 +13160,14 @@ async function jsse(options = {}, ...userConfigs) {
   }
   const combinedConfigs = await combineAsync(...configs, ...userConfigs);
   if (off && off.length > 0) {
-    log.debug("Turning off rules", off);
-    const currentlyActiveRules = /* @__PURE__ */ new Set();
-    for (const config of combinedConfigs) {
-      for (const rule of Object.keys(config.rules ?? {}))
-        currentlyActiveRules.add(rule);
-    }
-    for (const rule of off) {
-      if (!currentlyActiveRules.has(rule)) {
-        log.info(
-          `Rule \`${rule}\` is not active in the current config, you can remove it from the off list`
-        );
-      }
-    }
-    for (const config of combinedConfigs) {
-      for (const cfgRules of [config.rules, config.plugins]) {
-        if (cfgRules) {
-          for (const rule of off) {
-            if (cfgRules[rule] !== void 0 && cfgRules[rule] !== "off" && cfgRules[rule] !== 0) {
-              cfgRules[rule] = "off";
-            }
-          }
-        }
-      }
-    }
+    turnOffRules(combinedConfigs, off);
   }
   if (normalizedOptions.rootId !== "jsse") {
     for (const config of combinedConfigs) {
       if (config.name && config.name.startsWith("jsse/")) {
         config.name = config.name.replace(
           "jsse/",
-          `${normalizedOptions.rootId}:`
+          `${normalizedOptions.rootId}/`
         );
       }
     }
@@ -12622,23 +13207,25 @@ async function jsse(options = {}, ...userConfigs) {
   }
   return combinedConfigs;
 }
+async function defineConfig(options = {}, ...userConfigs) {
+  return jsse(options, ...userConfigs);
+}
 
 // src/presets.ts
-function jssestd() {
-  return jsse({
-    typescript: {
-      tsconfig: ["./tsconfig.json", "./tsconfig.eslint.json"]
-    }
-  });
-}
-function jsseReact() {
-  return jsse({
-    react: true,
-    typescript: {
-      tsconfig: ["./tsconfig.json", "./tsconfig.eslint.json"]
-    }
-  });
-}
+var jsseReact = (options, ...configs) => {
+  return jsse(
+    {
+      react: true,
+      reactRefresh: true,
+      tailwind: true,
+      typescript: {
+        tsconfig: ["./tsconfig.json", "./tsconfig.eslint.json"]
+      },
+      ...options
+    },
+    ...configs
+  );
+};
 export {
   GLOB_ALL_SRC,
   GLOB_CSS,
@@ -12654,6 +13241,7 @@ export {
   GLOB_LESS,
   GLOB_MARKDOWN,
   GLOB_MARKDOWN_CODE,
+  GLOB_MARKDOWN_IN_MARKDOWN,
   GLOB_SCSS,
   GLOB_SRC,
   GLOB_SRC_EXT,
@@ -12665,9 +13253,12 @@ export {
   GLOB_TSX,
   GLOB_YAML,
   SLOW_RULES,
+  changeRuleEntrySeverity,
   combine,
   combineAsync,
   jsse as default,
+  defineConfig,
+  error2warn,
   importJsoncLibs,
   importParserJsonc,
   importPluginJsdoc,
@@ -12686,16 +13277,19 @@ export {
   isInEditor,
   jsse,
   jsseReact,
-  jssestd,
+  parserPlain,
   parserTs,
-  default3 as pluginAntfu,
-  default4 as pluginEslintComments,
+  default4 as pluginAntfu,
+  default2 as pluginEslintComments,
   pluginImport,
   default5 as pluginN,
   default6 as pluginPerfectionist,
-  default2 as pluginTs,
+  default3 as pluginTs,
   default7 as pluginUnicorn,
   default8 as pluginUnusedImports,
   renameRules,
-  uniqueStrings
+  safeImportPluginTailwind,
+  turnOffRules,
+  uniqueStrings,
+  warn2error
 };