@jsse/eslint-config 0.2.18 → 0.2.20

package/dist/index.js

@@ -24,9 +24,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/.pnpm/globals@15.9.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.9.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,
@@ -99,6 +99,7 @@ var require_globals = __commonJS({
         BackgroundFetchManager: false,
         BackgroundFetchRecord: false,
         BackgroundFetchRegistration: false,
+        BarcodeDetector: false,
         BarProp: false,
         BaseAudioContext: false,
         BatteryManager: false,
@@ -702,6 +703,8 @@ var require_globals = __commonJS({
         onresize: true,
         onscroll: true,
         onscrollend: true,
+        onscrollsnapchange: true,
+        onscrollsnapchanging: true,
         onsearch: true,
         onsecuritypolicyviolation: true,
         onseeked: true,
@@ -893,6 +896,7 @@ var require_globals = __commonJS({
         showDirectoryPicker: false,
         showOpenFilePicker: false,
         showSaveFilePicker: false,
+        SnapEvent: false,
         SourceBuffer: false,
         SourceBufferList: false,
         speechSynthesis: false,
@@ -1950,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,
@@ -2660,6 +2696,7 @@ var require_globals = __commonJS({
         BackgroundFetchManager: false,
         BackgroundFetchRecord: false,
         BackgroundFetchRegistration: false,
+        BarcodeDetector: false,
         Blob: false,
         BroadcastChannel: false,
         btoa: false,
@@ -2963,9 +3000,9 @@ var require_globals = __commonJS({
   }
 });
 
-// node_modules/.pnpm/globals@15.9.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.9.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();
   }
@@ -6092,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() {
@@ -8166,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;
@@ -8409,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 = /^\.?\//;
@@ -8466,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";
@@ -9781,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
         );
@@ -9859,6 +9896,7 @@ 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)";
@@ -9916,8 +9954,505 @@ var GLOB_EXCLUDE = [
   "**/yarn.lock"
 ];
 
+// 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 new (P || (P = Promise))(function(resolve2, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    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 __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);
+  }
+}
+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 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/utils.ts
 import process3 from "node:process";
+
+// 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/utils.ts
 async function combine(...configs) {
   const resolved = await Promise.all(configs);
   return resolved.flat();
@@ -9964,6 +10499,57 @@ function uniqueStrings(...strings) {
   }
   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) {
+      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";
+            }
+          }
+        }
+      }
+    }
+  }
+  return configs;
+}
 
 // src/plugins.ts
 import { default as default2 } from "@typescript-eslint/eslint-plugin";
@@ -9983,6 +10569,7 @@ async function importPluginReact() {
 }
 async function importPluginReactHooks() {
   const pluginReactHooks = await interopDefault2(
+    // @ts-expect-error - bad types
     import("eslint-plugin-react-hooks")
   );
   return {
@@ -9991,6 +10578,7 @@ async function importPluginReactHooks() {
 }
 async function importPluginReactRefresh() {
   const pluginReactRefresh = await interopDefault2(
+    // @ts-expect-error - bad types
     import("eslint-plugin-react-refresh")
   );
   return {
@@ -10001,7 +10589,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"))
     ]
   );
@@ -10034,7 +10624,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
   };
@@ -10059,10 +10649,23 @@ 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 () => {
@@ -10525,6 +11128,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 {
@@ -10946,6 +11552,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
@@ -10954,6 +11561,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",
@@ -10962,10 +11576,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: [
@@ -11004,22 +11634,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"
+      }
     }
   ];
 };
@@ -11515,6 +12161,7 @@ var react = async (options) => {
       rules: {
         ...reactRecomendedRules(),
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        // @ts-expect-error index access
         ...pluginReact.configs["jsx-runtime"].rules,
         ...reactRules()
       },
@@ -11537,6 +12184,14 @@ var react = async (options) => {
           version: "detect"
         }
       }
+    },
+    {
+      files: [GLOB_JSX, GLOB_TSX],
+      name: "jsse/react/disables",
+      rules: {
+        "unicorn/no-null": "off"
+        // null is bueno in react
+      }
     }
   ];
   if (reactRefresh) {
@@ -11839,25 +12494,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
@@ -12256,86 +12919,6 @@ 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
 var flatConfigProps = [
   "files",
@@ -12347,7 +12930,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: [],
@@ -12538,37 +13123,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}/`
         );
       }
     }
@@ -12640,6 +13202,7 @@ export {
   GLOB_LESS,
   GLOB_MARKDOWN,
   GLOB_MARKDOWN_CODE,
+  GLOB_MARKDOWN_IN_MARKDOWN,
   GLOB_SCSS,
   GLOB_SRC,
   GLOB_SRC_EXT,
@@ -12673,6 +13236,7 @@ export {
   jsse,
   jsseReact,
   jssestd,
+  parserPlain,
   parserTs,
   default3 as pluginAntfu,
   default4 as pluginEslintComments,
@@ -12683,5 +13247,7 @@ export {
   default7 as pluginUnicorn,
   default8 as pluginUnusedImports,
   renameRules,
+  safeImportPluginTailwind,
+  turnOffRules,
   uniqueStrings
 };