@aussieljk/forkbook 0.0.1-5 → 0.0.1-7

package/dist/_node-chunks/{mdx-plugin-BKWCT6CB.js → mdx-plugin-6M6CMNL3.js}

@@ -1,10 +1,10 @@
-import CJS_COMPAT_NODE_URL_1qqypd7gt14 from 'node:url';
-import CJS_COMPAT_NODE_PATH_1qqypd7gt14 from 'node:path';
-import CJS_COMPAT_NODE_MODULE_1qqypd7gt14 from "node:module";
+import CJS_COMPAT_NODE_URL_j88npgqhy9 from 'node:url';
+import CJS_COMPAT_NODE_PATH_j88npgqhy9 from 'node:path';
+import CJS_COMPAT_NODE_MODULE_j88npgqhy9 from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_1qqypd7gt14.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_1qqypd7gt14.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_1qqypd7gt14.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_j88npgqhy9.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_j88npgqhy9.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_j88npgqhy9.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Forkbook's esbuild configuration
@@ -12,35 +12,52 @@ var require = CJS_COMPAT_NODE_MODULE_1qqypd7gt14.createRequire(import.meta.url);
 import {
   esm_default,
   stringify
-} from "./chunk-ZPPVG262.js";
+} from "./chunk-SZYMLCHF.js";
 import {
-  visit
-} from "./chunk-AX2ALHBK.js";
+  EXIT,
+  convert,
+  visit,
+  visitParents
+} from "./chunk-MF5BYASO.js";
 import {
   walk
-} from "./chunk-KCAPE7OJ.js";
+} from "./chunk-PQLXHVWK.js";
 import {
   VFileMessage,
+  asciiAlpha,
+  asciiAlphanumeric,
+  asciiControl,
+  blankLine,
+  ccount,
+  classifyCharacter,
+  combineExtensions,
+  factorySpace,
   fromMarkdown,
+  markdownLineEnding,
+  markdownLineEndingOrSpace,
+  markdownSpace,
   mdxFromMarkdown,
   mdxToMarkdown,
   mdxjs,
   name,
+  normalizeIdentifier,
   normalizeUri,
   positionFromEstree,
-  stringifyPosition
-} from "./chunk-LSP54OYM.js";
+  resolveAll,
+  splice,
+  stringifyPosition,
+  toString,
+  unicodePunctuation,
+  unicodeWhitespace
+} from "./chunk-FTUQ7T3V.js";
 import {
   require_acorn_jsx
-} from "./chunk-RECGEABN.js";
-import {
-  isPlainObject
-} from "./chunk-MMFUHYSU.js";
+} from "./chunk-U6DHF3RM.js";
 import {
   __commonJS,
   __export,
   __toESM
-} from "./chunk-TZ2TZW2K.js";
+} from "./chunk-NLPC2DDQ.js";
 
 // ../../node_modules/inline-style-parser/cjs/index.js
 var require_cjs = __commonJS({
@@ -240,7 +257,7 @@ var require_extend = __commonJS({
 
 // src/addon-docs/mdx-plugin.ts
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { createFilter } from "@rollup/pluginutils";
+import { createFilter } from "vite";
 
 // ../../node_modules/vfile/lib/minpath.js
 import { default as default2 } from "node:path";
@@ -400,8 +417,8 @@ var order = (
    * @returns {undefined}
    *   Nothing.
    */
-  set path(path) {
-    isUrl(path) && (path = fileURLToPath(path)), assertNonEmpty(path, "path"), this.path !== path && this.history.push(path);
+  set path(path2) {
+    isUrl(path2) && (path2 = fileURLToPath(path2)), assertNonEmpty(path2, "path"), this.path !== path2 && this.history.push(path2);
   }
   /**
    * Get the stem (basename w/o extname) (example: `'index.min'`).
@@ -648,8 +665,8 @@ function assertNonEmpty(part, name2) {
   if (!part)
     throw new Error("`" + name2 + "` cannot be empty");
 }
-function assertPath(path, name2) {
-  if (!path)
+function assertPath(path2, name2) {
+  if (!path2)
     throw new Error("Setting `" + name2 + "` requires `path` to be set too");
 }
 function isUint8Array(value) {
@@ -772,8 +789,8 @@ function buildJsx(tree, options) {
 `).replace(/\n+/g, `
 `).replace(/\n+$/, "").replace(/^\n+/, "").replace(/\n/g, " ");
           if (value) {
-            let text3 = { type: "Literal", value };
-            create(child, text3), children.push(text3);
+            let text5 = { type: "Literal", value };
+            create(child, text5), children.push(text5);
           }
         } else
           child.type !== "JSXElement" && child.type !== "JSXFragment" && child.type, children.push(child);
@@ -900,21 +917,21 @@ function toProperty(node) {
   return create(node, replacement), replacement;
 }
 function toIdentifier(node) {
-  let replace;
+  let replace2;
   if (node.type === "JSXMemberExpression") {
     let id = toIdentifier(node.property);
-    replace = {
+    replace2 = {
       type: "MemberExpression",
       object: toIdentifier(node.object),
       property: id,
       computed: id.type === "Literal",
       optional: !1
     };
-  } else node.type === "JSXNamespacedName" ? replace = {
+  } else node.type === "JSXNamespacedName" ? replace2 = {
     type: "Literal",
     value: node.namespace.name + ":" + node.name.name
-  } : replace = name(node.name) ? { type: "Identifier", name: node.name } : { type: "Literal", value: node.name };
-  return create(node, replace), replace;
+  } : replace2 = name(node.name) ? { type: "Identifier", name: node.name } : { type: "Literal", value: node.name };
+  return create(node, replace2), replace2;
 }
 function toMemberExpression(id) {
   let identifiers = id.split("."), index = -1, result;
@@ -1039,22 +1056,22 @@ function formatExpression(state, node, parentNode, isRightHand) {
   let { generator } = state;
   expressionNeedsParenthesis(state, node, parentNode, isRightHand) ? (state.write("("), generator[node.type](node, state), state.write(")")) : generator[node.type](node, state);
 }
-function reindent(state, text3, indent, lineEnd) {
-  let lines = text3.split(`
+function reindent(state, text5, indent2, lineEnd) {
+  let lines = text5.split(`
 `), end = lines.length - 1;
   if (state.write(lines[0].trim()), end > 0) {
     state.write(lineEnd);
     for (let i = 1; i < end; i++)
-      state.write(indent + lines[i].trim() + lineEnd);
-    state.write(indent + lines[end].trim());
+      state.write(indent2 + lines[i].trim() + lineEnd);
+    state.write(indent2 + lines[end].trim());
   }
 }
-function formatComments(state, comments, indent, lineEnd) {
+function formatComments(state, comments, indent2, lineEnd) {
   let { length } = comments;
   for (let i = 0; i < length; i++) {
     let comment2 = comments[i];
-    state.write(indent), comment2.type[0] === "L" ? state.write("// " + comment2.value.trim() + `
-`, comment2) : (state.write("/*"), reindent(state, comment2.value, indent, lineEnd), state.write("*/" + lineEnd));
+    state.write(indent2), comment2.type[0] === "L" ? state.write("// " + comment2.value.trim() + `
+`, comment2) : (state.write("/*"), reindent(state, comment2.value, indent2, lineEnd), state.write("*/" + lineEnd));
   }
 }
 function hasCallExpression(node) {
@@ -1084,17 +1101,17 @@ var ForInStatement, FunctionDeclaration, RestElement, BinaryExpression, ArrayExp
   Default generator.
   */
   Program(node, state) {
-    let indent = state.indent.repeat(state.indentLevel), { lineEnd, writeComments } = state;
-    writeComments && node.comments != null && formatComments(state, node.comments, indent, lineEnd);
+    let indent2 = state.indent.repeat(state.indentLevel), { lineEnd, writeComments } = state;
+    writeComments && node.comments != null && formatComments(state, node.comments, indent2, lineEnd);
     let statements = node.body, { length } = statements;
     for (let i = 0; i < length; i++) {
       let statement = statements[i];
-      writeComments && statement.comments != null && formatComments(state, statement.comments, indent, lineEnd), state.write(indent), this[statement.type](statement, state), state.write(lineEnd);
+      writeComments && statement.comments != null && formatComments(state, statement.comments, indent2, lineEnd), state.write(indent2), this[statement.type](statement, state), state.write(lineEnd);
     }
-    writeComments && node.trailingComments != null && formatComments(state, node.trailingComments, indent, lineEnd);
+    writeComments && node.trailingComments != null && formatComments(state, node.trailingComments, indent2, lineEnd);
   },
   BlockStatement: BlockStatement = function(node, state) {
-    let indent = state.indent.repeat(state.indentLevel++), { lineEnd, writeComments } = state, statementIndent = indent + state.indent;
+    let indent2 = state.indent.repeat(state.indentLevel++), { lineEnd, writeComments } = state, statementIndent = indent2 + state.indent;
     state.write("{");
     let statements = node.body;
     if (statements != null && statements.length > 0) {
@@ -1104,9 +1121,9 @@ var ForInStatement, FunctionDeclaration, RestElement, BinaryExpression, ArrayExp
         let statement = statements[i];
         writeComments && statement.comments != null && formatComments(state, statement.comments, statementIndent, lineEnd), state.write(statementIndent), this[statement.type](statement, state), state.write(lineEnd);
       }
-      state.write(indent);
+      state.write(indent2);
     } else
-      writeComments && node.comments != null && (state.write(lineEnd), formatComments(state, node.comments, statementIndent, lineEnd), state.write(indent));
+      writeComments && node.comments != null && (state.write(lineEnd), formatComments(state, node.comments, statementIndent, lineEnd), state.write(indent2));
     writeComments && node.trailingComments != null && formatComments(state, node.trailingComments, statementIndent, lineEnd), state.write("}"), state.indentLevel--;
   },
   ClassBody: BlockStatement,
@@ -1136,9 +1153,9 @@ var ForInStatement, FunctionDeclaration, RestElement, BinaryExpression, ArrayExp
     state.write("with ("), this[node.object.type](node.object, state), state.write(") "), this[node.body.type](node.body, state);
   },
   SwitchStatement(node, state) {
-    let indent = state.indent.repeat(state.indentLevel++), { lineEnd, writeComments } = state;
+    let indent2 = state.indent.repeat(state.indentLevel++), { lineEnd, writeComments } = state;
     state.indentLevel++;
-    let caseIndent = indent + state.indent, statementIndent = caseIndent + state.indent;
+    let caseIndent = indent2 + state.indent, statementIndent = caseIndent + state.indent;
     state.write("switch ("), this[node.discriminant.type](node.discriminant, state), state.write(") {" + lineEnd);
     let { cases: occurences } = node, { length: occurencesCount } = occurences;
     for (let i = 0; i < occurencesCount; i++) {
@@ -1150,7 +1167,7 @@ var ForInStatement, FunctionDeclaration, RestElement, BinaryExpression, ArrayExp
         writeComments && statement.comments != null && formatComments(state, statement.comments, statementIndent, lineEnd), state.write(statementIndent), this[statement.type](statement, state), state.write(lineEnd);
       }
     }
-    state.indentLevel -= 2, state.write(indent + "}");
+    state.indentLevel -= 2, state.write(indent2 + "}");
   },
   ReturnStatement(node, state) {
     state.write("return"), node.argument && (state.write(" "), this[node.argument.type](node.argument, state)), state.write(";");
@@ -1346,7 +1363,7 @@ var ForInStatement, FunctionDeclaration, RestElement, BinaryExpression, ArrayExp
   },
   ArrayPattern: ArrayExpression,
   ObjectExpression(node, state) {
-    let indent = state.indent.repeat(state.indentLevel++), { lineEnd, writeComments } = state, propertyIndent = indent + state.indent;
+    let indent2 = state.indent.repeat(state.indentLevel++), { lineEnd, writeComments } = state, propertyIndent = indent2 + state.indent;
     if (state.write("{"), node.properties.length > 0) {
       state.write(lineEnd), writeComments && node.comments != null && formatComments(state, node.comments, propertyIndent, lineEnd);
       let comma = "," + lineEnd, { properties } = node, { length } = properties;
@@ -1357,8 +1374,8 @@ var ForInStatement, FunctionDeclaration, RestElement, BinaryExpression, ArrayExp
         else
           break;
       }
-      state.write(lineEnd), writeComments && node.trailingComments != null && formatComments(state, node.trailingComments, propertyIndent, lineEnd), state.write(indent + "}");
-    } else writeComments ? node.comments != null ? (state.write(lineEnd), formatComments(state, node.comments, propertyIndent, lineEnd), node.trailingComments != null && formatComments(state, node.trailingComments, propertyIndent, lineEnd), state.write(indent + "}")) : node.trailingComments != null ? (state.write(lineEnd), formatComments(state, node.trailingComments, propertyIndent, lineEnd), state.write(indent + "}")) : state.write("}") : state.write("}");
+      state.write(lineEnd), writeComments && node.trailingComments != null && formatComments(state, node.trailingComments, propertyIndent, lineEnd), state.write(indent2 + "}");
+    } else writeComments ? node.comments != null ? (state.write(lineEnd), formatComments(state, node.comments, propertyIndent, lineEnd), node.trailingComments != null && formatComments(state, node.trailingComments, propertyIndent, lineEnd), state.write(indent2 + "}")) : node.trailingComments != null ? (state.write(lineEnd), formatComments(state, node.trailingComments, propertyIndent, lineEnd), state.write(indent2 + "}")) : state.write("}") : state.write("}");
     state.indentLevel--;
   },
   Property(node, state) {
@@ -1459,19 +1476,19 @@ var State = class {
       source: setup.sourceMap.file || setup.sourceMap._file
     });
   }
