ovellum 0.2.0 → 0.2.1

package/dist/index.cjs

@@ -58,10 +58,12 @@ var DEFAULT_CONFIG = {
     search: { enabled: false },
     pageMeta: { readingTime: true, lastModified: true },
     topbarNav: [],
+    footerNav: [],
     landing: {
       enabled: false,
       hero: { ctas: [] },
-      features: []
+      features: [],
+      scenes: []
     }
   }
 };
@@ -253,6 +255,33 @@ function validateUserConfig(input2) {
         if (typeof item.href !== "string") {
           throw new ConfigError(`\`${path23}.href\` must be a string.`);
         }
+        if (item.icon !== void 0 && typeof item.icon !== "string") {
+          throw new ConfigError(`\`${path23}.icon\` must be a string.`);
+        }
+        if (item.external !== void 0 && typeof item.external !== "boolean") {
+          throw new ConfigError(`\`${path23}.external\` must be a boolean.`);
+        }
+      });
+    }
+    if (s.version !== void 0 && typeof s.version !== "string") {
+      throw new ConfigError("`site.version` must be a string when set.");
+    }
+    if (s.footerNav !== void 0) {
+      if (!Array.isArray(s.footerNav)) {
+        throw new ConfigError("`site.footerNav` must be an array.");
+      }
+      s.footerNav.forEach((item, i) => {
+        const path23 = `site.footerNav[${i}]`;
+        if (!isPlainObject(item)) throw new ConfigError(`\`${path23}\` must be an object.`);
+        if (typeof item.label !== "string") {
+          throw new ConfigError(`\`${path23}.label\` must be a string.`);
+        }
+        if (typeof item.href !== "string") {
+          throw new ConfigError(`\`${path23}.href\` must be a string.`);
+        }
+        if (item.icon !== void 0 && typeof item.icon !== "string") {
+          throw new ConfigError(`\`${path23}.icon\` must be a string.`);
+        }
         if (item.external !== void 0 && typeof item.external !== "boolean") {
           throw new ConfigError(`\`${path23}.external\` must be a boolean.`);
         }
@@ -301,6 +330,7 @@ function validateLanding(value) {
       }
       h.ctas.forEach((cta, i) => validateCta(cta, `site.landing.hero.ctas[${i}]`));
     }
+    if (h.media !== void 0) validateHeroMedia(h.media);
   }
   if (l.features !== void 0) {
     if (!Array.isArray(l.features)) {
@@ -308,6 +338,12 @@ function validateLanding(value) {
     }
     l.features.forEach((f, i) => validateFeature(f, `site.landing.features[${i}]`));
   }
+  if (l.scenes !== void 0) {
+    if (!Array.isArray(l.scenes)) {
+      throw new ConfigError("`site.landing.scenes` must be an array.");
+    }
+    l.scenes.forEach((s, i) => validateScene(s, `site.landing.scenes[${i}]`));
+  }
   if (l.trustStrip !== void 0) {
     if (!isPlainObject(l.trustStrip)) {
       throw new ConfigError("`site.landing.trustStrip` must be an object.");
@@ -324,6 +360,21 @@ function validateLanding(value) {
     }
   }
 }
+function validateHeroMedia(value) {
+  if (!isPlainObject(value)) {
+    throw new ConfigError("`site.landing.hero.media` must be an object.");
+  }
+  const m = value;
+  if (typeof m.light !== "string" || m.light.length === 0) {
+    throw new ConfigError("`site.landing.hero.media.light` must be a non-empty string path.");
+  }
+  if (m.dark !== void 0 && typeof m.dark !== "string") {
+    throw new ConfigError("`site.landing.hero.media.dark` must be a string path.");
+  }
+  if (m.alt !== void 0 && typeof m.alt !== "string") {
+    throw new ConfigError("`site.landing.hero.media.alt` must be a string.");
+  }
+}
 function validateCta(value, path23) {
   if (!isPlainObject(value)) throw new ConfigError(`\`${path23}\` must be an object.`);
   const c = value;
@@ -344,6 +395,19 @@ function validateFeature(value, path23) {
     throw new ConfigError(`\`${path23}.icon\` must be a string.`);
   }
 }
+function validateScene(value, path23) {
+  if (!isPlainObject(value)) throw new ConfigError(`\`${path23}\` must be an object.`);
+  const s = value;
+  if (typeof s.light !== "string" || s.light.length === 0) {
+    throw new ConfigError(`\`${path23}.light\` must be a non-empty string path.`);
+  }
+  if (s.dark !== void 0 && typeof s.dark !== "string") {
+    throw new ConfigError(`\`${path23}.dark\` must be a string path.`);
+  }
+  if (s.alt !== void 0 && typeof s.alt !== "string") {
+    throw new ConfigError(`\`${path23}.alt\` must be a string.`);
+  }
+}
 function validateTrustItem(value, path23) {
   if (!isPlainObject(value)) throw new ConfigError(`\`${path23}\` must be an object.`);
   const t = value;
@@ -418,8 +482,8 @@ function emptyJsDocInfo() {
     tags: {}
   };
 }
-function extractJsDoc(node) {
-  const blocks = node.getJsDocs();
+function extractJsDoc(node2) {
+  const blocks = node2.getJsDocs();
   if (blocks.length === 0) return emptyJsDocInfo();
   const block = blocks[blocks.length - 1];
   return parseBlock(block);
@@ -484,11 +548,11 @@ function readComment(tag) {
   return (raw ?? "").replace(/^\s*-\s*/, "").trim();
 }
 function readParamName(tag) {
-  const node = tag.compilerNode;
-  const named = node.name?.getText?.();
+  const node2 = tag.compilerNode;
+  const named = node2.name?.getText?.();
   if (named) return named;
-  const text = tag.getText();
-  const match = text.match(/@param\s+(?:\{[^}]*\}\s+)?([A-Za-z_$][\w$]*)/);
+  const text3 = tag.getText();
+  const match = text3.match(/@param\s+(?:\{[^}]*\}\s+)?([A-Za-z_$][\w$]*)/);
   return match ? match[1] : void 0;
 }
 function extractFromFile(sf, ctx) {
@@ -520,7 +584,7 @@ function fromFunction(fn, ctx) {
     returnType: returnTypeText,
     isAsync: fn.isAsync()
   });
-  const node = {
+  const node2 = {
     id: anchorId(ctx.relPath, name),
     kind: "function",
     name,
@@ -537,8 +601,8 @@ function fromFunction(fn, ctx) {
       description: jsdoc.returnsDescription
     }
   };
-  attachJsDocFields(node, jsdoc);
-  return [node];
+  attachJsDocFields(node2, jsdoc);
+  return [node2];
 }
 function fromClass(cls, ctx) {
   const name = cls.getName();
@@ -565,7 +629,7 @@ function fromClass(cls, ctx) {
     const childNode = fromProperty(prop, ctx, name);
     if (childNode) children.push(childNode);
   }
-  const node = {
+  const node2 = {
     id: anchorId(ctx.relPath, name),
     kind: "class",
     name,
@@ -578,8 +642,8 @@ function fromClass(cls, ctx) {
     tags: jsdoc.tags,
     children: children.length ? children : void 0
   };
-  attachJsDocFields(node, jsdoc);
-  return [node];
+  attachJsDocFields(node2, jsdoc);
+  return [node2];
 }
 function fromMethod(method, ctx, className) {
   const name = method.getName();
@@ -592,7 +656,7 @@ function fromMethod(method, ctx, className) {
   const generics = method.getTypeParameters().map((tp) => tp.getText());
   const gen = generics.length ? `<${generics.join(", ")}>` : "";
   const signature = `${name}${gen}(${method.getParameters().map(paramSignaturePart).join(", ")}): ${returnTypeText}`;
-  const node = {
+  const node2 = {
     id: anchorId(ctx.relPath, `${className}.${name}`),
     kind: "method",
     name,
@@ -609,8 +673,8 @@ function fromMethod(method, ctx, className) {
       description: jsdoc.returnsDescription
     }
   };
-  attachJsDocFields(node, jsdoc);
-  return node;
+  attachJsDocFields(node2, jsdoc);
+  return node2;
 }
 function fromProperty(prop, ctx, className) {
   const name = prop.getName();
@@ -619,7 +683,7 @@ function fromProperty(prop, ctx, className) {
   if (isPrivate && !ctx.config.includePrivate && !ctx.config.includeInternal) return void 0;
   if (jsdoc.internal && !ctx.config.includeInternal) return void 0;
   const typeText = prop.getTypeNode()?.getText() ?? prop.getType().getText(prop);
-  const node = {
+  const node2 = {
     id: anchorId(ctx.relPath, `${className}.${name}`),
     kind: "property",
     name,
@@ -631,8 +695,8 @@ function fromProperty(prop, ctx, className) {
     isPreserved: jsdoc.preserved,
     tags: jsdoc.tags
   };
-  attachJsDocFields(node, jsdoc);
-  return node;
+  attachJsDocFields(node2, jsdoc);
+  return node2;
 }
 function fromInterface(iface, ctx) {
   const name = iface.getName();
@@ -687,7 +751,7 @@ function fromInterface(iface, ctx) {
     attachJsDocFields(methodNode, methodJsdoc);
     children.push(methodNode);
   }
-  const node = {
+  const node2 = {
     id: anchorId(ctx.relPath, name),
     kind: "interface",
     name,
@@ -700,8 +764,8 @@ function fromInterface(iface, ctx) {
     tags: jsdoc.tags,
     children: children.length ? children : void 0
   };
-  attachJsDocFields(node, jsdoc);
-  return [node];
+  attachJsDocFields(node2, jsdoc);
+  return [node2];
 }
 function fromTypeAlias(alias, ctx) {
   const name = alias.getName();
@@ -711,7 +775,7 @@ function fromTypeAlias(alias, ctx) {
   const generics = alias.getTypeParameters().map((tp) => tp.getText());
   const gen = generics.length ? `<${generics.join(", ")}>` : "";
   const typeText = alias.getTypeNode()?.getText() ?? alias.getType().getText(alias);
-  const node = {
+  const node2 = {
     id: anchorId(ctx.relPath, name),
     kind: "type",
     name,
@@ -723,8 +787,8 @@ function fromTypeAlias(alias, ctx) {
     isPreserved: jsdoc.preserved,
     tags: jsdoc.tags
   };
-  attachJsDocFields(node, jsdoc);
-  return [node];
+  attachJsDocFields(node2, jsdoc);
+  return [node2];
 }
 function fromEnum(en, ctx) {
   const name = en.getName();
@@ -751,7 +815,7 @@ function fromEnum(en, ctx) {
     attachJsDocFields(memberNode, memberJsdoc);
     return memberNode;
   });
-  const node = {
+  const node2 = {
     id: anchorId(ctx.relPath, name),
     kind: "enum",
     name,
@@ -764,8 +828,8 @@ function fromEnum(en, ctx) {
     tags: jsdoc.tags,
     children
   };
-  attachJsDocFields(node, jsdoc);
-  return [node];
+  attachJsDocFields(node2, jsdoc);
+  return [node2];
 }
 function paramSignaturePart(p) {
   const name = p.getName();
@@ -796,12 +860,12 @@ function buildFunctionSignature(opts) {
   const asyncKw = opts.isAsync ? "async " : "";
   return `${asyncKw}function ${opts.name}${gen}(${opts.params.join(", ")}): ${opts.returnType}`;
 }
-function attachJsDocFields(node, jsdoc) {
-  if (jsdoc.description) node.description = jsdoc.description;
-  if (jsdoc.examples.length) node.examples = jsdoc.examples;
-  if (jsdoc.throws.length) node.throws = jsdoc.throws;
-  if (jsdoc.deprecated) node.deprecated = jsdoc.deprecated;
-  if (jsdoc.since) node.since = jsdoc.since;
+function attachJsDocFields(node2, jsdoc) {
+  if (jsdoc.description) node2.description = jsdoc.description;
+  if (jsdoc.examples.length) node2.examples = jsdoc.examples;
+  if (jsdoc.throws.length) node2.throws = jsdoc.throws;
+  if (jsdoc.deprecated) node2.deprecated = jsdoc.deprecated;
+  if (jsdoc.since) node2.since = jsdoc.since;
 }
 function parseProject(options) {
   const { config, cwd } = options;
@@ -897,38 +961,38 @@ function outputPathFor(sourceRelPath, config) {
 function stripLeadingDotSlash(p) {
   return p.replace(/^\.\/+/, "").replace(/\/+$/, "");
 }
-function renderNode(node) {
+function renderNode(node2) {
   const parts = [];
-  parts.push(headingFor(node));
-  parts.push(anchorComment(node));
-  parts.push(signatureBlock(node));
-  if (node.deprecated) {
-    parts.push(`> **Deprecated.** ${escapeInline(node.deprecated)}`);
+  parts.push(headingFor(node2));
+  parts.push(anchorComment(node2));
+  parts.push(signatureBlock(node2));
+  if (node2.deprecated) {
+    parts.push(`> **Deprecated.** ${escapeInline(node2.deprecated)}`);
   }
-  if (node.description) {
-    parts.push(node.description.trim());
+  if (node2.description) {
+    parts.push(node2.description.trim());
   }
-  if (node.since) {
-    parts.push(`*Since: ${escapeInline(node.since)}*`);
+  if (node2.since) {
+    parts.push(`*Since: ${escapeInline(node2.since)}*`);
   }
-  if (node.params && node.params.length > 0) {
+  if (node2.params && node2.params.length > 0) {
     parts.push("**Parameters**");
-    parts.push(paramsTable(node.params));
+    parts.push(paramsTable(node2.params));
   }
-  if (node.returns && node.returns.type && node.returns.type !== "void") {
-    const desc = node.returns.description ? ` - ${node.returns.description}` : "";
-    parts.push(`**Returns** \`${node.returns.type}\`${desc}`);
+  if (node2.returns && node2.returns.type && node2.returns.type !== "void") {
+    const desc = node2.returns.description ? ` - ${node2.returns.description}` : "";
+    parts.push(`**Returns** \`${node2.returns.type}\`${desc}`);
   }
-  if (node.throws && node.throws.length > 0) {
+  if (node2.throws && node2.throws.length > 0) {
     parts.push("**Throws**");
-    for (const t of node.throws) parts.push(`- ${escapeInline(t)}`);
+    for (const t of node2.throws) parts.push(`- ${escapeInline(t)}`);
   }
-  if (node.examples && node.examples.length > 0) {
+  if (node2.examples && node2.examples.length > 0) {
     parts.push("**Example**");
-    for (const ex of node.examples) parts.push(fence(ex.trim(), "typescript"));
+    for (const ex of node2.examples) parts.push(fence(ex.trim(), "typescript"));
   }
-  if (node.children && node.children.length > 0) {
-    parts.push(renderChildren(node));
+  if (node2.children && node2.children.length > 0) {
+    parts.push(renderChildren(node2));
   }
   return parts.filter(Boolean).join("\n\n");
 }
@@ -959,25 +1023,25 @@ ${buckets.method.map(renderMember).join("\n\n")}`);
   }
   return sections.join("\n\n");
 }
-function renderMember(node) {
+function renderMember(node2) {
   const parts = [];
-  parts.push(`##### \`${node.name}\``);
-  parts.push(anchorComment(node));
-  parts.push(fence(node.signature, "typescript"));
-  if (node.description) parts.push(node.description.trim());
-  if (node.params && node.params.length > 0) {
-    parts.push(paramsTable(node.params));
+  parts.push(`##### \`${node2.name}\``);
+  parts.push(anchorComment(node2));
+  parts.push(fence(node2.signature, "typescript"));
+  if (node2.description) parts.push(node2.description.trim());
+  if (node2.params && node2.params.length > 0) {
+    parts.push(paramsTable(node2.params));
   }
-  if (node.returns && node.returns.type && node.returns.type !== "void") {
-    parts.push(`Returns \`${node.returns.type}\``);
+  if (node2.returns && node2.returns.type && node2.returns.type !== "void") {
+    parts.push(`Returns \`${node2.returns.type}\``);
   }
   return parts.filter(Boolean).join("\n\n");
 }
-function headingFor(node) {
-  return `## \`${node.name}\``;
+function headingFor(node2) {
+  return `## \`${node2.name}\``;
 }
-function signatureBlock(node) {
-  return fence(node.signature, "typescript");
+function signatureBlock(node2) {
+  return fence(node2.signature, "typescript");
 }
 function paramsTable(params) {
   const head = "| Name | Type | Description |\n| --- | --- | --- |";
@@ -1006,8 +1070,8 @@ function signatureTypeOnly(signature, name) {
   if (eqMatch) return eqMatch[1].trim();
   return signature;
 }
-function anchorComment(node) {
-  return `<!-- ovellum:anchor id="${node.id}" generated="${(/* @__PURE__ */ new Date()).toISOString()}" -->`;
+function anchorComment(node2) {
+  return `<!-- ovellum:anchor id="${node2.id}" generated="${(/* @__PURE__ */ new Date()).toISOString()}" -->`;
 }
 function fence(content, lang) {
   return "```" + lang + "\n" + content + "\n```";
@@ -1036,8 +1100,8 @@ function renderFile(file, generatedAt) {
   if (file.description) {
     parts.push(file.description.trim());
   }
-  for (const node of file.nodes) {
-    parts.push(renderNode(node));
+  for (const node2 of file.nodes) {
+    parts.push(renderNode(node2));
   }
   return parts.filter(Boolean).join("\n\n") + "\n";
 }
@@ -1151,7 +1215,15 @@ function parseManualDoc(raw, filePath) {
   const frontmatter = parsed.data ?? {};
   const content = parsed.content;
   const protectedBlocks = extractProtectedZones(content);
-  return { filePath, frontmatter, content, protectedBlocks };
+  const warnings = [];
+  for (const block of protectedBlocks) {
+    if (!block.hasExplicitId) {
+      warnings.push(
+        `${filePath}:${block.startLine}: protected zone "${block.id}" uses a positional fallback id. Add id="..." on the <!-- @manual:start --> tag so the block survives reordering.`
+      );
+    }
+  }
+  return { filePath, frontmatter, content, protectedBlocks, warnings };
 }
 
 // ../merger/dist/index.js
@@ -1167,146 +1239,3588 @@ function findAnchors(content) {
     if (!id) continue;
     out.push({ id, index: m.index, endIndex: m.index + m[0].length });
   }
-  return out;
+  return out;
+}
+function merge(generated, manual, options = {}) {
+  const orphans = [];
+  const warnings = [];
+  const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const sourceFile = options.sourceFile ?? manual.filePath;
+  const anchorToBlocks = /* @__PURE__ */ new Map();
+  const anchorless = [];
+  for (const block of manual.protectedBlocks) {
+    if (!block.anchorId) {
+      anchorless.push(block);
+      continue;
+    }
+    let list2 = anchorToBlocks.get(block.anchorId);
+    if (!list2) {
+      list2 = [];
+      anchorToBlocks.set(block.anchorId, list2);
+    }
+    list2.push(block);
+  }
+  for (const block of anchorless) {
+    warnings.push(`Protected block ${block.id} has no associated anchor \u2014 treated as orphan.`);
+    orphans.push(orphanFromBlock(block, void 0, sourceFile, now));
+  }
+  const anchors = findAnchors(generated);
+  if (anchors.length === 0) {
+    for (const [anchorId2, blocks] of anchorToBlocks) {
+      for (const block of blocks) {
+        orphans.push(orphanFromBlock(block, anchorId2, sourceFile, now));
+      }
+    }
+    return { content: generated, orphans, warnings };
+  }
+  const pieces = [];
+  let cursor = 0;
+  for (let i = 0; i < anchors.length; i++) {
+    const anchor = anchors[i];
+    const sectionEnd = findSectionEnd(generated, anchor.endIndex);
+    pieces.push(generated.slice(cursor, sectionEnd));
+    const blocks = anchorToBlocks.get(anchor.id);
+    if (blocks && blocks.length > 0) {
+      pieces.push(renderBlocks(blocks));
+      anchorToBlocks.delete(anchor.id);
+    }
+    cursor = sectionEnd;
+  }
+  if (cursor < generated.length) {
+    pieces.push(generated.slice(cursor));
+  }
+  for (const [anchorId2, blocks] of anchorToBlocks) {
+    for (const block of blocks) {
+      orphans.push(orphanFromBlock(block, anchorId2, sourceFile, now));
+    }
+  }
+  return { content: pieces.join(""), orphans, warnings };
+}
+function findSectionEnd(content, from) {
+  const re = /\n(#{1,6} )/g;
+  re.lastIndex = from;
+  const m = re.exec(content);
+  return m ? m.index + 1 : content.length;
+}
+function renderBlocks(blocks) {
+  return blocks.map((b) => renderBlock(b)).join("\n");
+}
+function renderBlock(block) {
+  const idAttr = block.hasExplicitId ? ` id="${block.id}"` : "";
+  return `<!-- @manual:start${idAttr} -->
+${block.content}
+<!-- @manual:end -->
+
+`;
+}
+function orphanFromBlock(block, anchorId2, sourceFile, orphanedAt) {
+  const out = {
+    orphanedAt,
+    sourceFile,
+    anchorId: anchorId2 ?? "unknown",
+    content: block.content
+  };
+  if (block.hasExplicitId) out.manualBlockId = block.id;
+  return out;
+}
+function slugifyAnchor(anchorId2) {
+  return anchorId2.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+function formatDateUTC(d) {
+  const y = d.getUTCFullYear();
+  const m = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(d.getUTCDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+function renderOrphanFile(record) {
+  const fields = {
+    orphaned: record.orphanedAt,
+    source_file: record.sourceFile,
+    anchor_id: record.anchorId
+  };
+  if (record.anchorLastSeen) fields.anchor_last_seen = record.anchorLastSeen;
+  if (record.manualBlockId) fields.manual_block_id = record.manualBlockId;
+  const yaml = Object.entries(fields).map(([k, v]) => `${k}: ${formatYamlScalar2(v)}`).join("\n");
+  return `---
+${yaml}
+---
+
+${record.content}
+`;
+}
+async function writeOrphan(record, orphanDir) {
+  const slug = slugifyAnchor(record.anchorId);
+  const dateStamp = formatDateUTC(new Date(record.orphanedAt));
+  const filename = `${dateStamp}_${slug}.md`;
+  const absPath = import_path4.default.resolve(orphanDir, filename);
+  await (0, import_promises2.mkdir)(orphanDir, { recursive: true });
+  await (0, import_promises2.writeFile)(absPath, renderOrphanFile(record), "utf8");
+  return absPath;
+}
+function formatYamlScalar2(s) {
+  if (/[:#\-?{}[\],&*!|>'"%@`]/.test(s) || /^\s|\s$/.test(s)) {
+    return `'${s.replace(/'/g, "''")}'`;
+  }
+  return s;
+}
+
+// ../site/dist/index.js
+var import_fs2 = require("fs");
+var import_promises3 = require("fs/promises");
+var import_path5 = __toESM(require("path"), 1);
+var import_url = require("url");
+var import_gray_matter2 = __toESM(require("gray-matter"), 1);
+var import_unified = require("unified");
+var import_remark_parse = __toESM(require("remark-parse"), 1);
+
+// ../../node_modules/.pnpm/ccount@2.0.1/node_modules/ccount/index.js
+function ccount(value, character) {
+  const source = String(value);
+  if (typeof character !== "string") {
+    throw new TypeError("Expected character");
+  }
+  let count = 0;
+  let index = source.indexOf(character);
+  while (index !== -1) {
+    count++;
+    index = source.indexOf(character, index + character.length);
+  }
+  return count;
+}
+
+// ../../node_modules/.pnpm/devlop@1.1.0/node_modules/devlop/lib/default.js
+function ok() {
+}
+
+// ../../node_modules/.pnpm/micromark-util-character@2.1.1/node_modules/micromark-util-character/index.js
+var asciiAlpha = regexCheck(/[A-Za-z]/);
+var asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);
+var asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/);
+function asciiControl(code3) {
+  return (
+    // Special whitespace codes (which have negative values), C0 and Control
+    // character DEL
+    code3 !== null && (code3 < 32 || code3 === 127)
+  );
+}
+var asciiDigit = regexCheck(/\d/);
+var asciiHexDigit = regexCheck(/[\dA-Fa-f]/);
+var asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);
+function markdownLineEnding(code3) {
+  return code3 !== null && code3 < -2;
+}
+function markdownLineEndingOrSpace(code3) {
+  return code3 !== null && (code3 < 0 || code3 === 32);
+}
+function markdownSpace(code3) {
+  return code3 === -2 || code3 === -1 || code3 === 32;
+}
+var unicodePunctuation = regexCheck(new RegExp("\\p{P}|\\p{S}", "u"));
+var unicodeWhitespace = regexCheck(/\s/);
+function regexCheck(regex) {
+  return check;
+  function check(code3) {
+    return code3 !== null && code3 > -1 && regex.test(String.fromCharCode(code3));
+  }
+}
+
+// ../../node_modules/.pnpm/escape-string-regexp@5.0.0/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/.pnpm/unist-util-is@6.0.1/node_modules/unist-util-is/lib/index.js
+var convert = (
+  // Note: overloads in JSDoc can’t yet use different `@template`s.
+  /**
+   * @type {(
+   *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &
+   *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &
+   *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &
+   *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &
+   *   ((test?: Test) => Check)
+   * )}
+   */
+  /**
+   * @param {Test} [test]
+   * @returns {Check}
+   */
+  (function(test) {
+    if (test === null || test === void 0) {
+      return ok2;
+    }
+    if (typeof test === "function") {
+      return castFactory(test);
+    }
+    if (typeof test === "object") {
+      return Array.isArray(test) ? anyFactory(test) : (
+        // Cast because `ReadonlyArray` goes into the above but `isArray`
+        // narrows to `Array`.
+        propertiesFactory(
+          /** @type {Props} */
+          test
+        )
+      );
+    }
+    if (typeof test === "string") {
+      return typeFactory(test);
+    }
+    throw new Error("Expected function, string, or object as test");
+  })
+);
+function anyFactory(tests) {
+  const checks = [];
+  let index = -1;
+  while (++index < tests.length) {
+    checks[index] = convert(tests[index]);
+  }
+  return castFactory(any);
+  function any(...parameters) {
+    let index2 = -1;
+    while (++index2 < checks.length) {
+      if (checks[index2].apply(this, parameters)) return true;
+    }
+    return false;
+  }
+}
+function propertiesFactory(check) {
+  const checkAsRecord = (
+    /** @type {Record<string, unknown>} */
+    check
+  );
+  return castFactory(all2);
+  function all2(node2) {
+    const nodeAsRecord = (
+      /** @type {Record<string, unknown>} */
+      /** @type {unknown} */
+      node2
+    );
+    let key;
+    for (key in check) {
+      if (nodeAsRecord[key] !== checkAsRecord[key]) return false;
+    }
+    return true;
+  }
+}
+function typeFactory(check) {
+  return castFactory(type);
+  function type(node2) {
+    return node2 && node2.type === check;
+  }
+}
+function castFactory(testFunction) {
+  return check;
+  function check(value, index, parent) {
+    return Boolean(
+      looksLikeANode(value) && testFunction.call(
+        this,
+        value,
+        typeof index === "number" ? index : void 0,
+        parent || void 0
+      )
+    );
+  }
+}
+function ok2() {
+  return true;
+}
+function looksLikeANode(value) {
+  return value !== null && typeof value === "object" && "type" in value;
+}
+
+// ../../node_modules/.pnpm/unist-util-visit-parents@6.0.2/node_modules/unist-util-visit-parents/lib/color.node.js
+function color(d) {
+  return "\x1B[33m" + d + "\x1B[39m";
+}
+
+// ../../node_modules/.pnpm/unist-util-visit-parents@6.0.2/node_modules/unist-util-visit-parents/lib/index.js
+var empty = [];
+var CONTINUE = true;
+var EXIT = false;
+var SKIP = "skip";
+function visitParents(tree, test, visitor, reverse) {
+  let check;
+  if (typeof test === "function" && typeof visitor !== "function") {
+    reverse = visitor;
+    visitor = test;
+  } else {
+    check = test;
+  }
+  const is2 = convert(check);
+  const step = reverse ? -1 : 1;
+  factory(tree, void 0, [])();
+  function factory(node2, index, parents) {
+    const value = (
+      /** @type {Record<string, unknown>} */
+      node2 && typeof node2 === "object" ? node2 : {}
+    );
+    if (typeof value.type === "string") {
+      const name = (
+        // `hast`
+        typeof value.tagName === "string" ? value.tagName : (
+          // `xast`
+          typeof value.name === "string" ? value.name : void 0
+        )
+      );
+      Object.defineProperty(visit3, "name", {
+        value: "node (" + color(node2.type + (name ? "<" + name + ">" : "")) + ")"
+      });
+    }
+    return visit3;
+    function visit3() {
+      let result = empty;
+      let subresult;
+      let offset;
+      let grandparents;
+      if (!test || is2(node2, index, parents[parents.length - 1] || void 0)) {
+        result = toResult(visitor(node2, parents));
+        if (result[0] === EXIT) {
+          return result;
+        }
+      }
+      if ("children" in node2 && node2.children) {
+        const nodeAsParent = (
+          /** @type {UnistParent} */
+          node2
+        );
+        if (nodeAsParent.children && result[0] !== SKIP) {
+          offset = (reverse ? nodeAsParent.children.length : -1) + step;
+          grandparents = parents.concat(nodeAsParent);
+          while (offset > -1 && offset < nodeAsParent.children.length) {
+            const child = nodeAsParent.children[offset];
+            subresult = factory(child, offset, grandparents)();
+            if (subresult[0] === EXIT) {
+              return subresult;
+            }
+            offset = typeof subresult[1] === "number" ? subresult[1] : offset + step;
+          }
+        }
+      }
+      return result;
+    }
+  }
+}
+function toResult(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value === "number") {
+    return [CONTINUE, value];
+  }
+  return value === null || value === void 0 ? empty : [value];
+}
+
+// ../../node_modules/.pnpm/mdast-util-find-and-replace@3.0.2/node_modules/mdast-util-find-and-replace/lib/index.js
+function findAndReplace(tree, list2, options) {
+  const settings = options || {};
+  const ignored = convert(settings.ignore || []);
+  const pairs = toPairs(list2);
+  let pairIndex = -1;
+  while (++pairIndex < pairs.length) {
+    visitParents(tree, "text", visitor);
+  }
+  function visitor(node2, parents) {
+    let index = -1;
+    let grandparent;
+    while (++index < parents.length) {
+      const parent = parents[index];
+      const siblings = grandparent ? grandparent.children : void 0;
+      if (ignored(
+        parent,
+        siblings ? siblings.indexOf(parent) : void 0,
+        grandparent
+      )) {
+        return;
+      }
+      grandparent = parent;
+    }
+    if (grandparent) {
+      return handler(node2, parents);
+    }
+  }
+  function handler(node2, parents) {
+    const parent = parents[parents.length - 1];
+    const find = pairs[pairIndex][0];
+    const replace2 = pairs[pairIndex][1];
+    let start = 0;
+    const siblings = parent.children;
+    const index = siblings.indexOf(node2);
+    let change = false;
+    let nodes = [];
+    find.lastIndex = 0;
+    let match = find.exec(node2.value);
+    while (match) {
+      const position = match.index;
+      const matchObject = {
+        index: match.index,
+        input: match.input,
+        stack: [...parents, node2]
+      };
+      let value = replace2(...match, matchObject);
+      if (typeof value === "string") {
+        value = value.length > 0 ? { type: "text", value } : void 0;
+      }
+      if (value === false) {
+        find.lastIndex = position + 1;
+      } else {
+        if (start !== position) {
+          nodes.push({
+            type: "text",
+            value: node2.value.slice(start, position)
+          });
+        }
+        if (Array.isArray(value)) {
+          nodes.push(...value);
+        } else if (value) {
+          nodes.push(value);
+        }
+        start = position + match[0].length;
+        change = true;
+      }
+      if (!find.global) {
+        break;
+      }
+      match = find.exec(node2.value);
+    }
+    if (change) {
+      if (start < node2.value.length) {
+        nodes.push({ type: "text", value: node2.value.slice(start) });
+      }
+      parent.children.splice(index, 1, ...nodes);
+    } else {
+      nodes = [node2];
+    }
+    return index + nodes.length;
+  }
+}
+function toPairs(tupleOrList) {
+  const result = [];
+  if (!Array.isArray(tupleOrList)) {
+    throw new TypeError("Expected find and replace tuple or list of tuples");
+  }
+  const list2 = !tupleOrList[0] || Array.isArray(tupleOrList[0]) ? tupleOrList : [tupleOrList];
+  let index = -1;
+  while (++index < list2.length) {
+    const tuple = list2[index];
+    result.push([toExpression(tuple[0]), toFunction(tuple[1])]);
+  }
+  return result;
+}
+function toExpression(find) {
+  return typeof find === "string" ? new RegExp(escapeStringRegexp(find), "g") : find;
+}
+function toFunction(replace2) {
+  return typeof replace2 === "function" ? replace2 : function() {
+    return replace2;
+  };
+}
+
+// ../../node_modules/.pnpm/mdast-util-gfm-autolink-literal@2.0.1/node_modules/mdast-util-gfm-autolink-literal/lib/index.js
+var inConstruct = "phrasing";
+var 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);
+  const node2 = this.stack[this.stack.length - 1];
+  ok(node2.type === "link");
+  node2.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, path16, match) {
+  let prefix = "";
+  if (!previous(match)) {
+    return false;
+  }
+  if (/^w/i.test(protocol)) {
+    domain2 = protocol + domain2;
+    protocol = "";
+    prefix = "http://";
+  }
+  if (!isCorrectDomain(domain2)) {
+    return false;
+  }
+  const parts = splitUrl(domain2 + path16);
+  if (!parts[0]) return false;
+  const result = {
+    type: "link",
+    title: null,
+    url: prefix + protocol + parts[0],
+    children: [{ type: "text", value: protocol + parts[0] }]
+  };
+  if (parts[1]) {
+    return [result, { type: "text", value: parts[1] }];
+  }
+  return result;
+}
+function findEmail(_, atext, label, match) {
+  if (
+    // Not an expected previous character.
+    !previous(match, true) || // Label ends in not allowed character.
+    /[-\d_]$/.test(label)
+  ) {
+    return false;
+  }
+  return {
+    type: "link",
+    title: null,
+    url: "mailto:" + atext + "@" + label,
+    children: [{ type: "text", value: atext + "@" + label }]
+  };
+}
+function isCorrectDomain(domain2) {
+  const parts = domain2.split(".");
+  if (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]))) {
+    return false;
+  }
+  return true;
+}
+function splitUrl(url) {
+  const trailExec = /[!"&'),.:;<>?\]}]+$/.exec(url);
+  if (!trailExec) {
+    return [url, void 0];
+  }
+  url = url.slice(0, trailExec.index);
+  let trail2 = trailExec[0];
+  let closingParenIndex = trail2.indexOf(")");
+  const openingParens = ccount(url, "(");
+  let closingParens = ccount(url, ")");
+  while (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) {
+  const code3 = match.input.charCodeAt(match.index - 1);
+  return (match.index === 0 || unicodeWhitespace(code3) || unicodePunctuation(code3)) && // If it’s an email, the previous character should not be a slash.
+  (!email || code3 !== 47);
+}
+
+// ../../node_modules/.pnpm/micromark-util-normalize-identifier@2.0.1/node_modules/micromark-util-normalize-identifier/index.js
+function normalizeIdentifier(value) {
+  return value.replace(/[\t\n\r ]+/g, " ").replace(/^ | $/g, "").toLowerCase().toUpperCase();
+}
+
+// ../../node_modules/.pnpm/mdast-util-gfm-footnote@2.1.0/node_modules/mdast-util-gfm-footnote/lib/index.js
+footnoteReference.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) {
+  const label = this.resume();
+  const node2 = this.stack[this.stack.length - 1];
+  ok(node2.type === "footnoteReference");
+  node2.identifier = normalizeIdentifier(
+    this.sliceSerialize(token)
+  ).toLowerCase();
+  node2.label = label;
+}
+function exitFootnoteCall(token) {
+  this.exit(token);
+}
+function exitFootnoteDefinitionLabelString(token) {
+  const label = this.resume();
+  const node2 = this.stack[this.stack.length - 1];
+  ok(node2.type === "footnoteDefinition");
+  node2.identifier = normalizeIdentifier(
+    this.sliceSerialize(token)
+  ).toLowerCase();
+  node2.label = label;
+}
+function exitFootnoteDefinition(token) {
+  this.exit(token);
+}
+function footnoteReferencePeek() {
+  return "[";
+}
+function footnoteReference(node2, _, state, info) {
+  const tracker = state.createTracker(info);
+  let value = tracker.move("[^");
+  const exit2 = state.enter("footnoteReference");
+  const subexit = state.enter("reference");
+  value += tracker.move(
+    state.safe(state.associationId(node2), { after: "]", before: value })
+  );
+  subexit();
+  exit2();
+  value += tracker.move("]");
+  return 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 = false;
+  if (options && options.firstLineBlank) {
+    firstLineBlank = true;
+  }
+  return {
+    handlers: { footnoteDefinition, footnoteReference },
+    // This is on by default already.
+    unsafe: [{ character: "[", inConstruct: ["label", "phrasing", "reference"] }]
+  };
+  function footnoteDefinition(node2, _, state, info) {
+    const tracker = state.createTracker(info);
+    let value = tracker.move("[^");
+    const exit2 = state.enter("footnoteDefinition");
+    const subexit = state.enter("label");
+    value += tracker.move(
+      state.safe(state.associationId(node2), { before: value, after: "]" })
+    );
+    subexit();
+    value += tracker.move("]:");
+    if (node2.children && node2.children.length > 0) {
+      tracker.shift(4);
+      value += tracker.move(
+        (firstLineBlank ? "\n" : " ") + state.indentLines(
+          state.containerFlow(node2, tracker.current()),
+          firstLineBlank ? mapAll : mapExceptFirst
+        )
+      );
+    }
+    exit2();
+    return value;
+  }
+}
+function mapExceptFirst(line, index, blank) {
+  return index === 0 ? line : mapAll(line, index, blank);
+}
+function mapAll(line, index, blank) {
+  return (blank ? "" : "    ") + line;
+}
+
+// ../../node_modules/.pnpm/mdast-util-gfm-strikethrough@2.0.0/node_modules/mdast-util-gfm-strikethrough/lib/index.js
+var constructsWithoutStrikethrough = [
+  "autolink",
+  "destinationLiteral",
+  "destinationRaw",
+  "reference",
+  "titleQuote",
+  "titleApostrophe"
+];
+handleDelete.peek = peekDelete;
+function gfmStrikethroughFromMarkdown() {
+  return {
+    canContainEols: ["delete"],
+    enter: { strikethrough: enterStrikethrough },
+    exit: { strikethrough: exitStrikethrough }
+  };
+}
+function gfmStrikethroughToMarkdown() {
+  return {
+    unsafe: [
+      {
+        character: "~",
+        inConstruct: "phrasing",
+        notInConstruct: constructsWithoutStrikethrough
+      }
+    ],
+    handlers: { delete: handleDelete }
+  };
+}
+function enterStrikethrough(token) {
+  this.enter({ type: "delete", children: [] }, token);
+}
+function exitStrikethrough(token) {
+  this.exit(token);
+}
+function handleDelete(node2, _, state, info) {
+  const tracker = state.createTracker(info);
+  const exit2 = state.enter("strikethrough");
+  let value = tracker.move("~~");
+  value += state.containerPhrasing(node2, {
+    ...tracker.current(),
+    before: value,
+    after: "~"
+  });
+  value += tracker.move("~~");
+  exit2();
+  return value;
+}
+function peekDelete() {
+  return "~";
+}
+
+// ../../node_modules/.pnpm/markdown-table@3.0.4/node_modules/markdown-table/index.js
+function defaultStringLength(value) {
+  return value.length;
+}
+function markdownTable(table, options) {
+  const settings = options || {};
+  const align = (settings.align || []).concat();
+  const stringLength = settings.stringLength || defaultStringLength;
+  const alignments = [];
+  const cellMatrix = [];
+  const sizeMatrix = [];
+  const longestCellByColumn = [];
+  let mostCellsPerRow = 0;
+  let rowIndex = -1;
+  while (++rowIndex < table.length) {
+    const row2 = [];
+    const sizes2 = [];
+    let columnIndex2 = -1;
+    if (table[rowIndex].length > mostCellsPerRow) {
+      mostCellsPerRow = table[rowIndex].length;
+    }
+    while (++columnIndex2 < table[rowIndex].length) {
+      const cell = serialize(table[rowIndex][columnIndex2]);
+      if (settings.alignDelimiters !== false) {
+        const size = stringLength(cell);
+        sizes2[columnIndex2] = size;
+        if (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) {
+    while (++columnIndex < mostCellsPerRow) {
+      alignments[columnIndex] = toAlignment(align[columnIndex]);
+    }
+  } else {
+    const code3 = toAlignment(align);
+    while (++columnIndex < mostCellsPerRow) {
+      alignments[columnIndex] = code3;
+    }
+  }
+  columnIndex = -1;
+  const row = [];
+  const sizes = [];
+  while (++columnIndex < mostCellsPerRow) {
+    const code3 = alignments[columnIndex];
+    let before = "";
+    let after = "";
+    if (code3 === 99) {
+      before = ":";
+      after = ":";
+    } else if (code3 === 108) {
+      before = ":";
+    } else if (code3 === 114) {
+      after = ":";
+    }
+    let size = settings.alignDelimiters === false ? 1 : Math.max(
+      1,
+      longestCellByColumn[columnIndex] - before.length - after.length
+    );
+    const cell = before + "-".repeat(size) + after;
+    if (settings.alignDelimiters !== false) {
+      size = before.length + size + after.length;
+      if (size > longestCellByColumn[columnIndex]) {
+        longestCellByColumn[columnIndex] = size;
+      }
+      sizes[columnIndex] = size;
+    }
+    row[columnIndex] = cell;
+  }
+  cellMatrix.splice(1, 0, row);
+  sizeMatrix.splice(1, 0, sizes);
+  rowIndex = -1;
+  const lines = [];
+  while (++rowIndex < cellMatrix.length) {
+    const row2 = cellMatrix[rowIndex];
+    const sizes2 = sizeMatrix[rowIndex];
+    columnIndex = -1;
+    const line = [];
+    while (++columnIndex < mostCellsPerRow) {
+      const cell = row2[columnIndex] || "";
+      let before = "";
+      let after = "";
+      if (settings.alignDelimiters !== false) {
+        const size = longestCellByColumn[columnIndex] - (sizes2[columnIndex] || 0);
+        const code3 = alignments[columnIndex];
+        if (code3 === 114) {
+          before = " ".repeat(size);
+        } else if (code3 === 99) {
+          if (size % 2) {
+            before = " ".repeat(size / 2 + 0.5);
+            after = " ".repeat(size / 2 - 0.5);
+          } else {
+            before = " ".repeat(size / 2);
+            after = before;
+          }
+        } else {
+          after = " ".repeat(size);
+        }
+      }
+      if (settings.delimiterStart !== false && !columnIndex) {
+        line.push("|");
+      }
+      if (settings.padding !== false && // Don’t add the opening space if we’re not aligning and the cell is
+      // empty: there will be a closing space.
+      !(settings.alignDelimiters === false && cell === "") && (settings.delimiterStart !== false || columnIndex)) {
+        line.push(" ");
+      }
+      if (settings.alignDelimiters !== false) {
+        line.push(before);
+      }
+      line.push(cell);
+      if (settings.alignDelimiters !== false) {
+        line.push(after);
+      }
+      if (settings.padding !== false) {
+        line.push(" ");
+      }
+      if (settings.delimiterEnd !== false || columnIndex !== mostCellsPerRow - 1) {
+        line.push("|");
+      }
+    }
+    lines.push(
+      settings.delimiterEnd === false ? line.join("").replace(/ +$/, "") : line.join("")
+    );
+  }
+  return lines.join("\n");
+}
+function serialize(value) {
+  return value === null || value === void 0 ? "" : String(value);
+}
+function toAlignment(value) {
+  const code3 = typeof value === "string" ? value.codePointAt(0) : 0;
+  return code3 === 67 || code3 === 99 ? 99 : code3 === 76 || code3 === 108 ? 108 : code3 === 82 || code3 === 114 ? 114 : 0;
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/blockquote.js
+function blockquote(node2, _, state, info) {
+  const exit2 = state.enter("blockquote");
+  const tracker = state.createTracker(info);
+  tracker.move("> ");
+  tracker.shift(2);
+  const value = state.indentLines(
+    state.containerFlow(node2, tracker.current()),
+    map
+  );
+  exit2();
+  return value;
+}
+function map(line, _, blank) {
+  return ">" + (blank ? "" : " ") + line;
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js
+function patternInScope(stack, pattern) {
+  return listInScope(stack, pattern.inConstruct, true) && !listInScope(stack, pattern.notInConstruct, false);
+}
+function listInScope(stack, list2, none) {
+  if (typeof list2 === "string") {
+    list2 = [list2];
+  }
+  if (!list2 || list2.length === 0) {
+    return none;
+  }
+  let index = -1;
+  while (++index < list2.length) {
+    if (stack.includes(list2[index])) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/break.js
+function hardBreak(_, _1, state, info) {
+  let index = -1;
+  while (++index < state.unsafe.length) {
+    if (state.unsafe[index].character === "\n" && patternInScope(state.stack, state.unsafe[index])) {
+      return /[ \t]/.test(info.before) ? "" : " ";
+    }
+  }
+  return "\\\n";
+}
+
+// ../../node_modules/.pnpm/longest-streak@3.1.0/node_modules/longest-streak/index.js
+function longestStreak(value, substring) {
+  const source = String(value);
+  let index = source.indexOf(substring);
+  let expected = index;
+  let count = 0;
+  let max = 0;
+  if (typeof substring !== "string") {
+    throw new TypeError("Expected substring");
+  }
+  while (index !== -1) {
+    if (index === expected) {
+      if (++count > max) {
+        max = count;
+      }
+    } else {
+      count = 1;
+    }
+    expected = index + substring.length;
+    index = source.indexOf(substring, expected);
+  }
+  return max;
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/format-code-as-indented.js
+function formatCodeAsIndented(node2, state) {
+  return Boolean(
+    state.options.fences === false && node2.value && // If there’s no info…
+    !node2.lang && // And there’s a non-whitespace character…
+    /[^ \r\n]/.test(node2.value) && // And the value doesn’t start or end in a blank…
+    !/^[\t ]*(?:[\r\n]|$)|(?:^|[\r\n])[\t ]*$/.test(node2.value)
+  );
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-fence.js
+function checkFence(state) {
+  const marker = state.options.fence || "`";
+  if (marker !== "`" && marker !== "~") {
+    throw new Error(
+      "Cannot serialize code with `" + marker + "` for `options.fence`, expected `` ` `` or `~`"
+    );
+  }
+  return marker;
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/code.js
+function code(node2, _, state, info) {
+  const marker = checkFence(state);
+  const raw = node2.value || "";
+  const suffix = marker === "`" ? "GraveAccent" : "Tilde";
+  if (formatCodeAsIndented(node2, state)) {
+    const exit3 = state.enter("codeIndented");
+    const value2 = state.indentLines(raw, map2);
+    exit3();
+    return value2;
+  }
+  const tracker = state.createTracker(info);
+  const sequence = marker.repeat(Math.max(longestStreak(raw, marker) + 1, 3));
+  const exit2 = state.enter("codeFenced");
+  let value = tracker.move(sequence);
+  if (node2.lang) {
+    const subexit = state.enter(`codeFencedLang${suffix}`);
+    value += tracker.move(
+      state.safe(node2.lang, {
+        before: value,
+        after: " ",
+        encode: ["`"],
+        ...tracker.current()
+      })
+    );
+    subexit();
+  }
+  if (node2.lang && node2.meta) {
+    const subexit = state.enter(`codeFencedMeta${suffix}`);
+    value += tracker.move(" ");
+    value += tracker.move(
+      state.safe(node2.meta, {
+        before: value,
+        after: "\n",
+        encode: ["`"],
+        ...tracker.current()
+      })
+    );
+    subexit();
+  }
+  value += tracker.move("\n");
+  if (raw) {
+    value += tracker.move(raw + "\n");
+  }
+  value += tracker.move(sequence);
+  exit2();
+  return value;
+}
+function map2(line, _, blank) {
+  return (blank ? "" : "    ") + line;
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-quote.js
+function checkQuote(state) {
+  const marker = state.options.quote || '"';
+  if (marker !== '"' && marker !== "'") {
+    throw new Error(
+      "Cannot serialize title with `" + marker + "` for `options.quote`, expected `\"`, or `'`"
+    );
+  }
+  return marker;
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/definition.js
+function definition(node2, _, state, info) {
+  const quote = checkQuote(state);
+  const suffix = quote === '"' ? "Quote" : "Apostrophe";
+  const exit2 = state.enter("definition");
+  let subexit = state.enter("label");
+  const tracker = state.createTracker(info);
+  let value = tracker.move("[");
+  value += tracker.move(
+    state.safe(state.associationId(node2), {
+      before: value,
+      after: "]",
+      ...tracker.current()
+    })
+  );
+  value += tracker.move("]: ");
+  subexit();
+  if (
+    // If there’s no url, or…
+    !node2.url || // If there are control characters or whitespace.
+    /[\0- \u007F]/.test(node2.url)
+  ) {
+    subexit = state.enter("destinationLiteral");
+    value += tracker.move("<");
+    value += tracker.move(
+      state.safe(node2.url, { before: value, after: ">", ...tracker.current() })
+    );
+    value += tracker.move(">");
+  } else {
+    subexit = state.enter("destinationRaw");
+    value += tracker.move(
+      state.safe(node2.url, {
+        before: value,
+        after: node2.title ? " " : "\n",
+        ...tracker.current()
+      })
+    );
+  }
+  subexit();
+  if (node2.title) {
+    subexit = state.enter(`title${suffix}`);
+    value += tracker.move(" " + quote);
+    value += tracker.move(
+      state.safe(node2.title, {
+        before: value,
+        after: quote,
+        ...tracker.current()
+      })
+    );
+    value += tracker.move(quote);
+    subexit();
+  }
+  exit2();
+  return value;
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-emphasis.js
+function checkEmphasis(state) {
+  const marker = state.options.emphasis || "*";
+  if (marker !== "*" && marker !== "_") {
+    throw new Error(
+      "Cannot serialize emphasis with `" + marker + "` for `options.emphasis`, expected `*`, or `_`"
+    );
+  }
+  return marker;
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/encode-character-reference.js
+function encodeCharacterReference(code3) {
+  return "&#x" + code3.toString(16).toUpperCase() + ";";
+}
+
+// ../../node_modules/.pnpm/micromark-util-classify-character@2.0.1/node_modules/micromark-util-classify-character/index.js
+function classifyCharacter(code3) {
+  if (code3 === null || markdownLineEndingOrSpace(code3) || unicodeWhitespace(code3)) {
+    return 1;
+  }
+  if (unicodePunctuation(code3)) {
+    return 2;
+  }
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/encode-info.js
+function encodeInfo(outside, inside, marker) {
+  const outsideKind = classifyCharacter(outside);
+  const insideKind = classifyCharacter(inside);
+  if (outsideKind === void 0) {
+    return insideKind === void 0 ? (
+      // Letter inside:
+      // we have to encode *both* letters for `_` as it is looser.
+      // it already forms for `*` (and GFMs `~`).
+      marker === "_" ? { inside: true, outside: true } : { inside: false, outside: false }
+    ) : insideKind === 1 ? (
+      // Whitespace inside: encode both (letter, whitespace).
+      { inside: true, outside: true }
+    ) : (
+      // Punctuation inside: encode outer (letter)
+      { inside: false, outside: true }
+    );
+  }
+  if (outsideKind === 1) {
+    return insideKind === void 0 ? (
+      // Letter inside: already forms.
+      { inside: false, outside: false }
+    ) : insideKind === 1 ? (
+      // Whitespace inside: encode both (whitespace).
+      { inside: true, outside: true }
+    ) : (
+      // Punctuation inside: already forms.
+      { inside: false, outside: false }
+    );
+  }
+  return insideKind === void 0 ? (
+    // Letter inside: already forms.
+    { inside: false, outside: false }
+  ) : insideKind === 1 ? (
+    // Whitespace inside: encode inner (whitespace).
+    { inside: true, outside: false }
+  ) : (
+    // Punctuation inside: already forms.
+    { inside: false, outside: false }
+  );
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/emphasis.js
+emphasis.peek = emphasisPeek;
+function emphasis(node2, _, state, info) {
+  const marker = checkEmphasis(state);
+  const exit2 = state.enter("emphasis");
+  const tracker = state.createTracker(info);
+  const before = tracker.move(marker);
+  let between = tracker.move(
+    state.containerPhrasing(node2, {
+      after: marker,
+      before,
+      ...tracker.current()
+    })
+  );
+  const betweenHead = between.charCodeAt(0);
+  const open = encodeInfo(
+    info.before.charCodeAt(info.before.length - 1),
+    betweenHead,
+    marker
+  );
+  if (open.inside) {
+    between = encodeCharacterReference(betweenHead) + between.slice(1);
+  }
+  const betweenTail = between.charCodeAt(between.length - 1);
+  const close2 = encodeInfo(info.after.charCodeAt(0), betweenTail, marker);
+  if (close2.inside) {
+    between = between.slice(0, -1) + encodeCharacterReference(betweenTail);
+  }
+  const after = tracker.move(marker);
+  exit2();
+  state.attentionEncodeSurroundingInfo = {
+    after: close2.outside,
+    before: open.outside
+  };
+  return before + between + after;
+}
+function emphasisPeek(_, _1, state) {
+  return state.options.emphasis || "*";
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js
+var import_unist_util_visit = require("unist-util-visit");
+
+// ../../node_modules/.pnpm/mdast-util-to-string@4.0.0/node_modules/mdast-util-to-string/lib/index.js
+var emptyOptions = {};
+function toString(value, options) {
+  const settings = options || emptyOptions;
+  const includeImageAlt = typeof settings.includeImageAlt === "boolean" ? settings.includeImageAlt : true;
+  const includeHtml = typeof settings.includeHtml === "boolean" ? settings.includeHtml : true;
+  return one(value, includeImageAlt, includeHtml);
+}
+function one(value, includeImageAlt, includeHtml) {
+  if (node(value)) {
+    if ("value" in value) {
+      return value.type === "html" && !includeHtml ? "" : value.value;
+    }
+    if (includeImageAlt && "alt" in value && value.alt) {
+      return value.alt;
+    }
+    if ("children" in value) {
+      return all(value.children, includeImageAlt, includeHtml);
+    }
+  }
+  if (Array.isArray(value)) {
+    return all(value, includeImageAlt, includeHtml);
+  }
+  return "";
+}
+function all(values, includeImageAlt, includeHtml) {
+  const result = [];
+  let index = -1;
+  while (++index < values.length) {
+    result[index] = one(values[index], includeImageAlt, includeHtml);
+  }
+  return result.join("");
+}
+function node(value) {
+  return Boolean(value && typeof value === "object");
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js
+function formatHeadingAsSetext(node2, state) {
+  let literalWithBreak = false;
+  (0, import_unist_util_visit.visit)(node2, function(node3) {
+    if ("value" in node3 && /\r?\n|\r/.test(node3.value) || node3.type === "break") {
+      literalWithBreak = true;
+      return import_unist_util_visit.EXIT;
+    }
+  });
+  return Boolean(
+    (!node2.depth || node2.depth < 3) && toString(node2) && (state.options.setext || literalWithBreak)
+  );
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/heading.js
+function heading(node2, _, state, info) {
+  const rank = Math.max(Math.min(6, node2.depth || 1), 1);
+  const tracker = state.createTracker(info);
+  if (formatHeadingAsSetext(node2, state)) {
+    const exit3 = state.enter("headingSetext");
+    const subexit2 = state.enter("phrasing");
+    const value2 = state.containerPhrasing(node2, {
+      ...tracker.current(),
+      before: "\n",
+      after: "\n"
+    });
+    subexit2();
+    exit3();
+    return value2 + "\n" + (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("\n")) + 1)
+    );
+  }
+  const sequence = "#".repeat(rank);
+  const exit2 = state.enter("headingAtx");
+  const subexit = state.enter("phrasing");
+  tracker.move(sequence + " ");
+  let value = state.containerPhrasing(node2, {
+    before: "# ",
+    after: "\n",
+    ...tracker.current()
+  });
+  if (/^[\t ]/.test(value)) {
+    value = encodeCharacterReference(value.charCodeAt(0)) + value.slice(1);
+  }
+  value = value ? sequence + " " + value : sequence;
+  if (state.options.closeAtx) {
+    value += " " + sequence;
+  }
+  subexit();
+  exit2();
+  return value;
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/html.js
+html.peek = htmlPeek;
+function html(node2) {
+  return node2.value || "";
+}
+function htmlPeek() {
+  return "<";
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/image.js
+image.peek = imagePeek;
+function image(node2, _, state, info) {
+  const quote = checkQuote(state);
+  const suffix = quote === '"' ? "Quote" : "Apostrophe";
+  const exit2 = state.enter("image");
+  let subexit = state.enter("label");
+  const tracker = state.createTracker(info);
+  let value = tracker.move("![");
+  value += tracker.move(
+    state.safe(node2.alt, { before: value, after: "]", ...tracker.current() })
+  );
+  value += tracker.move("](");
+  subexit();
+  if (
+    // If there’s no url but there is a title…
+    !node2.url && node2.title || // If there are control characters or whitespace.
+    /[\0- \u007F]/.test(node2.url)
+  ) {
+    subexit = state.enter("destinationLiteral");
+    value += tracker.move("<");
+    value += tracker.move(
+      state.safe(node2.url, { before: value, after: ">", ...tracker.current() })
+    );
+    value += tracker.move(">");
+  } else {
+    subexit = state.enter("destinationRaw");
+    value += tracker.move(
+      state.safe(node2.url, {
+        before: value,
+        after: node2.title ? " " : ")",
+        ...tracker.current()
+      })
+    );
+  }
+  subexit();
+  if (node2.title) {
+    subexit = state.enter(`title${suffix}`);
+    value += tracker.move(" " + quote);
+    value += tracker.move(
+      state.safe(node2.title, {
+        before: value,
+        after: quote,
+        ...tracker.current()
+      })
+    );
+    value += tracker.move(quote);
+    subexit();
+  }
+  value += tracker.move(")");
+  exit2();
+  return value;
+}
+function imagePeek() {
+  return "!";
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/image-reference.js
+imageReference.peek = imageReferencePeek;
+function imageReference(node2, _, state, info) {
+  const type = node2.referenceType;
+  const exit2 = state.enter("imageReference");
+  let subexit = state.enter("label");
+  const tracker = state.createTracker(info);
+  let value = tracker.move("![");
+  const alt = state.safe(node2.alt, {
+    before: value,
+    after: "]",
+    ...tracker.current()
+  });
+  value += tracker.move(alt + "][");
+  subexit();
+  const stack = state.stack;
+  state.stack = [];
+  subexit = state.enter("reference");
+  const reference = state.safe(state.associationId(node2), {
+    before: value,
+    after: "]",
+    ...tracker.current()
+  });
+  subexit();
+  state.stack = stack;
+  exit2();
+  if (type === "full" || !alt || alt !== reference) {
+    value += tracker.move(reference + "]");
+  } else if (type === "shortcut") {
+    value = value.slice(0, -1);
+  } else {
+    value += tracker.move("]");
+  }
+  return value;
+}
+function imageReferencePeek() {
+  return "!";
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/inline-code.js
+inlineCode.peek = inlineCodePeek;
+function inlineCode(node2, _, state) {
+  let value = node2.value || "";
+  let sequence = "`";
+  let index = -1;
+  while (new RegExp("(^|[^`])" + sequence + "([^`]|$)").test(value)) {
+    sequence += "`";
+  }
+  if (/[^ \r\n]/.test(value) && (/^[ \r\n]/.test(value) && /[ \r\n]$/.test(value) || /^`|`$/.test(value))) {
+    value = " " + value + " ";
+  }
+  while (++index < state.unsafe.length) {
+    const pattern = state.unsafe[index];
+    const expression = state.compilePattern(pattern);
+    let match;
+    if (!pattern.atBreak) continue;
+    while (match = expression.exec(value)) {
+      let position = match.index;
+      if (value.charCodeAt(position) === 10 && value.charCodeAt(position - 1) === 13) {
+        position--;
+      }
+      value = value.slice(0, position) + " " + value.slice(match.index + 1);
+    }
+  }
+  return sequence + value + sequence;
+}
+function inlineCodePeek() {
+  return "`";
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.js
+function formatLinkAsAutolink(node2, state) {
+  const raw = toString(node2);
+  return Boolean(
+    !state.options.resourceLink && // If there’s a url…
+    node2.url && // And there’s a no title…
+    !node2.title && // And the content of `node` is a single text node…
+    node2.children && node2.children.length === 1 && node2.children[0].type === "text" && // And if the url is the same as the content…
+    (raw === node2.url || "mailto:" + raw === node2.url) && // And that starts w/ a protocol…
+    /^[a-z][a-z+.-]+:/i.test(node2.url) && // And that doesn’t contain ASCII control codes (character escapes and
+    // references don’t work), space, or angle brackets…
+    !/[\0- <>\u007F]/.test(node2.url)
+  );
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/link.js
+link.peek = linkPeek;
+function link(node2, _, state, info) {
+  const quote = checkQuote(state);
+  const suffix = quote === '"' ? "Quote" : "Apostrophe";
+  const tracker = state.createTracker(info);
+  let exit2;
+  let subexit;
+  if (formatLinkAsAutolink(node2, state)) {
+    const stack = state.stack;
+    state.stack = [];
+    exit2 = state.enter("autolink");
+    let value2 = tracker.move("<");
+    value2 += tracker.move(
+      state.containerPhrasing(node2, {
+        before: value2,
+        after: ">",
+        ...tracker.current()
+      })
+    );
+    value2 += tracker.move(">");
+    exit2();
+    state.stack = stack;
+    return value2;
+  }
+  exit2 = state.enter("link");
+  subexit = state.enter("label");
+  let value = tracker.move("[");
+  value += tracker.move(
+    state.containerPhrasing(node2, {
+      before: value,
+      after: "](",
+      ...tracker.current()
+    })
+  );
+  value += tracker.move("](");
+  subexit();
+  if (
+    // If there’s no url but there is a title…
+    !node2.url && node2.title || // If there are control characters or whitespace.
+    /[\0- \u007F]/.test(node2.url)
+  ) {
+    subexit = state.enter("destinationLiteral");
+    value += tracker.move("<");
+    value += tracker.move(
+      state.safe(node2.url, { before: value, after: ">", ...tracker.current() })
+    );
+    value += tracker.move(">");
+  } else {
+    subexit = state.enter("destinationRaw");
+    value += tracker.move(
+      state.safe(node2.url, {
+        before: value,
+        after: node2.title ? " " : ")",
+        ...tracker.current()
+      })
+    );
+  }
+  subexit();
+  if (node2.title) {
+    subexit = state.enter(`title${suffix}`);
+    value += tracker.move(" " + quote);
+    value += tracker.move(
+      state.safe(node2.title, {
+        before: value,
+        after: quote,
+        ...tracker.current()
+      })
+    );
+    value += tracker.move(quote);
+    subexit();
+  }
+  value += tracker.move(")");
+  exit2();
+  return value;
+}
+function linkPeek(node2, _, state) {
+  return formatLinkAsAutolink(node2, state) ? "<" : "[";
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/link-reference.js
+linkReference.peek = linkReferencePeek;
+function linkReference(node2, _, state, info) {
+  const type = node2.referenceType;
+  const exit2 = state.enter("linkReference");
+  let subexit = state.enter("label");
+  const tracker = state.createTracker(info);
+  let value = tracker.move("[");
+  const text3 = state.containerPhrasing(node2, {
+    before: value,
+    after: "]",
+    ...tracker.current()
+  });
+  value += tracker.move(text3 + "][");
+  subexit();
+  const stack = state.stack;
+  state.stack = [];
+  subexit = state.enter("reference");
+  const reference = state.safe(state.associationId(node2), {
+    before: value,
+    after: "]",
+    ...tracker.current()
+  });
+  subexit();
+  state.stack = stack;
+  exit2();
+  if (type === "full" || !text3 || text3 !== reference) {
+    value += tracker.move(reference + "]");
+  } else if (type === "shortcut") {
+    value = value.slice(0, -1);
+  } else {
+    value += tracker.move("]");
+  }
+  return value;
+}
+function linkReferencePeek() {
+  return "[";
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-bullet.js
+function checkBullet(state) {
+  const 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/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-bullet-other.js
+function checkBulletOther(state) {
+  const bullet = checkBullet(state);
+  const 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/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-bullet-ordered.js
+function checkBulletOrdered(state) {
+  const marker = state.options.bulletOrdered || ".";
+  if (marker !== "." && marker !== ")") {
+    throw new Error(
+      "Cannot serialize items with `" + marker + "` for `options.bulletOrdered`, expected `.` or `)`"
+    );
+  }
+  return marker;
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-rule.js
+function checkRule(state) {
+  const 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/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/list.js
+function list(node2, parent, state, info) {
+  const exit2 = state.enter("list");
+  const bulletCurrent = state.bulletCurrent;
+  let bullet = node2.ordered ? checkBulletOrdered(state) : checkBullet(state);
+  const bulletOther = node2.ordered ? bullet === "." ? ")" : "." : checkBulletOther(state);
+  let useDifferentMarker = parent && state.bulletLastUsed ? bullet === state.bulletLastUsed : false;
+  if (!node2.ordered) {
+    const firstListItem = node2.children ? node2.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 = true;
+    }
+    if (checkRule(state) === bullet && firstListItem) {
+      let index = -1;
+      while (++index < node2.children.length) {
+        const item = node2.children[index];
+        if (item && item.type === "listItem" && item.children && item.children[0] && item.children[0].type === "thematicBreak") {
+          useDifferentMarker = true;
+          break;
+        }
+      }
+    }
+  }
+  if (useDifferentMarker) {
+    bullet = bulletOther;
+  }
+  state.bulletCurrent = bullet;
+  const value = state.containerFlow(node2, info);
+  state.bulletLastUsed = bullet;
+  state.bulletCurrent = bulletCurrent;
+  exit2();
+  return value;
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js
+function checkListItemIndent(state) {
+  const 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/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/list-item.js
+function listItem(node2, parent, state, info) {
+  const listItemIndent = checkListItemIndent(state);
+  let bullet = state.bulletCurrent || checkBullet(state);
+  if (parent && parent.type === "list" && parent.ordered) {
+    bullet = (typeof parent.start === "number" && parent.start > -1 ? parent.start : 1) + (state.options.incrementListMarker === false ? 0 : parent.children.indexOf(node2)) + bullet;
+  }
+  let size = bullet.length + 1;
+  if (listItemIndent === "tab" || listItemIndent === "mixed" && (parent && parent.type === "list" && parent.spread || node2.spread)) {
+    size = Math.ceil(size / 4) * 4;
+  }
+  const tracker = state.createTracker(info);
+  tracker.move(bullet + " ".repeat(size - bullet.length));
+  tracker.shift(size);
+  const exit2 = state.enter("listItem");
+  const value = state.indentLines(
+    state.containerFlow(node2, tracker.current()),
+    map3
+  );
+  exit2();
+  return value;
+  function map3(line, index, blank) {
+    if (index) {
+      return (blank ? "" : " ".repeat(size)) + line;
+    }
+    return (blank ? bullet : bullet + " ".repeat(size - bullet.length)) + line;
+  }
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/paragraph.js
+function paragraph(node2, _, state, info) {
+  const exit2 = state.enter("paragraph");
+  const subexit = state.enter("phrasing");
+  const value = state.containerPhrasing(node2, info);
+  subexit();
+  exit2();
+  return value;
+}
+
+// ../../node_modules/.pnpm/mdast-util-phrasing@4.1.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/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/root.js
+function root(node2, _, state, info) {
+  const hasPhrasing = node2.children.some(function(d) {
+    return phrasing(d);
+  });
+  const container = hasPhrasing ? state.containerPhrasing : state.containerFlow;
+  return container.call(state, node2, info);
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-strong.js
+function checkStrong(state) {
+  const marker = state.options.strong || "*";
+  if (marker !== "*" && marker !== "_") {
+    throw new Error(
+      "Cannot serialize strong with `" + marker + "` for `options.strong`, expected `*`, or `_`"
+    );
+  }
+  return marker;
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/strong.js
+strong.peek = strongPeek;
+function strong(node2, _, state, info) {
+  const marker = checkStrong(state);
+  const exit2 = state.enter("strong");
+  const tracker = state.createTracker(info);
+  const before = tracker.move(marker + marker);
+  let between = tracker.move(
+    state.containerPhrasing(node2, {
+      after: marker,
+      before,
+      ...tracker.current()
+    })
+  );
+  const betweenHead = between.charCodeAt(0);
+  const open = encodeInfo(
+    info.before.charCodeAt(info.before.length - 1),
+    betweenHead,
+    marker
+  );
+  if (open.inside) {
+    between = encodeCharacterReference(betweenHead) + between.slice(1);
+  }
+  const betweenTail = between.charCodeAt(between.length - 1);
+  const close2 = encodeInfo(info.after.charCodeAt(0), betweenTail, marker);
+  if (close2.inside) {
+    between = between.slice(0, -1) + encodeCharacterReference(betweenTail);
+  }
+  const after = tracker.move(marker + marker);
+  exit2();
+  state.attentionEncodeSurroundingInfo = {
+    after: close2.outside,
+    before: open.outside
+  };
+  return before + between + after;
+}
+function strongPeek(_, _1, state) {
+  return state.options.strong || "*";
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/text.js
+function text(node2, _, state, info) {
+  return state.safe(node2.value, info);
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-rule-repetition.js
+function checkRuleRepetition(state) {
+  const 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/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/thematic-break.js
+function thematicBreak(_, _1, state) {
+  const value = (checkRule(state) + (state.options.ruleSpaces ? " " : "")).repeat(checkRuleRepetition(state));
+  return state.options.ruleSpaces ? value.slice(0, -1) : value;
+}
+
+// ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/index.js
+var handle = {
+  blockquote,
+  break: hardBreak,
+  code,
+  definition,
+  emphasis,
+  hardBreak,
+  heading,
+  html,
+  image,
+  imageReference,
+  inlineCode,
+  link,
+  linkReference,
+  list,
+  listItem,
+  paragraph,
+  root,
+  strong,
+  text,
+  thematicBreak
+};
+
+// ../../node_modules/.pnpm/mdast-util-gfm-table@2.0.0/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) {
+  const align = token._align;
+  ok(align, "expected `_align` on table");
+  this.enter(
+    {
+      type: "table",
+      align: align.map(function(d) {
+        return d === "none" ? null : d;
+      }),
+      children: []
+    },
+    token
+  );
+  this.data.inTable = true;
+}
+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();
+  if (this.data.inTable) {
+    value = value.replace(/\\([\\|])/g, replace);
+  }
+  const node2 = this.stack[this.stack.length - 1];
+  ok(node2.type === "inlineCode");
+  node2.value = value;
+  this.exit(token);
+}
+function replace($0, $1) {
+  return $1 === "|" ? $1 : $0;
+}
+function gfmTableToMarkdown(options) {
+  const settings = options || {};
+  const padding = settings.tableCellPadding;
+  const alignDelimiters = settings.tablePipeAlign;
+  const stringLength = settings.stringLength;
+  const around = padding ? " " : "|";
+  return {
+    unsafe: [
+      { character: "\r", inConstruct: "tableCell" },
+      { character: "\n", 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: true, 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: true, 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: true, character: "-", after: "[:|-]" }
+    ],
+    handlers: {
+      inlineCode: inlineCodeWithTable,
+      table: handleTable,
+      tableCell: handleTableCell,
+      tableRow: handleTableRow
+    }
+  };
+  function handleTable(node2, _, state, info) {
+    return serializeData(handleTableAsData(node2, state, info), node2.align);
+  }
+  function handleTableRow(node2, _, state, info) {
+    const row = handleTableRowAsData(node2, state, info);
+    const value = serializeData([row]);
+    return value.slice(0, value.indexOf("\n"));
+  }
+  function handleTableCell(node2, _, state, info) {
+    const exit2 = state.enter("tableCell");
+    const subexit = state.enter("phrasing");
+    const value = state.containerPhrasing(node2, {
+      ...info,
+      before: around,
+      after: around
+    });
+    subexit();
+    exit2();
+    return 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(node2, state, info) {
+    const children = node2.children;
+    let index = -1;
+    const result = [];
+    const subexit = state.enter("table");
+    while (++index < children.length) {
+      result[index] = handleTableRowAsData(children[index], state, info);
+    }
+    subexit();
+    return result;
+  }
+  function handleTableRowAsData(node2, state, info) {
+    const children = node2.children;
+    let index = -1;
+    const result = [];
+    const subexit = state.enter("tableRow");
+    while (++index < children.length) {
+      result[index] = handleTableCell(children[index], node2, state, info);
+    }
+    subexit();
+    return result;
+  }
+  function inlineCodeWithTable(node2, parent, state) {
+    let value = handle.inlineCode(node2, parent, state);
+    if (state.stack.includes("tableCell")) {
+      value = value.replace(/\|/g, "\\$&");
+    }
+    return value;
+  }
+}
+
+// ../../node_modules/.pnpm/mdast-util-gfm-task-list-item@2.0.0/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: true, character: "-", after: "[:|-]" }],
+    handlers: { listItem: listItemWithTaskListItem }
+  };
+}
+function exitCheck(token) {
+  const node2 = this.stack[this.stack.length - 2];
+  ok(node2.type === "listItem");
+  node2.checked = token.type === "taskListCheckValueChecked";
+}
+function exitParagraphWithTaskListItem(token) {
+  const parent = this.stack[this.stack.length - 2];
+  if (parent && parent.type === "listItem" && typeof parent.checked === "boolean") {
+    const node2 = this.stack[this.stack.length - 1];
+    ok(node2.type === "paragraph");
+    const head = node2.children[0];
+    if (head && head.type === "text") {
+      const siblings = parent.children;
+      let index = -1;
+      let firstParaghraph;
+      while (++index < siblings.length) {
+        const sibling = siblings[index];
+        if (sibling.type === "paragraph") {
+          firstParaghraph = sibling;
+          break;
+        }
+      }
+      if (firstParaghraph === node2) {
+        head.value = head.value.slice(1);
+        if (head.value.length === 0) {
+          node2.children.shift();
+        } else if (node2.position && head.position && typeof head.position.start.offset === "number") {
+          head.position.start.column++;
+          head.position.start.offset++;
+          node2.position.start = Object.assign({}, head.position.start);
+        }
+      }
+    }
+  }
+  this.exit(token);
+}
+function listItemWithTaskListItem(node2, parent, state, info) {
+  const head = node2.children[0];
+  const checkable = typeof node2.checked === "boolean" && head && head.type === "paragraph";
+  const checkbox = "[" + (node2.checked ? "x" : " ") + "] ";
+  const tracker = state.createTracker(info);
+  if (checkable) {
+    tracker.move(checkbox);
+  }
+  let value = handle.listItem(node2, parent, state, {
+    ...info,
+    ...tracker.current()
+  });
+  if (checkable) {
+    value = value.replace(/^(?:[*+-]|\d+\.)([\r\n]| {1,3})/, check);
+  }
+  return value;
+  function check($0) {
+    return $0 + checkbox;
+  }
+}
+
+// ../../node_modules/.pnpm/mdast-util-gfm@3.1.0/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/.pnpm/micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.js
+function splice(list2, start, remove, items) {
+  const end = list2.length;
+  let chunkStart = 0;
+  let parameters;
+  if (start < 0) {
+    start = -start > end ? 0 : end + start;
+  } else {
+    start = start > end ? end : start;
+  }
+  remove = remove > 0 ? remove : 0;
+  if (items.length < 1e4) {
+    parameters = Array.from(items);
+    parameters.unshift(start, remove);
+    list2.splice(...parameters);
+  } else {
+    if (remove) list2.splice(start, remove);
+    while (chunkStart < items.length) {
+      parameters = items.slice(chunkStart, chunkStart + 1e4);
+      parameters.unshift(start, 0);
+      list2.splice(...parameters);
+      chunkStart += 1e4;
+      start += 1e4;
+    }
+  }
+}
+
+// ../../node_modules/.pnpm/micromark-util-combine-extensions@2.0.1/node_modules/micromark-util-combine-extensions/index.js
+var hasOwnProperty = {}.hasOwnProperty;
+function combineExtensions(extensions) {
+  const all2 = {};
+  let index = -1;
+  while (++index < extensions.length) {
+    syntaxExtension(all2, extensions[index]);
+  }
+  return all2;
+}
+function syntaxExtension(all2, extension) {
+  let hook;
+  for (hook in extension) {
+    const maybe = hasOwnProperty.call(all2, hook) ? all2[hook] : void 0;
+    const left = maybe || (all2[hook] = {});
+    const right = extension[hook];
+    let code3;
+    if (right) {
+      for (code3 in right) {
+        if (!hasOwnProperty.call(left, code3)) left[code3] = [];
+        const value = right[code3];
+        constructs(
+          // @ts-expect-error Looks like a list.
+          left[code3],
+          Array.isArray(value) ? value : value ? [value] : []
+        );
+      }
+    }
+  }
+}
+function constructs(existing, list2) {
+  let index = -1;
+  const before = [];
+  while (++index < list2.length) {
+    ;
+    (list2[index].add === "after" ? existing : before).push(list2[index]);
+  }
+  splice(existing, 0, 0, before);
+}
+
+// ../../node_modules/.pnpm/micromark-extension-gfm-autolink-literal@2.1.0/node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js
+var wwwPrefix = {
+  tokenize: tokenizeWwwPrefix,
+  partial: true
+};
+var domain = {
+  tokenize: tokenizeDomain,
+  partial: true
+};
+var path5 = {
+  tokenize: tokenizePath,
+  partial: true
+};
+var trail = {
+  tokenize: tokenizeTrail,
+  partial: true
+};
+var emailDomainDotTrail = {
+  tokenize: tokenizeEmailDomainDotTrail,
+  partial: true
+};
+var wwwAutolink = {
+  name: "wwwAutolink",
+  tokenize: tokenizeWwwAutolink,
+  previous: previousWww
+};
+var protocolAutolink = {
+  name: "protocolAutolink",
+  tokenize: tokenizeProtocolAutolink,
+  previous: previousProtocol
+};
+var emailAutolink = {
+  name: "emailAutolink",
+  tokenize: tokenizeEmailAutolink,
+  previous: previousEmail
+};
+var text2 = {};
+function gfmAutolinkLiteral() {
+  return {
+    text: text2
+  };
+}
+var code2 = 48;
+while (code2 < 123) {
+  text2[code2] = emailAutolink;
+  code2++;
+  if (code2 === 58) code2 = 65;
+  else if (code2 === 91) code2 = 97;
+}
+text2[43] = emailAutolink;
+text2[45] = emailAutolink;
+text2[46] = emailAutolink;
+text2[95] = emailAutolink;
+text2[72] = [emailAutolink, protocolAutolink];
+text2[104] = [emailAutolink, protocolAutolink];
+text2[87] = [emailAutolink, wwwAutolink];
+text2[119] = [emailAutolink, wwwAutolink];
+function tokenizeEmailAutolink(effects, ok3, nok) {
+  const self = this;
+  let dot;
+  let data;
+  return start;
+  function start(code3) {
+    if (!gfmAtext(code3) || !previousEmail.call(self, self.previous) || previousUnbalanced(self.events)) {
+      return nok(code3);
+    }
+    effects.enter("literalAutolink");
+    effects.enter("literalAutolinkEmail");
+    return atext(code3);
+  }
+  function atext(code3) {
+    if (gfmAtext(code3)) {
+      effects.consume(code3);
+      return atext;
+    }
+    if (code3 === 64) {
+      effects.consume(code3);
+      return emailDomain;
+    }
+    return nok(code3);
+  }
+  function emailDomain(code3) {
+    if (code3 === 46) {
+      return effects.check(emailDomainDotTrail, emailDomainAfter, emailDomainDot)(code3);
+    }
+    if (code3 === 45 || code3 === 95 || asciiAlphanumeric(code3)) {
+      data = true;
+      effects.consume(code3);
+      return emailDomain;
+    }
+    return emailDomainAfter(code3);
+  }
+  function emailDomainDot(code3) {
+    effects.consume(code3);
+    dot = true;
+    return emailDomain;
+  }
+  function emailDomainAfter(code3) {
+    if (data && dot && asciiAlpha(self.previous)) {
+      effects.exit("literalAutolinkEmail");
+      effects.exit("literalAutolink");
+      return ok3(code3);
+    }
+    return nok(code3);
+  }
+}
+function tokenizeWwwAutolink(effects, ok3, nok) {
+  const self = this;
+  return wwwStart;
+  function wwwStart(code3) {
+    if (code3 !== 87 && code3 !== 119 || !previousWww.call(self, self.previous) || previousUnbalanced(self.events)) {
+      return nok(code3);
+    }
+    effects.enter("literalAutolink");
+    effects.enter("literalAutolinkWww");
+    return effects.check(wwwPrefix, effects.attempt(domain, effects.attempt(path5, wwwAfter), nok), nok)(code3);
+  }
+  function wwwAfter(code3) {
+    effects.exit("literalAutolinkWww");
+    effects.exit("literalAutolink");
+    return ok3(code3);
+  }
+}
+function tokenizeProtocolAutolink(effects, ok3, nok) {
+  const self = this;
+  let buffer = "";
+  let seen = false;
+  return protocolStart;
+  function protocolStart(code3) {
+    if ((code3 === 72 || code3 === 104) && previousProtocol.call(self, self.previous) && !previousUnbalanced(self.events)) {
+      effects.enter("literalAutolink");
+      effects.enter("literalAutolinkHttp");
+      buffer += String.fromCodePoint(code3);
+      effects.consume(code3);
+      return protocolPrefixInside;
+    }
+    return nok(code3);
+  }
+  function protocolPrefixInside(code3) {
+    if (asciiAlpha(code3) && buffer.length < 5) {
+      buffer += String.fromCodePoint(code3);
+      effects.consume(code3);
+      return protocolPrefixInside;
+    }
+    if (code3 === 58) {
+      const protocol = buffer.toLowerCase();
+      if (protocol === "http" || protocol === "https") {
+        effects.consume(code3);
+        return protocolSlashesInside;
+      }
+    }
+    return nok(code3);
+  }
+  function protocolSlashesInside(code3) {
+    if (code3 === 47) {
+      effects.consume(code3);
+      if (seen) {
+        return afterProtocol;
+      }
+      seen = true;
+      return protocolSlashesInside;
+    }
+    return nok(code3);
+  }
+  function afterProtocol(code3) {
+    return code3 === null || asciiControl(code3) || markdownLineEndingOrSpace(code3) || unicodeWhitespace(code3) || unicodePunctuation(code3) ? nok(code3) : effects.attempt(domain, effects.attempt(path5, protocolAfter), nok)(code3);
+  }
+  function protocolAfter(code3) {
+    effects.exit("literalAutolinkHttp");
+    effects.exit("literalAutolink");
+    return ok3(code3);
+  }
+}
+function tokenizeWwwPrefix(effects, ok3, nok) {
+  let size = 0;
+  return wwwPrefixInside;
+  function wwwPrefixInside(code3) {
+    if ((code3 === 87 || code3 === 119) && size < 3) {
+      size++;
+      effects.consume(code3);
+      return wwwPrefixInside;
+    }
+    if (code3 === 46 && size === 3) {
+      effects.consume(code3);
+      return wwwPrefixAfter;
+    }
+    return nok(code3);
+  }
+  function wwwPrefixAfter(code3) {
+    return code3 === null ? nok(code3) : ok3(code3);
+  }
+}
+function tokenizeDomain(effects, ok3, nok) {
+  let underscoreInLastSegment;
+  let underscoreInLastLastSegment;
+  let seen;
+  return domainInside;
+  function domainInside(code3) {
+    if (code3 === 46 || code3 === 95) {
+      return effects.check(trail, domainAfter, domainAtPunctuation)(code3);
+    }
+    if (code3 === null || markdownLineEndingOrSpace(code3) || unicodeWhitespace(code3) || code3 !== 45 && unicodePunctuation(code3)) {
+      return domainAfter(code3);
+    }
+    seen = true;
+    effects.consume(code3);
+    return domainInside;
+  }
+  function domainAtPunctuation(code3) {
+    if (code3 === 95) {
+      underscoreInLastSegment = true;
+    } else {
+      underscoreInLastLastSegment = underscoreInLastSegment;
+      underscoreInLastSegment = void 0;
+    }
+    effects.consume(code3);
+    return domainInside;
+  }
+  function domainAfter(code3) {
+    if (underscoreInLastLastSegment || underscoreInLastSegment || !seen) {
+      return nok(code3);
+    }
+    return ok3(code3);
+  }
+}
+function tokenizePath(effects, ok3) {
+  let sizeOpen = 0;
+  let sizeClose = 0;
+  return pathInside;
+  function pathInside(code3) {
+    if (code3 === 40) {
+      sizeOpen++;
+      effects.consume(code3);
+      return pathInside;
+    }
+    if (code3 === 41 && sizeClose < sizeOpen) {
+      return pathAtPunctuation(code3);
+    }
+    if (code3 === 33 || code3 === 34 || code3 === 38 || code3 === 39 || code3 === 41 || code3 === 42 || code3 === 44 || code3 === 46 || code3 === 58 || code3 === 59 || code3 === 60 || code3 === 63 || code3 === 93 || code3 === 95 || code3 === 126) {
+      return effects.check(trail, ok3, pathAtPunctuation)(code3);
+    }
+    if (code3 === null || markdownLineEndingOrSpace(code3) || unicodeWhitespace(code3)) {
+      return ok3(code3);
+    }
+    effects.consume(code3);
+    return pathInside;
+  }
+  function pathAtPunctuation(code3) {
+    if (code3 === 41) {
+      sizeClose++;
+    }
+    effects.consume(code3);
+    return pathInside;
+  }
+}
+function tokenizeTrail(effects, ok3, nok) {
+  return trail2;
+  function trail2(code3) {
+    if (code3 === 33 || code3 === 34 || code3 === 39 || code3 === 41 || code3 === 42 || code3 === 44 || code3 === 46 || code3 === 58 || code3 === 59 || code3 === 63 || code3 === 95 || code3 === 126) {
+      effects.consume(code3);
+      return trail2;
+    }
+    if (code3 === 38) {
+      effects.consume(code3);
+      return trailCharacterReferenceStart;
+    }
+    if (code3 === 93) {
+      effects.consume(code3);
+      return trailBracketAfter;
+    }
+    if (
+      // `<` is an end.
+      code3 === 60 || // So is whitespace.
+      code3 === null || markdownLineEndingOrSpace(code3) || unicodeWhitespace(code3)
+    ) {
+      return ok3(code3);
+    }
+    return nok(code3);
+  }
+  function trailBracketAfter(code3) {
+    if (code3 === null || code3 === 40 || code3 === 91 || markdownLineEndingOrSpace(code3) || unicodeWhitespace(code3)) {
+      return ok3(code3);
+    }
+    return trail2(code3);
+  }
+  function trailCharacterReferenceStart(code3) {
+    return asciiAlpha(code3) ? trailCharacterReferenceInside(code3) : nok(code3);
+  }
+  function trailCharacterReferenceInside(code3) {
+    if (code3 === 59) {
+      effects.consume(code3);
+      return trail2;
+    }
+    if (asciiAlpha(code3)) {
+      effects.consume(code3);
+      return trailCharacterReferenceInside;
+    }
+    return nok(code3);
+  }
+}
+function tokenizeEmailDomainDotTrail(effects, ok3, nok) {
+  return start;
+  function start(code3) {
+    effects.consume(code3);
+    return after;
+  }
+  function after(code3) {
+    return asciiAlphanumeric(code3) ? nok(code3) : ok3(code3);
+  }
+}
+function previousWww(code3) {
+  return code3 === null || code3 === 40 || code3 === 42 || code3 === 95 || code3 === 91 || code3 === 93 || code3 === 126 || markdownLineEndingOrSpace(code3);
+}
+function previousProtocol(code3) {
+  return !asciiAlpha(code3);
+}
+function previousEmail(code3) {
+  return !(code3 === 47 || gfmAtext(code3));
+}
+function gfmAtext(code3) {
+  return code3 === 43 || code3 === 45 || code3 === 46 || code3 === 95 || asciiAlphanumeric(code3);
+}
+function previousUnbalanced(events) {
+  let index = events.length;
+  let result = false;
+  while (index--) {
+    const token = events[index][1];
+    if ((token.type === "labelLink" || token.type === "labelImage") && !token._balanced) {
+      result = true;
+      break;
+    }
+    if (token._gfmAutolinkLiteralWalkedInto) {
+      result = false;
+      break;
+    }
+  }
+  if (events.length > 0 && !result) {
+    events[events.length - 1][1]._gfmAutolinkLiteralWalkedInto = true;
+  }
+  return result;
+}
+
+// ../../node_modules/.pnpm/micromark-util-resolve-all@2.0.1/node_modules/micromark-util-resolve-all/index.js
+function resolveAll(constructs2, events, context) {
+  const called = [];
+  let index = -1;
+  while (++index < constructs2.length) {
+    const resolve = constructs2[index].resolveAll;
+    if (resolve && !called.includes(resolve)) {
+      events = resolve(events, context);
+      called.push(resolve);
+    }
+  }
+  return events;
+}
+
+// ../../node_modules/.pnpm/micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.js
+function factorySpace(effects, ok3, type, max) {
+  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
+  let size = 0;
+  return start;
+  function start(code3) {
+    if (markdownSpace(code3)) {
+      effects.enter(type);
+      return prefix(code3);
+    }
+    return ok3(code3);
+  }
+  function prefix(code3) {
+    if (markdownSpace(code3) && size++ < limit) {
+      effects.consume(code3);
+      return prefix;
+    }
+    effects.exit(type);
+    return ok3(code3);
+  }
+}
+
+// ../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/blank-line.js
+var blankLine = {
+  partial: true,
+  tokenize: tokenizeBlankLine
+};
+function tokenizeBlankLine(effects, ok3, nok) {
+  return start;
+  function start(code3) {
+    return markdownSpace(code3) ? factorySpace(effects, after, "linePrefix")(code3) : after(code3);
+  }
+  function after(code3) {
+    return code3 === null || markdownLineEnding(code3) ? ok3(code3) : nok(code3);
+  }
+}
+
+// ../../node_modules/.pnpm/micromark-extension-gfm-footnote@2.1.0/node_modules/micromark-extension-gfm-footnote/lib/syntax.js
+var indent = {
+  tokenize: tokenizeIndent,
+  partial: true
+};
+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, ok3, nok) {
+  const self = this;
+  let index = self.events.length;
+  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
+  let labelStart;
+  while (index--) {
+    const 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(code3) {
+    if (!labelStart || !labelStart._balanced) {
+      return nok(code3);
+    }
+    const id = normalizeIdentifier(self.sliceSerialize({
+      start: labelStart.end,
+      end: self.now()
+    }));
+    if (id.codePointAt(0) !== 94 || !defined.includes(id.slice(1))) {
+      return nok(code3);
+    }
+    effects.enter("gfmFootnoteCallLabelMarker");
+    effects.consume(code3);
+    effects.exit("gfmFootnoteCallLabelMarker");
+    return ok3(code3);
+  }
+}
+function resolveToPotentialGfmFootnoteCall(events, context) {
+  let index = events.length;
+  let labelStart;
+  while (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";
+  const call = {
+    type: "gfmFootnoteCall",
+    start: Object.assign({}, events[index + 3][1].start),
+    end: Object.assign({}, events[events.length - 1][1].end)
+  };
+  const 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++;
+  const string = {
+    type: "gfmFootnoteCallString",
+    start: Object.assign({}, marker.end),
+    end: Object.assign({}, events[events.length - 1][1].start)
+  };
+  const chunk = {
+    type: "chunkString",
+    contentType: "string",
+    start: Object.assign({}, string.start),
+    end: Object.assign({}, string.end)
+  };
+  const 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]
+  ];
+  events.splice(index, events.length - index + 1, ...replacement);
+  return events;
+}
+function tokenizeGfmFootnoteCall(effects, ok3, nok) {
+  const self = this;
+  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
+  let size = 0;
+  let data;
+  return start;
+  function start(code3) {
+    effects.enter("gfmFootnoteCall");
+    effects.enter("gfmFootnoteCallLabelMarker");
+    effects.consume(code3);
+    effects.exit("gfmFootnoteCallLabelMarker");
+    return callStart;
+  }
+  function callStart(code3) {
+    if (code3 !== 94) return nok(code3);
+    effects.enter("gfmFootnoteCallMarker");
+    effects.consume(code3);
+    effects.exit("gfmFootnoteCallMarker");
+    effects.enter("gfmFootnoteCallString");
+    effects.enter("chunkString").contentType = "string";
+    return callData;
+  }
+  function callData(code3) {
+    if (
+      // Too long.
+      size > 999 || // Closing brace with nothing.
+      code3 === 93 && !data || // Space or tab is not supported by GFM for some reason.
+      // `\n` and `[` not being supported makes sense.
+      code3 === null || code3 === 91 || markdownLineEndingOrSpace(code3)
+    ) {
+      return nok(code3);
+    }
+    if (code3 === 93) {
+      effects.exit("chunkString");
+      const token = effects.exit("gfmFootnoteCallString");
+      if (!defined.includes(normalizeIdentifier(self.sliceSerialize(token)))) {
+        return nok(code3);
+      }
+      effects.enter("gfmFootnoteCallLabelMarker");
+      effects.consume(code3);
+      effects.exit("gfmFootnoteCallLabelMarker");
+      effects.exit("gfmFootnoteCall");
+      return ok3;
+    }
+    if (!markdownLineEndingOrSpace(code3)) {
+      data = true;
+    }
+    size++;
+    effects.consume(code3);
+    return code3 === 92 ? callEscape : callData;
+  }
+  function callEscape(code3) {
+    if (code3 === 91 || code3 === 92 || code3 === 93) {
+      effects.consume(code3);
+      size++;
+      return callData;
+    }
+    return callData(code3);
+  }
+}
+function tokenizeDefinitionStart(effects, ok3, nok) {
+  const self = this;
+  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
+  let identifier;
+  let size = 0;
+  let data;
+  return start;
+  function start(code3) {
+    effects.enter("gfmFootnoteDefinition")._container = true;
+    effects.enter("gfmFootnoteDefinitionLabel");
+    effects.enter("gfmFootnoteDefinitionLabelMarker");
+    effects.consume(code3);
+    effects.exit("gfmFootnoteDefinitionLabelMarker");
+    return labelAtMarker;
+  }
+  function labelAtMarker(code3) {
+    if (code3 === 94) {
+      effects.enter("gfmFootnoteDefinitionMarker");
+      effects.consume(code3);
+      effects.exit("gfmFootnoteDefinitionMarker");
+      effects.enter("gfmFootnoteDefinitionLabelString");
+      effects.enter("chunkString").contentType = "string";
+      return labelInside;
+    }
+    return nok(code3);
+  }
+  function labelInside(code3) {
+    if (
+      // Too long.
+      size > 999 || // Closing brace with nothing.
+      code3 === 93 && !data || // Space or tab is not supported by GFM for some reason.
+      // `\n` and `[` not being supported makes sense.
+      code3 === null || code3 === 91 || markdownLineEndingOrSpace(code3)
+    ) {
+      return nok(code3);
+    }
+    if (code3 === 93) {
+      effects.exit("chunkString");
+      const token = effects.exit("gfmFootnoteDefinitionLabelString");
+      identifier = normalizeIdentifier(self.sliceSerialize(token));
+      effects.enter("gfmFootnoteDefinitionLabelMarker");
+      effects.consume(code3);
+      effects.exit("gfmFootnoteDefinitionLabelMarker");
+      effects.exit("gfmFootnoteDefinitionLabel");
+      return labelAfter;
+    }
+    if (!markdownLineEndingOrSpace(code3)) {
+      data = true;
+    }
+    size++;
+    effects.consume(code3);
+    return code3 === 92 ? labelEscape : labelInside;
+  }
+  function labelEscape(code3) {
+    if (code3 === 91 || code3 === 92 || code3 === 93) {
+      effects.consume(code3);
+      size++;
+      return labelInside;
+    }
+    return labelInside(code3);
+  }
+  function labelAfter(code3) {
+    if (code3 === 58) {
+      effects.enter("definitionMarker");
+      effects.consume(code3);
+      effects.exit("definitionMarker");
+      if (!defined.includes(identifier)) {
+        defined.push(identifier);
+      }
+      return factorySpace(effects, whitespaceAfter, "gfmFootnoteDefinitionWhitespace");
+    }
+    return nok(code3);
+  }
+  function whitespaceAfter(code3) {
+    return ok3(code3);
+  }
+}
+function tokenizeDefinitionContinuation(effects, ok3, nok) {
+  return effects.check(blankLine, ok3, effects.attempt(indent, ok3, nok));
+}
+function gfmFootnoteDefinitionEnd(effects) {
+  effects.exit("gfmFootnoteDefinition");
+}
+function tokenizeIndent(effects, ok3, nok) {
+  const self = this;
+  return factorySpace(effects, afterPrefix, "gfmFootnoteDefinitionIndent", 4 + 1);
+  function afterPrefix(code3) {
+    const tail = self.events[self.events.length - 1];
+    return tail && tail[1].type === "gfmFootnoteDefinitionIndent" && tail[2].sliceSerialize(tail[1], true).length === 4 ? ok3(code3) : nok(code3);
+  }
+}
+
+// ../../node_modules/.pnpm/micromark-extension-gfm-strikethrough@2.1.0/node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js
+function gfmStrikethrough(options) {
+  const options_ = options || {};
+  let single = options_.singleTilde;
+  const tokenizer = {
+    name: "strikethrough",
+    tokenize: tokenizeStrikethrough,
+    resolveAll: resolveAllStrikethrough
+  };
+  if (single === null || single === void 0) {
+    single = true;
+  }
+  return {
+    text: {
+      [126]: tokenizer
+    },
+    insideSpan: {
+      null: [tokenizer]
+    },
+    attentionMarkers: {
+      null: [126]
+    }
+  };
+  function resolveAllStrikethrough(events, context) {
+    let index = -1;
+    while (++index < events.length) {
+      if (events[index][0] === "enter" && events[index][1].type === "strikethroughSequenceTemporary" && events[index][1]._close) {
+        let open = index;
+        while (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";
+            const strikethrough = {
+              type: "strikethrough",
+              start: Object.assign({}, events[open][1].start),
+              end: Object.assign({}, events[index][1].end)
+            };
+            const text3 = {
+              type: "strikethroughText",
+              start: Object.assign({}, events[open][1].end),
+              end: Object.assign({}, events[index][1].start)
+            };
+            const nextEvents = [["enter", strikethrough, context], ["enter", events[open][1], context], ["exit", events[open][1], context], ["enter", text3, context]];
+            const insideSpan = context.parser.constructs.insideSpan.null;
+            if (insideSpan) {
+              splice(nextEvents, nextEvents.length, 0, resolveAll(insideSpan, events.slice(open + 1, index), context));
+            }
+            splice(nextEvents, nextEvents.length, 0, [["exit", text3, context], ["enter", events[index][1], context], ["exit", events[index][1], context], ["exit", strikethrough, context]]);
+            splice(events, open - 1, index - open + 3, nextEvents);
+            index = open + nextEvents.length - 2;
+            break;
+          }
+        }
+      }
+    }
+    index = -1;
+    while (++index < events.length) {
+      if (events[index][1].type === "strikethroughSequenceTemporary") {
+        events[index][1].type = "data";
+      }
+    }
+    return events;
+  }
+  function tokenizeStrikethrough(effects, ok3, nok) {
+    const previous2 = this.previous;
+    const events = this.events;
+    let size = 0;
+    return start;
+    function start(code3) {
+      if (previous2 === 126 && events[events.length - 1][1].type !== "characterEscape") {
+        return nok(code3);
+      }
+      effects.enter("strikethroughSequenceTemporary");
+      return more(code3);
+    }
+    function more(code3) {
+      const before = classifyCharacter(previous2);
+      if (code3 === 126) {
+        if (size > 1) return nok(code3);
+        effects.consume(code3);
+        size++;
+        return more;
+      }
+      if (size < 2 && !single) return nok(code3);
+      const token = effects.exit("strikethroughSequenceTemporary");
+      const after = classifyCharacter(code3);
+      token._open = !after || after === 2 && Boolean(before);
+      token._close = !before || before === 2 && Boolean(after);
+      return ok3(code3);
+    }
+  }
+}
+
+// ../../node_modules/.pnpm/micromark-extension-gfm-table@2.1.1/node_modules/micromark-extension-gfm-table/lib/edit-map.js
+var EditMap = class {
+  /**
+   * Create a new edit map.
+   */
+  constructor() {
+    this.map = [];
+  }
+  /**
+   * Create an edit: a remove and/or add at a certain place.
+   *
+   * @param {number} index
+   * @param {number} remove
+   * @param {Array<Event>} add
+   * @returns {undefined}
+   */
+  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
+   * @returns {undefined}
+   */
+  consume(events) {
+    this.map.sort(function(a, b) {
+      return a[0] - b[0];
+    });
+    if (this.map.length === 0) {
+      return;
+    }
+    let index = this.map.length;
+    const vecs = [];
+    while (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 slice = vecs.pop();
+    while (slice) {
+      for (const element of slice) {
+        events.push(element);
+      }
+      slice = vecs.pop();
+    }
+    this.map.length = 0;
+  }
+};
+function addImplementation(editMap, at, remove, add) {
+  let index = 0;
+  if (remove === 0 && add.length === 0) {
+    return;
+  }
+  while (index < editMap.map.length) {
+    if (editMap.map[index][0] === at) {
+      editMap.map[index][1] += remove;
+      editMap.map[index][2].push(...add);
+      return;
+    }
+    index += 1;
+  }
+  editMap.map.push([at, remove, add]);
+}
+
+// ../../node_modules/.pnpm/micromark-extension-gfm-table@2.1.1/node_modules/micromark-extension-gfm-table/lib/infer.js
+function gfmTableAlign(events, index) {
+  let inDelimiterRow = false;
+  const align = [];
+  while (index < events.length) {
+    const event = events[index];
+    if (inDelimiterRow) {
+      if (event[0] === "enter") {
+        if (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") {
+          const alignIndex = align.length - 1;
+          align[alignIndex] = align[alignIndex] === "left" ? "center" : "right";
+        }
+      } else if (event[1].type === "tableDelimiterRow") {
+        break;
+      }
+    } else if (event[0] === "enter" && event[1].type === "tableDelimiterRow") {
+      inDelimiterRow = true;
+    }
+    index += 1;
+  }
+  return align;
 }
-function merge(generated, manual, options = {}) {
-  const orphans = [];
-  const warnings = [];
-  const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
-  const sourceFile = options.sourceFile ?? manual.filePath;
-  const anchorToBlocks = /* @__PURE__ */ new Map();
-  const anchorless = [];
-  for (const block of manual.protectedBlocks) {
-    if (!block.anchorId) {
-      anchorless.push(block);
-      continue;
+
+// ../../node_modules/.pnpm/micromark-extension-gfm-table@2.1.1/node_modules/micromark-extension-gfm-table/lib/syntax.js
+function gfmTable() {
+  return {
+    flow: {
+      null: {
+        name: "table",
+        tokenize: tokenizeTable,
+        resolveAll: resolveTable
+      }
+    }
+  };
+}
+function tokenizeTable(effects, ok3, nok) {
+  const self = this;
+  let size = 0;
+  let sizeB = 0;
+  let seen;
+  return start;
+  function start(code3) {
+    let index = self.events.length - 1;
+    while (index > -1) {
+      const type = self.events[index][1].type;
+      if (type === "lineEnding" || // Note: markdown-rs uses `whitespace` instead of `linePrefix`
+      type === "linePrefix") index--;
+      else break;
     }
-    let list = anchorToBlocks.get(block.anchorId);
-    if (!list) {
-      list = [];
-      anchorToBlocks.set(block.anchorId, list);
+    const tail = index > -1 ? self.events[index][1].type : null;
+    const next = tail === "tableHead" || tail === "tableRow" ? bodyRowStart : headRowBefore;
+    if (next === bodyRowStart && self.parser.lazy[self.now().line]) {
+      return nok(code3);
     }
-    list.push(block);
+    return next(code3);
   }
-  for (const block of anchorless) {
-    warnings.push(`Protected block ${block.id} has no associated anchor \u2014 treated as orphan.`);
-    orphans.push(orphanFromBlock(block, void 0, sourceFile, now));
+  function headRowBefore(code3) {
+    effects.enter("tableHead");
+    effects.enter("tableRow");
+    return headRowStart(code3);
   }
-  const anchors = findAnchors(generated);
-  if (anchors.length === 0) {
-    for (const [anchorId2, blocks] of anchorToBlocks) {
-      for (const block of blocks) {
-        orphans.push(orphanFromBlock(block, anchorId2, sourceFile, now));
+  function headRowStart(code3) {
+    if (code3 === 124) {
+      return headRowBreak(code3);
+    }
+    seen = true;
+    sizeB += 1;
+    return headRowBreak(code3);
+  }
+  function headRowBreak(code3) {
+    if (code3 === null) {
+      return nok(code3);
+    }
+    if (markdownLineEnding(code3)) {
+      if (sizeB > 1) {
+        sizeB = 0;
+        self.interrupt = true;
+        effects.exit("tableRow");
+        effects.enter("lineEnding");
+        effects.consume(code3);
+        effects.exit("lineEnding");
+        return headDelimiterStart;
       }
+      return nok(code3);
     }
-    return { content: generated, orphans, warnings };
+    if (markdownSpace(code3)) {
+      return factorySpace(effects, headRowBreak, "whitespace")(code3);
+    }
+    sizeB += 1;
+    if (seen) {
+      seen = false;
+      size += 1;
+    }
+    if (code3 === 124) {
+      effects.enter("tableCellDivider");
+      effects.consume(code3);
+      effects.exit("tableCellDivider");
+      seen = true;
+      return headRowBreak;
+    }
+    effects.enter("data");
+    return headRowData(code3);
   }
-  const pieces = [];
-  let cursor = 0;
-  for (let i = 0; i < anchors.length; i++) {
-    const anchor = anchors[i];
-    const sectionEnd = findSectionEnd(generated, anchor.endIndex);
-    pieces.push(generated.slice(cursor, sectionEnd));
-    const blocks = anchorToBlocks.get(anchor.id);
-    if (blocks && blocks.length > 0) {
-      pieces.push(renderBlocks(blocks));
-      anchorToBlocks.delete(anchor.id);
+  function headRowData(code3) {
+    if (code3 === null || code3 === 124 || markdownLineEndingOrSpace(code3)) {
+      effects.exit("data");
+      return headRowBreak(code3);
     }
-    cursor = sectionEnd;
+    effects.consume(code3);
+    return code3 === 92 ? headRowEscape : headRowData;
   }
-  if (cursor < generated.length) {
-    pieces.push(generated.slice(cursor));
+  function headRowEscape(code3) {
+    if (code3 === 92 || code3 === 124) {
+      effects.consume(code3);
+      return headRowData;
+    }
+    return headRowData(code3);
   }
-  for (const [anchorId2, blocks] of anchorToBlocks) {
-    for (const block of blocks) {
-      orphans.push(orphanFromBlock(block, anchorId2, sourceFile, now));
+  function headDelimiterStart(code3) {
+    self.interrupt = false;
+    if (self.parser.lazy[self.now().line]) {
+      return nok(code3);
+    }
+    effects.enter("tableDelimiterRow");
+    seen = false;
+    if (markdownSpace(code3)) {
+      return factorySpace(effects, headDelimiterBefore, "linePrefix", self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(code3);
     }
+    return headDelimiterBefore(code3);
+  }
+  function headDelimiterBefore(code3) {
+    if (code3 === 45 || code3 === 58) {
+      return headDelimiterValueBefore(code3);
+    }
+    if (code3 === 124) {
+      seen = true;
+      effects.enter("tableCellDivider");
+      effects.consume(code3);
+      effects.exit("tableCellDivider");
+      return headDelimiterCellBefore;
+    }
+    return headDelimiterNok(code3);
+  }
+  function headDelimiterCellBefore(code3) {
+    if (markdownSpace(code3)) {
+      return factorySpace(effects, headDelimiterValueBefore, "whitespace")(code3);
+    }
+    return headDelimiterValueBefore(code3);
+  }
+  function headDelimiterValueBefore(code3) {
+    if (code3 === 58) {
+      sizeB += 1;
+      seen = true;
+      effects.enter("tableDelimiterMarker");
+      effects.consume(code3);
+      effects.exit("tableDelimiterMarker");
+      return headDelimiterLeftAlignmentAfter;
+    }
+    if (code3 === 45) {
+      sizeB += 1;
+      return headDelimiterLeftAlignmentAfter(code3);
+    }
+    if (code3 === null || markdownLineEnding(code3)) {
+      return headDelimiterCellAfter(code3);
+    }
+    return headDelimiterNok(code3);
+  }
+  function headDelimiterLeftAlignmentAfter(code3) {
+    if (code3 === 45) {
+      effects.enter("tableDelimiterFiller");
+      return headDelimiterFiller(code3);
+    }
+    return headDelimiterNok(code3);
+  }
+  function headDelimiterFiller(code3) {
+    if (code3 === 45) {
+      effects.consume(code3);
+      return headDelimiterFiller;
+    }
+    if (code3 === 58) {
+      seen = true;
+      effects.exit("tableDelimiterFiller");
+      effects.enter("tableDelimiterMarker");
+      effects.consume(code3);
+      effects.exit("tableDelimiterMarker");
+      return headDelimiterRightAlignmentAfter;
+    }
+    effects.exit("tableDelimiterFiller");
+    return headDelimiterRightAlignmentAfter(code3);
+  }
+  function headDelimiterRightAlignmentAfter(code3) {
+    if (markdownSpace(code3)) {
+      return factorySpace(effects, headDelimiterCellAfter, "whitespace")(code3);
+    }
+    return headDelimiterCellAfter(code3);
+  }
+  function headDelimiterCellAfter(code3) {
+    if (code3 === 124) {
+      return headDelimiterBefore(code3);
+    }
+    if (code3 === null || markdownLineEnding(code3)) {
+      if (!seen || size !== sizeB) {
+        return headDelimiterNok(code3);
+      }
+      effects.exit("tableDelimiterRow");
+      effects.exit("tableHead");
+      return ok3(code3);
+    }
+    return headDelimiterNok(code3);
+  }
+  function headDelimiterNok(code3) {
+    return nok(code3);
+  }
+  function bodyRowStart(code3) {
+    effects.enter("tableRow");
+    return bodyRowBreak(code3);
+  }
+  function bodyRowBreak(code3) {
+    if (code3 === 124) {
+      effects.enter("tableCellDivider");
+      effects.consume(code3);
+      effects.exit("tableCellDivider");
+      return bodyRowBreak;
+    }
+    if (code3 === null || markdownLineEnding(code3)) {
+      effects.exit("tableRow");
+      return ok3(code3);
+    }
+    if (markdownSpace(code3)) {
+      return factorySpace(effects, bodyRowBreak, "whitespace")(code3);
+    }
+    effects.enter("data");
+    return bodyRowData(code3);
+  }
+  function bodyRowData(code3) {
+    if (code3 === null || code3 === 124 || markdownLineEndingOrSpace(code3)) {
+      effects.exit("data");
+      return bodyRowBreak(code3);
+    }
+    effects.consume(code3);
+    return code3 === 92 ? bodyRowEscape : bodyRowData;
+  }
+  function bodyRowEscape(code3) {
+    if (code3 === 92 || code3 === 124) {
+      effects.consume(code3);
+      return bodyRowData;
+    }
+    return bodyRowData(code3);
   }
-  return { content: pieces.join(""), orphans, warnings };
 }
-function findSectionEnd(content, from) {
-  const re = /\n(#{1,6} )/g;
-  re.lastIndex = from;
-  const m = re.exec(content);
-  return m ? m.index + 1 : content.length;
+function resolveTable(events, context) {
+  let index = -1;
+  let inFirstCellAwaitingPipe = true;
+  let rowKind = 0;
+  let lastCell = [0, 0, 0, 0];
+  let cell = [0, 0, 0, 0];
+  let afterHeadAwaitingFirstBodyRow = false;
+  let lastTableEnd = 0;
+  let currentTable;
+  let currentBody;
+  let currentCell;
+  const map3 = new EditMap();
+  while (++index < events.length) {
+    const event = events[index];
+    const token = event[1];
+    if (event[0] === "enter") {
+      if (token.type === "tableHead") {
+        afterHeadAwaitingFirstBodyRow = false;
+        if (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]]);
+      } else if (token.type === "tableRow" || token.type === "tableDelimiterRow") {
+        inFirstCellAwaitingPipe = true;
+        currentCell = void 0;
+        lastCell = [0, 0, 0, 0];
+        cell = [0, index + 1, 0, 0];
+        if (afterHeadAwaitingFirstBodyRow) {
+          afterHeadAwaitingFirstBodyRow = false;
+          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;
+      } else if (rowKind && (token.type === "data" || token.type === "tableDelimiterMarker" || token.type === "tableDelimiterFiller")) {
+        inFirstCellAwaitingPipe = false;
+        if (cell[2] === 0) {
+          if (lastCell[1] !== 0) {
+            cell[0] = cell[1];
+            currentCell = flushCell(map3, context, lastCell, rowKind, void 0, currentCell);
+            lastCell = [0, 0, 0, 0];
+          }
+          cell[2] = index;
+        }
+      } else if (token.type === "tableCellDivider") {
+        if (inFirstCellAwaitingPipe) {
+          inFirstCellAwaitingPipe = false;
+        } else {
+          if (lastCell[1] !== 0) {
+            cell[0] = cell[1];
+            currentCell = flushCell(map3, context, lastCell, rowKind, void 0, currentCell);
+          }
+          lastCell = cell;
+          cell = [lastCell[1], index, 0, 0];
+        }
+      }
+    } else if (token.type === "tableHead") {
+      afterHeadAwaitingFirstBodyRow = true;
+      lastTableEnd = index;
+    } else if (token.type === "tableRow" || token.type === "tableDelimiterRow") {
+      lastTableEnd = index;
+      if (lastCell[1] !== 0) {
+        cell[0] = cell[1];
+        currentCell = flushCell(map3, context, lastCell, rowKind, index, currentCell);
+      } else if (cell[1] !== 0) {
+        currentCell = flushCell(map3, context, cell, rowKind, index, currentCell);
+      }
+      rowKind = 0;
+    } else if (rowKind && (token.type === "data" || token.type === "tableDelimiterMarker" || token.type === "tableDelimiterFiller")) {
+      cell[3] = index;
+    }
+  }
+  if (lastTableEnd !== 0) {
+    flushTableEnd(map3, context, lastTableEnd, currentTable, currentBody);
+  }
+  map3.consume(context.events);
+  index = -1;
+  while (++index < context.events.length) {
+    const event = context.events[index];
+    if (event[0] === "enter" && event[1].type === "table") {
+      event[1]._align = gfmTableAlign(context.events, index);
+    }
+  }
+  return events;
+}
+function flushCell(map3, context, range, rowKind, rowEnd, previousCell) {
+  const groupName = rowKind === 1 ? "tableHeader" : rowKind === 2 ? "tableDelimiter" : "tableData";
+  const valueName = "tableContent";
+  if (range[0] !== 0) {
+    previousCell.end = Object.assign({}, getPoint(context.events, range[0]));
+    map3.add(range[0], 0, [["exit", previousCell, context]]);
+  }
+  const now = getPoint(context.events, range[1]);
+  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]]);
+  if (range[2] !== 0) {
+    const relatedStart = getPoint(context.events, range[2]);
+    const relatedEnd = getPoint(context.events, range[3]);
+    const valueToken = {
+      type: valueName,
+      start: Object.assign({}, relatedStart),
+      end: Object.assign({}, relatedEnd)
+    };
+    map3.add(range[2], 0, [["enter", valueToken, context]]);
+    if (rowKind !== 2) {
+      const start = context.events[range[2]];
+      const end = context.events[range[3]];
+      start[1].end = Object.assign({}, end[1].end);
+      start[1].type = "chunkText";
+      start[1].contentType = "text";
+      if (range[3] > range[2] + 1) {
+        const a = range[2] + 1;
+        const b = range[3] - range[2] - 1;
+        map3.add(a, b, []);
+      }
+    }
+    map3.add(range[3] + 1, 0, [["exit", valueToken, context]]);
+  }
+  if (rowEnd !== void 0) {
+    previousCell.end = Object.assign({}, getPoint(context.events, rowEnd));
+    map3.add(rowEnd, 0, [["exit", previousCell, context]]);
+    previousCell = void 0;
+  }
+  return previousCell;
+}
+function flushTableEnd(map3, context, index, table, tableBody) {
+  const exits = [];
+  const related = getPoint(context.events, index);
+  if (tableBody) {
+    tableBody.end = Object.assign({}, related);
+    exits.push(["exit", tableBody, context]);
+  }
+  table.end = Object.assign({}, related);
+  exits.push(["exit", table, context]);
+  map3.add(index + 1, 0, exits);
 }
-function renderBlocks(blocks) {
-  return blocks.map((b) => renderBlock(b)).join("\n");
+function getPoint(events, index) {
+  const event = events[index];
+  const side = event[0] === "enter" ? "start" : "end";
+  return event[1][side];
 }
-function renderBlock(block) {
-  const idAttr = block.hasExplicitId ? ` id="${block.id}"` : "";
-  return `<!-- @manual:start${idAttr} -->
-${block.content}
-<!-- @manual:end -->
 
-`;
-}
-function orphanFromBlock(block, anchorId2, sourceFile, orphanedAt) {
-  const out = {
-    orphanedAt,
-    sourceFile,
-    anchorId: anchorId2 ?? "unknown",
-    content: block.content
+// ../../node_modules/.pnpm/micromark-extension-gfm-task-list-item@2.1.0/node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js
+var tasklistCheck = {
+  name: "tasklistCheck",
+  tokenize: tokenizeTasklistCheck
+};
+function gfmTaskListItem() {
+  return {
+    text: {
+      [91]: tasklistCheck
+    }
   };
-  if (block.hasExplicitId) out.manualBlockId = block.id;
-  return out;
 }
-function slugifyAnchor(anchorId2) {
-  return anchorId2.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+function tokenizeTasklistCheck(effects, ok3, nok) {
+  const self = this;
+  return open;
+  function open(code3) {
+    if (
+      // 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
+    ) {
+      return nok(code3);
+    }
+    effects.enter("taskListCheck");
+    effects.enter("taskListCheckMarker");
+    effects.consume(code3);
+    effects.exit("taskListCheckMarker");
+    return inside;
+  }
+  function inside(code3) {
+    if (markdownLineEndingOrSpace(code3)) {
+      effects.enter("taskListCheckValueUnchecked");
+      effects.consume(code3);
+      effects.exit("taskListCheckValueUnchecked");
+      return close2;
+    }
+    if (code3 === 88 || code3 === 120) {
+      effects.enter("taskListCheckValueChecked");
+      effects.consume(code3);
+      effects.exit("taskListCheckValueChecked");
+      return close2;
+    }
+    return nok(code3);
+  }
+  function close2(code3) {
+    if (code3 === 93) {
+      effects.enter("taskListCheckMarker");
+      effects.consume(code3);
+      effects.exit("taskListCheckMarker");
+      effects.exit("taskListCheck");
+      return after;
+    }
+    return nok(code3);
+  }
+  function after(code3) {
+    if (markdownLineEnding(code3)) {
+      return ok3(code3);
+    }
+    if (markdownSpace(code3)) {
+      return effects.check({
+        tokenize: spaceThenNonSpace
+      }, ok3, nok)(code3);
+    }
+    return nok(code3);
+  }
 }
-function formatDateUTC(d) {
-  const y = d.getUTCFullYear();
-  const m = String(d.getUTCMonth() + 1).padStart(2, "0");
-  const day = String(d.getUTCDate()).padStart(2, "0");
-  return `${y}-${m}-${day}`;
+function spaceThenNonSpace(effects, ok3, nok) {
+  return factorySpace(effects, after, "whitespace");
+  function after(code3) {
+    return code3 === null ? nok(code3) : ok3(code3);
+  }
 }
-function renderOrphanFile(record) {
-  const fields = {
-    orphaned: record.orphanedAt,
-    source_file: record.sourceFile,
-    anchor_id: record.anchorId
-  };
-  if (record.anchorLastSeen) fields.anchor_last_seen = record.anchorLastSeen;
-  if (record.manualBlockId) fields.manual_block_id = record.manualBlockId;
-  const yaml = Object.entries(fields).map(([k, v]) => `${k}: ${formatYamlScalar2(v)}`).join("\n");
-  return `---
-${yaml}
----
 
-${record.content}
-`;
-}
-async function writeOrphan(record, orphanDir) {
-  const slug = slugifyAnchor(record.anchorId);
-  const dateStamp = formatDateUTC(new Date(record.orphanedAt));
-  const filename = `${dateStamp}_${slug}.md`;
-  const absPath = import_path4.default.resolve(orphanDir, filename);
-  await (0, import_promises2.mkdir)(orphanDir, { recursive: true });
-  await (0, import_promises2.writeFile)(absPath, renderOrphanFile(record), "utf8");
-  return absPath;
+// ../../node_modules/.pnpm/micromark-extension-gfm@3.0.0/node_modules/micromark-extension-gfm/index.js
+function gfm(options) {
+  return combineExtensions([
+    gfmAutolinkLiteral(),
+    gfmFootnote(),
+    gfmStrikethrough(options),
+    gfmTable(),
+    gfmTaskListItem()
+  ]);
 }
-function formatYamlScalar2(s) {
-  if (/[:#\-?{}[\],&*!|>'"%@`]/.test(s) || /^\s|\s$/.test(s)) {
-    return `'${s.replace(/'/g, "''")}'`;
-  }
-  return s;
+
+// ../../node_modules/.pnpm/remark-gfm@4.0.1/node_modules/remark-gfm/lib/index.js
+var emptyOptions2 = {};
+function remarkGfm(options) {
+  const self = (
+    /** @type {Processor<Root>} */
+    this
+  );
+  const settings = options || emptyOptions2;
+  const data = self.data();
+  const micromarkExtensions = data.micromarkExtensions || (data.micromarkExtensions = []);
+  const fromMarkdownExtensions = data.fromMarkdownExtensions || (data.fromMarkdownExtensions = []);
+  const toMarkdownExtensions = data.toMarkdownExtensions || (data.toMarkdownExtensions = []);
+  micromarkExtensions.push(gfm(settings));
+  fromMarkdownExtensions.push(gfmFromMarkdown());
+  toMarkdownExtensions.push(gfmToMarkdown(settings));
 }
 
 // ../site/dist/index.js
-var import_fs2 = require("fs");
-var import_promises3 = require("fs/promises");
-var import_path5 = __toESM(require("path"), 1);
-var import_url = require("url");
-var import_gray_matter2 = __toESM(require("gray-matter"), 1);
-var import_unified = require("unified");
-var import_remark_parse = __toESM(require("remark-parse"), 1);
 var import_remark_rehype = __toESM(require("remark-rehype"), 1);
 var import_rehype_raw = __toESM(require("rehype-raw"), 1);
 var import_rehype_sanitize = __toESM(require("rehype-sanitize"), 1);
 var import_rehype_slug = __toESM(require("rehype-slug"), 1);
 var import_rehype_autolink_headings = __toESM(require("rehype-autolink-headings"), 1);
 var import_rehype_stringify = __toESM(require("rehype-stringify"), 1);
-var import_unist_util_visit = require("unist-util-visit");
+var import_unist_util_visit2 = require("unist-util-visit");
 var import_shiki = require("shiki");
 var import_promises4 = require("fs/promises");
 var import_path6 = __toESM(require("path"), 1);
@@ -1318,15 +4832,18 @@ var pagefind = __toESM(require("pagefind"), 1);
 var import_check = __toESM(require("lucide/dist/esm/icons/check.mjs"), 1);
 var import_chevron_down = __toESM(require("lucide/dist/esm/icons/chevron-down.mjs"), 1);
 var import_external_link = __toESM(require("lucide/dist/esm/icons/external-link.mjs"), 1);
+var import_mail = __toESM(require("lucide/dist/esm/icons/mail.mjs"), 1);
 var import_menu = __toESM(require("lucide/dist/esm/icons/menu.mjs"), 1);
 var import_monitor = __toESM(require("lucide/dist/esm/icons/monitor.mjs"), 1);
 var import_moon = __toESM(require("lucide/dist/esm/icons/moon.mjs"), 1);
+var import_package = __toESM(require("lucide/dist/esm/icons/package.mjs"), 1);
+var import_rss = __toESM(require("lucide/dist/esm/icons/rss.mjs"), 1);
 var import_search = __toESM(require("lucide/dist/esm/icons/search.mjs"), 1);
 var import_sun = __toESM(require("lucide/dist/esm/icons/sun.mjs"), 1);
 var import_x = __toESM(require("lucide/dist/esm/icons/x.mjs"), 1);
 var import_unified2 = require("unified");
 var import_remark_parse2 = __toESM(require("remark-parse"), 1);
-var import_unist_util_visit2 = require("unist-util-visit");
+var import_unist_util_visit3 = require("unist-util-visit");
 var import_meta = {};
 var CODE_THEME_PAIRS = {
   github: { light: "github-light", dark: "github-dark" },
@@ -1375,7 +4892,7 @@ async function renderMarkdown(md, opts = {}) {
   const highlighter = await getHighlighter();
   const themes = CODE_THEME_PAIRS[opts.codeTheme ?? "github"] ?? CODE_THEME_PAIRS.github;
   const headings = [];
-  const file = await (0, import_unified.unified)().use(import_remark_parse.default).use(import_remark_rehype.default, { allowDangerousHtml: true }).use(import_rehype_raw.default).use(import_rehype_sanitize.default, SANITIZE_SCHEMA).use(import_rehype_slug.default).use(import_rehype_autolink_headings.default, {
+  const file = await (0, import_unified.unified)().use(import_remark_parse.default).use(remarkGfm).use(import_remark_rehype.default, { allowDangerousHtml: true }).use(import_rehype_raw.default).use(import_rehype_sanitize.default, SANITIZE_SCHEMA).use(rehypeCallouts).use(rehypeTableWrap).use(import_rehype_slug.default).use(import_rehype_autolink_headings.default, {
     // `append` keeps the heading text flush-left along with the prose;
     // the `#` indicator floats in after the text on hover (see styles).
     behavior: "append",
@@ -1387,29 +4904,103 @@ async function renderMarkdown(md, opts = {}) {
   }).use(import_rehype_stringify.default, { allowDangerousHtml: true }).process(md);
   return { html: String(file), headings };
 }
+function rehypeTableWrap() {
+  return (tree) => {
+    (0, import_unist_util_visit2.visit)(tree, "element", (node2, index, parent) => {
+      if (node2.tagName !== "table") return;
+      if (!parent || typeof index !== "number") return;
+      if (parent.type === "element" && readClassNames(parent).includes("ov-table-wrap")) {
+        return;
+      }
+      const wrapper = {
+        type: "element",
+        tagName: "div",
+        properties: { className: ["ov-table-wrap"] },
+        children: [node2]
+      };
+      parent.children[index] = wrapper;
+    });
+  };
+}
+var CALLOUT_RE = /^\s*\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\][^\S\n]*\n?/i;
+var CALLOUT_LABEL = {
+  note: "Note",
+  tip: "Tip",
+  important: "Important",
+  warning: "Warning",
+  caution: "Caution"
+};
+function rehypeCallouts() {
+  return (tree) => {
+    (0, import_unist_util_visit2.visit)(tree, "element", (node2) => {
+      if (node2.tagName !== "blockquote") return;
+      const firstP = node2.children.find(
+        (c) => c.type === "element" && c.tagName === "p"
+      );
+      if (!firstP) return;
+      const firstText = firstP.children[0];
+      if (!firstText || firstText.type !== "text") return;
+      const m = CALLOUT_RE.exec(firstText.value);
+      if (!m) return;
+      const type = m[1].toLowerCase();
+      firstText.value = firstText.value.slice(m[0].length);
+      const stripped = firstText.value.replace(/^\s+/, "");
+      if (firstP.children.length === 1 && firstText.type === "text" && stripped.length === 0) {
+        node2.children = node2.children.filter((c) => c !== firstP);
+      } else {
+        firstText.value = stripped;
+      }
+      node2.tagName = "div";
+      node2.properties = {
+        ...node2.properties ?? {},
+        className: ["ov-callout", `ov-callout--${type}`]
+      };
+      const label = {
+        type: "element",
+        tagName: "div",
+        properties: { className: ["ov-callout-label"] },
+        children: [{ type: "text", value: CALLOUT_LABEL[type] }]
+      };
+      node2.children = [label, ...node2.children];
+    });
+  };
+}
 function collectHeadings(tree, into) {
-  (0, import_unist_util_visit.visit)(tree, "element", (node) => {
-    if (!/^h[2-3]$/.test(node.tagName)) return;
-    const depth = Number(node.tagName.slice(1));
-    const id = typeof node.properties?.id === "string" ? node.properties.id : "";
+  (0, import_unist_util_visit2.visit)(tree, "element", (node2) => {
+    if (!/^h[2-3]$/.test(node2.tagName)) return;
+    const depth = Number(node2.tagName.slice(1));
+    const id = typeof node2.properties?.id === "string" ? node2.properties.id : "";
     if (!id) return;
-    const text = textOf(node).replace(/^#/, "").trim();
-    into.push({ depth, text, id });
+    const text3 = textOfHeading(node2).trim();
+    into.push({ depth, text: text3, id });
   });
 }
+function textOfHeading(node2) {
+  let out = "";
+  for (const child of node2.children) {
+    if (child.type === "text") {
+      out += child.value;
+    } else if (child.type === "element") {
+      const classNames = readClassNames(child);
+      if (classNames.includes("heading-anchor")) continue;
+      out += textOf(child);
+    }
+  }
+  return out;
+}
 function highlightCodeBlocks(tree, highlighter, themes) {
-  (0, import_unist_util_visit.visit)(tree, "element", (node, index, parent) => {
-    if (node.tagName !== "pre" || !parent || typeof index !== "number" || !node.children?.length) {
+  (0, import_unist_util_visit2.visit)(tree, "element", (node2, index, parent) => {
+    if (node2.tagName !== "pre" || !parent || typeof index !== "number" || !node2.children?.length) {
       return;
     }
-    const code = node.children.find(
+    const code3 = node2.children.find(
       (c) => c.type === "element" && c.tagName === "code"
     );
-    if (!code) return;
-    const langClass = readClassNames(code).find((c) => c.startsWith("language-"));
+    if (!code3) return;
+    const langClass = readClassNames(code3).find((c) => c.startsWith("language-"));
     const lang = langClass ? langClass.slice("language-".length) : "text";
     if (!SHIKI_LANGS.includes(lang)) return;
-    const source = textOf(code);
+    const source = textOf(code3);
     const hast = highlighter.codeToHast(source, {
       lang,
       themes,
@@ -1417,48 +5008,66 @@ function highlightCodeBlocks(tree, highlighter, themes) {
     });
     const replacement = hast.children[0];
     if (!replacement || replacement.type !== "element") return;
+    replacement.properties = {
+      ...replacement.properties ?? {},
+      "data-language": LANG_LABEL[lang] ?? lang,
+      "data-copy": "true"
+    };
     parent.children[index] = replacement;
   });
 }
-function readClassNames(node) {
-  const cn = node.properties?.className;
+var LANG_LABEL = {
+  typescript: "ts",
+  tsx: "tsx",
+  javascript: "js",
+  jsx: "jsx",
+  json: "json",
+  bash: "bash",
+  shell: "shell",
+  markdown: "md",
+  yaml: "yaml",
+  html: "html",
+  css: "css"
+};
+function readClassNames(node2) {
+  const cn = node2.properties?.className;
   if (Array.isArray(cn)) return cn.filter((c) => typeof c === "string");
   if (typeof cn === "string") return cn.split(/\s+/);
   return [];
 }
-function textOf(node) {
+function textOf(node2) {
   let out = "";
-  for (const child of node.children) {
+  for (const child of node2.children) {
     if (child.type === "text") out += child.value;
     else if (child.type === "element") out += textOf(child);
   }
   return out;
 }
-function flattenNav(root) {
+function flattenNav(root2) {
   const out = [];
-  function walk2(node) {
-    if (node.sourcePath !== void 0) out.push(node);
-    for (const child of node.children) walk2(child);
+  function walk2(node2) {
+    if (node2.sourcePath !== void 0) out.push(node2);
+    for (const child of node2.children) walk2(child);
   }
-  walk2(root);
+  walk2(root2);
   return out;
 }
-function findBreadcrumbs(root, url) {
+function findBreadcrumbs(root2, url) {
   const path32 = [];
-  function walk2(node) {
-    path32.push(node);
-    if (node.url === url) return true;
-    for (const child of node.children) {
+  function walk2(node2) {
+    path32.push(node2);
+    if (node2.url === url) return true;
+    for (const child of node2.children) {
       if (walk2(child)) return true;
     }
     path32.pop();
     return false;
   }
-  walk2(root);
+  walk2(root2);
   return path32;
 }
-function findAdjacent(root, url) {
-  const flat = flattenNav(root);
+function findAdjacent(root2, url) {
+  const flat = flattenNav(root2);
   const idx = flat.findIndex((p) => p.url === url);
   if (idx === -1) return {};
   return {
@@ -1544,8 +5153,8 @@ function applyOrdering(children, meta) {
   }
   children.sort((a, b) => a.title.localeCompare(b.title));
 }
-function slugOf(node) {
-  const trimmed = node.url.replace(/\/+$/, "");
+function slugOf(node2) {
+  const trimmed = node2.url.replace(/\/+$/, "");
   return trimmed.slice(trimmed.lastIndexOf("/") + 1);
 }
 function isMarkdown(name) {
@@ -1613,13 +5222,66 @@ async function indexSite(input2) {
     errors: writeRes.errors
   };
 }
-function generateSitemap(input2) {
+function generateRss(input2) {
   if (!input2.baseUrl) return void 0;
   const base = stripTrailingSlash(input2.baseUrl);
   const prefix = input2.basePath ? stripTrailingSlash(input2.basePath) : "";
   const exclude = new Set(input2.exclude ?? ["/404/"]);
+  const limit = input2.limit ?? 20;
+  const generatedAt = input2.generatedAt ?? /* @__PURE__ */ new Date();
+  const homeLink = base + (prefix || "/");
+  const selfLink = base + prefix + "/feed.xml";
+  const items = input2.pages.filter((p) => !exclude.has(p.url)).sort((a, b) => compareLastMod(a.lastModified, b.lastModified)).slice(0, limit).map((p) => renderItem(p, base + prefix));
+  const channelDesc = input2.description ? escapeXml(input2.description) : "";
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <title>${escapeXml(input2.title)}</title>
+    <link>${escapeXml(homeLink)}</link>
+    <description>${channelDesc}</description>
+    <atom:link href="${escapeXml(selfLink)}" rel="self" type="application/rss+xml" />
+    <lastBuildDate>${toRfc822(generatedAt)}</lastBuildDate>
+${items.join("\n")}
+  </channel>
+</rss>
+`;
+}
+function renderItem(page, baseWithPrefix) {
+  const link2 = baseWithPrefix + page.url;
+  const pubDate = page.lastModified ? toRfc822(new Date(page.lastModified)) : void 0;
+  const lines = [
+    "    <item>",
+    `      <title>${escapeXml(page.title)}</title>`,
+    `      <link>${escapeXml(link2)}</link>`,
+    `      <guid isPermaLink="true">${escapeXml(link2)}</guid>`,
+    `      <description>${page.description ? escapeXml(page.description) : ""}</description>`
+  ];
+  if (pubDate) lines.push(`      <pubDate>${pubDate}</pubDate>`);
+  lines.push("    </item>");
+  return lines.join("\n");
+}
+function compareLastMod(a, b) {
+  if (a && b) return b.localeCompare(a);
+  if (a && !b) return -1;
+  if (!a && b) return 1;
+  return 0;
+}
+function toRfc822(d) {
+  return d.toUTCString();
+}
+function stripTrailingSlash(s) {
+  return s.replace(/\/+$/, "");
+}
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function generateSitemap(input2) {
+  if (!input2.baseUrl) return void 0;
+  const base = stripTrailingSlash2(input2.baseUrl);
+  const prefix = input2.basePath ? stripTrailingSlash2(input2.basePath) : "";
+  const exclude = new Set(input2.exclude ?? ["/404/"]);
   const entries = input2.pages.filter((p) => !exclude.has(p.url)).map((p) => `  <url>
-    <loc>${escapeXml(base + prefix + p.url)}</loc>
+    <loc>${escapeXml2(base + prefix + p.url)}</loc>
   </url>`).join("\n");
   return `<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
@@ -1627,10 +5289,10 @@ ${entries}
 </urlset>
 `;
 }
-function stripTrailingSlash(s) {
+function stripTrailingSlash2(s) {
   return s.replace(/\/+$/, "");
 }
-function escapeXml(s) {
+function escapeXml2(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 var GITHUB_MARK = [
@@ -1652,7 +5314,10 @@ var REGISTRY = {
   github: GITHUB_MARK,
   "external-link": import_external_link.default,
   search: import_search.default,
-  check: import_check.default
+  check: import_check.default,
+  rss: import_rss.default,
+  mail: import_mail.default,
+  package: import_package.default
 };
 var ICONS = Object.fromEntries(
   Object.keys(REGISTRY).map((name) => [name, nodesToInnerHtml(REGISTRY[name])])
@@ -1668,8 +5333,8 @@ function renderIcon(name, opts = {}) {
 function nodesToInnerHtml(nodes) {
   return nodes.map(nodeToHtml).join("");
 }
-function nodeToHtml(node) {
-  const [tag, attrs, children] = node;
+function nodeToHtml(node2) {
+  const [tag, attrs, children] = node2;
   const attrStr = Object.entries(attrs).map(([k, v]) => `${k}="${escapeAttr(String(v))}"`).join(" ");
   const inner = children && children.length > 0 ? nodesToInnerHtml(children) : "";
   return inner ? `<${tag} ${attrStr}>${inner}</${tag}>` : `<${tag} ${attrStr}/>`;
@@ -1716,9 +5381,18 @@ function renderShell(opts) {
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
+  <!-- Drives Safari's URL bar tint and the top-of-page rubber-band area.
+       data-light / data-dark are hex approximations of --color-bg
+       (body) in light + dark \u2014 the topbar now reads as a continuation
+       of the body, so the URL bar should match body, not chrome.
+       Update these if --color-bg moves. The inline boot script below
+       picks the right one before paint, and script.js keeps it in
+       sync with the theme toggle + OS changes. -->
+  <meta name="theme-color" id="ov-theme-color" data-light="#f4f4f4" data-dark="#101010" content="#f4f4f4">
   <title>${escapeHtml(opts.fullTitle)}</title>
   ${desc ? `<meta name="description" content="${escapeAttr2(desc)}">` : ""}
   ${opts.site.baseUrl ? `<link rel="canonical" href="${escapeAttr2(join(opts.site.baseUrl, basePath + opts.url))}">` : ""}
+  ${opts.site.baseUrl ? `<link rel="alternate" type="application/rss+xml" title="${escapeAttr2(opts.site.title)}" href="${escapeAttr2(join(opts.site.baseUrl, basePath + "/feed.xml"))}">` : ""}
   <link rel="stylesheet" href="${escapeAttr2(assets)}assets/ovellum.css">
   ${searchHead}
   <script>
@@ -1727,6 +5401,16 @@ function renderShell(opts) {
         var t = localStorage.getItem('ovellum-theme');
         if (t === 'light' || t === 'dark' || t === 'auto') {
           document.documentElement.setAttribute('data-theme', t);
+        } else {
+          t = document.documentElement.getAttribute('data-theme') || 'auto';
+        }
+        var effective = t;
+        if (t === 'auto') {
+          effective = window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+        }
+        var meta = document.getElementById('ov-theme-color');
+        if (meta) {
+          meta.setAttribute('content', meta.getAttribute(effective === 'dark' ? 'data-dark' : 'data-light'));
         }
       } catch (_) {}
     })();
@@ -1735,28 +5419,47 @@ function renderShell(opts) {
 <body${opts.bodyClass ? ` class="${escapeAttr2(opts.bodyClass)}"` : ""}>
   ${renderTopbar(opts.site, assets, opts.docsHref ? siteUrl(opts.docsHref, basePath) : void 0, searchEnabled, basePath)}
   ${opts.body}
-  ${renderFooter(opts.site, opts.generatedAt)}
+  ${renderFooter(opts.site, opts.generatedAt, basePath)}
   ${searchScripts}
   <script src="${escapeAttr2(assets)}assets/ovellum.js" defer></script>
 </body>
 </html>
 `;
 }
-function renderTopbar(site, assets, docsHref, searchEnabled, basePath) {
-  const navItems = site.topbarNav ?? [];
-  const items = navItems.map((item) => {
+var BRAND_MARK = `<svg class="ov-brand-mark" width="24" height="24" viewBox="0 0 3334 3334" fill="currentColor" aria-hidden="true" xmlns="http://www.w3.org/2000/svg"><path d="M1610.79,192.942l-603.283,-0.069c-72.722,290.674 -294.48,871.657 -294.48,871.657c-53.158,128.398 -37.404,275.067 41.795,389.217l743.687,1149.95l0,233.06c-42.509,41.505 -68.98,99.335 -68.98,163.352c-0.069,126.096 102.07,228.236 228.167,228.167c126.096,0.069 228.308,-102.144 228.235,-228.236c-0,-64.017 -26.471,-121.847 -68.985,-163.21l0,-233.06l743.765,-1150.03c79.122,-114.228 94.806,-260.819 41.722,-389.143c0,-0 -221.472,-580.983 -294.052,-871.652l-603.352,0l-94.239,-0.005Zm323.188,921.357c0,140.409 -104.731,256.078 -240.177,273.7l0,1386.96c-11.868,-1.795 -23.809,-3.093 -36.036,-3.093c-12.375,-0 -24.243,1.224 -36.037,3.093l-0,-1386.97c-135.593,-17.623 -240.251,-133.218 -240.251,-273.627c0,-152.635 123.652,-276.287 276.288,-276.287c152.635,0 276.282,123.656 276.213,276.223Z"/></svg>`;
+function resolveTopbarItems(site, basePath) {
+  return (site.topbarNav ?? []).map((item) => {
     const external = item.external === true || /^https?:\/\//i.test(item.href);
-    const href = external ? item.href : siteUrl(item.href, basePath);
+    const icon = item.icon && item.icon in ICONS ? item.icon : void 0;
+    return {
+      label: item.label,
+      href: external ? item.href : siteUrl(item.href, basePath),
+      external,
+      icon
+    };
+  });
+}
+function renderTopbarLinks(items, docsHref, compact) {
+  const links = items.map(({ label, href, external, icon }) => {
     const rel = external ? ' rel="noopener" target="_blank"' : "";
-    const icon = external ? ` ${renderIcon("external-link", { class: "ov-topbar-icon", size: 14 })}` : "";
-    return `<a class="ov-topbar-link" href="${escapeAttr2(href)}"${rel}>${escapeHtml(item.label)}${icon}</a>`;
+    if (icon && compact) {
+      return `<a class="ov-topbar-link ov-topbar-link--icon" href="${escapeAttr2(href)}"${rel} aria-label="${escapeAttr2(label)}" title="${escapeAttr2(label)}">${renderIcon(icon, { class: "ov-topbar-glyph", size: 18 })}<span class="ov-sr-only">${escapeHtml(label)}</span></a>`;
+    }
+    const glyph = icon ? `${renderIcon(icon, { class: "ov-topbar-glyph", size: 18 })}` : "";
+    const ext = external && !icon ? ` ${renderIcon("external-link", { class: "ov-topbar-icon", size: 14 })}` : "";
+    return `<a class="ov-topbar-link" href="${escapeAttr2(href)}"${rel}>${glyph}${escapeHtml(label)}${ext}</a>`;
   });
-  if (docsHref) {
-    items.push(
+  if (docsHref && !items.some((it) => it.href === docsHref)) {
+    links.push(
       `<a class="ov-topbar-link ov-topbar-link--docs" href="${escapeAttr2(docsHref)}">Docs</a>`
     );
   }
-  const navLinks = items.join("\n      ");
+  return links.join("\n        ");
+}
+function renderTopbar(site, assets, docsHref, searchEnabled, basePath) {
+  const items = resolveTopbarItems(site, basePath);
+  const desktopLinks = renderTopbarLinks(items, docsHref, true);
+  const mobileLinks = renderTopbarLinks(items, docsHref, false);
   const search = searchEnabled ? `<div id="ov-search" class="ov-search"></div>` : "";
   const menuButton = `<button class="ov-topbar-menu" type="button"
       aria-label="Open menu" aria-expanded="false" aria-controls="ov-mobile-nav"
@@ -1770,22 +5473,46 @@ function renderTopbar(site, assets, docsHref, searchEnabled, basePath) {
       <span class="ov-theme-icon ov-theme-icon-light">${renderIcon("sun")}</span>
       <span class="ov-theme-icon ov-theme-icon-dark">${renderIcon("moon")}</span>
     </button>`;
+  const versionBadge = site.version ? `<span class="ov-brand-version" aria-label="Stable version ${escapeAttr2(site.version)}">${escapeHtml(site.version)}</span>` : "";
   return `<header class="ov-topbar">
-    <a class="ov-brand" href="${escapeAttr2(assets)}">${escapeHtml(site.title)}</a>
-    <nav class="ov-topbar-nav" aria-label="Primary">${navLinks}</nav>
-    <div class="ov-topbar-right">
-      ${search}
-      ${themeButton}
-      ${menuButton}
+    <div class="ov-topbar-inner">
+      <div class="ov-brand-row">
+        <a class="ov-brand" href="${escapeAttr2(assets)}">${BRAND_MARK}<span class="ov-brand-name">${escapeHtml(site.title)}</span></a>
+        ${versionBadge}
+      </div>
+      <div class="ov-topbar-search">${search}</div>
+      <div class="ov-topbar-right">
+        <nav class="ov-topbar-nav" aria-label="Primary">${desktopLinks}</nav>
+        ${themeButton}
+        ${menuButton}
+      </div>
+      <nav id="ov-mobile-nav" class="ov-mobile-nav" aria-label="Mobile">
+        ${mobileLinks}
+        <div class="ov-mobile-theme">
+          <span class="ov-mobile-theme-label">Theme</span>
+          ${themeButton}
+        </div>
+      </nav>
     </div>
-    <nav id="ov-mobile-nav" class="ov-mobile-nav" aria-label="Mobile">
-      ${navLinks}
-    </nav>
   </header>`;
 }
-function renderFooter(site, generatedAt) {
-  if (!site.footer) return "";
-  return `<footer class="ov-footer"><span>${escapeHtml(site.footer)}</span><span class="ov-footer-sep"> \xB7 </span><time datetime="${escapeAttr2(generatedAt)}">${escapeHtml(generatedAt.slice(0, 10))}</time></footer>`;
+function renderFooter(site, generatedAt, basePath) {
+  const items = site.footerNav ?? [];
+  const hasItems = items.length > 0;
+  if (!site.footer && !hasItems) return "";
+  const left = site.footer ? `<div class="ov-footer-left"><span>${escapeHtml(site.footer)}</span><span class="ov-footer-sep">\xB7</span><time datetime="${escapeAttr2(generatedAt)}">${escapeHtml(generatedAt.slice(0, 10))}</time></div>` : '<div class="ov-footer-left"></div>';
+  const right = hasItems ? `<nav class="ov-footer-right" aria-label="Site links">${items.map((item) => renderFooterNavItem(item, basePath)).join("")}</nav>` : "";
+  return `<footer class="ov-footer"><div class="ov-footer-inner">${left}${right}</div></footer>`;
+}
+function renderFooterNavItem(item, basePath) {
+  const external = item.external === true || /^https?:\/\//i.test(item.href);
+  const href = external ? item.href : siteUrl(item.href, basePath);
+  const rel = external ? ' rel="noopener" target="_blank"' : "";
+  const iconName = item.icon;
+  if (iconName && iconName in ICONS) {
+    return `<a class="ov-footer-link ov-footer-link--icon" href="${escapeAttr2(href)}"${rel} aria-label="${escapeAttr2(item.label)}" title="${escapeAttr2(item.label)}">${renderIcon(iconName, { class: "ov-footer-icon", size: 18 })}<span class="ov-sr-only">${escapeHtml(item.label)}</span></a>`;
+  }
+  return `<a class="ov-footer-link" href="${escapeAttr2(href)}"${rel}>${escapeHtml(item.label)}</a>`;
 }
 function renderPage(input2) {
   const fullTitle = input2.title && input2.title !== input2.site.title ? `${input2.title} \xB7 ${input2.site.title}` : input2.site.title;
@@ -1827,16 +5554,26 @@ function renderLanding(input2) {
     heroTitle,
     input2.landing.hero.subtitle,
     input2.landing.hero.ctas,
+    input2.landing.hero.media,
     basePath
   );
   const features = renderFeatures(input2.landing.features);
   const pitch = input2.pitchHtml ? `<section class="ov-pitch"><div class="ov-pitch-inner">${input2.pitchHtml}</div></section>` : "";
   const trust = renderTrustStrip(input2.landing.trustStrip);
+  const sections = [hero, features, pitch, trust].filter((s) => s !== "");
+  const scenes = input2.landing.scenes ?? [];
+  const interleaved = [];
+  sections.forEach((section, i) => {
+    interleaved.push(section);
+    if (i < sections.length - 1 && scenes[i]) {
+      interleaved.push(renderScene(scenes[i], i, basePath));
+    }
+  });
+  scenes.slice(Math.max(0, sections.length - 1)).forEach((sc, j) => {
+    interleaved.push(renderScene(sc, sections.length - 1 + j, basePath));
+  });
   const body = `<main class="ov-landing">
-    ${hero}
-    ${features}
-    ${pitch}
-    ${trust}
+    ${interleaved.join("\n    ")}
   </main>`;
   return renderShell({
     site: input2.site,
@@ -1850,7 +5587,7 @@ function renderLanding(input2) {
     bodyClass: "ov-body-landing"
   });
 }
-function renderHero(title, subtitle, ctas, basePath) {
+function renderHero(title, subtitle, ctas, media, basePath) {
   const ctaButtons = ctas.map((cta, i) => {
     const style = cta.style ?? (i === 0 ? "primary" : "secondary");
     return `<a class="ov-cta ov-cta--${escapeAttr2(style)}" href="${escapeAttr2(siteUrl(cta.href, basePath))}">${escapeHtml(cta.label)}</a>`;
@@ -1858,17 +5595,42 @@ function renderHero(title, subtitle, ctas, basePath) {
   const ctaRow = ctas.length > 0 ? `<div class="ov-cta-row">
       ${ctaButtons}
     </div>` : "";
-  return `<section class="ov-hero">
-    <h1 class="ov-hero-title">${escapeHtml(title)}</h1>
-    ${subtitle ? `<p class="ov-hero-subtitle">${escapeHtml(subtitle)}</p>` : ""}
-    ${ctaRow}
+  const art = media ? renderHeroArt(media, basePath) : "";
+  const sectionAttrs = media ? " data-media" : "";
+  return `<section class="ov-hero"${sectionAttrs}>
+    ${art}
+    <div class="ov-hero-inner">
+      <h1 class="ov-hero-title">${escapeHtml(title)}</h1>
+      ${subtitle ? `<p class="ov-hero-subtitle">${escapeHtml(subtitle)}</p>` : ""}
+      ${ctaRow}
+    </div>
   </section>`;
 }
+function renderHeroArt(media, basePath) {
+  const alt = media.alt ?? "";
+  const lightSrc = escapeAttr2(siteUrl(media.light, basePath));
+  const darkSrc = media.dark ? escapeAttr2(siteUrl(media.dark, basePath)) : lightSrc;
+  return `<div class="ov-hero-art" aria-hidden="${alt ? "false" : "true"}">
+      <img class="ov-hero-art-img ov-hero-art-img--light" src="${lightSrc}" alt="${escapeAttr2(alt)}" loading="eager" decoding="async">
+      <img class="ov-hero-art-img ov-hero-art-img--dark" src="${darkSrc}" alt="" loading="eager" decoding="async">
+    </div>`;
+}
+function renderScene(scene, index, basePath) {
+  const alt = scene.alt ?? "";
+  const lightSrc = escapeAttr2(siteUrl(scene.light, basePath));
+  const darkSrc = scene.dark ? escapeAttr2(siteUrl(scene.dark, basePath)) : lightSrc;
+  return `<section class="ov-scene" aria-hidden="${alt ? "false" : "true"}" style="--ov-scene-i: ${index};">
+      <figure class="ov-scene-art">
+        <img class="ov-scene-img ov-scene-img--light" src="${lightSrc}" alt="${escapeAttr2(alt)}" loading="lazy" decoding="async">
+        <img class="ov-scene-img ov-scene-img--dark" src="${darkSrc}" alt="" loading="lazy" decoding="async">
+      </figure>
+    </section>`;
+}
 function renderFeatures(features) {
   if (features.length === 0) return "";
   const cards = features.map((f) => {
     const icon = f.icon ? `<div class="ov-feature-icon" aria-hidden="true">${f.icon}</div>` : "";
-    return `<article class="ov-feature-card">
+    return `<article class="ov-card ov-feature-card">
         ${icon}
         <h3 class="ov-feature-title">${escapeHtml(f.title)}</h3>
         <p class="ov-feature-description">${escapeHtml(f.description)}</p>
@@ -1898,23 +5660,23 @@ function renderSidebar(nav, activeUrl, basePath) {
 }
 function navList(nodes, activeUrl, basePath) {
   if (nodes.length === 0) return "";
-  return nodes.map((node) => {
-    const isActive = node.url === activeUrl;
-    const hasChildren = node.children.length > 0;
-    const link = node.sourcePath ? `<a class="ov-nav-link${isActive ? " is-active" : ""}" href="${escapeAttr2(siteUrl(node.url, basePath))}">${escapeHtml(node.title)}</a>` : `<span class="ov-nav-group">${escapeHtml(node.title)}</span>`;
-    const children = hasChildren ? `<ul class="ov-nav-children">${navList(node.children, activeUrl, basePath)}</ul>` : "";
-    return `<li>${link}${children}</li>`;
+  return nodes.map((node2) => {
+    const isActive = node2.url === activeUrl;
+    const hasChildren = node2.children.length > 0;
+    const link2 = node2.sourcePath ? `<a class="ov-nav-link${isActive ? " is-active" : ""}" href="${escapeAttr2(siteUrl(node2.url, basePath))}">${escapeHtml(node2.title)}</a>` : `<span class="ov-nav-group">${escapeHtml(node2.title)}</span>`;
+    const children = hasChildren ? `<ul class="ov-nav-children">${navList(node2.children, activeUrl, basePath)}</ul>` : "";
+    return `<li>${link2}${children}</li>`;
   }).join("");
 }
-function renderBreadcrumbs(trail, basePath) {
-  if (!trail || trail.length < 3) return "";
-  const visible = trail.slice(1);
-  const items = visible.map((node, i) => {
+function renderBreadcrumbs(trail2, basePath) {
+  if (!trail2 || trail2.length < 3) return "";
+  const visible = trail2.slice(1);
+  const items = visible.map((node2, i) => {
     const isLast = i === visible.length - 1;
     if (isLast) {
-      return `<li class="ov-crumb is-current" aria-current="page">${escapeHtml(node.title)}</li>`;
+      return `<li class="ov-crumb is-current" aria-current="page">${escapeHtml(node2.title)}</li>`;
     }
-    return `<li class="ov-crumb"><a href="${escapeAttr2(siteUrl(node.url, basePath))}">${escapeHtml(node.title)}</a></li>`;
+    return `<li class="ov-crumb"><a href="${escapeAttr2(siteUrl(node2.url, basePath))}">${escapeHtml(node2.title)}</a></li>`;
   }).join("\n      ");
   return `<nav class="ov-breadcrumbs" aria-label="Breadcrumb">
     <ol>
@@ -1992,14 +5754,14 @@ async function buildSite(options) {
   let landingRendered = false;
   if (landingEnabled) {
     const landingBody = await readLandingBody(inputAbs, site);
-    const html = renderLanding({
+    const html2 = renderLanding({
       site,
       landing: site.landing,
       pitchHtml: landingBody?.html,
       generatedAt: now.toISOString(),
       docsHref
     });
-    await (0, import_promises3.writeFile)(import_path5.default.join(outputAbs, "index.html"), html, "utf8");
+    await (0, import_promises3.writeFile)(import_path5.default.join(outputAbs, "index.html"), html2, "utf8");
     pages.push({
       sourcePath: landingBody?.sourcePath ?? "(landing config)",
       outputPath: import_path5.default.relative(cwd, import_path5.default.join(outputAbs, "index.html")).replace(/\\/g, "/"),
@@ -2026,7 +5788,9 @@ async function buildSite(options) {
         absInput: file,
         url,
         site,
-        nav,
+        // Sidebar renders the section subtree; prev/next + breadcrumbs above
+        // still use the full nav so reading order spans the whole site.
+        nav: sidebarRootFor(nav),
         cwd,
         generatedAt: now.toISOString(),
         docsHref,
@@ -2041,7 +5805,9 @@ async function buildSite(options) {
         sourcePath: import_path5.default.relative(cwd, file).replace(/\\/g, "/"),
         outputPath: import_path5.default.relative(cwd, outputPath).replace(/\\/g, "/"),
         url,
-        title: result.title
+        title: result.title,
+        description: result.description,
+        lastModified: result.lastModified
       });
       warnings.push(...result.warnings);
     } else {
@@ -2058,9 +5824,19 @@ async function buildSite(options) {
   if (site.baseUrl) {
     const xml = generateSitemap({ pages, baseUrl: site.baseUrl, basePath: site.basePath });
     if (xml) await (0, import_promises3.writeFile)(import_path5.default.join(outputAbs, "sitemap.xml"), xml, "utf8");
+    const rss = generateRss({
+      pages,
+      baseUrl: site.baseUrl,
+      basePath: site.basePath,
+      title: site.title,
+      description: site.description,
+      exclude: ["/404/", "/"],
+      generatedAt: now
+    });
+    if (rss) await (0, import_promises3.writeFile)(import_path5.default.join(outputAbs, "feed.xml"), rss, "utf8");
   } else {
     warnings.push(
-      "sitemap.xml not generated: set `site.baseUrl` in your config to enable it."
+      "sitemap.xml and feed.xml not generated: set `site.baseUrl` in your config to enable them."
     );
   }
   if (site.search.enabled) {
@@ -2089,7 +5865,7 @@ async function renderOne(input2) {
   const pageMetaCfg = input2.site.pageMeta;
   const readingMin = pageMetaCfg.readingTime ? readingMinutes(countWords(parsed.content)) : void 0;
   const lastModified = pageMetaCfg.lastModified ? await lastModifiedISO({ absPath: input2.absInput, cwd: input2.cwd }) : void 0;
-  const html = renderPage({
+  const html2 = renderPage({
     site: input2.site,
     nav: input2.nav,
     url: input2.url,
@@ -2107,7 +5883,13 @@ async function renderOne(input2) {
     lastModified,
     bodyClass: input2.url === "/404/" ? "ov-body-404" : void 0
   });
-  return { html, title, warnings: [] };
+  return {
+    html: html2,
+    title,
+    description: frontmatter.description,
+    lastModified,
+    warnings: []
+  };
 }
 async function readLandingBody(inputAbs, site) {
   const abs = import_path5.default.join(inputAbs, LANDING_BODY_FILE);
@@ -2115,13 +5897,30 @@ async function readLandingBody(inputAbs, site) {
   const raw = await (0, import_promises3.readFile)(abs, "utf8");
   const { content } = (0, import_gray_matter2.default)(raw);
   if (!content.trim()) return void 0;
-  const { html } = await renderMarkdown(content, { codeTheme: site.codeTheme });
-  return { html, sourcePath: import_path5.default.join(import_path5.default.basename(inputAbs), LANDING_BODY_FILE) };
+  const { html: html2 } = await renderMarkdown(content, { codeTheme: site.codeTheme });
+  return { html: html2, sourcePath: import_path5.default.join(import_path5.default.basename(inputAbs), LANDING_BODY_FILE) };
 }
 function firstNavUrl(nav) {
   const first = nav.children.find((c) => c.sourcePath !== void 0);
   return first?.url;
 }
+function sidebarRootFor(nav) {
+  const groups = nav.children.filter((c) => c.children.length > 0);
+  const looseRootPages = nav.children.filter(
+    (c) => c.sourcePath !== void 0 && c.children.length === 0 && c.url !== "/404/"
+  );
+  if (groups.length !== 1 || looseRootPages.length > 0) return nav;
+  const section = groups[0];
+  const lead = section.sourcePath ? [
+    {
+      title: section.title,
+      url: section.url,
+      sourcePath: section.sourcePath,
+      children: []
+    }
+  ] : [];
+  return { ...section, children: [...lead, ...section.children] };
+}
 function resolveSiteConfig(config) {
   const title = config.site.title ?? config.name ?? "Ovellum site";
   return { ...config.site, title };
@@ -2179,11 +5978,11 @@ function resolveTemplateDir() {
 function extractMarkdownLinks(content) {
   const tree = (0, import_unified2.unified)().use(import_remark_parse2.default).parse(content);
   const out = [];
-  (0, import_unist_util_visit2.visit)(tree, "link", (node) => {
-    if (typeof node.url !== "string") return;
+  (0, import_unist_util_visit3.visit)(tree, "link", (node2) => {
+    if (typeof node2.url !== "string") return;
     out.push({
-      target: node.url,
-      line: node.position?.start.line ?? 1
+      target: node2.url,
+      line: node2.position?.start.line ?? 1
     });
   });
   return out;
@@ -2213,6 +6012,7 @@ async function runBuild(input2) {
     let finalBody = generatedBody;
     if (config.mode === "hybrid" && (0, import_node_fs.existsSync)(abs)) {
       const manualDoc = await readManualDoc(abs);
+      warnings.push(...manualDoc.warnings);
       if (manualDoc.protectedBlocks.length > 0) {
         const result = merge(generatedBody, manualDoc, { sourceFile: relOut });
         finalBody = result.content;
@@ -2716,10 +6516,10 @@ async function serve404(opts, res) {
   res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
   res.end("Not Found");
 }
-function injectReloadScript(html) {
+function injectReloadScript(html2) {
   const tag = `<script src="${RELOAD_SCRIPT_PATH}" defer></script>`;
-  if (/<\/body>/i.test(html)) return html.replace(/<\/body>/i, `${tag}$&`);
-  return html + tag;
+  if (/<\/body>/i.test(html2)) return html2.replace(/<\/body>/i, `${tag}$&`);
+  return html2 + tag;
 }
 async function findFreePort(host, start, range) {
   for (let p = start; p < start + range; p++) {
@@ -3131,11 +6931,11 @@ ${a.description || `Welcome to **${a.title}**. This file is \`${a.input}/index.m
 async function ensureGitignore(cwd, a) {
   const gi = import_node_path7.default.join(cwd, ".gitignore");
   const want = a.mode === "auto" ? [a.output, ".orphans/"] : [a.output, ".orphans/"];
-  const wantNorm = want.map((p) => stripTrailingSlash2(p));
+  const wantNorm = want.map((p) => stripTrailingSlash3(p));
   let current = "";
   if ((0, import_node_fs4.existsSync)(gi)) current = await (0, import_promises9.readFile)(gi, "utf8");
   const have = new Set(
-    current.split(/\r?\n/).map((l) => stripTrailingSlash2(l.trim())).filter(Boolean)
+    current.split(/\r?\n/).map((l) => stripTrailingSlash3(l.trim())).filter(Boolean)
   );
   const missing = wantNorm.filter((p) => !have.has(p));
   if (missing.length === 0) return false;
@@ -3164,7 +6964,7 @@ function nextSteps(a) {
 function titleFromName(name) {
   return name.split(/[-_./@\s]/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
 }
-function stripTrailingSlash2(s) {
+function stripTrailingSlash3(s) {
   return s.endsWith("/") ? s.slice(0, -1) : s;
 }