@icebreakers/eslint-config 1.0.4 → 1.1.1

package/dist/lib-XEKWCYO4.js

@@ -0,0 +1,1234 @@
+import {
+  __dirname,
+  __export,
+  __require
+} from "./chunk-Q36VO4VV.js";
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/index.js
+var lib_exports2 = {};
+__export(lib_exports2, {
+  DEFAULT_LANGUAGE_MAPPER: () => DEFAULT_LANGUAGE_MAPPER,
+  base: () => base,
+  cjsRequire: () => cjsRequire3,
+  codeBlocks: () => codeBlocks,
+  configs: () => configs,
+  createRemarkProcessor: () => createRemarkProcessor,
+  flat: () => flat,
+  flatCodeBlocks: () => flatCodeBlocks,
+  getGlobals: () => getGlobals,
+  getShortLang: () => getShortLang,
+  meta: () => meta2,
+  overrides: () => overrides,
+  processorOptions: () => processorOptions,
+  processors: () => processors,
+  recommended: () => recommended,
+  remark: () => remark2,
+  rules: () => rules
+});
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/configs/base.js
+var base = {
+  parser: "eslint-mdx",
+  parserOptions: {
+    sourceType: "module",
+    ecmaVersion: "latest"
+  },
+  plugins: ["mdx"],
+  processor: "mdx/remark",
+  rules: {
+    "mdx/remark": "warn",
+    "no-unused-expressions": "error"
+  }
+};
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/configs/code-blocks.js
+var codeBlocks = {
+  parserOptions: {
+    ecmaFeatures: {
+      impliedStrict: true
+    }
+  },
+  rules: {
+    "eol-last": "off",
+    "no-undef": "off",
+    "no-unused-expressions": "off",
+    "no-unused-vars": "off",
+    "@typescript-eslint/no-unused-vars": "off",
+    "padded-blocks": "off",
+    strict: "off",
+    "unicode-bom": "off"
+  }
+};
+
+// ../../node_modules/.pnpm/eslint-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-mdx/lib/index.js
+var lib_exports = {};
+__export(lib_exports, {
+  DEFAULT_EXTENSIONS: () => DEFAULT_EXTENSIONS,
+  MARKDOWN_EXTENSIONS: () => MARKDOWN_EXTENSIONS,
+  Parser: () => Parser,
+  arrayify: () => arrayify,
+  cjsRequire: () => cjsRequire,
+  getPhysicalFilename: () => getPhysicalFilename,
+  getPositionAtFactory: () => getPositionAtFactory,
+  meta: () => meta,
+  nextCharOffsetFactory: () => nextCharOffsetFactory,
+  normalizePosition: () => normalizePosition,
+  parse: () => parse,
+  parseForESLint: () => parseForESLint,
+  parser: () => parser,
+  performSyncWork: () => performSyncWork,
+  prevCharOffsetFactory: () => prevCharOffsetFactory
+});
+
+// ../../node_modules/.pnpm/eslint-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-mdx/lib/helpers.js
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+var arrayify = (...args) => args.reduce((arr, curr) => {
+  arr.push(...Array.isArray(curr) ? curr : curr == null ? [] : [curr]);
+  return arr;
+}, []);
+var getPhysicalFilename = (filename, child) => {
+  try {
+    if (fs.statSync(filename).isDirectory()) {
+      return child || filename;
+    }
+  } catch (err) {
+    const { code } = err;
+    if (code === "ENOTDIR" || code === "ENOENT") {
+      return getPhysicalFilename(path.dirname(filename), filename);
+    }
+  }
+  return filename;
+};
+var getPositionAtFactory = (code) => {
+  const lines = code.split("\n");
+  return (offset) => {
+    let currOffset = 0;
+    for (const [index, line_] of lines.entries()) {
+      const line = index + 1;
+      const nextOffset = currOffset + line_.length;
+      if (nextOffset >= offset) {
+        return {
+          line,
+          column: offset - currOffset
+        };
+      }
+      currOffset = nextOffset + 1;
+    }
+  };
+};
+var normalizePosition = ({ start, end, code }) => {
+  const startOffset = start.offset;
+  const endOffset = end.offset;
+  const range = [startOffset, endOffset];
+  const getPositionAt = code == null ? null : getPositionAtFactory(code);
+  return {
+    start: startOffset,
+    end: endOffset,
+    loc: {
+      start: "line" in start ? start : getPositionAt(startOffset),
+      end: "line" in end ? end : getPositionAt(endOffset)
+    },
+    range
+  };
+};
+var prevCharOffsetFactory = (code) => (offset) => {
+  for (let i = offset; i >= 0; i--) {
+    const char = code[i];
+    if (/^\S$/.test(char)) {
+      return i;
+    }
+  }
+};
+var nextCharOffsetFactory = (text) => {
+  const total = text.length;
+  return (offset) => {
+    for (let i = offset; i <= total; i++) {
+      const char = text[i];
+      if (/^\S$/.test(char)) {
+        return i;
+      }
+    }
+  };
+};
+var cjsRequire = typeof __require === "undefined" ? createRequire(import.meta.url) : __require;
+
+// ../../node_modules/.pnpm/eslint-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-mdx/lib/meta.js
+var pkg = cjsRequire("../package.json");
+var meta = { name: pkg.name, version: pkg.version };
+
+// ../../node_modules/.pnpm/eslint-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-mdx/lib/parser.js
+import path5 from "node:path";
+
+// ../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
+function __rest(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+}
+
+// ../../node_modules/.pnpm/synckit@0.11.3/node_modules/synckit/lib/index.js
+import path4 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// ../../node_modules/.pnpm/synckit@0.11.3/node_modules/synckit/lib/common.js
+var _a;
+var NODE_OPTIONS = (_a = process.env.NODE_OPTIONS) === null || _a === void 0 ? void 0 : _a.split(/\s+/);
+var hasFlag = (flag) => (NODE_OPTIONS === null || NODE_OPTIONS === void 0 ? void 0 : NODE_OPTIONS.includes(flag)) || process.argv.includes(flag);
+var parseVersion = (version) => version.split(".").map(Number.parseFloat);
+var compareVersion = (version1, version2) => {
+  const versions1 = parseVersion(version1);
+  const versions2 = parseVersion(version2);
+  const length = Math.max(versions1.length, versions2.length);
+  for (let i = 0; i < length; i++) {
+    const v1 = versions1[i] || 0;
+    const v2 = versions2[i] || 0;
+    if (v1 > v2) {
+      return 1;
+    }
+    if (v1 < v2) {
+      return -1;
+    }
+  }
+  return 0;
+};
+var NODE_VERSION = process.versions.node;
+var compareNodeVersion = (version) => compareVersion(NODE_VERSION, version);
+
+// ../../node_modules/.pnpm/synckit@0.11.3/node_modules/synckit/lib/constants.js
+var TsRunner = {
+  Node: "node",
+  Bun: "bun",
+  TsNode: "ts-node",
+  EsbuildRegister: "esbuild-register",
+  EsbuildRunner: "esbuild-runner",
+  OXC: "oxc",
+  SWC: "swc",
+  TSX: "tsx"
+};
+var { NODE_OPTIONS: NODE_OPTIONS_ = "", SYNCKIT_EXEC_ARGV = "", SYNCKIT_GLOBAL_SHIMS, SYNCKIT_TIMEOUT, SYNCKIT_TS_RUNNER } = process.env;
+var TS_ESM_PARTIAL_SUPPORTED = compareNodeVersion("16") >= 0 && compareNodeVersion("18.19") < 0;
+var MTS_SUPPORTED = compareNodeVersion("20.8") >= 0;
+var MODULE_REGISTER_SUPPORTED = MTS_SUPPORTED || compareNodeVersion("18.19") >= 0;
+var STRIP_TYPES_NODE_VERSION = "22.6";
+var TRANSFORM_TYPES_NODE_VERSION = "22.7";
+var FEATURE_TYPESCRIPT_NODE_VERSION = "22.10";
+var DEFAULT_TYPES_NODE_VERSION = "23.6";
+var STRIP_TYPES_FLAG = "--experimental-strip-types";
+var TRANSFORM_TYPES_FLAG = "--experimental-transform-types";
+var NO_STRIP_TYPES_FLAG = "--no-experimental-strip-types";
+var NODE_OPTIONS2 = NODE_OPTIONS_.split(/\s+/);
+var NO_STRIP_TYPES = hasFlag(NO_STRIP_TYPES_FLAG) && (compareNodeVersion(FEATURE_TYPESCRIPT_NODE_VERSION) >= 0 ? process.features.typescript === false : !hasFlag(STRIP_TYPES_FLAG) && !hasFlag(TRANSFORM_TYPES_FLAG));
+var DEFAULT_TIMEOUT = SYNCKIT_TIMEOUT ? +SYNCKIT_TIMEOUT : void 0;
+var DEFAULT_EXEC_ARGV = SYNCKIT_EXEC_ARGV.split(",");
+var DEFAULT_TS_RUNNER = SYNCKIT_TS_RUNNER;
+var DEFAULT_GLOBAL_SHIMS = ["1", "true"].includes(SYNCKIT_GLOBAL_SHIMS);
+var DEFAULT_GLOBAL_SHIMS_PRESET = [
+  {
+    moduleName: "node-fetch",
+    globalName: "fetch"
+  },
+  {
+    moduleName: "node:perf_hooks",
+    globalName: "performance",
+    named: "performance"
+  }
+];
+var IMPORT_FLAG = "--import";
+var REQUIRE_FLAG = "--require";
+var REQUIRE_ABBR_FLAG = "-r";
+var REQUIRE_FLAGS = /* @__PURE__ */ new Set([REQUIRE_FLAG, REQUIRE_ABBR_FLAG]);
+var LOADER_FLAG = "--loader";
+var EXPERIMENTAL_LOADER_FLAG = "--experimental-loader";
+var LOADER_FLAGS = /* @__PURE__ */ new Set([LOADER_FLAG, EXPERIMENTAL_LOADER_FLAG]);
+var IMPORT_FLAG_SUPPORTED = compareNodeVersion("20.6") >= 0;
+var INT32_BYTES = 4;
+
+// ../../node_modules/.pnpm/synckit@0.11.3/node_modules/synckit/lib/helpers.js
+import { createHash } from "node:crypto";
+import fs3 from "node:fs";
+import path3 from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { MessageChannel, Worker, receiveMessageOnPort } from "node:worker_threads";
+
+// ../../node_modules/.pnpm/@pkgr+core@0.2.2/node_modules/@pkgr/core/lib/constants.js
+import { createRequire as createRequire2 } from "node:module";
+var CWD = process.cwd();
+var cjsRequire2 = typeof __require === "undefined" ? createRequire2(import.meta.url) : __require;
+var EXTENSIONS = [".ts", ".tsx", ...Object.keys(cjsRequire2.extensions)];
+
+// ../../node_modules/.pnpm/@pkgr+core@0.2.2/node_modules/@pkgr/core/lib/helpers.js
+import fs2 from "node:fs";
+import path2 from "node:path";
+var tryPkg = (pkg3) => {
+  try {
+    return cjsRequire2.resolve(pkg3);
+  } catch {
+  }
+};
+var isPkgAvailable = (pkg3) => !!tryPkg(pkg3);
+var tryFile = (filename, includeDir = false, base2 = CWD) => {
+  if (typeof filename === "string") {
+    const filepath = path2.resolve(base2, filename);
+    return fs2.existsSync(filepath) && (includeDir || fs2.statSync(filepath).isFile()) ? filepath : "";
+  }
+  for (const file of filename ?? []) {
+    const filepath = tryFile(file, includeDir, base2);
+    if (filepath) {
+      return filepath;
+    }
+  }
+  return "";
+};
+var tryExtensions = (filepath, extensions = EXTENSIONS) => {
+  const ext = [...extensions, ""].find((ext2) => tryFile(filepath + ext2));
+  return ext == null ? "" : filepath + ext;
+};
+var findUp = (searchEntry, searchFileOrIncludeDir, includeDir) => {
+  console.assert(path2.isAbsolute(searchEntry));
+  if (!tryFile(searchEntry, true) || searchEntry !== CWD && !searchEntry.startsWith(CWD + path2.sep)) {
+    return "";
+  }
+  searchEntry = path2.resolve(fs2.statSync(searchEntry).isDirectory() ? searchEntry : path2.resolve(searchEntry, ".."));
+  const isSearchFile = typeof searchFileOrIncludeDir === "string";
+  const searchFile = isSearchFile ? searchFileOrIncludeDir : "package.json";
+  do {
+    const searched = tryFile(path2.resolve(searchEntry, searchFile), isSearchFile && includeDir);
+    if (searched) {
+      return searched;
+    }
+    searchEntry = path2.resolve(searchEntry, "..");
+  } while (searchEntry === CWD || searchEntry.startsWith(CWD + path2.sep));
+  return "";
+};
+
+// ../../node_modules/.pnpm/synckit@0.11.3/node_modules/synckit/lib/helpers.js
+var isFile = (path7) => {
+  var _a2;
+  try {
+    return !!((_a2 = fs3.statSync(path7, { throwIfNoEntry: false })) === null || _a2 === void 0 ? void 0 : _a2.isFile());
+  } catch (_b) {
+    return false;
+  }
+};
+var dataUrl = (code) => new URL(`data:text/javascript,${encodeURIComponent(code)}`);
+var hasRequireFlag = (execArgv) => execArgv.some((execArg) => REQUIRE_FLAGS.has(execArg));
+var hasImportFlag = (execArgv) => execArgv.includes(IMPORT_FLAG);
+var hasLoaderFlag = (execArgv) => execArgv.some((execArg) => LOADER_FLAGS.has(execArg));
+var setupTsRunner = (workerPath, { execArgv = DEFAULT_EXEC_ARGV, tsRunner } = {}) => {
+  let ext = path3.extname(workerPath);
+  if (!/([/\\])node_modules\1/.test(workerPath) && (!ext || /^\.[cm]?js$/.test(ext))) {
+    const workPathWithoutExt = ext ? workerPath.slice(0, -ext.length) : workerPath;
+    let extensions;
+    switch (ext) {
+      case ".cjs": {
+        extensions = [".cts", ".cjs"];
+        break;
+      }
+      case ".mjs": {
+        extensions = [".mts", ".mjs"];
+        break;
+      }
+      default: {
+        extensions = [".ts", ".js"];
+        break;
+      }
+    }
+    const found = tryExtensions(workPathWithoutExt, extensions);
+    let differentExt;
+    if (found && (!ext || (differentExt = found !== workPathWithoutExt))) {
+      workerPath = found;
+      if (differentExt) {
+        ext = path3.extname(workerPath);
+      }
+    }
+  }
+  const isTs = /\.[cm]?ts$/.test(workerPath);
+  let jsUseEsm = ext === ".mjs";
+  let tsUseEsm = ext === ".mts";
+  if (isTs) {
+    if (!tsUseEsm && ext !== ".cts") {
+      const pkg3 = findUp(workerPath);
+      if (pkg3) {
+        tsUseEsm = cjsRequire2(pkg3).type === "module";
+      }
+    }
+    const stripTypesIndex = execArgv.indexOf(STRIP_TYPES_FLAG);
+    const transformTypesIndex = execArgv.indexOf(TRANSFORM_TYPES_FLAG);
+    const noStripTypesIndex = execArgv.indexOf(NO_STRIP_TYPES_FLAG);
+    const execArgvNoStripTypes = noStripTypesIndex > stripTypesIndex || noStripTypesIndex > transformTypesIndex;
+    const noStripTypes = execArgvNoStripTypes || stripTypesIndex === -1 && transformTypesIndex === -1 && NO_STRIP_TYPES;
+    if (tsRunner == null) {
+      if (process.versions.bun) {
+        tsRunner = TsRunner.Bun;
+      } else if (!noStripTypes && compareNodeVersion(STRIP_TYPES_NODE_VERSION) >= 0) {
+        tsRunner = TsRunner.Node;
+      } else if (isPkgAvailable(TsRunner.TsNode)) {
+        tsRunner = TsRunner.TsNode;
+      }
+    }
+    switch (tsRunner) {
+      case TsRunner.Bun: {
+        break;
+      }
+      case TsRunner.Node: {
+        if (compareNodeVersion(STRIP_TYPES_NODE_VERSION) < 0) {
+          throw new Error("type stripping is not supported in this node version");
+        }
+        if (noStripTypes) {
+          throw new Error("type stripping is disabled explicitly");
+        }
+        if (compareNodeVersion(DEFAULT_TYPES_NODE_VERSION) >= 0) {
+          break;
+        }
+        if (compareNodeVersion(TRANSFORM_TYPES_NODE_VERSION) >= 0 && !execArgv.includes(TRANSFORM_TYPES_FLAG)) {
+          execArgv = [TRANSFORM_TYPES_FLAG, ...execArgv];
+        } else if (compareNodeVersion(STRIP_TYPES_NODE_VERSION) >= 0 && !execArgv.includes(STRIP_TYPES_FLAG)) {
+          execArgv = [STRIP_TYPES_FLAG, ...execArgv];
+        }
+        break;
+      }
+      case TsRunner.TsNode: {
+        if (tsUseEsm) {
+          if (!execArgv.includes(LOADER_FLAG)) {
+            execArgv = [LOADER_FLAG, `${TsRunner.TsNode}/esm`, ...execArgv];
+          }
+        } else if (!hasRequireFlag(execArgv)) {
+          execArgv = [
+            REQUIRE_ABBR_FLAG,
+            `${TsRunner.TsNode}/register`,
+            ...execArgv
+          ];
+        }
+        break;
+      }
+      case TsRunner.EsbuildRegister: {
+        if (tsUseEsm) {
+          if (!hasLoaderFlag(execArgv)) {
+            execArgv = [
+              LOADER_FLAG,
+              `${TsRunner.EsbuildRegister}/loader`,
+              ...execArgv
+            ];
+          }
+        } else if (!hasRequireFlag(execArgv)) {
+          execArgv = [REQUIRE_ABBR_FLAG, TsRunner.EsbuildRegister, ...execArgv];
+        }
+        break;
+      }
+      case TsRunner.EsbuildRunner: {
+        if (!hasRequireFlag(execArgv)) {
+          execArgv = [
+            REQUIRE_ABBR_FLAG,
+            `${TsRunner.EsbuildRunner}/register`,
+            ...execArgv
+          ];
+        }
+        break;
+      }
+      case TsRunner.OXC: {
+        if (!execArgv.includes(IMPORT_FLAG)) {
+          execArgv = [
+            IMPORT_FLAG,
+            `@${TsRunner.OXC}-node/core/register`,
+            ...execArgv
+          ];
+        }
+        break;
+      }
+      case TsRunner.SWC: {
+        if (tsUseEsm) {
+          if (IMPORT_FLAG_SUPPORTED) {
+            if (!hasImportFlag(execArgv)) {
+              execArgv = [
+                IMPORT_FLAG,
+                `@${TsRunner.SWC}-node/register/esm-register`,
+                ...execArgv
+              ];
+            }
+          } else if (!hasLoaderFlag(execArgv)) {
+            execArgv = [
+              LOADER_FLAG,
+              `@${TsRunner.SWC}-node/register/esm`,
+              ...execArgv
+            ];
+          }
+        } else if (!hasRequireFlag(execArgv)) {
+          execArgv = [
+            REQUIRE_ABBR_FLAG,
+            `@${TsRunner.SWC}-node/register`,
+            ...execArgv
+          ];
+        }
+        break;
+      }
+      case TsRunner.TSX: {
+        if (IMPORT_FLAG_SUPPORTED) {
+          if (!execArgv.includes(IMPORT_FLAG)) {
+            execArgv = [IMPORT_FLAG, TsRunner.TSX, ...execArgv];
+          }
+        } else if (!execArgv.includes(LOADER_FLAG)) {
+          execArgv = [LOADER_FLAG, TsRunner.TSX, ...execArgv];
+        }
+        break;
+      }
+      default: {
+        throw new Error(`Unknown ts runner: ${String(tsRunner)}`);
+      }
+    }
+  } else if (!jsUseEsm && ext !== ".cjs") {
+    const pkg3 = findUp(workerPath);
+    if (pkg3) {
+      jsUseEsm = cjsRequire2(pkg3).type === "module";
+    }
+  }
+  let resolvedPnpLoaderPath;
+  if (process.versions.pnp) {
+    let pnpApiPath;
+    try {
+      pnpApiPath = cjsRequire2.resolve("pnpapi");
+    } catch (_a2) {
+    }
+    if (pnpApiPath && !NODE_OPTIONS2.some((option, index) => REQUIRE_FLAGS.has(option) && pnpApiPath === cjsRequire2.resolve(NODE_OPTIONS2[index + 1])) && !execArgv.includes(pnpApiPath)) {
+      execArgv = [REQUIRE_ABBR_FLAG, pnpApiPath, ...execArgv];
+      const pnpLoaderPath = path3.resolve(pnpApiPath, "../.pnp.loader.mjs");
+      if (isFile(pnpLoaderPath)) {
+        resolvedPnpLoaderPath = pathToFileURL(pnpLoaderPath).href;
+        if (!MODULE_REGISTER_SUPPORTED) {
+          execArgv = [LOADER_FLAG, resolvedPnpLoaderPath, ...execArgv];
+        }
+      }
+    }
+  }
+  return {
+    ext,
+    isTs,
+    jsUseEsm,
+    tsRunner,
+    tsUseEsm,
+    workerPath,
+    pnpLoaderPath: resolvedPnpLoaderPath,
+    execArgv
+  };
+};
+var md5Hash = (text) => createHash("md5").update(text).digest("hex");
+var encodeImportModule = (moduleNameOrGlobalShim, type = "import") => {
+  const { moduleName, globalName, named, conditional } = typeof moduleNameOrGlobalShim === "string" ? { moduleName: moduleNameOrGlobalShim } : moduleNameOrGlobalShim;
+  const importStatement = type === "import" ? `import${globalName ? " " + (named === null ? "* as " + globalName : (named === null || named === void 0 ? void 0 : named.trim()) ? `{${named}}` : globalName) + " from" : ""} '${path3.isAbsolute(moduleName) ? String(pathToFileURL(moduleName)) : moduleName}'` : `${globalName ? "const " + ((named === null || named === void 0 ? void 0 : named.trim()) ? `{${named}}` : globalName) + "=" : ""}require('${moduleName.replace(/\\/g, "\\\\")}')`;
+  if (!globalName) {
+    return importStatement;
+  }
+  const overrideStatement = `globalThis.${globalName}=${(named === null || named === void 0 ? void 0 : named.trim()) ? named : globalName}`;
+  return importStatement + (conditional === false ? `;${overrideStatement}` : `;if(!globalThis.${globalName})${overrideStatement}`);
+};
+var _generateGlobals = (globalShims, type) => globalShims.reduce((acc, shim) => `${acc}${acc ? ";" : ""}${encodeImportModule(shim, type)}`, "");
+var globalsCache;
+var tmpdir;
+var _dirname = typeof __dirname === "undefined" ? path3.dirname(fileURLToPath(import.meta.url)) : __dirname;
+var generateGlobals = (workerPath, globalShims, type = "import") => {
+  if (globalShims.length === 0) {
+    return "";
+  }
+  globalsCache !== null && globalsCache !== void 0 ? globalsCache : globalsCache = /* @__PURE__ */ new Map();
+  const cached = globalsCache.get(workerPath);
+  if (cached) {
+    const [content2, filepath2] = cached;
+    if (type === "require" && !filepath2 || type === "import" && filepath2 && isFile(filepath2)) {
+      return content2;
+    }
+  }
+  const globals = _generateGlobals(globalShims, type);
+  let content = globals;
+  let filepath;
+  if (type === "import") {
+    if (!tmpdir) {
+      tmpdir = path3.resolve(findUp(_dirname), "../node_modules/.synckit");
+    }
+    fs3.mkdirSync(tmpdir, { recursive: true });
+    filepath = path3.resolve(tmpdir, md5Hash(workerPath) + ".mjs");
+    content = encodeImportModule(filepath);
+    fs3.writeFileSync(filepath, globals);
+  }
+  globalsCache.set(workerPath, [content, filepath]);
+  return content;
+};
+var sharedBuffer;
+var sharedBufferView;
+function startWorkerThread(workerPath, { timeout = DEFAULT_TIMEOUT, execArgv = DEFAULT_EXEC_ARGV, tsRunner = DEFAULT_TS_RUNNER, transferList = [], globalShims = DEFAULT_GLOBAL_SHIMS } = {}) {
+  const { port1: mainPort, port2: workerPort } = new MessageChannel();
+  const { isTs, ext, jsUseEsm, tsUseEsm, tsRunner: finalTsRunner, workerPath: finalWorkerPath, pnpLoaderPath, execArgv: finalExecArgv } = setupTsRunner(workerPath, { execArgv, tsRunner });
+  const workerPathUrl = pathToFileURL(finalWorkerPath);
+  if (/\.[cm]ts$/.test(finalWorkerPath)) {
+    const isTsxSupported = !tsUseEsm || TS_ESM_PARTIAL_SUPPORTED;
+    if (!finalTsRunner) {
+      throw new Error("No ts runner specified, ts worker path is not supported");
+    } else if ([
+      TsRunner.EsbuildRegister,
+      TsRunner.EsbuildRunner,
+      ...TS_ESM_PARTIAL_SUPPORTED ? [
+        TsRunner.OXC,
+        TsRunner.SWC
+      ] : [],
+      ...isTsxSupported ? [] : [TsRunner.TSX]
+    ].includes(finalTsRunner)) {
+      throw new Error(`${finalTsRunner} is not supported for ${ext} files yet` + (isTsxSupported ? ", you can try [tsx](https://github.com/esbuild-kit/tsx) instead" : MTS_SUPPORTED ? ", you can try [oxc](https://github.com/oxc-project/oxc-node) or [swc](https://github.com/swc-project/swc-node/tree/master/packages/register) instead" : ""));
+    }
+  }
+  const finalGlobalShims = (globalShims === true ? DEFAULT_GLOBAL_SHIMS_PRESET : Array.isArray(globalShims) ? globalShims : []).filter(({ moduleName }) => isPkgAvailable(moduleName));
+  sharedBufferView !== null && sharedBufferView !== void 0 ? sharedBufferView : sharedBufferView = new Int32Array(sharedBuffer !== null && sharedBuffer !== void 0 ? sharedBuffer : sharedBuffer = new SharedArrayBuffer(INT32_BYTES), 0, 1);
+  const useGlobals = finalGlobalShims.length > 0;
+  const useEval = isTs ? !tsUseEsm : !jsUseEsm && useGlobals;
+  const worker = new Worker(jsUseEsm && useGlobals || tsUseEsm && finalTsRunner === TsRunner.TsNode ? dataUrl(`${generateGlobals(finalWorkerPath, finalGlobalShims)};import '${String(workerPathUrl)}'`) : useEval ? `${generateGlobals(finalWorkerPath, finalGlobalShims, "require")};${encodeImportModule(finalWorkerPath, "require")}` : workerPathUrl, {
+    eval: useEval,
+    workerData: { sharedBufferView, workerPort, pnpLoaderPath },
+    transferList: [workerPort, ...transferList],
+    execArgv: finalExecArgv
+  });
+  let nextID = 0;
+  const receiveMessageWithId = (port, expectedId, waitingTimeout) => {
+    const start = Date.now();
+    const status = Atomics.wait(sharedBufferView, 0, 0, waitingTimeout);
+    Atomics.store(sharedBufferView, 0, 0);
+    if (!["ok", "not-equal"].includes(status)) {
+      const abortMsg = {
+        id: expectedId,
+        cmd: "abort"
+      };
+      port.postMessage(abortMsg);
+      throw new Error("Internal error: Atomics.wait() failed: " + status);
+    }
+    const _a2 = receiveMessageOnPort(mainPort).message, { id } = _a2, message = __rest(_a2, ["id"]);
+    if (id < expectedId) {
+      const waitingTime = Date.now() - start;
+      return receiveMessageWithId(port, expectedId, waitingTimeout ? waitingTimeout - waitingTime : void 0);
+    }
+    if (expectedId !== id) {
+      throw new Error(`Internal error: Expected id ${expectedId} but got id ${id}`);
+    }
+    return Object.assign({ id }, message);
+  };
+  const syncFn = (...args) => {
+    const id = nextID++;
+    const msg = { id, args };
+    worker.postMessage(msg);
+    const { result, error, properties, stdio } = receiveMessageWithId(mainPort, id, timeout);
+    for (const { type, chunk, encoding } of stdio) {
+      process[type].write(chunk, encoding);
+    }
+    if (error) {
+      throw Object.assign(error, properties);
+    }
+    return result;
+  };
+  worker.unref();
+  return syncFn;
+}
+
+// ../../node_modules/.pnpm/synckit@0.11.3/node_modules/synckit/lib/index.js
+var syncFnCache;
+function createSyncFn(workerPath, timeoutOrOptions) {
+  syncFnCache !== null && syncFnCache !== void 0 ? syncFnCache : syncFnCache = /* @__PURE__ */ new Map();
+  if (typeof workerPath !== "string" || workerPath.startsWith("file://")) {
+    workerPath = fileURLToPath2(workerPath);
+  }
+  const cachedSyncFn = syncFnCache.get(workerPath);
+  if (cachedSyncFn) {
+    return cachedSyncFn;
+  }
+  if (!path4.isAbsolute(workerPath)) {
+    throw new Error("`workerPath` must be absolute");
+  }
+  const syncFn = startWorkerThread(workerPath, typeof timeoutOrOptions === "number" ? { timeout: timeoutOrOptions } : timeoutOrOptions);
+  syncFnCache.set(workerPath, syncFn);
+  return syncFn;
+}
+
+// ../../node_modules/.pnpm/eslint-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-mdx/lib/sync.js
+var performSyncWork = createSyncFn(cjsRequire.resolve("./worker.js"));
+
+// ../../node_modules/.pnpm/eslint-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-mdx/lib/parser.js
+var DEFAULT_EXTENSIONS = [".mdx"];
+var MARKDOWN_EXTENSIONS = [".md"];
+var Parser = class {
+  constructor() {
+    this.parse = this.parse.bind(this);
+    this.parseForESLint = this.parseForESLint.bind(this);
+  }
+  parse(code, options) {
+    return this.parseForESLint(code, options).ast;
+  }
+  parseForESLint(code, { filePath, sourceType, ignoreRemarkConfig, extensions, markdownExtensions }) {
+    const extname = path5.extname(filePath);
+    const isMdx = [...DEFAULT_EXTENSIONS, ...arrayify(extensions)].includes(extname);
+    const isMarkdown = [
+      ...MARKDOWN_EXTENSIONS,
+      ...arrayify(markdownExtensions)
+    ].includes(extname);
+    if (!isMdx && !isMarkdown) {
+      throw new Error("Unsupported file extension, make sure setting the `extensions` or `markdownExtensions` option correctly.");
+    }
+    let result;
+    try {
+      result = performSyncWork({
+        filePath: getPhysicalFilename(filePath),
+        code,
+        isMdx,
+        ignoreRemarkConfig
+      });
+    } catch (err) {
+      if (process.argv.includes("--debug")) {
+        console.error(err);
+      }
+      const { message, line, column, place } = err;
+      const point = place && ("start" in place ? place.start : place);
+      throw Object.assign(new SyntaxError(message, {
+        cause: err
+      }), {
+        lineNumber: line,
+        column,
+        index: point?.offset
+      });
+    }
+    const { root, body, comments, tokens } = result;
+    return {
+      ast: {
+        ...normalizePosition(root.position),
+        type: "Program",
+        sourceType,
+        body,
+        comments,
+        tokens
+      }
+    };
+  }
+};
+var parser = new Parser();
+var { parse, parseForESLint } = parser;
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/configs/flat.js
+var flat = {
+  files: ["**/*.{md,mdx}"],
+  languageOptions: {
+    sourceType: "module",
+    ecmaVersion: "latest",
+    parser: lib_exports,
+    globals: {
+      React: false
+    }
+  },
+  plugins: {
+    mdx: lib_exports2
+  },
+  rules: {
+    "mdx/remark": "warn",
+    "no-unused-expressions": "error",
+    "react/react-in-jsx-scope": "off"
+  }
+};
+var { parserOptions, ...restConfig } = codeBlocks;
+var flatCodeBlocks = {
+  files: ["**/*.{md,mdx}/**"],
+  languageOptions: {
+    parserOptions
+  },
+  ...restConfig
+};
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/helpers.js
+import { createRequire as createRequire3 } from "node:module";
+var getGlobals = (sources, initialGlobals = {}) => (Array.isArray(sources) ? sources : Object.keys(sources)).reduce((globals, source) => Object.assign(globals, {
+  [source]: false
+}), initialGlobals);
+var cjsRequire3 = typeof __require === "undefined" ? createRequire3(import.meta.url) : __require;
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/configs/overrides.js
+var isReactPluginAvailable = false;
+try {
+  cjsRequire3.resolve("eslint-plugin-react");
+  isReactPluginAvailable = true;
+} catch {
+}
+var overrides = {
+  ...base,
+  globals: {
+    React: false
+  },
+  plugins: arrayify(base.plugins, isReactPluginAvailable ? "react" : null),
+  rules: {
+    "react/jsx-no-undef": isReactPluginAvailable ? [
+      2,
+      {
+        allowGlobals: true
+      }
+    ] : 0,
+    "react/react-in-jsx-scope": 0
+  }
+};
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/configs/recommended.js
+var overrides2 = [
+  {
+    files: ["*.md", "*.mdx"],
+    extends: "plugin:mdx/overrides",
+    ...base
+  },
+  {
+    files: "**/*.{md,mdx}/**",
+    extends: "plugin:mdx/code-blocks"
+  }
+];
+var recommended = {
+  overrides: overrides2
+};
+var addPrettierRules = () => {
+  try {
+    cjsRequire3.resolve("prettier");
+    const { meta: meta3 } = cjsRequire3("eslint-plugin-prettier");
+    const version = meta3?.version || "";
+    const [major, minor, patch] = version.split(".");
+    if (+major > 5 || +major === 5 && (+minor > 1 || +minor === 1 && Number.parseInt(patch) >= 2)) {
+      return;
+    }
+    overrides2.push({
+      files: "*.md",
+      rules: {
+        "prettier/prettier": [
+          "error",
+          {
+            parser: "markdown"
+          }
+        ]
+      }
+    }, {
+      files: "*.mdx",
+      rules: {
+        "prettier/prettier": [
+          "error",
+          {
+            parser: "mdx"
+          }
+        ]
+      }
+    });
+  } catch {
+  }
+};
+addPrettierRules();
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/configs/index.js
+var configs = {
+  base,
+  "code-blocks": codeBlocks,
+  codeBlocks,
+  flat,
+  flatCodeBlocks,
+  overrides,
+  recommended
+};
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/meta.js
+var pkg2 = cjsRequire3("../package.json");
+var meta2 = { name: pkg2.name, version: pkg2.version };
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/processors/helpers.js
+var DEFAULT_LANGUAGE_MAPPER = {
+  ecmascript: "js",
+  javascript: "js",
+  javascriptreact: "jsx",
+  typescript: "ts",
+  typescriptreact: "tsx",
+  markdown: "md",
+  markdownjsx: "mdx",
+  markdownreact: "mdx",
+  mdown: "md",
+  mkdn: "md"
+};
+function getShortLang(filename, languageMapper) {
+  const language = filename.split(".").at(-1);
+  if (languageMapper === false) {
+    return language;
+  }
+  languageMapper = languageMapper ? { ...DEFAULT_LANGUAGE_MAPPER, ...languageMapper } : DEFAULT_LANGUAGE_MAPPER;
+  const mapped = languageMapper[language];
+  if (mapped) {
+    return mapped;
+  }
+  const lang = language.toLowerCase();
+  return languageMapper[lang] || lang;
+}
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/from-markdown.js
+var fromMarkdown = createSyncFn(cjsRequire3.resolve("./worker.js"));
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/processors/markdown.js
+var UNSATISFIABLE_RULES = /* @__PURE__ */ new Set([
+  "eol-last",
+  "unicode-bom"
+]);
+var SUPPORTS_AUTOFIX = true;
+var BOM = "\uFEFF";
+var blocksCache = /* @__PURE__ */ new Map();
+function traverse(node, callbacks) {
+  if (callbacks[node.type]) {
+    callbacks[node.type](node);
+  } else {
+    callbacks["*"]();
+  }
+  const parent = node;
+  if ("children" in parent) {
+    for (const child of parent.children) {
+      traverse(child, callbacks);
+    }
+  }
+}
+var COMMENTS = [
+  [
+    /^<!-{2,}/,
+    /-{2,}>$/
+  ],
+  [
+    /^\/\*+/,
+    /\*+\/$/
+  ]
+];
+var eslintCommentRegex = /^(?:eslint\b|global\s)/u;
+function getComment(value, isMdx = false) {
+  const [commentStart, commentEnd] = COMMENTS[+isMdx];
+  const commentStartMatched = commentStart.exec(value);
+  const commentEndMatched = commentEnd.exec(value);
+  if (commentStartMatched == null || commentEndMatched == null) {
+    return "";
+  }
+  const comment = value.slice(commentStartMatched[0].length, -commentEndMatched[0].length).trim();
+  if (!eslintCommentRegex.test(comment)) {
+    return "";
+  }
+  return comment;
+}
+var leadingWhitespaceRegex = /^[>\s]*/u;
+function getBeginningOfLineOffset(node) {
+  return node.position.start.offset - node.position.start.column + 1;
+}
+function getIndentText(text, node) {
+  return leadingWhitespaceRegex.exec(text.slice(getBeginningOfLineOffset(node)))[0];
+}
+function getBlockRangeMap(text, node, comments) {
+  const startOffset = getBeginningOfLineOffset(node);
+  const code = text.slice(startOffset, node.position.end.offset);
+  const lines = code.split("\n");
+  const baseIndent = getIndentText(text, node).length;
+  const commentLength = comments.reduce((len, comment) => len + comment.length + 1, 0);
+  const rangeMap = [
+    {
+      indent: baseIndent,
+      js: 0,
+      md: 0
+    }
+  ];
+  let jsOffset = commentLength;
+  let mdOffset = startOffset + lines[0].length + 1;
+  for (let i = 0; i + 1 < lines.length; i++) {
+    const line = lines[i + 1];
+    const leadingWhitespaceLength = leadingWhitespaceRegex.exec(line)[0].length;
+    const trimLength = Math.min(baseIndent, leadingWhitespaceLength);
+    rangeMap.push({
+      indent: trimLength,
+      js: jsOffset,
+      md: mdOffset + trimLength - jsOffset
+    });
+    mdOffset += line.length + 1;
+    jsOffset += line.length - trimLength + 1;
+  }
+  return rangeMap;
+}
+var codeBlockFileNameRegex = /filename=(?<quote>["'])(?<filename>.*?)\1/u;
+function fileNameFromMeta(block) {
+  return codeBlockFileNameRegex.exec(block.meta)?.groups.filename.replaceAll(/\s+/gu, "_");
+}
+function preprocess(sourceText, filename) {
+  const text = sourceText.startsWith(BOM) ? sourceText.slice(1) : sourceText;
+  const ast = fromMarkdown(text, filename.endsWith(".mdx"));
+  const blocks = [];
+  blocksCache.set(filename, blocks);
+  let allComments = [];
+  function mdxExpression(node) {
+    const comment = getComment(node.value, true);
+    if (comment) {
+      allComments.push(comment);
+    } else {
+      allComments = [];
+    }
+  }
+  traverse(ast, {
+    "*"() {
+      allComments = [];
+    },
+    code(node) {
+      if (!node.lang) {
+        return;
+      }
+      const comments = [];
+      for (const comment of allComments) {
+        if (comment === "eslint-skip") {
+          allComments = [];
+          return;
+        }
+        comments.push(`/* ${comment} */`);
+      }
+      allComments = [];
+      blocks.push({
+        ...node,
+        baseIndentText: getIndentText(text, node),
+        comments,
+        rangeMap: getBlockRangeMap(text, node, comments)
+      });
+    },
+    html(node) {
+      const comment = getComment(node.value);
+      if (comment) {
+        allComments.push(comment);
+      } else {
+        allComments = [];
+      }
+    },
+    mdxFlowExpression: mdxExpression,
+    mdxTextExpression: mdxExpression
+  });
+  return blocks.map((block, index) => {
+    const [language] = block.lang.trim().split(" ");
+    return {
+      filename: fileNameFromMeta(block) ?? `${index}.${language}`,
+      text: [...block.comments, block.value, ""].join("\n")
+    };
+  });
+}
+function adjustFix(block, fix) {
+  return {
+    range: fix.range.map((range) => {
+      let i = 1;
+      while (i < block.rangeMap.length && block.rangeMap[i].js <= range) {
+        i++;
+      }
+      return range + block.rangeMap[i - 1].md;
+    }),
+    text: fix.text.replaceAll("\n", `
+${block.baseIndentText}`)
+  };
+}
+function adjustBlock(block) {
+  const leadingCommentLines = block.comments.reduce((count, comment) => count + comment.split("\n").length, 0);
+  const blockStart = block.position.start.line;
+  return function adjustMessage(message) {
+    if (!Number.isInteger(message.line)) {
+      return {
+        ...message,
+        line: blockStart,
+        column: block.position.start.column
+      };
+    }
+    const lineInCode = message.line - leadingCommentLines;
+    if (lineInCode < 1 || lineInCode >= block.rangeMap.length) {
+      return null;
+    }
+    const out = {
+      line: lineInCode + blockStart,
+      column: message.column + block.rangeMap[lineInCode].indent
+    };
+    if (Number.isInteger(message.endLine)) {
+      out.endLine = message.endLine - leadingCommentLines + blockStart;
+    }
+    if (Array.isArray(message.suggestions)) {
+      out.suggestions = message.suggestions.map((suggestion) => ({
+        ...suggestion,
+        fix: adjustFix(block, suggestion.fix)
+      }));
+    }
+    const adjustedFix = {};
+    if (message.fix) {
+      adjustedFix.fix = adjustFix(block, message.fix);
+    }
+    return { ...message, ...out, ...adjustedFix };
+  };
+}
+function excludeUnsatisfiableRules(message) {
+  return message && !UNSATISFIABLE_RULES.has(message.ruleId);
+}
+function postprocess(messages, filename) {
+  const blocks = blocksCache.get(filename);
+  blocksCache.delete(filename);
+  return messages.flatMap((group, i) => {
+    const adjust = adjustBlock(blocks[i]);
+    return group.map(adjust).filter(excludeUnsatisfiableRules);
+  });
+}
+var markdownProcessor = {
+  meta: {
+    name: "mdx/markdown",
+    version: meta2.version
+  },
+  preprocess,
+  postprocess,
+  supportsAutofix: SUPPORTS_AUTOFIX
+};
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/processors/options.js
+var processorOptions = {};
+var linterPath = Object.keys(cjsRequire3.cache).find((path7) => /([/\\])eslint\1lib(?:\1linter){2}\.js$/.test(path7));
+if (!linterPath) {
+  throw new Error("Could not find ESLint Linter in require cache");
+}
+var ESLinter = cjsRequire3(linterPath).Linter;
+var { verify } = ESLinter.prototype;
+ESLinter.prototype.verify = function(code, config, options) {
+  const settings = (config.extractConfig?.(typeof options === "undefined" || typeof options === "string" ? options : options.filename) ?? config).settings ?? {};
+  processorOptions.lintCodeBlocks = settings["mdx/code-blocks"] === true;
+  processorOptions.languageMapper = settings["mdx/language-mapper"];
+  return verify.call(this, code, config, options);
+};
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/processors/remark.js
+var createRemarkProcessor = (processorOptions2 = processorOptions) => ({
+  meta: {
+    name: "mdx/remark",
+    version: meta2.version
+  },
+  supportsAutofix: true,
+  preprocess(text, filename) {
+    if (!processorOptions2.lintCodeBlocks) {
+      return [text];
+    }
+    return [
+      text,
+      ...markdownProcessor.preprocess(text, filename).map(({ text: text2, filename: filename2 }) => ({
+        text: text2,
+        filename: filename2.slice(0, filename2.lastIndexOf(".")) + "." + getShortLang(filename2, processorOptions2.languageMapper)
+      }))
+    ];
+  },
+  postprocess([mdxMessages, ...markdownMessages], filename) {
+    return [
+      ...mdxMessages,
+      ...markdownProcessor.postprocess(markdownMessages, filename)
+    ].sort((a, b) => a.line - b.line || a.column - b.column).map((lintMessage) => {
+      const { message, ruleId: eslintRuleId, severity: eslintSeverity } = lintMessage;
+      if (eslintRuleId !== "mdx/remark") {
+        return lintMessage;
+      }
+      const { source, ruleId, reason, severity } = JSON.parse(message);
+      return {
+        ...lintMessage,
+        ruleId: `${source}-${ruleId}`,
+        message: reason,
+        severity: Math.max(eslintSeverity, severity)
+      };
+    });
+  }
+});
+var remark = createRemarkProcessor();
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/processors/index.js
+var processors = { remark };
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/rules/remark.js
+import path6 from "node:path";
+var remark2 = {
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Linter integration with remark plugins",
+      category: "Stylistic Issues",
+      recommended: true
+    },
+    fixable: "code"
+  },
+  create(context) {
+    const filename = context.getFilename();
+    const extname = path6.extname(filename);
+    const sourceCode = context.getSourceCode();
+    const options = context.parserOptions;
+    const isMdx = [
+      ...DEFAULT_EXTENSIONS,
+      ...options.extensions || []
+    ].includes(extname);
+    const isMarkdown = [
+      ...MARKDOWN_EXTENSIONS,
+      ...options.markdownExtensions || []
+    ].includes(extname);
+    return {
+      Program(node) {
+        if (!isMdx && !isMarkdown) {
+          return;
+        }
+        const ignoreRemarkConfig = Boolean(options.ignoreRemarkConfig);
+        const sourceText = sourceCode.getText(node);
+        const { messages, content: fixedText } = performSyncWork({
+          filePath: getPhysicalFilename(filename),
+          code: sourceText,
+          cwd: context.getCwd(),
+          isMdx,
+          process: true,
+          ignoreRemarkConfig
+        });
+        let fixed = 0;
+        for (const { source, reason, ruleId, fatal, line, column, place } of messages) {
+          const severity = fatal ? 2 : fatal == null ? 0 : 1;
+          if (!severity) {
+            continue;
+          }
+          const message = {
+            reason,
+            source,
+            ruleId,
+            severity
+          };
+          const point = {
+            line,
+            column: column - 1
+          };
+          context.report({
+            message: JSON.stringify(message),
+            loc: place && "start" in place ? {
+              ...point,
+              start: { ...place.start, column: place.start.column - 1 },
+              end: { ...place.end, column: place.end.column - 1 }
+            } : point,
+            node,
+            fix: fixedText == null || fixedText === sourceText ? null : () => fixed++ ? null : {
+              range: [0, sourceText.length],
+              text: fixedText
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.4.0_eslint@9.24.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/rules/index.js
+var rules = { remark: remark2 };
+export {
+  DEFAULT_LANGUAGE_MAPPER,
+  base,
+  cjsRequire3 as cjsRequire,
+  codeBlocks,
+  configs,
+  createRemarkProcessor,
+  flat,
+  flatCodeBlocks,
+  getGlobals,
+  getShortLang,
+  meta2 as meta,
+  overrides,
+  processorOptions,
+  processors,
+  recommended,
+  remark2 as remark,
+  rules
+};