@icebreakers/eslint-config 1.0.1 → 1.0.3

package/dist/index.es2015-XG66TMMA.js

@@ -0,0 +1,1347 @@
+import {
+  __dirname,
+  __export,
+  __require
+} from "./chunk-4JACZTJG.js";
+
+// ../../node_modules/.pnpm/eslint-mdx@3.2.0_eslint@9.22.0_jiti@2.4.2_/node_modules/eslint-mdx/lib/index.es2015.mjs
+var index_es2015_exports = {};
+__export(index_es2015_exports, {
+  DEFAULT_EXTENSIONS: () => DEFAULT_EXTENSIONS,
+  MARKDOWN_EXTENSIONS: () => MARKDOWN_EXTENSIONS,
+  Parser: () => Parser,
+  arrayify: () => arrayify,
+  getPhysicalFilename: () => getPhysicalFilename,
+  getPositionAtFactory: () => getPositionAtFactory,
+  last: () => last,
+  loadEsmModule: () => loadEsmModule,
+  meta: () => meta,
+  nextCharOffsetFactory: () => nextCharOffsetFactory,
+  normalizePosition: () => normalizePosition,
+  parse: () => parse,
+  parseForESLint: () => parseForESLint,
+  parser: () => parser,
+  performSyncWork: () => performSyncWork,
+  prevCharOffsetFactory: () => prevCharOffsetFactory
+});
+import fs3 from "node:fs";
+import path3 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.9.2/node_modules/synckit/lib/index.js
+import { createHash } from "node:crypto";
+import fs2 from "node:fs";
+import module from "node:module";
+import path2 from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { MessageChannel, Worker, parentPort, receiveMessageOnPort, workerData } from "node:worker_threads";
+
+// ../../node_modules/.pnpm/@pkgr+core@0.1.1/node_modules/@pkgr/core/lib/constants.js
+import { createRequire } from "node:module";
+var CWD = process.cwd();
+var cjsRequire = typeof __require === "undefined" ? createRequire(import.meta.url) : __require;
+var EXTENSIONS = [".ts", ".tsx", ...Object.keys(cjsRequire.extensions)];
+
+// ../../node_modules/.pnpm/@pkgr+core@0.1.1/node_modules/@pkgr/core/lib/helpers.js
+import fs from "node:fs";
+import path from "node:path";
+var tryPkg = (pkg) => {
+  try {
+    return cjsRequire.resolve(pkg);
+  } catch (_a2) {
+  }
+};
+var isPkgAvailable = (pkg) => !!tryPkg(pkg);
+var tryFile = (filePath, includeDir = false) => {
+  if (typeof filePath === "string") {
+    return fs.existsSync(filePath) && (includeDir || fs.statSync(filePath).isFile()) ? filePath : "";
+  }
+  for (const file of filePath !== null && filePath !== void 0 ? filePath : []) {
+    if (tryFile(file, includeDir)) {
+      return file;
+    }
+  }
+  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(path.isAbsolute(searchEntry));
+  if (!tryFile(searchEntry, true) || searchEntry !== CWD && !searchEntry.startsWith(CWD + path.sep)) {
+    return "";
+  }
+  searchEntry = path.resolve(fs.statSync(searchEntry).isDirectory() ? searchEntry : path.resolve(searchEntry, ".."));
+  const isSearchFile = typeof searchFileOrIncludeDir === "string";
+  const searchFile = isSearchFile ? searchFileOrIncludeDir : "package.json";
+  do {
+    const searched = tryFile(path.resolve(searchEntry, searchFile), isSearchFile && includeDir);
+    if (searched) {
+      return searched;
+    }
+    searchEntry = path.resolve(searchEntry, "..");
+  } while (searchEntry === CWD || searchEntry.startsWith(CWD + path.sep));
+  return "";
+};
+
+// ../../node_modules/.pnpm/synckit@0.9.2/node_modules/synckit/lib/index.js
+var INT32_BYTES = 4;
+var TsRunner = {
+  TsNode: "ts-node",
+  EsbuildRegister: "esbuild-register",
+  EsbuildRunner: "esbuild-runner",
+  SWC: "swc",
+  TSX: "tsx"
+};
+var { NODE_OPTIONS, SYNCKIT_EXEC_ARGV, SYNCKIT_GLOBAL_SHIMS, SYNCKIT_TIMEOUT, SYNCKIT_TS_RUNNER } = process.env;
+var IS_NODE_20 = Number(process.versions.node.split(".")[0]) >= 20;
+var DEFAULT_TIMEOUT = SYNCKIT_TIMEOUT ? +SYNCKIT_TIMEOUT : void 0;
+var DEFAULT_EXEC_ARGV = (SYNCKIT_EXEC_ARGV === null || SYNCKIT_EXEC_ARGV === void 0 ? void 0 : 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 MTS_SUPPORTED_NODE_VERSION = 16;
+var syncFnCache;
+function createSyncFn(workerPath2, timeoutOrOptions) {
+  syncFnCache !== null && syncFnCache !== void 0 ? syncFnCache : syncFnCache = /* @__PURE__ */ new Map();
+  const cachedSyncFn = syncFnCache.get(workerPath2);
+  if (cachedSyncFn) {
+    return cachedSyncFn;
+  }
+  if (!path2.isAbsolute(workerPath2)) {
+    throw new Error("`workerPath` must be absolute");
+  }
+  const syncFn = startWorkerThread(workerPath2, typeof timeoutOrOptions === "number" ? { timeout: timeoutOrOptions } : timeoutOrOptions);
+  syncFnCache.set(workerPath2, syncFn);
+  return syncFn;
+}
+var cjsRequire2 = typeof __require === "undefined" ? module.createRequire(import.meta.url) : __require;
+var dataUrl = (code) => new URL(`data:text/javascript,${encodeURIComponent(code)}`);
+var isFile = (path5) => {
+  var _a2;
+  try {
+    return !!((_a2 = fs2.statSync(path5, { throwIfNoEntry: false })) === null || _a2 === void 0 ? void 0 : _a2.isFile());
+  } catch (_b) {
+    return false;
+  }
+};
+var setupTsRunner = (workerPath2, { execArgv, tsRunner }) => {
+  let ext = path2.extname(workerPath2);
+  if (!/[/\\]node_modules[/\\]/.test(workerPath2) && (!ext || /^\.[cm]?js$/.test(ext))) {
+    const workPathWithoutExt = ext ? workerPath2.slice(0, -ext.length) : workerPath2;
+    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))) {
+      workerPath2 = found;
+      if (differentExt) {
+        ext = path2.extname(workerPath2);
+      }
+    }
+  }
+  const isTs = /\.[cm]?ts$/.test(workerPath2);
+  let jsUseEsm = workerPath2.endsWith(".mjs");
+  let tsUseEsm = workerPath2.endsWith(".mts");
+  if (isTs) {
+    if (!tsUseEsm) {
+      const pkg = findUp(workerPath2);
+      if (pkg) {
+        tsUseEsm = cjsRequire2(pkg).type === "module";
+      }
+    }
+    if (tsRunner == null && isPkgAvailable(TsRunner.TsNode)) {
+      tsRunner = TsRunner.TsNode;
+    }
+    switch (tsRunner) {
+      case TsRunner.TsNode: {
+        if (tsUseEsm) {
+          if (!execArgv.includes("--loader")) {
+            execArgv = ["--loader", `${TsRunner.TsNode}/esm`, ...execArgv];
+          }
+        } else if (!execArgv.includes("-r")) {
+          execArgv = ["-r", `${TsRunner.TsNode}/register`, ...execArgv];
+        }
+        break;
+      }
+      case TsRunner.EsbuildRegister: {
+        if (!execArgv.includes("-r")) {
+          execArgv = ["-r", TsRunner.EsbuildRegister, ...execArgv];
+        }
+        break;
+      }
+      case TsRunner.EsbuildRunner: {
+        if (!execArgv.includes("-r")) {
+          execArgv = ["-r", `${TsRunner.EsbuildRunner}/register`, ...execArgv];
+        }
+        break;
+      }
+      case TsRunner.SWC: {
+        if (!execArgv.includes("-r")) {
+          execArgv = ["-r", `@${TsRunner.SWC}-node/register`, ...execArgv];
+        }
+        break;
+      }
+      case TsRunner.TSX: {
+        if (!execArgv.includes("--loader")) {
+          execArgv = ["--loader", TsRunner.TSX, ...execArgv];
+        }
+        break;
+      }
+      default: {
+        throw new Error(`Unknown ts runner: ${String(tsRunner)}`);
+      }
+    }
+  } else if (!jsUseEsm) {
+    const pkg = findUp(workerPath2);
+    if (pkg) {
+      jsUseEsm = cjsRequire2(pkg).type === "module";
+    }
+  }
+  let resolvedPnpLoaderPath;
+  if (process.versions.pnp) {
+    const nodeOptions = NODE_OPTIONS === null || NODE_OPTIONS === void 0 ? void 0 : NODE_OPTIONS.split(/\s+/);
+    let pnpApiPath;
+    try {
+      pnpApiPath = cjsRequire2.resolve("pnpapi");
+    } catch (_a2) {
+    }
+    if (pnpApiPath && !(nodeOptions === null || nodeOptions === void 0 ? void 0 : nodeOptions.some((option, index) => ["-r", "--require"].includes(option) && pnpApiPath === cjsRequire2.resolve(nodeOptions[index + 1]))) && !execArgv.includes(pnpApiPath)) {
+      execArgv = ["-r", pnpApiPath, ...execArgv];
+      const pnpLoaderPath = path2.resolve(pnpApiPath, "../.pnp.loader.mjs");
+      if (isFile(pnpLoaderPath)) {
+        resolvedPnpLoaderPath = pathToFileURL(pnpLoaderPath).toString();
+        if (!IS_NODE_20) {
+          execArgv = [
+            "--experimental-loader",
+            resolvedPnpLoaderPath,
+            ...execArgv
+          ];
+        }
+      }
+    }
+  }
+  return {
+    ext,
+    isTs,
+    jsUseEsm,
+    tsRunner,
+    tsUseEsm,
+    workerPath: workerPath2,
+    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" : ""} '${path2.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" ? path2.dirname(fileURLToPath(import.meta.url)) : __dirname;
+var sharedBuffer;
+var sharedBufferView;
+var generateGlobals = (workerPath2, globalShims, type = "import") => {
+  globalsCache !== null && globalsCache !== void 0 ? globalsCache : globalsCache = /* @__PURE__ */ new Map();
+  const cached = globalsCache.get(workerPath2);
+  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 = path2.resolve(findUp(_dirname), "../node_modules/.synckit");
+    }
+    fs2.mkdirSync(tmpdir, { recursive: true });
+    filepath = path2.resolve(tmpdir, md5Hash(workerPath2) + ".mjs");
+    content = encodeImportModule(filepath);
+    fs2.writeFileSync(filepath, globals);
+  }
+  globalsCache.set(workerPath2, [content, filepath]);
+  return content;
+};
+function startWorkerThread(workerPath2, { 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(workerPath2, { execArgv, tsRunner });
+  const workerPathUrl = pathToFileURL(finalWorkerPath);
+  if (/\.[cm]ts$/.test(finalWorkerPath)) {
+    const isTsxSupported = !tsUseEsm || Number.parseFloat(process.versions.node) >= MTS_SUPPORTED_NODE_VERSION;
+    if (!finalTsRunner) {
+      throw new Error("No ts runner specified, ts worker path is not supported");
+    } else if ([
+      TsRunner.EsbuildRegister,
+      TsRunner.EsbuildRunner,
+      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" : ""));
+    }
+  }
+  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: { sharedBuffer, 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 } = receiveMessageWithId(mainPort, id, timeout);
+    if (error) {
+      throw Object.assign(error, properties);
+    }
+    return result;
+  };
+  worker.unref();
+  return syncFn;
+}
+
+// ../../node_modules/.pnpm/eslint-mdx@3.2.0_eslint@9.22.0_jiti@2.4.2_/node_modules/eslint-mdx/lib/index.es2015.mjs
+var last = (items) => (
+  // eslint-disable-next-line unicorn/prefer-at -- FIXME: Node 16.6+ required
+  items && items[items.length - 1]
+);
+var arrayify = (...args) => args.reduce((arr, curr) => {
+  arr.push(...Array.isArray(curr) ? curr : curr == null ? [] : [curr]);
+  return arr;
+}, []);
+var getPhysicalFilename = (filename, child) => {
+  try {
+    if (fs3.statSync(filename).isDirectory()) {
+      return child || filename;
+    }
+  } catch (err) {
+    const { code } = err;
+    if (code === "ENOTDIR" || code === "ENOENT") {
+      return getPhysicalFilename(path3.dirname(filename), filename);
+    }
+  }
+  return filename;
+};
+var loadEsmModule = (modulePath) => (
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval, no-new-func
+  new Function("modulePath", `return import(modulePath);`)(
+    modulePath
+  )
+);
+var getPositionAtFactory = (text) => {
+  const lines = text.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,
+  text
+}) => {
+  const startOffset = start.offset;
+  const endOffset = end.offset;
+  const range = [startOffset, endOffset];
+  const getPositionAt = text == null ? null : (
+    /* istanbul ignore next -- used in worker */
+    getPositionAtFactory(text)
+  );
+  return {
+    start: startOffset,
+    end: endOffset,
+    loc: {
+      start: (
+        /* istanbul ignore next -- used in worker */
+        "line" in start ? start : getPositionAt(startOffset)
+      ),
+      end: (
+        /* istanbul ignore next -- used in worker */
+        "line" in end ? end : getPositionAt(endOffset)
+      )
+    },
+    range
+  };
+};
+var prevCharOffsetFactory = (text) => (offset) => {
+  for (let i = offset; i >= 0; i--) {
+    const char = text[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 name = "eslint-mdx";
+var version = "3.2.0";
+var meta = { name, version };
+var workerPath = __require.resolve("./worker");
+var performSyncWork = createSyncFn(workerPath);
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 = path3.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."
+      );
+    }
+    const physicalFilename = getPhysicalFilename(filePath);
+    let result;
+    try {
+      result = performSyncWork({
+        fileOptions: {
+          path: physicalFilename,
+          value: code
+        },
+        physicalFilename,
+        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: (
+            /* istanbul ignore next */
+            point == null ? void 0 : point.offset
+          )
+        }
+      );
+    }
+    const { root, body, comments, tokens } = result;
+    return {
+      ast: __spreadProps(__spreadValues({}, normalizePosition(root.position)), {
+        type: "Program",
+        sourceType,
+        body,
+        comments,
+        tokens
+      })
+    };
+  }
+};
+var parser = new Parser();
+var { parse, parseForESLint } = parser;
+
+// ../../node_modules/.pnpm/eslint-plugin-mdx@3.2.0_eslint@9.22.0_jiti@2.4.2_/node_modules/eslint-plugin-mdx/lib/index.es2015.mjs
+import path4 from "node:path";
+import { createRequire as createRequire2 } from "node:module";
+var mdx = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  get DEFAULT_LANGUAGE_MAPPER() {
+    return DEFAULT_LANGUAGE_MAPPER;
+  },
+  get base() {
+    return base;
+  },
+  get codeBlocks() {
+    return codeBlocks;
+  },
+  get configs() {
+    return configs;
+  },
+  get createRemarkProcessor() {
+    return createRemarkProcessor;
+  },
+  get flat() {
+    return flat;
+  },
+  get flatCodeBlocks() {
+    return flatCodeBlocks;
+  },
+  get getGlobals() {
+    return getGlobals;
+  },
+  get getShortLang() {
+    return getShortLang;
+  },
+  get meta() {
+    return meta2;
+  },
+  get overrides() {
+    return overrides$1;
+  },
+  get processorOptions() {
+    return processorOptions;
+  },
+  get processors() {
+    return processors;
+  },
+  get recommended() {
+    return recommended;
+  },
+  get remark() {
+    return remark;
+  },
+  get rules() {
+    return rules;
+  }
+});
+var base = {
+  parser: "eslint-mdx",
+  parserOptions: {
+    sourceType: "module",
+    ecmaVersion: "latest"
+  },
+  plugins: ["mdx"],
+  processor: "mdx/remark",
+  rules: {
+    "mdx/remark": "warn",
+    "no-unused-expressions": "error"
+  }
+};
+var codeBlocks = {
+  parserOptions: {
+    ecmaFeatures: {
+      // Adding a "use strict" directive at the top of
+      // every code block is tedious and distracting, so
+      // opt into strict mode parsing without the
+      // directive.
+      impliedStrict: true
+    }
+  },
+  rules: {
+    // The Markdown parser automatically trims trailing
+    // newlines from code blocks.
+    "eol-last": "off",
+    // In code snippets and examples, these rules are often
+    // counterproductive to clarity and brevity.
+    "no-undef": "off",
+    "no-unused-expressions": "off",
+    "no-unused-vars": "off",
+    "padded-blocks": "off",
+    // Adding a "use strict" directive at the top of every
+    // code block is tedious and distracting. The config
+    // opts into strict mode parsing without the directive.
+    strict: "off",
+    // The processor will not receive a Unicode Byte Order
+    // Mark from the Markdown parser.
+    "unicode-bom": "off"
+  }
+};
+var __defProp$6 = Object.defineProperty;
+var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
+var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$6 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$6.call(b, prop))
+      __defNormalProp$6(a, prop, b[prop]);
+  if (__getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(b)) {
+      if (__propIsEnum$6.call(b, prop))
+        __defNormalProp$6(a, prop, b[prop]);
+    }
+  return a;
+};
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$6.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$6.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var flat = {
+  files: ["**/*.{md,mdx}"],
+  languageOptions: {
+    sourceType: "module",
+    ecmaVersion: "latest",
+    parser: index_es2015_exports,
+    globals: {
+      React: false
+    }
+  },
+  plugins: {
+    mdx
+  },
+  rules: {
+    "mdx/remark": "warn",
+    "no-unused-expressions": "error",
+    "react/react-in-jsx-scope": 0
+  }
+};
+var _a = codeBlocks;
+var { parserOptions } = _a;
+var restConfig = __objRest(_a, ["parserOptions"]);
+var flatCodeBlocks = __spreadValues$6({
+  files: ["**/*.{md,mdx}/*"],
+  languageOptions: {
+    parserOptions
+  }
+}, restConfig);
+var __defProp$5 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
+var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
+var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$5 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$5.call(b, prop))
+      __defNormalProp$5(a, prop, b[prop]);
+  if (__getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(b)) {
+      if (__propIsEnum$5.call(b, prop))
+        __defNormalProp$5(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+var isReactPluginAvailable = false;
+try {
+  __require.resolve("eslint-plugin-react");
+  isReactPluginAvailable = true;
+} catch (e) {
+}
+var overrides$1 = __spreadProps$3(__spreadValues$5({}, base), {
+  globals: {
+    React: false
+  },
+  plugins: arrayify(
+    base.plugins,
+    /* istanbul ignore next */
+    isReactPluginAvailable ? "react" : null
+  ),
+  rules: {
+    "react/jsx-no-undef": (
+      /* istanbul ignore next */
+      isReactPluginAvailable ? [
+        2,
+        {
+          allowGlobals: true
+        }
+      ] : 0
+    ),
+    "react/react-in-jsx-scope": 0
+  }
+});
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
+    }
+  return a;
+};
+var overrides = [
+  __spreadValues$4({
+    files: ["*.md", "*.mdx"],
+    extends: "plugin:mdx/overrides"
+  }, base),
+  {
+    files: "**/*.{md,mdx}/**",
+    extends: "plugin:mdx/code-blocks"
+  }
+];
+var recommended = {
+  overrides
+};
+var getImportMetaUrl = () => {
+  try {
+    return new Function("return import.meta.url")();
+  } catch (e) {
+    return path4.resolve(process.cwd(), "__test__.js");
+  }
+};
+var cjsRequire3 = typeof __require === "undefined" ? createRequire2(getImportMetaUrl()) : __require;
+var addPrettierRules = () => {
+  try {
+    cjsRequire3.resolve("prettier");
+    const { meta: meta3 } = cjsRequire3("eslint-plugin-prettier");
+    const version3 = (meta3 == null ? void 0 : meta3.version) || "";
+    const [major, minor, patch] = version3.split(".");
+    if (
+      /* istanbul ignore next */
+      +major > 5 || +major === 5 && (+minor > 1 || +minor === 1 && Number.parseInt(patch) >= 2)
+    ) {
+      return;
+    }
+    overrides.push(
+      {
+        files: "*.md",
+        rules: {
+          "prettier/prettier": [
+            "error",
+            {
+              parser: "markdown"
+            }
+          ]
+        }
+      },
+      {
+        files: "*.mdx",
+        rules: {
+          "prettier/prettier": [
+            "error",
+            {
+              parser: "mdx"
+            }
+          ]
+        }
+      }
+    );
+  } catch (e) {
+  }
+};
+addPrettierRules();
+var configs = {
+  base,
+  "code-blocks": codeBlocks,
+  codeBlocks,
+  flat,
+  flatCodeBlocks,
+  overrides: overrides$1,
+  recommended
+};
+var getGlobals = (sources, initialGlobals = {}) => (Array.isArray(sources) ? (
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+  sources
+) : Object.keys(sources)).reduce(
+  (globals, source) => Object.assign(globals, {
+    [source]: false
+  }),
+  // eslint-disable-next-line @typescript-eslint/prefer-reduce-type-parameter
+  initialGlobals
+);
+var name2 = "eslint-plugin-mdx";
+var version2 = "3.2.0";
+var meta2 = { name: name2, version: version2 };
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+var DEFAULT_LANGUAGE_MAPPER = {
+  javascript: "js",
+  javascriptreact: "jsx",
+  typescript: "ts",
+  typescriptreact: "tsx",
+  markdown: "md",
+  mdown: "md",
+  mkdn: "md"
+};
+function getShortLang(filename, languageMapper) {
+  const language = last(filename.split("."));
+  if (languageMapper === false) {
+    return language;
+  }
+  languageMapper = __spreadValues$3(__spreadValues$3({}, DEFAULT_LANGUAGE_MAPPER), languageMapper);
+  const lang = language.toLowerCase();
+  return languageMapper[language] || languageMapper[lang] || lang;
+}
+var fromMarkdown = createSyncFn(
+  __require.resolve("./worker")
+);
+var __defProp$2 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+var UNSATISFIABLE_RULES = /* @__PURE__ */ new Set([
+  "eol-last",
+  // The Markdown parser strips trailing newlines in code fences
+  "unicode-bom"
+  // Code blocks will begin in the middle of Markdown files
+]);
+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);
+    }
+  }
+}
+function getComment(html) {
+  const commentStart = "<!--";
+  const commentEnd = "-->";
+  const regex = /^(?:eslint\b|global\s)/u;
+  if (!html.startsWith(commentStart) || !html.endsWith(commentEnd)) {
+    return "";
+  }
+  const comment = html.slice(commentStart.length, -commentEnd.length);
+  if (!regex.test(comment.trim())) {
+    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,
+      // Advance `trimLength` character from the beginning of the Markdown
+      // line to the beginning of the equivalent JS line, then compute the
+      // delta.
+      md: mdOffset + trimLength - jsOffset
+    });
+    mdOffset += line.length + 1;
+    jsOffset += line.length - trimLength + 1;
+  }
+  return rangeMap;
+}
+var codeBlockFileNameRegex = /filename=(["']).*?\1/u;
+function fileNameFromMeta(block) {
+  var _a2, _b;
+  return (_b = (_a2 = block.meta) == null ? void 0 : _a2.match(codeBlockFileNameRegex)) == null ? void 0 : _b.groups.filename.replaceAll(/\s+/gu, "_");
+}
+var languageToFileExtension = {
+  javascript: "js",
+  ecmascript: "js",
+  typescript: "ts",
+  markdown: "md"
+};
+function preprocess(sourceText, filename) {
+  const text = sourceText.startsWith(BOM) ? sourceText.slice(1) : sourceText;
+  const ast = fromMarkdown(text);
+  const blocks = [];
+  blocksCache.set(filename, blocks);
+  let htmlComments = [];
+  traverse(ast, {
+    "*"() {
+      htmlComments = [];
+    },
+    /**
+     * Visit a code node.
+     * @param {CodeNode} node The visited node.
+     * @returns {void}
+     */
+    code(node) {
+      if (node.lang) {
+        const comments = [];
+        for (const comment of htmlComments) {
+          if (comment.trim() === "eslint-skip") {
+            htmlComments = [];
+            return;
+          }
+          comments.push(`/*${comment}*/`);
+        }
+        htmlComments = [];
+        blocks.push(__spreadProps$2(__spreadValues$2({}, node), {
+          baseIndentText: getIndentText(text, node),
+          comments,
+          rangeMap: getBlockRangeMap(text, node, comments)
+        }));
+      }
+    },
+    /**
+     * Visit an HTML node.
+     * @param {HtmlNode} node The visited node.
+     * @returns {void}
+     */
+    html(node) {
+      const comment = getComment(node.value);
+      if (comment) {
+        htmlComments.push(comment);
+      } else {
+        htmlComments = [];
+      }
+    }
+  });
+  return blocks.map((block, index) => {
+    var _a2;
+    const [language] = block.lang.trim().split(" ");
+    const fileExtension = Object.hasOwn(languageToFileExtension, language) ? languageToFileExtension[language] : language;
+    return {
+      filename: (_a2 = fileNameFromMeta(block)) != null ? _a2 : `${index}.${fileExtension}`,
+      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 __spreadProps$2(__spreadValues$2({}, 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) => __spreadProps$2(__spreadValues$2({}, suggestion), {
+        fix: adjustFix(block, suggestion.fix)
+      }));
+    }
+    const adjustedFix = {};
+    if (message.fix) {
+      adjustedFix.fix = adjustFix(block, message.fix);
+    }
+    return __spreadValues$2(__spreadValues$2(__spreadValues$2({}, 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: "@eslint/markdown/markdown",
+    version: "6.3.0"
+  },
+  preprocess,
+  postprocess,
+  supportsAutofix: SUPPORTS_AUTOFIX
+};
+var processorOptions = {};
+var linterPath = Object.keys(__require.cache).find(
+  (path5) => /([/\\])eslint\1lib(?:\1linter){2}\.js$/.test(path5)
+);
+if (!linterPath) {
+  throw new Error("Could not find ESLint Linter in require cache");
+}
+var ESLinter = __require(linterPath).Linter;
+var { verify } = ESLinter.prototype;
+ESLinter.prototype.verify = function(code, config, options) {
+  const settings = config && (typeof config.extractConfig === "function" ? config.extractConfig(
+    /* istanbul ignore next */
+    // eslint-disable-next-line unicorn/no-typeof-undefined
+    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);
+};
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+var createRemarkProcessor = (processorOptions$1 = processorOptions) => ({
+  meta: {
+    name: "mdx/remark",
+    version: meta2.version
+  },
+  supportsAutofix: true,
+  preprocess(text, filename) {
+    if (!processorOptions$1.lintCodeBlocks) {
+      return [text];
+    }
+    return [
+      text,
+      ...markdownProcessor.preprocess(text, filename).map(({ text: text2, filename: filename2 }) => ({
+        text: text2,
+        filename: filename2.slice(0, filename2.lastIndexOf(".")) + "." + getShortLang(filename2, processorOptions$1.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 __spreadProps$1(__spreadValues$1({}, lintMessage), {
+        ruleId: `${source}-${ruleId}`,
+        message: reason,
+        severity: Math.max(eslintSeverity, severity)
+      });
+    });
+  }
+});
+var remark$1 = createRemarkProcessor();
+var processors = { remark: remark$1 };
+var __defProp2 = Object.defineProperty;
+var __defProps2 = Object.defineProperties;
+var __getOwnPropDescs2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols2 = Object.getOwnPropertySymbols;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __propIsEnum2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp2.call(b, prop))
+      __defNormalProp2(a, prop, b[prop]);
+  if (__getOwnPropSymbols2)
+    for (var prop of __getOwnPropSymbols2(b)) {
+      if (__propIsEnum2.call(b, prop))
+        __defNormalProp2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps2 = (a, b) => __defProps2(a, __getOwnPropDescs2(b));
+var remark = {
+  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 = path4.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 {
+      // eslint-disable-next-line sonarjs/cognitive-complexity
+      Program(node) {
+        if (!isMdx && !isMarkdown) {
+          return;
+        }
+        const ignoreRemarkConfig = Boolean(options.ignoreRemarkConfig);
+        const physicalFilename = getPhysicalFilename(filename);
+        const sourceText = sourceCode.getText(node);
+        const { messages, content: fixedText } = performSyncWork({
+          fileOptions: {
+            path: physicalFilename,
+            value: sourceText,
+            // eslint-disable-next-line sonar/deprecation -- FIXME: ESLint 8.40+ required
+            cwd: context.getCwd()
+          },
+          physicalFilename,
+          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,
+            // ! eslint ast column is 0-indexed, but unified is 1-indexed
+            column: column - 1
+          };
+          context.report({
+            // related to https://github.com/eslint/eslint/issues/14198
+            message: JSON.stringify(message),
+            loc: (
+              /* istanbul ignore next */
+              place && "start" in place ? __spreadProps2(__spreadValues2({}, point), {
+                start: __spreadProps2(__spreadValues2({}, place.start), { column: place.start.column - 1 }),
+                end: __spreadProps2(__spreadValues2({}, place.end), { column: place.end.column - 1 })
+              }) : point
+            ),
+            node,
+            fix: fixedText === sourceText ? null : () => fixed++ ? null : {
+              range: [0, sourceText.length],
+              text: fixedText
+            }
+          });
+        }
+      }
+    };
+  }
+};
+var rules = { remark };
+export {
+  DEFAULT_LANGUAGE_MAPPER,
+  base,
+  codeBlocks,
+  configs,
+  createRemarkProcessor,
+  flat,
+  flatCodeBlocks,
+  getGlobals,
+  getShortLang,
+  meta2 as meta,
+  overrides$1 as overrides,
+  processorOptions,
+  processors,
+  recommended,
+  remark,
+  rules
+};