-  write(code2) {
-    this.output += code2;
+  write(code5) {
+    this.output += code5;
   }
-  writeToStream(code2) {
-    this.output.write(code2);
+  writeToStream(code5) {
+    this.output.write(code5);
   }
-  writeAndMap(code2, node) {
-    this.output += code2, this.map(code2, node);
+  writeAndMap(code5, node) {
+    this.output += code5, this.map(code5, node);
   }
-  writeToStreamAndMap(code2, node) {
-    this.output.write(code2), this.map(code2, node);
+  writeToStreamAndMap(code5, node) {
+    this.output.write(code5), this.map(code5, node);
   }
-  map(code2, node) {
+  map(code5, node) {
     if (node != null) {
       let { type } = node;
       if (type[0] === "L" && type[2] === "n") {
@@ -1483,16 +1500,16 @@ var State = class {
         mapping.original = node.loc.start, mapping.name = node.name, this.sourceMap.addMapping(mapping);
       }
       if (type[0] === "T" && type[8] === "E" || type[0] === "L" && type[1] === "i" && typeof node.value == "string") {
-        let { length: length2 } = code2, { column, line } = this;
+        let { length: length2 } = code5, { column, line } = this;
         for (let i = 0; i < length2; i++)
-          code2[i] === `
+          code5[i] === `
 ` ? (column = 0, line++) : column++;
         this.column = column, this.line = line;
         return;
       }
     }
-    let { length } = code2, { lineEnd } = this;
-    length > 0 && (this.lineEndSize > 0 && (lineEnd.length === 1 ? code2[length - 1] === lineEnd : code2.endsWith(lineEnd)) ? (this.line += this.lineEndSize, this.column = 0) : this.column += length);
+    let { length } = code5, { lineEnd } = this;
+    length > 0 && (this.lineEndSize > 0 && (lineEnd.length === 1 ? code5[length - 1] === lineEnd : code5.endsWith(lineEnd)) ? (this.line += this.lineEndSize, this.column = 0) : this.column += length);
   }
   toString() {
     return this.output;
@@ -1514,8 +1531,8 @@ function toJs(tree, options) {
       generator: { ...GENERATOR, ...handlers3 },
       sourceMap: sourceMap || void 0
     }
-  ), map = sourceMap ? sourceMap.toJSON() : void 0;
-  return { value, map };
+  ), map3 = sourceMap ? sourceMap.toJSON() : void 0;
+  return { value, map: map3 };
 }
 
 // ../../node_modules/estree-util-to-js/lib/jsx.js
@@ -1671,8 +1688,8 @@ Schema.prototype.space = void 0;
 // ../../node_modules/property-information/lib/util/merge.js
 function merge(definitions, space) {
   let property = {}, normal = {};
-  for (let definition of definitions)
-    Object.assign(property, definition.property), Object.assign(normal, definition.normal);
+  for (let definition2 of definitions)
+    Object.assign(property, definition2.property), Object.assign(normal, definition2.normal);
   return new Schema(property, normal, space);
 }
 
@@ -1757,18 +1774,18 @@ function mark(values, key, value) {
 }
 
 // ../../node_modules/property-information/lib/util/create.js
-function create2(definition) {
+function create2(definition2) {
   let properties = {}, normals = {};
-  for (let [property, value] of Object.entries(definition.properties)) {
+  for (let [property, value] of Object.entries(definition2.properties)) {
     let info = new DefinedInfo(
       property,
-      definition.transform(definition.attributes || {}, property),
+      definition2.transform(definition2.attributes || {}, property),
       value,
-      definition.space
+      definition2.space
     );
-    definition.mustUseProperty && definition.mustUseProperty.includes(property) && (info.mustUseProperty = !0), properties[property] = info, normals[normalize(property)] = property, normals[normalize(info.attribute)] = property;
+    definition2.mustUseProperty && definition2.mustUseProperty.includes(property) && (info.mustUseProperty = !0), properties[property] = info, normals[normalize(property)] = property, normals[normalize(info.attribute)] = property;
   }
-  return new Schema(properties, normals, definition.space);
+  return new Schema(properties, normals, definition2.space);
 }
 
 // ../../node_modules/property-information/lib/aria.js
@@ -2991,8 +3008,8 @@ function toDash($0) {
 // ../../node_modules/estree-util-attach-comments/lib/index.js
 var own2 = {}.hasOwnProperty, emptyComments = [];
 function attachComments(tree, comments) {
-  let list2 = comments ? [...comments].sort(compare) : emptyComments;
-  list2.length > 0 && walk2(tree, { comments: list2, index: 0 });
+  let list3 = comments ? [...comments].sort(compare) : emptyComments;
+  list3.length > 0 && walk2(tree, { comments: list3, index: 0 });
 }
 function walk2(node, state) {
   if (state.index === state.comments.length)
@@ -3210,11 +3227,11 @@ function createState(options) {
     all,
     createJsxAttributeName,
     createJsxElementName,
-    handle,
+    handle: handle2,
     inherit,
     patch
   };
-  function handle(node) {
+  function handle2(node) {
     return one(node, this);
   }
 }
@@ -3397,7 +3414,7 @@ function emphasis(state, node) {
 function footnoteReference(state, node) {
   let clobberPrefix = typeof state.options.clobberPrefix == "string" ? state.options.clobberPrefix : "user-content-", id = String(node.identifier).toUpperCase(), safeId = normalizeUri(id.toLowerCase()), index = state.footnoteOrder.indexOf(id), counter, reuseCounter = state.footnoteCounts.get(id);
   reuseCounter === void 0 ? (reuseCounter = 0, state.footnoteOrder.push(id), counter = state.footnoteOrder.length) : counter = index + 1, reuseCounter += 1, state.footnoteCounts.set(id, reuseCounter);
-  let link2 = {
+  let link3 = {
     type: "element",
     tagName: "a",
     properties: {
@@ -3408,12 +3425,12 @@ function footnoteReference(state, node) {
     },
     children: [{ type: "text", value: String(counter) }]
   };
-  state.patch(node, link2);
+  state.patch(node, link3);
   let sup = {
     type: "element",
     tagName: "sup",
     properties: {},
-    children: [link2]
+    children: [link3]
   };
   return state.patch(node, sup), state.applyData(node, sup);
 }
@@ -3450,11 +3467,11 @@ function revert(state, node) {
 
 // ../../node_modules/mdast-util-to-hast/lib/handlers/image-reference.js
 function imageReference(state, node) {
-  let id = String(node.identifier).toUpperCase(), definition = state.definitionById.get(id);
-  if (!definition)
+  let id = String(node.identifier).toUpperCase(), definition2 = state.definitionById.get(id);
+  if (!definition2)
     return revert(state, node);
-  let properties = { src: normalizeUri(definition.url || ""), alt: node.alt };
-  definition.title !== null && definition.title !== void 0 && (properties.title = definition.title);
+  let properties = { src: normalizeUri(definition2.url || ""), alt: node.alt };
+  definition2.title !== null && definition2.title !== void 0 && (properties.title = definition2.title);
   let result = { type: "element", tagName: "img", properties, children: [] };
   return state.patch(node, result), state.applyData(node, result);
 }
@@ -3469,24 +3486,24 @@ function image(state, node) {
 
 // ../../node_modules/mdast-util-to-hast/lib/handlers/inline-code.js
 function inlineCode(state, node) {
-  let text3 = { type: "text", value: node.value.replace(/\r?\n|\r/g, " ") };
-  state.patch(node, text3);
+  let text5 = { type: "text", value: node.value.replace(/\r?\n|\r/g, " ") };
+  state.patch(node, text5);
   let result = {
     type: "element",
     tagName: "code",
     properties: {},
-    children: [text3]
+    children: [text5]
   };
   return state.patch(node, result), state.applyData(node, result);
 }
 
 // ../../node_modules/mdast-util-to-hast/lib/handlers/link-reference.js
 function linkReference(state, node) {
-  let id = String(node.identifier).toUpperCase(), definition = state.definitionById.get(id);
-  if (!definition)
+  let id = String(node.identifier).toUpperCase(), definition2 = state.definitionById.get(id);
+  if (!definition2)
     return revert(state, node);
-  let properties = { href: normalizeUri(definition.url || "") };
-  definition.title !== null && definition.title !== void 0 && (properties.title = definition.title);
+  let properties = { href: normalizeUri(definition2.url || "") };
+  definition2.title !== null && definition2.title !== void 0 && (properties.title = definition2.title);
   let result = {
     type: "element",
     tagName: "a",
@@ -3513,8 +3530,8 @@ function link(state, node) {
 function listItem(state, node, parent) {
   let results = state.all(node), loose = parent ? listLoose(parent) : listItemLoose(node), properties = {}, children = [];
   if (typeof node.checked == "boolean") {
-    let head = results[0], paragraph2;
-    head && head.type === "element" && head.tagName === "p" ? paragraph2 = head : (paragraph2 = { type: "element", tagName: "p", properties: {}, children: [] }, results.unshift(paragraph2)), paragraph2.children.length > 0 && paragraph2.children.unshift({ type: "text", value: " " }), paragraph2.children.unshift({
+    let head = results[0], paragraph3;
+    head && head.type === "element" && head.tagName === "p" ? paragraph3 = head : (paragraph3 = { type: "element", tagName: "p", properties: {}, children: [] }, results.unshift(paragraph3)), paragraph3.children.length > 0 && paragraph3.children.unshift({ type: "text", value: " " }), paragraph3.children.unshift({
       type: "element",
       tagName: "input",
       properties: { type: "checkbox", checked: node.checked, disabled: !0 },
@@ -3668,14 +3685,14 @@ function trimLines(value) {
 function trimLine(value, start, end) {
   let startIndex = 0, endIndex = value.length;
   if (start) {
-    let code2 = value.codePointAt(startIndex);
-    for (; code2 === 9 || code2 === 32; )
-      startIndex++, code2 = value.codePointAt(startIndex);
+    let code5 = value.codePointAt(startIndex);
+    for (; code5 === 9 || code5 === 32; )
+      startIndex++, code5 = value.codePointAt(startIndex);
   }
   if (end) {
-    let code2 = value.codePointAt(endIndex - 1);
-    for (; code2 === 9 || code2 === 32; )
-      endIndex--, code2 = value.codePointAt(endIndex - 1);
+    let code5 = value.codePointAt(endIndex - 1);
+    for (; code5 === 9 || code5 === 32; )
+      endIndex--, code5 = value.codePointAt(endIndex - 1);
   }
   return endIndex > startIndex ? value.slice(startIndex, endIndex) : "";
 }
@@ -3749,12 +3766,12 @@ function footer(state) {
     className: ["sr-only"]
   }, listItems = [], referenceIndex = -1;
   for (; ++referenceIndex < state.footnoteOrder.length; ) {
-    let definition = state.footnoteById.get(
+    let definition2 = state.footnoteById.get(
       state.footnoteOrder[referenceIndex]
     );
-    if (!definition)
+    if (!definition2)
       continue;
-    let content = state.all(definition), id = String(definition.identifier).toUpperCase(), safeId = normalizeUri(id.toLowerCase()), rereferenceIndex = 0, backReferences = [], counts = state.footnoteCounts.get(id);
+    let content = state.all(definition2), id = String(definition2.identifier).toUpperCase(), safeId = normalizeUri(id.toLowerCase()), rereferenceIndex = 0, backReferences = [], counts = state.footnoteCounts.get(id);
     for (; counts !== void 0 && ++rereferenceIndex <= counts; ) {
       backReferences.length > 0 && backReferences.push({ type: "text", value: " " });
       let children = typeof footnoteBackContent == "string" ? footnoteBackContent : footnoteBackContent(referenceIndex, rereferenceIndex);
@@ -3776,13 +3793,13 @@ function footer(state) {
       tailTail && tailTail.type === "text" ? tailTail.value += " " : tail.children.push({ type: "text", value: " " }), tail.children.push(...backReferences);
     } else
       content.push(...backReferences);
-    let listItem2 = {
+    let listItem3 = {
       type: "element",
       tagName: "li",
       properties: { id: clobberPrefix + "fn-" + safeId },
       children: state.wrap(content, !0)
     };
-    state.patch(definition, listItem2), listItems.push(listItem2);
+    state.patch(definition2, listItem3), listItems.push(listItem3);
   }
   if (listItems.length !== 0)
     return {
@@ -3831,14 +3848,14 @@ function createState2(tree, options) {
   };
   return visit(tree, function(node) {
     if (node.type === "definition" || node.type === "footnoteDefinition") {
-      let map = node.type === "definition" ? definitionById : footnoteById, id = String(node.identifier).toUpperCase();
-      map.has(id) || map.set(id, node);
+      let map3 = node.type === "definition" ? definitionById : footnoteById, id = String(node.identifier).toUpperCase();
+      map3.has(id) || map3.set(id, node);
     }
   }), state;
   function one(node, parent) {
-    let type = node.type, handle = state.handlers[type];
-    if (own5.call(state.handlers, type) && handle)
-      return handle(state, node, parent);
+    let type = node.type, handle2 = state.handlers[type];
+    if (own5.call(state.handlers, type) && handle2)
+      return handle2(state, node, parent);
     if (state.options.passThrough && state.options.passThrough.includes(type)) {
       if ("children" in node) {
         let { children, ...shallow } = node, result = esm_default(shallow);
@@ -3903,9 +3920,9 @@ function wrap(nodes, loose) {
 ` }), result;
 }
 function trimMarkdownSpaceStart(value) {
-  let index = 0, code2 = value.charCodeAt(index);
-  for (; code2 === 9 || code2 === 32; )
-    index++, code2 = value.charCodeAt(index);
+  let index = 0, code5 = value.charCodeAt(index);
+  for (; code5 === 9 || code5 === 32; )
+    index++, code5 = value.charCodeAt(index);
   return value.slice(index);
 }
 
@@ -3941,6 +3958,14 @@ function bail(error) {
 // ../../node_modules/unified/lib/index.js
 var import_extend = __toESM(require_extend(), 1);
 
+// ../../node_modules/is-plain-obj/index.js
+function isPlainObject(value) {
+  if (typeof value != "object" || value === null)
+    return !1;
+  let prototype = Object.getPrototypeOf(value);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+
 // ../../node_modules/trough/lib/index.js
 function trough() {
   let fns = [], pipeline = { run: run2, use };
@@ -4643,7 +4668,7 @@ function recmaBuildJsxTransform(options) {
 // ../../node_modules/estree-util-scope/lib/index.js
 function createVisitors() {
   let scopes = [{ block: !1, defined: [] }];
-  return { enter, exit, scopes };
+  return { enter, exit: exit2, scopes };
   function enter(node) {
     if (node.type === "ArrowFunctionExpression") {
       scopes.push({ block: !1, defined: [] });
@@ -4670,7 +4695,7 @@ function createVisitors() {
       for (let declaration of node.declarations)
         definePattern(declaration.id, node.kind !== "var");
   }
-  function exit(node) {
+  function exit2(node) {
     if (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression") {
       let scope = scopes.pop();
       scope.block;
@@ -4898,7 +4923,7 @@ function recmaDocument(options) {
       handleEsm(node);
     }
     function handleEsm(node) {
-      let replace, init;
+      let replace2, init;
       if (outputFormat === "function-body")
         if (
           // Always have a source:
@@ -4907,7 +4932,7 @@ function recmaDocument(options) {
         ) {
           node.source;
           let argument = { type: "ImportExpression", source: node.source };
-          create3(node, argument), init = { type: "AwaitExpression", argument }, (node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration") && node.specifiers.length === 0 ? replace = { type: "ExpressionStatement", expression: init } : replace = {
+          create3(node, argument), init = { type: "AwaitExpression", argument }, (node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration") && node.specifiers.length === 0 ? replace2 = { type: "ExpressionStatement", expression: init } : replace2 = {
             type: "VariableDeclaration",
             kind: "const",
             declarations: node.type === "ExportAllDeclaration" ? [
@@ -4922,7 +4947,7 @@ function recmaDocument(options) {
             ] : specifiersToDeclarations(node.specifiers, init)
           };
         } else if (node.declaration)
-          replace = node.declaration;
+          replace2 = node.declaration;
         else {
           let declarators = [];
           for (let specifier of node.specifiers)
@@ -4931,15 +4956,15 @@ function recmaDocument(options) {
               id: specifier.exported,
               init: specifier.local
             });
-          declarators.length > 0 && (replace = {
+          declarators.length > 0 && (replace2 = {
             type: "VariableDeclaration",
             kind: "const",
             declarations: declarators
           });
         }
       else
-        replace = node;
-      replace && replacement.push(replace);
+        replace2 = node;
+      replace2 && replacement.push(replace2);
     }
   };
   function createMdxContent(content, outputFormat2, hasInternalLayout) {
@@ -5514,10 +5539,10 @@ function rehypeRemoveRaw() {
 var js = /\s+/g, html4 = /[\t\n\v\f\r ]+/g;
 function collapseWhiteSpace(value, options) {
   options ? typeof options == "string" && (options = { style: options }) : options = {};
-  let replace = options.preserveLineEndings ? replaceLineEnding : replaceSpace;
+  let replace2 = options.preserveLineEndings ? replaceLineEnding : replaceSpace;
   return String(value).replace(
     options.style === "html" ? html4 : js,
-    options.trim ? trimFactory(replace) : replace
+    options.trim ? trimFactory(replace2) : replace2
   );
 }
 function replaceLineEnding(value) {
@@ -5527,10 +5552,10 @@ function replaceLineEnding(value) {
 function replaceSpace() {
   return " ";
 }
-function trimFactory(replace) {
+function trimFactory(replace2) {
   return dropOrReplace;
   function dropOrReplace(value, index, all2) {
-    return index === 0 || index + value.length === all2.length ? "" : replace(value);
+    return index === 0 || index + value.length === all2.length ? "" : replace2(value);
   }
 }
 
@@ -5624,26 +5649,2134 @@ function compile(vfileCompatible, compileOptions) {
 
 // ../../node_modules/@mdx-js/mdx/lib/run.js
 var AsyncFunction = Object.getPrototypeOf(run).constructor;
-async function run(code2, options) {
-  return new AsyncFunction(String(code2))(options);
+async function run(code5, options) {
+  return new AsyncFunction(String(code5))(options);
+}
+
+// ../../node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp/index.js
+function escapeStringRegexp(string) {
+  if (typeof string != "string")
+    throw new TypeError("Expected a string");
+  return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+}
+
+// ../../node_modules/mdast-util-find-and-replace/lib/index.js
+function findAndReplace(tree, list3, options) {
+  let ignored = convert((options || {}).ignore || []), pairs = toPairs(list3), pairIndex = -1;
+  for (; ++pairIndex < pairs.length; )
+    visitParents(tree, "text", visitor);
+  function visitor(node, parents) {
+    let index = -1, grandparent;
+    for (; ++index < parents.length; ) {
+      let parent = parents[index], siblings = grandparent ? grandparent.children : void 0;
+      if (ignored(
+        parent,
+        siblings ? siblings.indexOf(parent) : void 0,
+        grandparent
+      ))
+        return;
+      grandparent = parent;
+    }
+    if (grandparent)
+      return handler(node, parents);
+  }
+  function handler(node, parents) {
+    let parent = parents[parents.length - 1], find2 = pairs[pairIndex][0], replace2 = pairs[pairIndex][1], start = 0, index = parent.children.indexOf(node), change = !1, nodes = [];
+    find2.lastIndex = 0;
+    let match = find2.exec(node.value);
+    for (; match; ) {
+      let position2 = match.index, matchObject = {
+        index: match.index,
+        input: match.input,
+        stack: [...parents, node]
+      }, value = replace2(...match, matchObject);
+      if (typeof value == "string" && (value = value.length > 0 ? { type: "text", value } : void 0), value === !1)
+        find2.lastIndex = position2 + 1;
+      else {
+        if (start !== position2 && add({ type: "text", value: node.value.slice(start, position2) }), Array.isArray(value))
+          for (let child of value) add(child);
+        else value && add(value);
+        start = position2 + match[0].length, change = !0;
+      }
+      if (!find2.global)
+        break;
+      match = find2.exec(node.value);
+    }
+    return change ? (start < node.value.length && add({ type: "text", value: node.value.slice(start) }), parent.children.splice(index, 1, ...nodes)) : nodes = [node], index + nodes.length;
+    function add(child) {
+      let previous2 = nodes[nodes.length - 1];
+      previous2 && previous2.type === "text" && child.type === "text" ? previous2.value += child.value : nodes.push(child);
+    }
+  }
+}
+function toPairs(tupleOrList) {
+  if (!Array.isArray(tupleOrList))
+    throw new TypeError("Expected find and replace tuple or list of tuples");
+  let result = [], list3 = !tupleOrList[0] || Array.isArray(tupleOrList[0]) ? tupleOrList : [tupleOrList], index = -1;
+  for (; ++index < list3.length; ) {
+    let tuple = list3[index];
+    result.push([toExpression(tuple[0]), toFunction(tuple[1])]);
+  }
+  return result;
+}
+function toExpression(find2) {
+  return typeof find2 == "string" ? new RegExp(escapeStringRegexp(find2), "g") : find2;
+}
+function toFunction(replace2) {
+  return typeof replace2 == "function" ? replace2 : function() {
+    return replace2;
+  };
+}
+
+// ../../node_modules/mdast-util-gfm-autolink-literal/lib/index.js
+var inConstruct = "phrasing", notInConstruct = ["autolink", "link", "image", "label"];
+function gfmAutolinkLiteralFromMarkdown() {
+  return {
+    transforms: [transformGfmAutolinkLiterals],
+    enter: {
+      literalAutolink: enterLiteralAutolink,
+      literalAutolinkEmail: enterLiteralAutolinkValue,
+      literalAutolinkHttp: enterLiteralAutolinkValue,
+      literalAutolinkWww: enterLiteralAutolinkValue
+    },
+    exit: {
+      literalAutolink: exitLiteralAutolink,
+      literalAutolinkEmail: exitLiteralAutolinkEmail,
+      literalAutolinkHttp: exitLiteralAutolinkHttp,
+      literalAutolinkWww: exitLiteralAutolinkWww
+    }
+  };
+}
+function gfmAutolinkLiteralToMarkdown() {
+  return {
+    unsafe: [
+      {
+        character: "@",
+        before: "[+\\-.\\w]",
+        after: "[\\-.\\w]",
+        inConstruct,
+        notInConstruct
+      },
+      {
+        character: ".",
+        before: "[Ww]",
+        after: "[\\-.\\w]",
+        inConstruct,
+        notInConstruct
+      },
+      {
+        character: ":",
+        before: "[ps]",
+        after: "\\/",
+        inConstruct,
+        notInConstruct
+      }
+    ]
+  };
+}
+function enterLiteralAutolink(token) {
+  this.enter({ type: "link", title: null, url: "", children: [] }, token);
+}
+function enterLiteralAutolinkValue(token) {
+  this.config.enter.autolinkProtocol.call(this, token);
+}
+function exitLiteralAutolinkHttp(token) {
+  this.config.exit.autolinkProtocol.call(this, token);
+}
+function exitLiteralAutolinkWww(token) {
+  this.config.exit.data.call(this, token);
+  let node = this.stack[this.stack.length - 1];
+  node.type, node.url = "http://" + this.sliceSerialize(token);
+}
+function exitLiteralAutolinkEmail(token) {
+  this.config.exit.autolinkEmail.call(this, token);
+}
+function exitLiteralAutolink(token) {
+  this.exit(token);
+}
+function transformGfmAutolinkLiterals(tree) {
+  findAndReplace(
+    tree,
+    [
+      [/(https?:\/\/|www(?=\.))([-.\w]+)([^ \t\r\n]*)/gi, findUrl],
+      [new RegExp("(?<=^|\\s|\\p{P}|\\p{S})([-.\\w+]+)@([-\\w]+(?:\\.[-\\w]+)+)", "gu"), findEmail]
+    ],
+    { ignore: ["link", "linkReference"] }
+  );
+}
+function findUrl(_, protocol, domain2, path2, match) {
+  let prefix = "";
+  if (!previous(match) || (/^w/i.test(protocol) && (domain2 = protocol + domain2, protocol = "", prefix = "http://"), !isCorrectDomain(domain2)))
+    return !1;
+  let parts = splitUrl(domain2 + path2);
+  if (!parts[0]) return !1;
+  let result = {
+    type: "link",
+    title: null,
+    url: prefix + protocol + parts[0],
+    children: [{ type: "text", value: protocol + parts[0] }]
+  };
+  return parts[1] ? [result, { type: "text", value: parts[1] }] : result;
+}
+function findEmail(_, atext, label, match) {
+  return (
+    // Not an expected previous character.
+    !previous(match, !0) || // Label ends in not allowed character.
+    /[-\d_]$/.test(label) ? !1 : {
+      type: "link",
+      title: null,
+      url: "mailto:" + atext + "@" + label,
+      children: [{ type: "text", value: atext + "@" + label }]
+    }
+  );
+}
+function isCorrectDomain(domain2) {
+  let parts = domain2.split(".");
+  return !(parts.length < 2 || parts[parts.length - 1] && (/_/.test(parts[parts.length - 1]) || !/[a-zA-Z\d]/.test(parts[parts.length - 1])) || parts[parts.length - 2] && (/_/.test(parts[parts.length - 2]) || !/[a-zA-Z\d]/.test(parts[parts.length - 2])));
+}
+function splitUrl(url) {
+  let trailExec = /[!"&'),.:;<>?\]}]+$/.exec(url);
+  if (!trailExec)
+    return [url, void 0];
+  url = url.slice(0, trailExec.index);
+  let trail2 = trailExec[0], closingParenIndex = trail2.indexOf(")"), openingParens = ccount(url, "("), closingParens = ccount(url, ")");
+  for (; closingParenIndex !== -1 && openingParens > closingParens; )
+    url += trail2.slice(0, closingParenIndex + 1), trail2 = trail2.slice(closingParenIndex + 1), closingParenIndex = trail2.indexOf(")"), closingParens++;
+  return [url, trail2];
+}
+function previous(match, email) {
+  let code5 = match.input.charCodeAt(match.index - 1);
+  return (match.index === 0 || unicodeWhitespace(code5) || unicodePunctuation(code5)) && // If it’s an email, the previous character should not be a slash.
+  (!email || code5 !== 47);
+}
+
+// ../../node_modules/mdast-util-gfm-footnote/lib/index.js
+footnoteReference2.peek = footnoteReferencePeek;
+function enterFootnoteCallString() {
+  this.buffer();
+}
+function enterFootnoteCall(token) {
+  this.enter({ type: "footnoteReference", identifier: "", label: "" }, token);
+}
+function enterFootnoteDefinitionLabelString() {
+  this.buffer();
+}
+function enterFootnoteDefinition(token) {
+  this.enter(
+    { type: "footnoteDefinition", identifier: "", label: "", children: [] },
+    token
+  );
+}
+function exitFootnoteCallString(token) {
+  let label = this.resume(), node = this.stack[this.stack.length - 1];
+  node.type, node.identifier = normalizeIdentifier(
+    this.sliceSerialize(token)
+  ).toLowerCase(), node.label = label;
+}
+function exitFootnoteCall(token) {
+  this.exit(token);
+}
+function exitFootnoteDefinitionLabelString(token) {
+  let label = this.resume(), node = this.stack[this.stack.length - 1];
+  node.type, node.identifier = normalizeIdentifier(
+    this.sliceSerialize(token)
+  ).toLowerCase(), node.label = label;
+}
+function exitFootnoteDefinition(token) {
+  this.exit(token);
+}
+function footnoteReferencePeek() {
+  return "[";
+}
+function footnoteReference2(node, _, state, info) {
+  let tracker = state.createTracker(info), value = tracker.move("[^"), exit2 = state.enter("footnoteReference"), subexit = state.enter("reference");
+  return value += tracker.move(
+    state.safe(state.associationId(node), { after: "]", before: value })
+  ), subexit(), exit2(), value += tracker.move("]"), value;
+}
+function gfmFootnoteFromMarkdown() {
+  return {
+    enter: {
+      gfmFootnoteCallString: enterFootnoteCallString,
+      gfmFootnoteCall: enterFootnoteCall,
+      gfmFootnoteDefinitionLabelString: enterFootnoteDefinitionLabelString,
+      gfmFootnoteDefinition: enterFootnoteDefinition
+    },
+    exit: {
+      gfmFootnoteCallString: exitFootnoteCallString,
+      gfmFootnoteCall: exitFootnoteCall,
+      gfmFootnoteDefinitionLabelString: exitFootnoteDefinitionLabelString,
+      gfmFootnoteDefinition: exitFootnoteDefinition
+    }
+  };
+}
+function gfmFootnoteToMarkdown(options) {
+  let firstLineBlank = !1;
+  return options && options.firstLineBlank && (firstLineBlank = !0), {
+    handlers: { footnoteDefinition, footnoteReference: footnoteReference2 },
+    // This is on by default already.
+    unsafe: [{ character: "[", inConstruct: ["label", "phrasing", "reference"] }]
+  };
+  function footnoteDefinition(node, _, state, info) {
+    let tracker = state.createTracker(info), value = tracker.move("[^"), exit2 = state.enter("footnoteDefinition"), subexit = state.enter("label");
+    return value += tracker.move(
+      state.safe(state.associationId(node), { before: value, after: "]" })
+    ), subexit(), value += tracker.move("]:"), node.children && node.children.length > 0 && (tracker.shift(4), value += tracker.move(
+      (firstLineBlank ? `
+` : " ") + state.indentLines(
+        state.containerFlow(node, tracker.current()),
+        firstLineBlank ? mapAll : mapExceptFirst
+      )
+    )), exit2(), value;
+  }
+}
+function mapExceptFirst(line, index, blank) {
+  return index === 0 ? line : mapAll(line, index, blank);
+}
+function mapAll(line, index, blank) {
+  return (blank ? "" : "    ") + line;
+}
+
+// ../../node_modules/mdast-util-gfm-strikethrough/lib/index.js
+var constructsWithoutStrikethrough = [
+  "autolink",
+  "destinationLiteral",
+  "destinationRaw",
+  "reference",
+  "titleQuote",
+  "titleApostrophe"
+];
+handleDelete.attention = attentionDelete;
+handleDelete.peek = peekDelete;
+function gfmStrikethroughFromMarkdown() {
+  return {
+    canContainEols: ["delete"],
+    enter: { strikethrough: enterStrikethrough },
+    exit: { strikethrough: exitStrikethrough }
+  };
+}
+function gfmStrikethroughToMarkdown() {
+  return {
+    handlers: { delete: handleDelete },
+    unsafe: [
+      {
+        character: "~",
+        inConstruct: "phrasing",
+        notInConstruct: constructsWithoutStrikethrough
+      }
+    ]
+  };
+}
+function enterStrikethrough(token) {
+  this.enter({ type: "delete", children: [], position: void 0 }, token);
+}
+function exitStrikethrough(token) {
+  this.exit(token);
+}
+function handleDelete(node, _, state, info) {
+  let tracker = state.createTracker(info), sequence = state.stack.includes("strikethrough") ? "~" : "~~", exit2 = state.enter("strikethrough"), value = tracker.move(sequence);
+  return value += state.containerPhrasing(node, {
+    ...tracker.current(),
+    before: value,
+    after: "~"
+  }), value += tracker.move(sequence), exit2(), value;
+}
+function attentionDelete() {
+  return { construct: "strikethrough", markers: ["~"], sizes: [2, 1] };
+}
+function peekDelete() {
+  return "~";
+}
+
+// ../../node_modules/markdown-table/index.js
+function defaultStringLength(value) {
+  return value.length;
+}
+function markdownTable(table2, options) {
+  let settings = options || {}, align = (settings.align || []).concat(), stringLength = settings.stringLength || defaultStringLength, alignments = [], cellMatrix = [], sizeMatrix = [], longestCellByColumn = [], mostCellsPerRow = 0, rowIndex = -1;
+  for (; ++rowIndex < table2.length; ) {
+    let row2 = [], sizes2 = [], columnIndex2 = -1;
+    for (table2[rowIndex].length > mostCellsPerRow && (mostCellsPerRow = table2[rowIndex].length); ++columnIndex2 < table2[rowIndex].length; ) {
+      let cell = serialize(table2[rowIndex][columnIndex2]);
+      if (settings.alignDelimiters !== !1) {
+        let size = stringLength(cell);
+        sizes2[columnIndex2] = size, (longestCellByColumn[columnIndex2] === void 0 || size > longestCellByColumn[columnIndex2]) && (longestCellByColumn[columnIndex2] = size);
+      }
+      row2.push(cell);
+    }
+    cellMatrix[rowIndex] = row2, sizeMatrix[rowIndex] = sizes2;
+  }
+  let columnIndex = -1;
+  if (typeof align == "object" && "length" in align)
+    for (; ++columnIndex < mostCellsPerRow; )
+      alignments[columnIndex] = toAlignment(align[columnIndex]);
+  else {
+    let code5 = toAlignment(align);
+    for (; ++columnIndex < mostCellsPerRow; )
+      alignments[columnIndex] = code5;
+  }
+  columnIndex = -1;
+  let row = [], sizes = [];
+  for (; ++columnIndex < mostCellsPerRow; ) {
+    let code5 = alignments[columnIndex], before = "", after = "";
+    code5 === 99 ? (before = ":", after = ":") : code5 === 108 ? before = ":" : code5 === 114 && (after = ":");
+    let size = settings.alignDelimiters === !1 ? 1 : Math.max(
+      1,
+      longestCellByColumn[columnIndex] - before.length - after.length
+    ), cell = before + "-".repeat(size) + after;
+    settings.alignDelimiters !== !1 && (size = before.length + size + after.length, size > longestCellByColumn[columnIndex] && (longestCellByColumn[columnIndex] = size), sizes[columnIndex] = size), row[columnIndex] = cell;
+  }
+  cellMatrix.splice(1, 0, row), sizeMatrix.splice(1, 0, sizes), rowIndex = -1;
+  let lines = [];
+  for (; ++rowIndex < cellMatrix.length; ) {
+    let row2 = cellMatrix[rowIndex], sizes2 = sizeMatrix[rowIndex];
+    columnIndex = -1;
+    let line = [];
+    for (; ++columnIndex < mostCellsPerRow; ) {
+      let cell = row2[columnIndex] || "", before = "", after = "";
+      if (settings.alignDelimiters !== !1) {
+        let size = longestCellByColumn[columnIndex] - (sizes2[columnIndex] || 0), code5 = alignments[columnIndex];
+        code5 === 114 ? before = " ".repeat(size) : code5 === 99 ? size % 2 ? (before = " ".repeat(size / 2 + 0.5), after = " ".repeat(size / 2 - 0.5)) : (before = " ".repeat(size / 2), after = before) : after = " ".repeat(size);
+      }
+      settings.delimiterStart !== !1 && !columnIndex && line.push("|"), settings.padding !== !1 && // Don’t add the opening space if we’re not aligning and the cell is
+      // empty: there will be a closing space.
+      !(settings.alignDelimiters === !1 && cell === "") && (settings.delimiterStart !== !1 || columnIndex) && line.push(" "), settings.alignDelimiters !== !1 && line.push(before), line.push(cell), settings.alignDelimiters !== !1 && line.push(after), settings.padding !== !1 && line.push(" "), (settings.delimiterEnd !== !1 || columnIndex !== mostCellsPerRow - 1) && line.push("|");
+    }
+    lines.push(
+      settings.delimiterEnd === !1 ? line.join("").replace(/ +$/, "") : line.join("")
+    );
+  }
+  return lines.join(`
+`);
+}
+function serialize(value) {
+  return value == null ? "" : String(value);
+}
+function toAlignment(value) {
+  let code5 = typeof value == "string" ? value.codePointAt(0) : 0;
+  return code5 === 67 || code5 === 99 ? 99 : code5 === 76 || code5 === 108 ? 108 : code5 === 82 || code5 === 114 ? 114 : 0;
+}
+
+// ../../node_modules/mdast-util-phrasing/lib/index.js
+var phrasing = (
+  /** @type {(node?: unknown) => node is Exclude<PhrasingContent, Html>} */
+  convert([
+    "break",
+    "delete",
+    "emphasis",
+    // To do: next major: removed since footnotes were added to GFM.
+    "footnote",
+    "footnoteReference",
+    "image",
+    "imageReference",
+    "inlineCode",
+    // Enabled by `mdast-util-math`:
+    "inlineMath",
+    "link",
+    "linkReference",
+    // Enabled by `mdast-util-mdx`:
+    "mdxJsxTextElement",
+    // Enabled by `mdast-util-mdx`:
+    "mdxTextExpression",
+    "strong",
+    "text",
+    // Enabled by `mdast-util-directive`:
+    "textDirective"
+  ])
+);
+
+// ../../node_modules/mdast-util-to-markdown/lib/configure.js
+var own7 = {}.hasOwnProperty;
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/blockquote.js
+function blockquote2(node, _, state, info) {
+  let exit2 = state.enter("blockquote"), tracker = state.createTracker(info);
+  tracker.move("> "), tracker.shift(2);
+  let value = state.indentLines(
+    state.containerFlow(node, tracker.current()),
+    map
+  );
+  return exit2(), value;
+}
+function map(line, _, blank) {
+  return ">" + (blank ? "" : " ") + line;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js
+function patternInScope(stack, pattern) {
+  return listInScope(stack, pattern.inConstruct, !0) && !listInScope(stack, pattern.notInConstruct, !1);
+}
+function listInScope(stack, list3, none) {
+  if (typeof list3 == "string" && (list3 = [list3]), !list3 || list3.length === 0)
+    return none;
+  let index = -1;
+  for (; ++index < list3.length; )
+    if (stack.includes(list3[index]))
+      return !0;
+  return !1;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/break.js
+function hardBreak2(_, _1, state, info) {
+  let index = -1;
+  for (; ++index < state.unsafe.length; ) {
+    let pattern = state.unsafe[index];
+    if (pattern.character === `
+` && !pattern.before && !pattern.after && patternInScope(state.stack, pattern))
+      return /[\t ]/.test(info.before) ? "" : " ";
+  }
+  return `\\
+`;
+}
+
+// ../../node_modules/longest-streak/index.js
+function longestStreak(value, substring) {
+  let source = String(value), index = source.indexOf(substring), expected = index, count = 0, max = 0;
+  if (typeof substring != "string")
+    throw new TypeError("Expected substring");
+  for (; index !== -1; )
+    index === expected ? ++count > max && (max = count) : count = 1, expected = index + substring.length, index = source.indexOf(substring, expected);
+  return max;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/format-code-as-indented.js
+function formatCodeAsIndented(node, state) {
+  return !!(state.options.fences === !1 && node.value && // If there’s no info…
+  !node.lang && // And there’s a non-whitespace character…
+  /[^\n\r ]/.test(node.value) && // And the value doesn’t start or end in a blank…
+  !/^[\t ]*(?:[\n\r]|$)|(?:^|[\n\r])[\t ]*$/.test(node.value));
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/check-fence.js
+function checkFence(state) {
+  let marker = state.options.fence || "`";
+  if (marker !== "`" && marker !== "~")
+    throw new Error(
+      "Cannot serialize code with `" + marker + "` for `options.fence`, expected `` ` `` or `~`"
+    );
+  return marker;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/code.js
+function code2(node, _, state, info) {
+  let marker = checkFence(state), raw = node.value || "";
+  if (formatCodeAsIndented(node, state)) {
+    let exit3 = state.enter("codeIndented"), value2 = state.indentLines(raw, map2);
+    return exit3(), value2;
+  }
+  let tracker = state.createTracker(info), sequence = marker.repeat(Math.max(longestStreak(raw, marker) + 1, 3)), exit2 = state.enter("codeFenced"), suffix = marker === "`" ? "GraveAccent" : "Tilde", value = tracker.move(sequence);
+  if (node.lang) {
+    let subexit = state.enter(`codeFencedLang${suffix}`);
+    value += tracker.move(
+      state.safe(node.lang, {
+        before: value,
+        after: " ",
+        encode: ["`"],
+        ...tracker.current()
+      })
+    ), subexit();
+  }
+  if (node.lang && node.meta) {
+    let subexit = state.enter(`codeFencedMeta${suffix}`);
+    value += tracker.move(" "), value += tracker.move(
+      state.safe(node.meta, {
+        before: value,
+        after: `
+`,
+        encode: ["`"],
+        ...tracker.current()
+      })
+    ), subexit();
+  }
+  return value += tracker.move(`
+`), raw && (value += tracker.move(raw + `
+`)), value += tracker.move(sequence), exit2(), value;
+}
+function map2(line, _, blank) {
+  return (blank ? "" : "    ") + line;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/check-quote.js
+function checkQuote(state) {
+  let marker = state.options.quote || '"';
+  if (marker !== '"' && marker !== "'")
+    throw new Error(
+      "Cannot serialize title with `" + marker + "` for `options.quote`, expected `\"`, or `'`"
+    );
+  return marker;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/definition.js
+function definition(node, _, state, info) {
+  let quote = checkQuote(state), suffix = quote === '"' ? "Quote" : "Apostrophe", exit2 = state.enter("definition"), subexit = state.enter("label"), tracker = state.createTracker(info), value = tracker.move("[");
+  return value += tracker.move(
+    state.safe(state.associationId(node), {
+      before: value,
+      after: "]",
+      ...tracker.current()
+    })
+  ), value += tracker.move("]: "), subexit(), // If there’s no url, or…
+  !node.url || // If there are control characters or whitespace.
+  /[\0- \u007F]/.test(node.url) ? (subexit = state.enter("destinationLiteral"), value += tracker.move("<"), value += tracker.move(
+    state.safe(node.url, { before: value, after: ">", ...tracker.current() })
+  ), value += tracker.move(">")) : (subexit = state.enter("destinationRaw"), value += tracker.move(
+    state.safe(node.url, {
+      before: value,
+      after: node.title ? " " : `
+`,
+      ...tracker.current()
+    })
+  )), subexit(), node.title && (subexit = state.enter(`title${suffix}`), value += tracker.move(" " + quote), value += tracker.move(
+    state.safe(node.title, {
+      before: value,
+      after: quote,
+      ...tracker.current()
+    })
+  ), value += tracker.move(quote), subexit()), exit2(), value;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/check-emphasis.js
+function checkEmphasis(state) {
+  let marker = state.options.emphasis || "*";
+  if (marker !== "*" && marker !== "_")
+    throw new Error(
+      "Cannot serialize emphasis with `" + marker + "` for `options.emphasis`, expected `*`, or `_`"
+    );
+  return marker;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/emphasis.js
+emphasis2.attention = attention;
+emphasis2.peek = peek;
+function emphasis2(node, _, state, info) {
+  let exit2 = state.enter("phrasing"), value = state.containerPhrasing({ type: "root", children: [node] }, info);
+  return exit2(), value;
+}
+function attention(_, state) {
+  return {
+    construct: "emphasis",
+    markers: checkEmphasis(state) === "*" ? ["*", "_"] : ["_", "*"],
+    sizes: [1]
+  };
+}
+function peek(_, _1, state) {
+  return state.options.emphasis || "*";
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/encode-character-reference.js
+function encodeCharacterReference(code5) {
+  return "&#x" + code5.toString(16).toUpperCase() + ";";
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js
+function formatHeadingAsSetext(node, state) {
+  let literalWithBreak = !1;
+  return visit(node, function(node2) {
+    if ("value" in node2 && /\r?\n|\r/.test(node2.value) || node2.type === "break")
+      return literalWithBreak = !0, EXIT;
+  }), !!((!node.depth || node.depth < 3) && toString(node) && (state.options.setext || literalWithBreak));
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/heading.js
+function heading2(node, _, state, info) {
+  let rank = Math.max(Math.min(6, node.depth || 1), 1), tracker = state.createTracker(info);
+  if (formatHeadingAsSetext(node, state)) {
+    let exit3 = state.enter("headingSetext"), subexit2 = state.enter("phrasing"), value2 = state.containerPhrasing(node, {
+      ...tracker.current(),
+      before: `
+`,
+      after: `
+`
+    });
+    return subexit2(), exit3(), value2 + `
+` + (rank === 1 ? "=" : "-").repeat(
+      // The whole size…
+      value2.length - // Minus the position of the character after the last EOL (or
+      // 0 if there is none)…
+      (Math.max(value2.lastIndexOf("\r"), value2.lastIndexOf(`
+`)) + 1)
+    );
+  }
+  let sequence = "#".repeat(rank), exit2 = state.enter("headingAtx"), subexit = state.enter("phrasing");
+  tracker.move(sequence + " ");
+  let value = state.containerPhrasing(node, {
+    before: "# ",
+    after: `
+`,
+    ...tracker.current()
+  }), head = value.charCodeAt(0);
+  return (head === 9 || head === 32) && (value = encodeCharacterReference(head) + value.slice(1)), value = value ? sequence + " " + value : sequence, state.options.closeAtx && (value += " " + sequence), subexit(), exit2(), value;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/html.js
+html5.peek = htmlPeek;
+function html5(node) {
+  return node.value || "";
+}
+function htmlPeek() {
+  return "<";
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/image.js
+image2.peek = imagePeek;
+function image2(node, _, state, info) {
+  let quote = checkQuote(state), suffix = quote === '"' ? "Quote" : "Apostrophe", exit2 = state.enter("image"), subexit = state.enter("label"), tracker = state.createTracker(info), value = tracker.move("![");
+  return value += tracker.move(
+    state.safe(node.alt, { before: value, after: "]", ...tracker.current() })
+  ), value += tracker.move("]("), subexit(), // If there’s no url but there is a title…
+  !node.url && node.title || // If there are control characters or whitespace.
+  /[\0- \u007F]/.test(node.url) ? (subexit = state.enter("destinationLiteral"), value += tracker.move("<"), value += tracker.move(
+    state.safe(node.url, { before: value, after: ">", ...tracker.current() })
+  ), value += tracker.move(">")) : (subexit = state.enter("destinationRaw"), value += tracker.move(
+    state.safe(node.url, {
+      before: value,
+      after: node.title ? " " : ")",
+      ...tracker.current()
+    })
+  )), subexit(), node.title && (subexit = state.enter(`title${suffix}`), value += tracker.move(" " + quote), value += tracker.move(
+    state.safe(node.title, {
+      before: value,
+      after: quote,
+      ...tracker.current()
+    })
+  ), value += tracker.move(quote), subexit()), value += tracker.move(")"), exit2(), value;
+}
+function imagePeek() {
+  return "!";
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/image-reference.js
+imageReference2.peek = imageReferencePeek;
+function imageReference2(node, _, state, info) {
+  let type = node.referenceType, exit2 = state.enter("imageReference"), subexit = state.enter("label"), tracker = state.createTracker(info), value = tracker.move("!["), alt = state.safe(node.alt, {
+    before: value,
+    after: "]",
+    ...tracker.current()
+  });
+  value += tracker.move(alt + "]["), subexit();
+  let stack = state.stack;
+  state.stack = stack.filter(function(d) {
+    return d !== "phrasing";
+  }), subexit = state.enter("reference");
+  let reference = state.safe(state.associationId(node), {
+    before: value,
+    after: "]",
+    ...tracker.current()
+  });
+  return subexit(), state.stack = stack, exit2(), type === "full" || !alt || alt !== reference ? value += tracker.move(reference + "]") : type === "shortcut" ? value = value.slice(0, -1) : value += tracker.move("]"), value;
+}
+function imageReferencePeek() {
+  return "!";
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/inline-code.js
+inlineCode2.peek = inlineCodePeek;
+function inlineCode2(node, _, state) {
+  let value = node.value || "", sequence = "`", index = -1;
+  for (; new RegExp("(^|[^`])" + sequence + "([^`]|$)").test(value); )
+    sequence += "`";
+  for (/[^\n\r ]/.test(value) && (/^[\n\r ]/.test(value) && /[\n\r ]$/.test(value) || /^`|`$/.test(value)) && (value = " " + value + " "); ++index < state.unsafe.length; ) {
+    let pattern = state.unsafe[index], expression = state.compilePattern(pattern);
+    if (!pattern.atBreak) continue;
+    let match;
+    for (; match = expression.exec(value); ) {
+      let position2 = match.index;
+      value.charCodeAt(position2) === 10 && value.charCodeAt(position2 - 1) === 13 && position2--, value = value.slice(0, position2) + " " + value.slice(match.index + 1);
+    }
+  }
+  return sequence + value + sequence;
+}
+function inlineCodePeek() {
+  return "`";
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.js
+function formatLinkAsAutolink(node, state) {
+  let raw = toString(node);
+  return !!(!state.options.resourceLink && // If there’s a url…
+  node.url && // And there’s no title…
+  !node.title && // And the content of `node` is a single text node…
+  node.children && node.children.length === 1 && node.children[0].type === "text" && // And if the url is the same as the content…
+  (raw === node.url || "mailto:" + raw === node.url) && // And that starts w/ a protocol…
+  /^[a-z][+\-.a-z]+:/i.test(node.url) && // And that doesn’t contain ASCII control codes (character escapes and
+  // references don’t work), space, or angle brackets…
+  !/[\0- <>\u007F]/.test(node.url));
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/link.js
+link2.peek = linkPeek;
+function link2(node, _, state, info) {
+  let quote = checkQuote(state), suffix = quote === '"' ? "Quote" : "Apostrophe", tracker = state.createTracker(info);
+  if (formatLinkAsAutolink(node, state)) {
+    let stack = state.stack;
+    state.stack = stack.filter(function(d) {
+      return d !== "phrasing";
+    });
+    let exit3 = state.enter("autolink"), value2 = tracker.move("<");
+    return value2 += tracker.move(
+      state.containerPhrasing(node, {
+        before: value2,
+        after: ">",
+        ...tracker.current()
+      })
+    ), value2 += tracker.move(">"), exit3(), state.stack = stack, value2;
+  }
+  let exit2 = state.enter("link"), subexit = state.enter("label"), value = tracker.move("[");
+  return value += tracker.move(
+    state.containerPhrasing(node, {
+      before: value,
+      after: "](",
+      ...tracker.current()
+    })
+  ), value += tracker.move("]("), subexit(), // If there’s no url but there is a title…
+  !node.url && node.title || // If there are control characters or whitespace.
+  /[\0- \u007F]/.test(node.url) ? (subexit = state.enter("destinationLiteral"), value += tracker.move("<"), value += tracker.move(
+    state.safe(node.url, { before: value, after: ">", ...tracker.current() })
+  ), value += tracker.move(">")) : (subexit = state.enter("destinationRaw"), value += tracker.move(
+    state.safe(node.url, {
+      before: value,
+      after: node.title ? " " : ")",
+      ...tracker.current()
+    })
+  )), subexit(), node.title && (subexit = state.enter(`title${suffix}`), value += tracker.move(" " + quote), value += tracker.move(
+    state.safe(node.title, {
+      before: value,
+      after: quote,
+      ...tracker.current()
+    })
+  ), value += tracker.move(quote), subexit()), value += tracker.move(")"), exit2(), value;
+}
+function linkPeek(node, _, state) {
+  return formatLinkAsAutolink(node, state) ? "<" : "[";
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/link-reference.js
+linkReference2.peek = linkReferencePeek;
+function linkReference2(node, _, state, info) {
+  let type = node.referenceType, exit2 = state.enter("linkReference"), subexit = state.enter("label"), tracker = state.createTracker(info), value = tracker.move("["), text5 = state.containerPhrasing(node, {
+    before: value,
+    after: "]",
+    ...tracker.current()
+  });
+  value += tracker.move(text5 + "]["), subexit();
+  let stack = state.stack;
+  state.stack = stack.filter(function(d) {
+    return d !== "phrasing";
+  }), subexit = state.enter("reference");
+  let reference = state.safe(state.associationId(node), {
+    before: value,
+    after: "]",
+    ...tracker.current()
+  });
+  return subexit(), state.stack = stack, exit2(), type === "full" || !text5 || text5 !== reference ? value += tracker.move(reference + "]") : type === "shortcut" ? value = value.slice(0, -1) : value += tracker.move("]"), value;
+}
+function linkReferencePeek() {
+  return "[";
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/check-bullet.js
+function checkBullet(state) {
+  let marker = state.options.bullet || "*";
+  if (marker !== "*" && marker !== "+" && marker !== "-")
+    throw new Error(
+      "Cannot serialize items with `" + marker + "` for `options.bullet`, expected `*`, `+`, or `-`"
+    );
+  return marker;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/check-bullet-other.js
+function checkBulletOther(state) {
+  let bullet = checkBullet(state), bulletOther = state.options.bulletOther;
+  if (!bulletOther)
+    return bullet === "*" ? "-" : "*";
+  if (bulletOther !== "*" && bulletOther !== "+" && bulletOther !== "-")
+    throw new Error(
+      "Cannot serialize items with `" + bulletOther + "` for `options.bulletOther`, expected `*`, `+`, or `-`"
+    );
+  if (bulletOther === bullet)
+    throw new Error(
+      "Expected `bullet` (`" + bullet + "`) and `bulletOther` (`" + bulletOther + "`) to be different"
+    );
+  return bulletOther;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/check-bullet-ordered.js
+function checkBulletOrdered(state) {
+  let marker = state.options.bulletOrdered || ".";
+  if (marker !== "." && marker !== ")")
+    throw new Error(
+      "Cannot serialize items with `" + marker + "` for `options.bulletOrdered`, expected `.` or `)`"
+    );
+  return marker;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/check-rule.js
+function checkRule(state) {
+  let marker = state.options.rule || "*";
+  if (marker !== "*" && marker !== "-" && marker !== "_")
+    throw new Error(
+      "Cannot serialize rules with `" + marker + "` for `options.rule`, expected `*`, `-`, or `_`"
+    );
+  return marker;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/list.js
+function list2(node, parent, state, info) {
+  let exit2 = state.enter("list"), bulletCurrent = state.bulletCurrent, bullet = node.ordered ? checkBulletOrdered(state) : checkBullet(state), bulletOther = node.ordered ? bullet === "." ? ")" : "." : checkBulletOther(state), useDifferentMarker = parent && state.bulletLastUsed ? bullet === state.bulletLastUsed : !1;
+  if (!node.ordered) {
+    let firstListItem = node.children ? node.children[0] : void 0;
+    if (
+      // Bullet could be used as a thematic break marker:
+      (bullet === "*" || bullet === "-") && // Empty first list item:
+      firstListItem && (!firstListItem.children || !firstListItem.children[0]) && // Directly in two other list items:
+      state.stack[state.stack.length - 1] === "list" && state.stack[state.stack.length - 2] === "listItem" && state.stack[state.stack.length - 3] === "list" && state.stack[state.stack.length - 4] === "listItem" && // That are each the first child.
+      state.indexStack[state.indexStack.length - 1] === 0 && state.indexStack[state.indexStack.length - 2] === 0 && state.indexStack[state.indexStack.length - 3] === 0 && (useDifferentMarker = !0), checkRule(state) === bullet && firstListItem
+    ) {
+      let index = -1;
+      for (; ++index < node.children.length; ) {
+        let item = node.children[index];
+        if (item && item.type === "listItem" && item.children && item.children[0] && item.children[0].type === "thematicBreak") {
+          useDifferentMarker = !0;
+          break;
+        }
+      }
+    }
+  }
+  useDifferentMarker && (bullet = bulletOther), state.bulletCurrent = bullet;
+  let value = state.containerFlow(node, info);
+  return state.bulletLastUsed = bullet, state.bulletCurrent = bulletCurrent, exit2(), value;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js
+function checkListItemIndent(state) {
+  let style = state.options.listItemIndent || "one";
+  if (style !== "tab" && style !== "one" && style !== "mixed")
+    throw new Error(
+      "Cannot serialize items with `" + style + "` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`"
+    );
+  return style;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/list-item.js
+function listItem2(node, parent, state, info) {
+  let listItemIndent = checkListItemIndent(state), bullet = state.bulletCurrent || checkBullet(state);
+  parent && parent.type === "list" && parent.ordered && (bullet = (typeof parent.start == "number" && parent.start > -1 ? parent.start : 1) + (state.options.incrementListMarker === !1 ? 0 : parent.children.indexOf(node)) + bullet);
+  let size = bullet.length + 1;
+  (listItemIndent === "tab" || listItemIndent === "mixed" && (parent && parent.type === "list" && parent.spread || node.spread)) && (size = Math.ceil(size / 4) * 4);
+  let tracker = state.createTracker(info);
+  tracker.move(bullet + " ".repeat(size - bullet.length)), tracker.shift(size);
+  let exit2 = state.enter("listItem"), value = state.indentLines(
+    state.containerFlow(node, tracker.current()),
+    map3
+  );
+  return exit2(), value;
+  function map3(line, index, blank) {
+    return index ? (blank ? "" : " ".repeat(size)) + line : (blank ? bullet : bullet + " ".repeat(size - bullet.length)) + line;
+  }
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/paragraph.js
+function paragraph2(node, _, state, info) {
+  let exit2 = state.enter("paragraph"), subexit = state.enter("phrasing"), value = state.containerPhrasing(node, info);
+  return subexit(), exit2(), value;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/root.js
+function root3(node, _, state, info) {
+  if (!node.children.some(function(d) {
+    return phrasing(d);
+  })) return state.containerFlow(node, info);
+  let exit2 = state.enter("phrasing"), value = state.containerPhrasing(node, info);
+  return exit2(), value;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/check-strong.js
+function checkStrong(state) {
+  let marker = state.options.strong || "*";
+  if (marker !== "*" && marker !== "_")
+    throw new Error(
+      "Cannot serialize strong with `" + marker + "` for `options.strong`, expected `*`, or `_`"
+    );
+  return marker;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/strong.js
+strong2.attention = attention2;
+strong2.peek = peek2;
+function strong2(node, _, state, info) {
+  let exit2 = state.enter("phrasing"), value = state.containerPhrasing({ type: "root", children: [node] }, info);
+  return exit2(), value;
+}
+function attention2(_, state) {
+  return {
+    construct: "strong",
+    markers: checkStrong(state) === "*" ? ["*", "_"] : ["_", "*"],
+    sizes: [2]
+  };
+}
+function peek2(_, _1, state) {
+  return state.options.strong || "*";
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/text.js
+function text3(node, parent, state, info) {
+  let siblings = parent ? parent.children : [], index = siblings.indexOf(node);
+  return state.safe(node.value, {
+    ...info,
+    afterNode: siblings[index + 1],
+    beforeNode: siblings[index - 1]
+  });
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/check-rule-repetition.js
+function checkRuleRepetition(state) {
+  let repetition = state.options.ruleRepetition || 3;
+  if (repetition < 3)
+    throw new Error(
+      "Cannot serialize rules with repetition `" + repetition + "` for `options.ruleRepetition`, expected `3` or more"
+    );
+  return repetition;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/thematic-break.js
+function thematicBreak2(_, _1, state) {
+  let value = (checkRule(state) + (state.options.ruleSpaces ? " " : "")).repeat(checkRuleRepetition(state));
+  return state.options.ruleSpaces ? value.slice(0, -1) : value;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/index.js
+var handle = {
+  blockquote: blockquote2,
+  break: hardBreak2,
+  code: code2,
+  definition,
+  emphasis: emphasis2,
+  hardBreak: hardBreak2,
+  heading: heading2,
+  html: html5,
+  image: image2,
+  imageReference: imageReference2,
+  inlineCode: inlineCode2,
+  link: link2,
+  linkReference: linkReference2,
+  list: list2,
+  listItem: listItem2,
+  paragraph: paragraph2,
+  root: root3,
+  strong: strong2,
+  text: text3,
+  thematicBreak: thematicBreak2
+};
+
+// ../../node_modules/mdast-util-to-markdown/lib/unsafe.js
+var fullPhrasingSpans = [
+  "autolink",
+  "destinationLiteral",
+  "destinationRaw",
+  "reference",
+  "titleQuote",
+  "titleApostrophe"
+], unsafe = [
+  { character: "	", after: "[\\r\\n]", inConstruct: "phrasing" },
+  { character: "	", before: "[\\r\\n]", inConstruct: "phrasing" },
+  {
+    character: "	",
+    inConstruct: ["codeFencedLangGraveAccent", "codeFencedLangTilde"]
+  },
+  {
+    character: "\r",
+    inConstruct: [
+      "codeFencedLangGraveAccent",
+      "codeFencedLangTilde",
+      "codeFencedMetaGraveAccent",
+      "codeFencedMetaTilde",
+      "destinationLiteral",
+      "headingAtx"
+    ]
+  },
+  {
+    character: `
+`,
+    inConstruct: [
+      "codeFencedLangGraveAccent",
+      "codeFencedLangTilde",
+      "codeFencedMetaGraveAccent",
+      "codeFencedMetaTilde",
+      "destinationLiteral",
+      "headingAtx"
+    ]
+  },
+  { character: "\r", before: "[\\r\\n]", inConstruct: "phrasing" },
+  { character: "\r", after: "\\r", inConstruct: "phrasing" },
+  { character: `
+`, before: "\\n", inConstruct: "phrasing" },
+  { character: `
+`, after: "[\\r\\n]", inConstruct: "phrasing" },
+  { character: " ", after: "[\\r\\n]", inConstruct: "phrasing" },
+  { character: " ", before: "[\\r\\n]", inConstruct: "phrasing" },
+  {
+    character: " ",
+    inConstruct: ["codeFencedLangGraveAccent", "codeFencedLangTilde"]
+  },
+  // An exclamation mark can start an image, if it is followed by a link or
+  // a link reference.
+  {
+    character: "!",
+    after: "\\[",
+    inConstruct: "phrasing",
+    notInConstruct: fullPhrasingSpans
+  },
+  // A quote can break out of a title.
+  { character: '"', inConstruct: "titleQuote" },
+  // A number sign could start an ATX heading if it starts a line.
+  { atBreak: !0, character: "#" },
+  { character: "#", inConstruct: "headingAtx", after: `(?:[\r
+]|$)` },
+  // Dollar sign and percentage are not used in markdown.
+  // An ampersand could start a character reference.
+  { character: "&", after: "[#A-Za-z]", inConstruct: "phrasing" },
+  // An apostrophe can break out of a title.
+  { character: "'", inConstruct: "titleApostrophe" },
+  // A left paren could break out of a destination raw.
+  { character: "(", inConstruct: "destinationRaw" },
+  // A left paren followed by `]` could make something into a link or image.
+  {
+    before: "\\]",
+    character: "(",
+    inConstruct: "phrasing",
+    notInConstruct: fullPhrasingSpans
+  },
+  // A right paren could start a list item or break out of a destination
+  // raw.
+  { atBreak: !0, before: "\\d+", character: ")" },
+  { character: ")", inConstruct: "destinationRaw" },
+  // An asterisk can start thematic breaks, list items, emphasis, strong.
+  { atBreak: !0, character: "*", after: `(?:[ 	\r
+*])` },
+  { character: "*", inConstruct: "phrasing", notInConstruct: fullPhrasingSpans },
+  // A plus sign could start a list item.
+  { atBreak: !0, character: "+", after: `(?:[ 	\r
+])` },
+  // A dash can start thematic breaks, list items, and setext heading
+  // underlines.
+  { atBreak: !0, character: "-", after: `(?:[ 	\r
+-])` },
+  // A dot could start a list item.
+  { atBreak: !0, before: "\\d+", character: ".", after: `(?:[ 	\r
+]|$)` },
+  // Slash, colon, and semicolon are not used in markdown for constructs.
+  // A less than can start html (flow or text) or an autolink.
+  // HTML could start with an exclamation mark (declaration, cdata, comment),
+  // slash (closing tag), question mark (instruction), or a letter (tag).
+  // An autolink also starts with a letter.
+  // Finally, it could break out of a destination literal.
+  { atBreak: !0, character: "<", after: "[!/?A-Za-z]" },
+  {
+    character: "<",
+    after: "[!/?A-Za-z]",
+    inConstruct: "phrasing",
+    notInConstruct: fullPhrasingSpans
+  },
+  { character: "<", inConstruct: "destinationLiteral" },
+  // An equals to can start setext heading underlines.
+  { atBreak: !0, character: "=" },
+  // A greater than can start block quotes and it can break out of a
+  // destination literal.
+  { atBreak: !0, character: ">" },
+  { character: ">", inConstruct: "destinationLiteral" },
+  // Question mark and at sign are not used in markdown for constructs.
+  // A left bracket can start definitions, references, labels,
+  { atBreak: !0, character: "[" },
+  { character: "[", inConstruct: "phrasing", notInConstruct: fullPhrasingSpans },
+  { character: "[", inConstruct: ["label", "reference"] },
+  // A backslash can start an escape (when followed by punctuation) or a
+  // hard break (when followed by an eol).
+  // Note: typical escapes are handled in `safe`!
+  { character: "\\", after: "[\\r\\n]", inConstruct: "phrasing" },
+  // A right bracket can exit labels.
+  { character: "]", inConstruct: ["label", "reference"] },
+  // Caret is not used in markdown for constructs.
+  // An underscore can start emphasis, strong, or a thematic break.
+  { atBreak: !0, character: "_" },
+  { character: "_", inConstruct: "phrasing", notInConstruct: fullPhrasingSpans },
+  // A grave accent can start code (fenced or text), or it can break out of
+  // a grave accent code fence.
+  { atBreak: !0, character: "`" },
+  {
+    character: "`",
+    inConstruct: ["codeFencedLangGraveAccent", "codeFencedMetaGraveAccent"]
+  },
+  { character: "`", inConstruct: "phrasing", notInConstruct: fullPhrasingSpans },
+  // Left brace, vertical bar, right brace are not used in markdown for
+  // constructs.
+  // A tilde can start code (fenced).
+  { atBreak: !0, character: "~" },
+  { character: "<", inConstruct: "autolink" },
+  { character: ">", inConstruct: "autolink" },
+  { character: "\x7F", inConstruct: "autolink" }
+], code3 = -1;
+for (; ++code3 < 33; )
+  unsafe.push({ character: String.fromCharCode(code3), inConstruct: "autolink" });
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/safe.js
+var own8 = {}.hasOwnProperty;
+
+// ../../node_modules/mdast-util-gfm-table/lib/index.js
+function gfmTableFromMarkdown() {
+  return {
+    enter: {
+      table: enterTable,
+      tableData: enterCell,
+      tableHeader: enterCell,
+      tableRow: enterRow
+    },
+    exit: {
+      codeText: exitCodeText,
+      table: exitTable,
+      tableData: exit,
+      tableHeader: exit,
+      tableRow: exit
+    }
+  };
+}
+function enterTable(token) {
+  let align = token._align;
+  this.enter(
+    {
+      type: "table",
+      align: align.map(function(d) {
+        return d === "none" ? null : d;
+      }),
+      children: []
+    },
+    token
+  ), this.data.inTable = !0;
+}
+function exitTable(token) {
+  this.exit(token), this.data.inTable = void 0;
+}
+function enterRow(token) {
+  this.enter({ type: "tableRow", children: [] }, token);
+}
+function exit(token) {
+  this.exit(token);
+}
+function enterCell(token) {
+  this.enter({ type: "tableCell", children: [] }, token);
+}
+function exitCodeText(token) {
+  let value = this.resume();
+  this.data.inTable && (value = value.replace(/\\([\\|])/g, replace));
+  let node = this.stack[this.stack.length - 1];
+  node.type, node.value = value, this.exit(token);
+}
+function replace($0, $1) {
+  return $1 === "|" ? $1 : $0;
+}
+function gfmTableToMarkdown(options) {
+  let settings = options || {}, padding = settings.tableCellPadding, alignDelimiters = settings.tablePipeAlign, stringLength = settings.stringLength, around = padding ? " " : "|";
+  return {
+    unsafe: [
+      { character: "\r", inConstruct: "tableCell" },
+      { character: `
+`, inConstruct: "tableCell" },
+      // A pipe, when followed by a tab or space (padding), or a dash or colon
+      // (unpadded delimiter row), could result in a table.
+      { atBreak: !0, character: "|", after: "[	 :-]" },
+      // A pipe in a cell must be encoded.
+      { character: "|", inConstruct: "tableCell" },
+      // A colon must be followed by a dash, in which case it could start a
+      // delimiter row.
+      { atBreak: !0, character: ":", after: "-" },
+      // A delimiter row can also start with a dash, when followed by more
+      // dashes, a colon, or a pipe.
+      // This is a stricter version than the built in check for lists, thematic
+      // breaks, and setex heading underlines though:
+      // <https://github.com/syntax-tree/mdast-util-to-markdown/blob/51a2038/lib/unsafe.js#L57>
+      { atBreak: !0, character: "-", after: "[:|-]" }
+    ],
+    handlers: {
+      inlineCode: inlineCodeWithTable,
+      table: handleTable,
+      tableCell: handleTableCell,
+      tableRow: handleTableRow
+    }
+  };
+  function handleTable(node, _, state, info) {
+    return serializeData(handleTableAsData(node, state, info), node.align);
+  }
+  function handleTableRow(node, _, state, info) {
+    let row = handleTableRowAsData(node, state, info), value = serializeData([row]);
+    return value.slice(0, value.indexOf(`
+`));
+  }
+  function handleTableCell(node, _, state, info) {
+    let exit2 = state.enter("tableCell"), subexit = state.enter("phrasing"), value = state.containerPhrasing(node, {
+      ...info,
+      before: around,
+      after: around
+    });
+    return subexit(), exit2(), value;
+  }
+  function serializeData(matrix, align) {
+    return markdownTable(matrix, {
+      align,
+      // @ts-expect-error: `markdown-table` types should support `null`.
+      alignDelimiters,
+      // @ts-expect-error: `markdown-table` types should support `null`.
+      padding,
+      // @ts-expect-error: `markdown-table` types should support `null`.
+      stringLength
+    });
+  }
+  function handleTableAsData(node, state, info) {
+    let children = node.children, index = -1, result = [], subexit = state.enter("table");
+    for (; ++index < children.length; )
+      result[index] = handleTableRowAsData(children[index], state, info);
+    return subexit(), result;
+  }
+  function handleTableRowAsData(node, state, info) {
+    let children = node.children, index = -1, result = [], subexit = state.enter("tableRow");
+    for (; ++index < children.length; )
+      result[index] = handleTableCell(children[index], node, state, info);
+    return subexit(), result;
+  }
+  function inlineCodeWithTable(node, parent, state) {
+    let value = handle.inlineCode(node, parent, state);
+    return state.stack.includes("tableCell") && (value = value.replace(/\|/g, "\\$&")), value;
+  }
+}
+
+// ../../node_modules/mdast-util-gfm-task-list-item/lib/index.js
+function gfmTaskListItemFromMarkdown() {
+  return {
+    exit: {
+      taskListCheckValueChecked: exitCheck,
+      taskListCheckValueUnchecked: exitCheck,
+      paragraph: exitParagraphWithTaskListItem
+    }
+  };
+}
+function gfmTaskListItemToMarkdown() {
+  return {
+    unsafe: [{ atBreak: !0, character: "-", after: "[:|-]" }],
+    handlers: { listItem: listItemWithTaskListItem }
+  };
+}
+function exitCheck(token) {
+  let node = this.stack[this.stack.length - 2];
+  node.type, node.checked = token.type === "taskListCheckValueChecked";
+}
+function exitParagraphWithTaskListItem(token) {
+  let parent = this.stack[this.stack.length - 2];
+  if (parent && parent.type === "listItem" && typeof parent.checked == "boolean") {
+    let node = this.stack[this.stack.length - 1];
+    node.type;
+    let head = node.children[0];
+    if (head && head.type === "text") {
+      let siblings = parent.children, index = -1, firstParaghraph;
+      for (; ++index < siblings.length; ) {
+        let sibling = siblings[index];
+        if (sibling.type === "paragraph") {
+          firstParaghraph = sibling;
+          break;
+        }
+      }
+      firstParaghraph === node && (head.value = head.value.slice(1), head.value.length === 0 ? node.children.shift() : node.position && head.position && typeof head.position.start.offset == "number" && (head.position.start.column++, head.position.start.offset++, node.position.start = Object.assign({}, head.position.start)));
+    }
+  }
+  this.exit(token);
+}
+function listItemWithTaskListItem(node, parent, state, info) {
+  let head = node.children[0], checkable = typeof node.checked == "boolean" && head && head.type === "paragraph", checkbox = "[" + (node.checked ? "x" : " ") + "] ", tracker = state.createTracker(info);
+  checkable && tracker.move(checkbox);
+  let value = handle.listItem(node, parent, state, {
+    ...info,
+    ...tracker.current()
+  });
+  return checkable && (value = value.replace(/^(?:[*+-]|\d+\.)([\r\n]| {1,3})/, check)), value;
+  function check($0) {
+    return $0 + checkbox;
+  }
+}
+
+// ../../node_modules/mdast-util-gfm/lib/index.js
+function gfmFromMarkdown() {
+  return [
+    gfmAutolinkLiteralFromMarkdown(),
+    gfmFootnoteFromMarkdown(),
+    gfmStrikethroughFromMarkdown(),
+    gfmTableFromMarkdown(),
+    gfmTaskListItemFromMarkdown()
+  ];
+}
+function gfmToMarkdown(options) {
+  return {
+    extensions: [
+      gfmAutolinkLiteralToMarkdown(),
+      gfmFootnoteToMarkdown(options),
+      gfmStrikethroughToMarkdown(),
+      gfmTableToMarkdown(options),
+      gfmTaskListItemToMarkdown()
+    ]
+  };
+}
+
+// ../../node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js
+var wwwPrefix = {
+  tokenize: tokenizeWwwPrefix,
+  partial: !0
+}, domain = {
+  tokenize: tokenizeDomain,
+  partial: !0
+}, path = {
+  tokenize: tokenizePath,
+  partial: !0
+}, trail = {
+  tokenize: tokenizeTrail,
+  partial: !0
+}, emailDomainDotTrail = {
+  tokenize: tokenizeEmailDomainDotTrail,
+  partial: !0
+}, wwwAutolink = {
+  name: "wwwAutolink",
+  tokenize: tokenizeWwwAutolink,
+  previous: previousWww
+}, protocolAutolink = {
+  name: "protocolAutolink",
+  tokenize: tokenizeProtocolAutolink,
+  previous: previousProtocol
+}, emailAutolink = {
+  name: "emailAutolink",
+  tokenize: tokenizeEmailAutolink,
+  previous: previousEmail
+}, text4 = {};
+function gfmAutolinkLiteral() {
+  return {
+    text: text4
+  };
+}
+var code4 = 48;
+for (; code4 < 123; )
+  text4[code4] = emailAutolink, code4++, code4 === 58 ? code4 = 65 : code4 === 91 && (code4 = 97);
+text4[43] = emailAutolink;
+text4[45] = emailAutolink;
+text4[46] = emailAutolink;
+text4[95] = emailAutolink;
+text4[72] = [emailAutolink, protocolAutolink];
+text4[104] = [emailAutolink, protocolAutolink];
+text4[87] = [emailAutolink, wwwAutolink];
+text4[119] = [emailAutolink, wwwAutolink];
+function tokenizeEmailAutolink(effects, ok2, nok) {
+  let self = this, dot, data;
+  return start;
+  function start(code5) {
+    return !gfmAtext(code5) || !previousEmail.call(self, self.previous) || previousUnbalanced(self.events) ? nok(code5) : (effects.enter("literalAutolink"), effects.enter("literalAutolinkEmail"), atext(code5));
+  }
+  function atext(code5) {
+    return gfmAtext(code5) ? (effects.consume(code5), atext) : code5 === 64 ? (effects.consume(code5), emailDomain) : nok(code5);
+  }
+  function emailDomain(code5) {
+    return code5 === 46 ? effects.check(emailDomainDotTrail, emailDomainAfter, emailDomainDot)(code5) : code5 === 45 || code5 === 95 || asciiAlphanumeric(code5) ? (data = !0, effects.consume(code5), emailDomain) : emailDomainAfter(code5);
+  }
+  function emailDomainDot(code5) {
+    return effects.consume(code5), dot = !0, emailDomain;
+  }
+  function emailDomainAfter(code5) {
+    return data && dot && asciiAlpha(self.previous) ? (effects.exit("literalAutolinkEmail"), effects.exit("literalAutolink"), ok2(code5)) : nok(code5);
+  }
+}
+function tokenizeWwwAutolink(effects, ok2, nok) {
+  let self = this;
+  return wwwStart;
+  function wwwStart(code5) {
+    return code5 !== 87 && code5 !== 119 || !previousWww.call(self, self.previous) || previousUnbalanced(self.events) ? nok(code5) : (effects.enter("literalAutolink"), effects.enter("literalAutolinkWww"), effects.check(wwwPrefix, effects.attempt(domain, effects.attempt(path, wwwAfter), nok), nok)(code5));
+  }
+  function wwwAfter(code5) {
+    return effects.exit("literalAutolinkWww"), effects.exit("literalAutolink"), ok2(code5);
+  }
+}
+function tokenizeProtocolAutolink(effects, ok2, nok) {
+  let self = this, buffer = "", seen = !1;
+  return protocolStart;
+  function protocolStart(code5) {
+    return (code5 === 72 || code5 === 104) && previousProtocol.call(self, self.previous) && !previousUnbalanced(self.events) ? (effects.enter("literalAutolink"), effects.enter("literalAutolinkHttp"), buffer += String.fromCodePoint(code5), effects.consume(code5), protocolPrefixInside) : nok(code5);
+  }
+  function protocolPrefixInside(code5) {
+    if (asciiAlpha(code5) && buffer.length < 5)
+      return buffer += String.fromCodePoint(code5), effects.consume(code5), protocolPrefixInside;
+    if (code5 === 58) {
+      let protocol = buffer.toLowerCase();
+      if (protocol === "http" || protocol === "https")
+        return effects.consume(code5), protocolSlashesInside;
+    }
+    return nok(code5);
+  }
+  function protocolSlashesInside(code5) {
+    return code5 === 47 ? (effects.consume(code5), seen ? afterProtocol : (seen = !0, protocolSlashesInside)) : nok(code5);
+  }
+  function afterProtocol(code5) {
+    return code5 === null || asciiControl(code5) || markdownLineEndingOrSpace(code5) || unicodeWhitespace(code5) || unicodePunctuation(code5) ? nok(code5) : effects.attempt(domain, effects.attempt(path, protocolAfter), nok)(code5);
+  }
+  function protocolAfter(code5) {
+    return effects.exit("literalAutolinkHttp"), effects.exit("literalAutolink"), ok2(code5);
+  }
+}
+function tokenizeWwwPrefix(effects, ok2, nok) {
+  let size = 0;
+  return wwwPrefixInside;
+  function wwwPrefixInside(code5) {
+    return (code5 === 87 || code5 === 119) && size < 3 ? (size++, effects.consume(code5), wwwPrefixInside) : code5 === 46 && size === 3 ? (effects.consume(code5), wwwPrefixAfter) : nok(code5);
+  }
+  function wwwPrefixAfter(code5) {
+    return code5 === null ? nok(code5) : ok2(code5);
+  }
+}
+function tokenizeDomain(effects, ok2, nok) {
+  let underscoreInLastSegment, underscoreInLastLastSegment, seen;
+  return domainInside;
+  function domainInside(code5) {
+    return code5 === 46 || code5 === 95 ? effects.check(trail, domainAfter, domainAtPunctuation)(code5) : code5 === null || markdownLineEndingOrSpace(code5) || unicodeWhitespace(code5) || code5 !== 45 && unicodePunctuation(code5) ? domainAfter(code5) : (seen = !0, effects.consume(code5), domainInside);
+  }
+  function domainAtPunctuation(code5) {
+    return code5 === 95 ? underscoreInLastSegment = !0 : (underscoreInLastLastSegment = underscoreInLastSegment, underscoreInLastSegment = void 0), effects.consume(code5), domainInside;
+  }
+  function domainAfter(code5) {
+    return underscoreInLastLastSegment || underscoreInLastSegment || !seen ? nok(code5) : ok2(code5);
+  }
+}
+function tokenizePath(effects, ok2) {
+  let sizeOpen = 0, sizeClose = 0;
+  return pathInside;
+  function pathInside(code5) {
+    return code5 === 40 ? (sizeOpen++, effects.consume(code5), pathInside) : code5 === 41 && sizeClose < sizeOpen ? pathAtPunctuation(code5) : code5 === 33 || code5 === 34 || code5 === 38 || code5 === 39 || code5 === 41 || code5 === 42 || code5 === 44 || code5 === 46 || code5 === 58 || code5 === 59 || code5 === 60 || code5 === 63 || code5 === 93 || code5 === 95 || code5 === 126 ? effects.check(trail, ok2, pathAtPunctuation)(code5) : code5 === null || markdownLineEndingOrSpace(code5) || unicodeWhitespace(code5) ? ok2(code5) : (effects.consume(code5), pathInside);
+  }
+  function pathAtPunctuation(code5) {
+    return code5 === 41 && sizeClose++, effects.consume(code5), pathInside;
+  }
+}
+function tokenizeTrail(effects, ok2, nok) {
+  return trail2;
+  function trail2(code5) {
+    return code5 === 33 || code5 === 34 || code5 === 39 || code5 === 41 || code5 === 42 || code5 === 44 || code5 === 46 || code5 === 58 || code5 === 59 || code5 === 63 || code5 === 95 || code5 === 126 ? (effects.consume(code5), trail2) : code5 === 38 ? (effects.consume(code5), trailCharacterReferenceStart) : code5 === 93 ? (effects.consume(code5), trailBracketAfter) : (
+      // `<` is an end.
+      code5 === 60 || // So is whitespace.
+      code5 === null || markdownLineEndingOrSpace(code5) || unicodeWhitespace(code5) ? ok2(code5) : nok(code5)
+    );
+  }
+  function trailBracketAfter(code5) {
+    return code5 === null || code5 === 40 || code5 === 91 || markdownLineEndingOrSpace(code5) || unicodeWhitespace(code5) ? ok2(code5) : trail2(code5);
+  }
+  function trailCharacterReferenceStart(code5) {
+    return asciiAlpha(code5) ? trailCharacterReferenceInside(code5) : nok(code5);
+  }
+  function trailCharacterReferenceInside(code5) {
+    return code5 === 59 ? (effects.consume(code5), trail2) : asciiAlpha(code5) ? (effects.consume(code5), trailCharacterReferenceInside) : nok(code5);
+  }
+}
+function tokenizeEmailDomainDotTrail(effects, ok2, nok) {
+  return start;
+  function start(code5) {
+    return effects.consume(code5), after;
+  }
+  function after(code5) {
+    return asciiAlphanumeric(code5) ? nok(code5) : ok2(code5);
+  }
+}
+function previousWww(code5) {
+  return code5 === null || code5 === 40 || code5 === 42 || code5 === 95 || code5 === 91 || code5 === 93 || code5 === 126 || markdownLineEndingOrSpace(code5);
+}
+function previousProtocol(code5) {
+  return !asciiAlpha(code5);
+}
+function previousEmail(code5) {
+  return !(code5 === 47 || gfmAtext(code5));
+}
+function gfmAtext(code5) {
+  return code5 === 43 || code5 === 45 || code5 === 46 || code5 === 95 || asciiAlphanumeric(code5);
+}
+function previousUnbalanced(events) {
+  let index = events.length, result = !1;
+  for (; index--; ) {
+    let token = events[index][1];
+    if ((token.type === "labelLink" || token.type === "labelImage") && !token._balanced) {
+      result = !0;
+      break;
+    }
+    if (token._gfmAutolinkLiteralWalkedInto) {
+      result = !1;
+      break;
+    }
+  }
+  return events.length > 0 && !result && (events[events.length - 1][1]._gfmAutolinkLiteralWalkedInto = !0), result;
+}
+
+// ../../node_modules/micromark-extension-gfm-footnote/lib/syntax.js
+var indent = {
+  tokenize: tokenizeIndent,
+  partial: !0
+};
+function gfmFootnote() {
+  return {
+    document: {
+      91: {
+        name: "gfmFootnoteDefinition",
+        tokenize: tokenizeDefinitionStart,
+        continuation: {
+          tokenize: tokenizeDefinitionContinuation
+        },
+        exit: gfmFootnoteDefinitionEnd
+      }
+    },
+    text: {
+      91: {
+        name: "gfmFootnoteCall",
+        tokenize: tokenizeGfmFootnoteCall
+      },
+      93: {
+        name: "gfmPotentialFootnoteCall",
+        add: "after",
+        tokenize: tokenizePotentialGfmFootnoteCall,
+        resolveTo: resolveToPotentialGfmFootnoteCall
+      }
+    }
+  };
+}
+function tokenizePotentialGfmFootnoteCall(effects, ok2, nok) {
+  let self = this, index = self.events.length, defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []), labelStart;
+  for (; index--; ) {
+    let token = self.events[index][1];
+    if (token.type === "labelImage") {
+      labelStart = token;
+      break;
+    }
+    if (token.type === "gfmFootnoteCall" || token.type === "labelLink" || token.type === "label" || token.type === "image" || token.type === "link")
+      break;
+  }
+  return start;
+  function start(code5) {
+    if (!labelStart || !labelStart._balanced)
+      return nok(code5);
+    let id = normalizeIdentifier(self.sliceSerialize({
+      start: labelStart.end,
+      end: self.now()
+    }));
+    return id.codePointAt(0) !== 94 || !defined.includes(id.slice(1)) ? nok(code5) : (effects.enter("gfmFootnoteCallLabelMarker"), effects.consume(code5), effects.exit("gfmFootnoteCallLabelMarker"), ok2(code5));
+  }
+}
+function resolveToPotentialGfmFootnoteCall(events, context) {
+  let index = events.length, labelStart;
+  for (; index--; )
+    if (events[index][1].type === "labelImage" && events[index][0] === "enter") {
+      labelStart = events[index][1];
+      break;
+    }
+  events[index + 1][1].type = "data", events[index + 3][1].type = "gfmFootnoteCallLabelMarker";
+  let call = {
+    type: "gfmFootnoteCall",
+    start: Object.assign({}, events[index + 3][1].start),
+    end: Object.assign({}, events[events.length - 1][1].end)
+  }, marker = {
+    type: "gfmFootnoteCallMarker",
+    start: Object.assign({}, events[index + 3][1].end),
+    end: Object.assign({}, events[index + 3][1].end)
+  };
+  marker.end.column++, marker.end.offset++, marker.end._bufferIndex++;
+  let string = {
+    type: "gfmFootnoteCallString",
+    start: Object.assign({}, marker.end),
+    end: Object.assign({}, events[events.length - 1][1].start)
+  }, chunk = {
+    type: "chunkString",
+    contentType: "string",
+    start: Object.assign({}, string.start),
+    end: Object.assign({}, string.end)
+  }, replacement = [
+    // Take the `labelImageMarker` (now `data`, the `!`)
+    events[index + 1],
+    events[index + 2],
+    ["enter", call, context],
+    // The `[`
+    events[index + 3],
+    events[index + 4],
+    // The `^`.
+    ["enter", marker, context],
+    ["exit", marker, context],
+    // Everything in between.
+    ["enter", string, context],
+    ["enter", chunk, context],
+    ["exit", chunk, context],
+    ["exit", string, context],
+    // The ending (`]`, properly parsed and labelled).
+    events[events.length - 2],
+    events[events.length - 1],
+    ["exit", call, context]
+  ];
+  return events.splice(index, events.length - index + 1, ...replacement), events;
+}
+function tokenizeGfmFootnoteCall(effects, ok2, nok) {
+  let self = this, defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []), size = 0, data;
+  return start;
+  function start(code5) {
+    return effects.enter("gfmFootnoteCall"), effects.enter("gfmFootnoteCallLabelMarker"), effects.consume(code5), effects.exit("gfmFootnoteCallLabelMarker"), callStart;
+  }
+  function callStart(code5) {
+    return code5 !== 94 ? nok(code5) : (effects.enter("gfmFootnoteCallMarker"), effects.consume(code5), effects.exit("gfmFootnoteCallMarker"), effects.enter("gfmFootnoteCallString"), effects.enter("chunkString").contentType = "string", callData);
+  }
+  function callData(code5) {
+    if (
+      // Too long.
+      size > 999 || // Closing brace with nothing.
+      code5 === 93 && !data || // Space or tab is not supported by GFM for some reason.
+      // `\n` and `[` not being supported makes sense.
+      code5 === null || code5 === 91 || markdownLineEndingOrSpace(code5)
+    )
+      return nok(code5);
+    if (code5 === 93) {
+      effects.exit("chunkString");
+      let token = effects.exit("gfmFootnoteCallString");
+      return defined.includes(normalizeIdentifier(self.sliceSerialize(token))) ? (effects.enter("gfmFootnoteCallLabelMarker"), effects.consume(code5), effects.exit("gfmFootnoteCallLabelMarker"), effects.exit("gfmFootnoteCall"), ok2) : nok(code5);
+    }
+    return markdownLineEndingOrSpace(code5) || (data = !0), size++, effects.consume(code5), code5 === 92 ? callEscape : callData;
+  }
+  function callEscape(code5) {
+    return code5 === 91 || code5 === 92 || code5 === 93 ? (effects.consume(code5), size++, callData) : callData(code5);
+  }
+}
+function tokenizeDefinitionStart(effects, ok2, nok) {
+  let self = this, defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []), identifier, size = 0, data;
+  return start;
+  function start(code5) {
+    return effects.enter("gfmFootnoteDefinition")._container = !0, effects.enter("gfmFootnoteDefinitionLabel"), effects.enter("gfmFootnoteDefinitionLabelMarker"), effects.consume(code5), effects.exit("gfmFootnoteDefinitionLabelMarker"), labelAtMarker;
+  }
+  function labelAtMarker(code5) {
+    return code5 === 94 ? (effects.enter("gfmFootnoteDefinitionMarker"), effects.consume(code5), effects.exit("gfmFootnoteDefinitionMarker"), effects.enter("gfmFootnoteDefinitionLabelString"), effects.enter("chunkString").contentType = "string", labelInside) : nok(code5);
+  }
+  function labelInside(code5) {
+    if (
+      // Too long.
+      size > 999 || // Closing brace with nothing.
+      code5 === 93 && !data || // Space or tab is not supported by GFM for some reason.
+      // `\n` and `[` not being supported makes sense.
+      code5 === null || code5 === 91 || markdownLineEndingOrSpace(code5)
+    )
+      return nok(code5);
+    if (code5 === 93) {
+      effects.exit("chunkString");
+      let token = effects.exit("gfmFootnoteDefinitionLabelString");
+      return identifier = normalizeIdentifier(self.sliceSerialize(token)), effects.enter("gfmFootnoteDefinitionLabelMarker"), effects.consume(code5), effects.exit("gfmFootnoteDefinitionLabelMarker"), effects.exit("gfmFootnoteDefinitionLabel"), labelAfter;
+    }
+    return markdownLineEndingOrSpace(code5) || (data = !0), size++, effects.consume(code5), code5 === 92 ? labelEscape : labelInside;
+  }
+  function labelEscape(code5) {
+    return code5 === 91 || code5 === 92 || code5 === 93 ? (effects.consume(code5), size++, labelInside) : labelInside(code5);
+  }
+  function labelAfter(code5) {
+    return code5 === 58 ? (effects.enter("definitionMarker"), effects.consume(code5), effects.exit("definitionMarker"), defined.includes(identifier) || defined.push(identifier), factorySpace(effects, whitespaceAfter, "gfmFootnoteDefinitionWhitespace")) : nok(code5);
+  }
+  function whitespaceAfter(code5) {
+    return ok2(code5);
+  }
+}
+function tokenizeDefinitionContinuation(effects, ok2, nok) {
+  return effects.check(blankLine, ok2, effects.attempt(indent, ok2, nok));
+}
+function gfmFootnoteDefinitionEnd(effects) {
+  effects.exit("gfmFootnoteDefinition");
+}
+function tokenizeIndent(effects, ok2, nok) {
+  let self = this;
+  return factorySpace(effects, afterPrefix, "gfmFootnoteDefinitionIndent", 5);
+  function afterPrefix(code5) {
+    let tail = self.events[self.events.length - 1];
+    return tail && tail[1].type === "gfmFootnoteDefinitionIndent" && tail[2].sliceSerialize(tail[1], !0).length === 4 ? ok2(code5) : nok(code5);
+  }
+}
+
+// ../../node_modules/micromark-extension-gfm-footnote/lib/html.js
+var own9 = {}.hasOwnProperty;
+
+// ../../node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js
+function gfmStrikethrough(options) {
+  let single = (options || {}).singleTilde, tokenizer = {
+    name: "strikethrough",
+    tokenize: tokenizeStrikethrough,
+    resolveAll: resolveAllStrikethrough
+  };
+  return single == null && (single = !0), {
+    text: {
+      126: tokenizer
+    },
+    insideSpan: {
+      null: [tokenizer]
+    },
+    attentionMarkers: {
+      null: [126]
+    }
+  };
+  function resolveAllStrikethrough(events, context) {
+    let index = -1;
+    for (; ++index < events.length; )
+      if (events[index][0] === "enter" && events[index][1].type === "strikethroughSequenceTemporary" && events[index][1]._close) {
+        let open = index;
+        for (; open--; )
+          if (events[open][0] === "exit" && events[open][1].type === "strikethroughSequenceTemporary" && events[open][1]._open && // If the sizes are the same:
+          events[index][1].end.offset - events[index][1].start.offset === events[open][1].end.offset - events[open][1].start.offset) {
+            events[index][1].type = "strikethroughSequence", events[open][1].type = "strikethroughSequence";
+            let strikethrough2 = {
+              type: "strikethrough",
+              start: Object.assign({}, events[open][1].start),
+              end: Object.assign({}, events[index][1].end)
+            }, text5 = {
+              type: "strikethroughText",
+              start: Object.assign({}, events[open][1].end),
+              end: Object.assign({}, events[index][1].start)
+            }, nextEvents = [["enter", strikethrough2, context], ["enter", events[open][1], context], ["exit", events[open][1], context], ["enter", text5, context]], insideSpan = context.parser.constructs.insideSpan.null;
+            insideSpan && splice(nextEvents, nextEvents.length, 0, resolveAll(insideSpan, events.slice(open + 1, index), context)), splice(nextEvents, nextEvents.length, 0, [["exit", text5, context], ["enter", events[index][1], context], ["exit", events[index][1], context], ["exit", strikethrough2, context]]), splice(events, open - 1, index - open + 3, nextEvents), index = open + nextEvents.length - 2;
+            break;
+          }
+      }
+    for (index = -1; ++index < events.length; )
+      events[index][1].type === "strikethroughSequenceTemporary" && (events[index][1].type = "data");
+    return events;
+  }
+  function tokenizeStrikethrough(effects, ok2, nok) {
+    let previous2 = this.previous, events = this.events, size = 0;
+    return start;
+    function start(code5) {
+      return previous2 === 126 && events[events.length - 1][1].type !== "characterEscape" ? nok(code5) : (effects.enter("strikethroughSequenceTemporary"), more(code5));
+    }
+    function more(code5) {
+      let before = classifyCharacter(previous2);
+      if (code5 === 126)
+        return size > 1 ? nok(code5) : (effects.consume(code5), size++, more);
+      if (size < 2 && !single) return nok(code5);
+      let token = effects.exit("strikethroughSequenceTemporary"), after = classifyCharacter(code5);
+      return token._open = !after || after === 2 && !!before, token._close = !before || before === 2 && !!after, ok2(code5);
+    }
+  }
+}
+
+// ../../node_modules/micromark-extension-gfm-table/lib/edit-map.js
+var EditMap = class {
+  /**
+   * Create a new edit map.
+   */
+  constructor() {
+    this.map = [], this.index = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Create an edit: a remove and/or add at a certain place.
+   *
+   * @param {number} index
+   *   Index at which to apply the edit.
+   * @param {number} remove
+   *   Count of items to remove at the index.
+   * @param {Array<Event>} add
+   *   Items to add at the index.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  add(index, remove, add) {
+    addImplementation(this, index, remove, add);
+  }
+  // To do: add this when moving to `micromark`.
+  // /**
+  //  * Create an edit: but insert `add` before existing additions.
+  //  *
+  //  * @param {number} index
+  //  * @param {number} remove
+  //  * @param {Array<Event>} add
+  //  * @returns {undefined}
+  //  */
+  // addBefore(index, remove, add) {
+  //   addImplementation(this, index, remove, add, true)
+  // }
+  /**
+   * Done, change the events.
+   *
+   * @param {Array<Event>} events
+   *   List of events to apply the edits to.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  consume(events) {
+    if (this.map.sort(function(a, b) {
+      return a[0] - b[0];
+    }), this.map.length === 0)
+      return;
+    let index = this.map.length, vecs = [];
+    for (; index > 0; )
+      index -= 1, vecs.push(events.slice(this.map[index][0] + this.map[index][1]), this.map[index][2]), events.length = this.map[index][0];
+    vecs.push(events.slice()), events.length = 0;
+    let slice2 = vecs.pop();
+    for (; slice2; ) {
+      for (let element2 of slice2)
+        events.push(element2);
+      slice2 = vecs.pop();
+    }
+    this.map.length = 0, this.index.clear();
+  }
+};
+function addImplementation(editMap, at, remove, add) {
+  if (remove === 0 && add.length === 0)
+    return;
+  let existing = editMap.index.get(at);
+  if (existing) {
+    existing[1] += remove, existing[2].push(...add);
+    return;
+  }
+  let change = [at, remove, add];
+  editMap.map.push(change), editMap.index.set(at, change);
+}
+
+// ../../node_modules/micromark-extension-gfm-table/lib/infer.js
+function gfmTableAlign(events, index) {
+  let inDelimiterRow = !1, align = [];
+  for (; index < events.length; ) {
+    let event = events[index];
+    if (inDelimiterRow) {
+      if (event[0] === "enter")
+        event[1].type === "tableContent" && align.push(events[index + 1][1].type === "tableDelimiterMarker" ? "left" : "none");
+      else if (event[1].type === "tableContent") {
+        if (events[index - 1][1].type === "tableDelimiterMarker") {
+          let alignIndex = align.length - 1;
+          align[alignIndex] = align[alignIndex] === "left" ? "center" : "right";
+        }
+      } else if (event[1].type === "tableDelimiterRow")
+        break;
+    } else event[0] === "enter" && event[1].type === "tableDelimiterRow" && (inDelimiterRow = !0);
+    index += 1;
+  }
+  return align;
+}
+
+// ../../node_modules/micromark-extension-gfm-table/lib/syntax.js
+function gfmTable() {
+  return {
+    flow: {
+      null: {
+        name: "table",
+        tokenize: tokenizeTable,
+        resolveAll: resolveTable
+      }
+    }
+  };
+}
+function tokenizeTable(effects, ok2, nok) {
+  let self = this, size = 0, sizeB = 0, seen;
+  return start;
+  function start(code5) {
+    let index = self.events.length - 1;
+    for (; index > -1; ) {
+      let {
+        type
+      } = self.events[index][1];
+      if (type === "lineEnding" || // Note: markdown-rs uses `whitespace` instead of `linePrefix`
+      type === "linePrefix")
+        index--;
+      else
+        break;
+    }
+    let tail = index > -1 ? self.events[index][1].type : null, next = tail === "tableHead" || tail === "tableRow" ? bodyRowStart : headRowBefore;
+    return next === bodyRowStart && self.parser.lazy[self.now().line] ? nok(code5) : next(code5);
+  }
+  function headRowBefore(code5) {
+    return effects.enter("tableHead"), effects.enter("tableRow"), headRowStart(code5);
+  }
+  function headRowStart(code5) {
+    return code5 === 124 || (seen = !0, sizeB += 1), headRowBreak(code5);
+  }
+  function headRowBreak(code5) {
+    return code5 === null ? nok(code5) : markdownLineEnding(code5) ? sizeB > 1 ? (sizeB = 0, self.interrupt = !0, effects.exit("tableRow"), effects.enter("lineEnding"), effects.consume(code5), effects.exit("lineEnding"), headDelimiterStart) : nok(code5) : markdownSpace(code5) ? factorySpace(effects, headRowBreak, "whitespace")(code5) : (sizeB += 1, seen && (seen = !1, size += 1), code5 === 124 ? (effects.enter("tableCellDivider"), effects.consume(code5), effects.exit("tableCellDivider"), seen = !0, headRowBreak) : (effects.enter("data"), headRowData(code5)));
+  }
+  function headRowData(code5) {
+    return code5 === null || code5 === 124 || markdownLineEndingOrSpace(code5) ? (effects.exit("data"), headRowBreak(code5)) : (effects.consume(code5), code5 === 92 ? headRowEscape : headRowData);
+  }
+  function headRowEscape(code5) {
+    return code5 === 92 || code5 === 124 ? (effects.consume(code5), headRowData) : headRowData(code5);
+  }
+  function headDelimiterStart(code5) {
+    return self.interrupt = !1, self.parser.lazy[self.now().line] ? nok(code5) : (effects.enter("tableDelimiterRow"), seen = !1, markdownSpace(code5) ? factorySpace(effects, headDelimiterBefore, "linePrefix", self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(code5) : headDelimiterBefore(code5));
+  }
+  function headDelimiterBefore(code5) {
+    return code5 === 45 || code5 === 58 ? headDelimiterValueBefore(code5) : code5 === 124 ? (seen = !0, effects.enter("tableCellDivider"), effects.consume(code5), effects.exit("tableCellDivider"), headDelimiterCellBefore) : headDelimiterNok(code5);
+  }
+  function headDelimiterCellBefore(code5) {
+    return markdownSpace(code5) ? factorySpace(effects, headDelimiterValueBefore, "whitespace")(code5) : headDelimiterValueBefore(code5);
+  }
+  function headDelimiterValueBefore(code5) {
+    return code5 === 58 ? (sizeB += 1, seen = !0, effects.enter("tableDelimiterMarker"), effects.consume(code5), effects.exit("tableDelimiterMarker"), headDelimiterLeftAlignmentAfter) : code5 === 45 ? (sizeB += 1, headDelimiterLeftAlignmentAfter(code5)) : code5 === null || markdownLineEnding(code5) ? headDelimiterCellAfter(code5) : headDelimiterNok(code5);
+  }
+  function headDelimiterLeftAlignmentAfter(code5) {
+    return code5 === 45 ? (effects.enter("tableDelimiterFiller"), headDelimiterFiller(code5)) : headDelimiterNok(code5);
+  }
+  function headDelimiterFiller(code5) {
+    return code5 === 45 ? (effects.consume(code5), headDelimiterFiller) : code5 === 58 ? (seen = !0, effects.exit("tableDelimiterFiller"), effects.enter("tableDelimiterMarker"), effects.consume(code5), effects.exit("tableDelimiterMarker"), headDelimiterRightAlignmentAfter) : (effects.exit("tableDelimiterFiller"), headDelimiterRightAlignmentAfter(code5));
+  }
+  function headDelimiterRightAlignmentAfter(code5) {
+    return markdownSpace(code5) ? factorySpace(effects, headDelimiterCellAfter, "whitespace")(code5) : headDelimiterCellAfter(code5);
+  }
+  function headDelimiterCellAfter(code5) {
+    return code5 === 124 ? headDelimiterBefore(code5) : code5 === null || markdownLineEnding(code5) ? !seen || size !== sizeB ? headDelimiterNok(code5) : (effects.exit("tableDelimiterRow"), effects.exit("tableHead"), ok2(code5)) : headDelimiterNok(code5);
+  }
+  function headDelimiterNok(code5) {
+    return nok(code5);
+  }
+  function bodyRowStart(code5) {
+    return effects.enter("tableRow"), bodyRowBreak(code5);
+  }
+  function bodyRowBreak(code5) {
+    return code5 === 124 ? (effects.enter("tableCellDivider"), effects.consume(code5), effects.exit("tableCellDivider"), bodyRowBreak) : code5 === null || markdownLineEnding(code5) ? (effects.exit("tableRow"), ok2(code5)) : markdownSpace(code5) ? factorySpace(effects, bodyRowBreak, "whitespace")(code5) : (effects.enter("data"), bodyRowData(code5));
+  }
+  function bodyRowData(code5) {
+    return code5 === null || code5 === 124 || markdownLineEndingOrSpace(code5) ? (effects.exit("data"), bodyRowBreak(code5)) : (effects.consume(code5), code5 === 92 ? bodyRowEscape : bodyRowData);
+  }
+  function bodyRowEscape(code5) {
+    return code5 === 92 || code5 === 124 ? (effects.consume(code5), bodyRowData) : bodyRowData(code5);
+  }
+}
+function resolveTable(events, context) {
+  let index = -1, inFirstCellAwaitingPipe = !0, rowKind = 0, lastCell = [0, 0, 0, 0], cell = [0, 0, 0, 0], afterHeadAwaitingFirstBodyRow = !1, lastTableEnd = 0, currentTable, currentBody, currentCell, map3 = new EditMap();
+  for (; ++index < events.length; ) {
+    let event = events[index], token = event[1];
+    event[0] === "enter" ? token.type === "tableHead" ? (afterHeadAwaitingFirstBodyRow = !1, lastTableEnd !== 0 && (flushTableEnd(map3, context, lastTableEnd, currentTable, currentBody), currentBody = void 0, lastTableEnd = 0), currentTable = {
+      type: "table",
+      start: Object.assign({}, token.start),
+      // Note: correct end is set later.
+      end: Object.assign({}, token.end)
+    }, map3.add(index, 0, [["enter", currentTable, context]])) : token.type === "tableRow" || token.type === "tableDelimiterRow" ? (inFirstCellAwaitingPipe = !0, currentCell = void 0, lastCell = [0, 0, 0, 0], cell = [0, index + 1, 0, 0], afterHeadAwaitingFirstBodyRow && (afterHeadAwaitingFirstBodyRow = !1, currentBody = {
+      type: "tableBody",
+      start: Object.assign({}, token.start),
+      // Note: correct end is set later.
+      end: Object.assign({}, token.end)
+    }, map3.add(index, 0, [["enter", currentBody, context]])), rowKind = token.type === "tableDelimiterRow" ? 2 : currentBody ? 3 : 1) : rowKind && (token.type === "data" || token.type === "tableDelimiterMarker" || token.type === "tableDelimiterFiller") ? (inFirstCellAwaitingPipe = !1, cell[2] === 0 && (lastCell[1] !== 0 && (cell[0] = cell[1], currentCell = flushCell(map3, context, lastCell, rowKind, void 0, currentCell), lastCell = [0, 0, 0, 0]), cell[2] = index)) : token.type === "tableCellDivider" && (inFirstCellAwaitingPipe ? inFirstCellAwaitingPipe = !1 : (lastCell[1] !== 0 && (cell[0] = cell[1], currentCell = flushCell(map3, context, lastCell, rowKind, void 0, currentCell)), lastCell = cell, cell = [lastCell[1], index, 0, 0])) : token.type === "tableHead" ? (afterHeadAwaitingFirstBodyRow = !0, lastTableEnd = index) : token.type === "tableRow" || token.type === "tableDelimiterRow" ? (lastTableEnd = index, lastCell[1] !== 0 ? (cell[0] = cell[1], currentCell = flushCell(map3, context, lastCell, rowKind, index, currentCell)) : cell[1] !== 0 && (currentCell = flushCell(map3, context, cell, rowKind, index, currentCell)), rowKind = 0) : rowKind && (token.type === "data" || token.type === "tableDelimiterMarker" || token.type === "tableDelimiterFiller") && (cell[3] = index);
+  }
+  for (lastTableEnd !== 0 && flushTableEnd(map3, context, lastTableEnd, currentTable, currentBody), map3.consume(context.events), index = -1; ++index < context.events.length; ) {
+    let event = context.events[index];
+    event[0] === "enter" && event[1].type === "table" && (event[1]._align = gfmTableAlign(context.events, index));
+  }
+  return events;
+}
+function flushCell(map3, context, range, rowKind, rowEnd, previousCell) {
+  let groupName = rowKind === 1 ? "tableHeader" : rowKind === 2 ? "tableDelimiter" : "tableData", valueName = "tableContent";
+  range[0] !== 0 && (previousCell.end = Object.assign({}, getPoint(context.events, range[0])), map3.add(range[0], 0, [["exit", previousCell, context]]));
+  let now = getPoint(context.events, range[1]);
+  if (previousCell = {
+    type: groupName,
+    start: Object.assign({}, now),
+    // Note: correct end is set later.
+    end: Object.assign({}, now)
+  }, map3.add(range[1], 0, [["enter", previousCell, context]]), range[2] !== 0) {
+    let relatedStart = getPoint(context.events, range[2]), relatedEnd = getPoint(context.events, range[3]), valueToken = {
+      type: valueName,
+      start: Object.assign({}, relatedStart),
+      end: Object.assign({}, relatedEnd)
+    };
+    if (map3.add(range[2], 0, [["enter", valueToken, context]]), rowKind !== 2) {
+      let start = context.events[range[2]], end = context.events[range[3]];
+      if (start[1].end = Object.assign({}, end[1].end), start[1].type = "chunkText", start[1].contentType = "text", range[3] > range[2] + 1) {
+        let a = range[2] + 1, b = range[3] - range[2] - 1;
+        map3.add(a, b, []);
+      }
+    }
+    map3.add(range[3] + 1, 0, [["exit", valueToken, context]]);
+  }
+  return rowEnd !== void 0 && (previousCell.end = Object.assign({}, getPoint(context.events, rowEnd)), map3.add(rowEnd, 0, [["exit", previousCell, context]]), previousCell = void 0), previousCell;
+}
+function flushTableEnd(map3, context, index, table2, tableBody) {
+  let exits = [], related = getPoint(context.events, index);
+  tableBody && (tableBody.end = Object.assign({}, related), exits.push(["exit", tableBody, context])), table2.end = Object.assign({}, related), exits.push(["exit", table2, context]), map3.add(index + 1, 0, exits);
+}
+function getPoint(events, index) {
+  let event = events[index], side = event[0] === "enter" ? "start" : "end";
+  return event[1][side];
+}
+
+// ../../node_modules/micromark-extension-gfm-tagfilter/lib/index.js
+var reFlow = /<(\/?)(iframe|noembed|noframes|plaintext|script|style|title|textarea|xmp)(?=[\t\n\f\r />])/gi, reText = new RegExp("^" + reFlow.source, "i");
+
+// ../../node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js
+var tasklistCheck = {
+  name: "tasklistCheck",
+  tokenize: tokenizeTasklistCheck
+};
+function gfmTaskListItem() {
+  return {
+    text: {
+      91: tasklistCheck
+    }
+  };
+}
+function tokenizeTasklistCheck(effects, ok2, nok) {
+  let self = this;
+  return open;
+  function open(code5) {
+    return (
+      // Exit if there’s stuff before.
+      self.previous !== null || // Exit if not in the first content that is the first child of a list
+      // item.
+      !self._gfmTasklistFirstContentOfListItem ? nok(code5) : (effects.enter("taskListCheck"), effects.enter("taskListCheckMarker"), effects.consume(code5), effects.exit("taskListCheckMarker"), inside)
+    );
+  }
+  function inside(code5) {
+    return markdownLineEndingOrSpace(code5) ? (effects.enter("taskListCheckValueUnchecked"), effects.consume(code5), effects.exit("taskListCheckValueUnchecked"), close) : code5 === 88 || code5 === 120 ? (effects.enter("taskListCheckValueChecked"), effects.consume(code5), effects.exit("taskListCheckValueChecked"), close) : nok(code5);
+  }
+  function close(code5) {
+    return code5 === 93 ? (effects.enter("taskListCheckMarker"), effects.consume(code5), effects.exit("taskListCheckMarker"), effects.exit("taskListCheck"), after) : nok(code5);
+  }
+  function after(code5) {
+    return markdownLineEnding(code5) ? ok2(code5) : markdownSpace(code5) ? effects.check({
+      tokenize: spaceThenNonSpace
+    }, ok2, nok)(code5) : nok(code5);
+  }
+}
+function spaceThenNonSpace(effects, ok2, nok) {
+  return factorySpace(effects, after, "whitespace");
+  function after(code5) {
+    return code5 === null ? nok(code5) : ok2(code5);
+  }
+}
+
+// ../../node_modules/micromark-extension-gfm/index.js
+function gfm(options) {
+  return combineExtensions([
+    gfmAutolinkLiteral(),
+    gfmFootnote(),
+    gfmStrikethrough(options),
+    gfmTable(),
+    gfmTaskListItem()
+  ]);
+}
+
+// ../../node_modules/remark-gfm/lib/index.js
+var emptyOptions4 = {};
+function remarkGfm(options) {
+  let self = (
+    /** @type {Processor<Root>} */
+    this
+  ), settings = options || emptyOptions4, data = self.data(), micromarkExtensions = data.micromarkExtensions || (data.micromarkExtensions = []), fromMarkdownExtensions = data.fromMarkdownExtensions || (data.fromMarkdownExtensions = []), toMarkdownExtensions = data.toMarkdownExtensions || (data.toMarkdownExtensions = []);
+  micromarkExtensions.push(gfm(settings)), fromMarkdownExtensions.push(gfmFromMarkdown()), toMarkdownExtensions.push(gfmToMarkdown(settings));
 }
 
 // src/addon-docs/compiler/index.ts
-var compile2 = async (input, { mdxCompileOptions = {} } = {}) => {
-  let options = getCompilerOptions(mdxCompileOptions);
+var compile2 = async (input, { mdxCompileOptions = {}, gfm: gfm2 } = {}) => {
+  let options = getCompilerOptions(mdxCompileOptions, gfm2);
   return (await compile(input, options)).toString();
 };
-function getCompilerOptions(mdxCompileOptions) {
+function getCompilerOptions(mdxCompileOptions, gfm2 = !0) {
+  let remarkPlugins = mdxCompileOptions?.remarkPlugins ?? [];
   return {
     providerImportSource: "@mdx-js/react",
     rehypePlugins: [],
-    ...mdxCompileOptions
+    ...mdxCompileOptions,
+    remarkPlugins: gfm2 ? [remarkGfm, ...remarkPlugins] : remarkPlugins
   };
 }
 
 // src/addon-docs/mdx-plugin.ts
 async function mdxPlugin(options) {
-  let include = /\.mdx$/, filter = createFilter(include), { presets } = options, mdxPluginOptions = (await presets.apply("options", {}))?.mdxPluginOptions, rehypeSlug = (await import("./rehype-slug-H5TWHJ6G.js")).default, rehypeExternalLinks = (await import("./rehype-external-links-RT5Z62RV.js")).default;
+  let include = /\.mdx$/, filter = createFilter(include), { presets } = options, mdxPluginOptions = (await presets.apply("options", {}))?.mdxPluginOptions, rehypeSlug = (await import("./rehype-slug-KQI7ULEZ.js")).default, rehypeExternalLinks = (await import("./rehype-external-links-LJTPLCGD.js")).default;
   return {
     name: "storybook:mdx-plugin",
     enforce: "pre",