@publish.os/nextjs 0.0.1-alpha.91 → 0.0.1-alpha.92

package/dist/{chunk-UYGCOWRF.js → chunk-DX7PXFCM.js}

@@ -89,27 +89,123 @@ import ts2 from "typescript";
 import { unified } from "unified";
 
 // src/lib/compiler/source/frontmatter.ts
-import matter from "gray-matter";
-var DATA_LANGUAGES = /* @__PURE__ */ new Set(["json", "yaml", "yml"]), FRONTMATTER_DELIMITER = "---", UnsupportedFrontmatterLanguageError = class extends Error {
-  constructor(language) {
-    super(`Unsupported frontmatter language "${language}". Use YAML or JSON.`);
-    this.language = language;
-    this.name = "UnsupportedFrontmatterLanguageError";
+import { isAlias, isMap, isScalar, isSeq, parseDocument } from "yaml";
+function decimalValue(value) {
+  let match = /^([+-]?)(\d*)(?:\.(\d*))?(?:e([+-]?\d+))?$/i.exec(value);
+  if (!match || !(match[2] || match[3])) return;
+  let digits = `${match[2]}${match[3] ?? ""}`.replace(/^0+/, "");
+  if (!digits) return "0";
+  let trimmed = digits.replace(/0+$/, ""), exponent = BigInt(match[4] ?? "0") - BigInt((match[3] ?? "").length) + BigInt(digits.length - trimmed.length);
+  return `${match[1] === "-" ? "-" : ""}${trimmed}e${exponent}`;
+}
+function numberIsExact(source, value) {
+  if (!Number.isFinite(value)) return !1;
+  if (/^[-+]?0[ox]/i.test(source))
+    try {
+      return Number.isInteger(value) && BigInt(source.replace(/^\+/, "")) === BigInt(value);
+    } catch {
+      return !1;
+    }
+  return decimalValue(source) === decimalValue(String(value));
+}
+var FrontmatterParseError = class extends Error {
+  constructor(message, line, column, field) {
+    super(`${message} at line ${line}, column ${column}.`);
+    this.line = line;
+    this.column = column;
+    this.field = field;
+    this.name = "FrontmatterParseError";
   }
-  language;
+  line;
+  column;
+  field;
 };
-function frontmatterLanguage(source) {
-  if (!matter.test(source) || source[FRONTMATTER_DELIMITER.length] === FRONTMATTER_DELIMITER.at(-1))
-    return;
-  let lineEnd = source.indexOf(`
-`, FRONTMATTER_DELIMITER.length), headerEnd = lineEnd === -1 ? source.length : lineEnd;
-  return source.slice(FRONTMATTER_DELIMITER.length, headerEnd).replace(/\r$/, "").trim();
-}
 function parseSourceFrontmatter(source) {
-  let inspected = source.charCodeAt(0) === 65279 ? source.slice(1) : source, marker = frontmatterLanguage(inspected), language = marker?.toLowerCase();
-  if (marker && language && (!DATA_LANGUAGES.has(language) || language === "json" && marker !== "json"))
-    throw new UnsupportedFrontmatterLanguageError(marker);
-  return matter(source, { language: "yaml" });
+  let firstLine = /^(?:\uFEFF)?---(?:\r?\n|$)/.exec(source);
+  if (!firstLine) return { data: {}, content: source };
+  let offset = firstLine[0].length, fence, end = -1, bodyStart = -1;
+  for (; offset < source.length; ) {
+    let next = source.indexOf(`
+`, offset), lineEnd = next < 0 ? source.length : next, line = source.slice(offset, lineEnd).replace(/\r$/, ""), marker = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+    if (marker) {
+      let run = marker[1] ?? "";
+      fence ? run.charAt(0) === fence.character && run.length >= fence.length && !(marker[2] ?? "").trim() && (fence = void 0) : fence = { character: run.charAt(0), length: run.length };
+    } else if (!fence && line === "---") {
+      end = offset, bodyStart = next < 0 ? source.length : next + 1;
+      break;
+    }
+    offset = next < 0 ? source.length : next + 1;
+  }
+  if (end < 0) return { data: {}, content: source };
+  let frontmatterOffset = firstLine[0].length;
+  function fail(message, offset2 = 0, field) {
+    let absoluteOffset = Math.min(frontmatterOffset + offset2, source.length), before = source.slice(0, absoluteOffset), line = before.split(`
+`).length, column = absoluteOffset - before.lastIndexOf(`
+`);
+    throw new FrontmatterParseError(message, line, column, field);
+  }
+  let doc = parseDocument(source.slice(firstLine[0].length, end), {
+    schema: "core",
+    uniqueKeys: !0
+  }), yamlError = doc.errors[0] ?? doc.warnings[0];
+  if (yamlError) {
+    let message = yamlError.message.replace(
+      / at line \d+, column \d+:[\s\S]*$/,
+      ""
+    );
+    fail(message, yamlError.pos[0]);
+  }
+  doc.contents && !isMap(doc.contents) && fail(
+    "Frontmatter must be a mapping with string keys",
+    doc.contents.range?.[0]
+  );
+  let visits = 0, active = /* @__PURE__ */ new Set();
+  function validate(node, field) {
+    if (node) {
+      if (++visits > 1e4 && fail("Frontmatter alias expansion exceeds the limit"), isAlias(node)) {
+        let target = node.resolve(doc);
+        target || fail(`Invalid alias in ${field}`, node.range?.[0], field), active.has(target) && fail(`Cyclic alias in ${field}`, node.range?.[0], field), validate(target, field);
+        return;
+      }
+      if (!(!isScalar(node) && !isMap(node) && !isSeq(node))) {
+        if (node.tag && ![
+          "tag:yaml.org,2002:str",
+          "tag:yaml.org,2002:int",
+          "tag:yaml.org,2002:float",
+          "tag:yaml.org,2002:bool",
+          "tag:yaml.org,2002:null",
+          "tag:yaml.org,2002:map",
+          "tag:yaml.org,2002:seq"
+        ].includes(node.tag) && fail(`Unsupported YAML tag in ${field}`, node.range?.[0], field), isScalar(node)) {
+          typeof node.value == "number" && !numberIsExact(node.source ?? String(node.value), node.value) && fail(
+            `Invalid number in ${field}; quote the value to preserve its exact digits`,
+            node.range?.[0],
+            field
+          );
+          return;
+        }
+        if (active.add(node), isMap(node))
+          for (let pair of node.items)
+            (!isScalar(pair.key) || typeof pair.key.value != "string") && fail(
+              `Frontmatter keys in ${field} must be strings`,
+              isScalar(pair.key) || isMap(pair.key) || isSeq(pair.key) || isAlias(pair.key) ? pair.key.range?.[0] : void 0,
+              field
+            ), validate(
+              pair.value,
+              field === "frontmatter" ? pair.key.value : `${field}.${pair.key.value}`
+            );
+        else
+          for (let item of node.items) validate(item, field);
+        active.delete(node);
+      }
+    }
+  }
+  validate(doc.contents, "frontmatter");
+  let data = doc.toJS({ maxAliasCount: 100 });
+  return {
+    data: data ? JSON.parse(JSON.stringify(data)) : {},
+    content: source.slice(bodyStart)
+  };
 }
 
 // src/lib/compiler/source/mdx-icon-imports.ts
@@ -187,7 +283,7 @@ async function validateMdxIconImports(source) {
   return imports;
 }
 
-// src/lib/compiler/source/config/root-content-group.ts
+// src/lib/shared/root-content-group.ts
 var ROOT_CONTENT_GROUP_KEY = "__root", ROOT_CONTENT_GROUP_TITLE = "Root";
 
 // src/lib/compiler/source/assert-source-dependency.ts
@@ -1478,31 +1574,16 @@ export type MediaAssetManifestEntry = MediaManifest["assets"][keyof MediaManifes
 }
 
 // src/lib/compiler/source/routing/slug-path.ts
-var SLUG_SEGMENT_RE = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
+var SLUG_SEGMENT_RE = /^[\p{L}\p{N}][\p{L}\p{M}\p{N}]*(?:[.-][\p{L}\p{N}][\p{L}\p{M}\p{N}]*)*$/u;
 function issue(code, message, details) {
   return details ? { code, message, details } : { code, message };
 }
-function isLowerAlpha(code) {
-  return code >= 97 && code <= 122;
-}
-function isUpperAlpha(code) {
-  return code >= 65 && code <= 90;
-}
-function isDigit(code) {
-  return code >= 48 && code <= 57;
-}
-function isAsciiAlphaNumeric(code) {
-  return isLowerAlpha(code) || isUpperAlpha(code) || isDigit(code);
-}
 function isWhitespace(code) {
   return code === 32 || code === 9 || code === 10 || code === 11 || code === 12 || code === 13 || code === 160;
 }
 function isUnsafeInvisible(code) {
   return code <= 31 || code >= 127 && code <= 159 || code >= 8203 && code <= 8207 || code >= 8232 && code <= 8239 || code >= 8288 && code <= 8303 || code === 65279;
 }
-function isCombiningMark(code) {
-  return code >= 768 && code <= 879 || code >= 6832 && code <= 6911 || code >= 7616 && code <= 7679 || code >= 8400 && code <= 8447 || code >= 65056 && code <= 65071;
-}
 function hasPercentEscape(value) {
   return /%[0-9a-fA-F]{2}/.test(value);
 }
@@ -1514,15 +1595,10 @@ function queueSeparator(current, next) {
 }
 function normalizeSegmentValue(input) {
   let output = [], pendingSeparator, sanitized = !1;
-  for (let char of input.normalize("NFKD")) {
+  for (let char of input.normalize("NFC").toLowerCase().normalize("NFC")) {
     let code = char.codePointAt(0) ?? 0;
-    if (isCombiningMark(code)) {
-      sanitized = !0;
-      continue;
-    }
-    if (isAsciiAlphaNumeric(code)) {
-      let lower = isUpperAlpha(code) ? char.toLowerCase() : char;
-      pendingSeparator = appendNormalizedChar(output, lower, pendingSeparator), sanitized = sanitized || lower !== char;
+    if (/^[\p{L}\p{M}\p{N}]$/u.test(char)) {
+      pendingSeparator = appendNormalizedChar(output, char, pendingSeparator);
       continue;
     }
     if (char === "." || char === "-") {
@@ -1548,7 +1624,7 @@ function validateSegment(slug, options) {
     isValid: !1
   } : SLUG_SEGMENT_RE.test(slug) ? { isValid: !0 } : {
     code: "SLUG_PATTERN_INVALID",
-    error: 'URL path can only include lowercase letters, numbers, and single "." or "-" separators',
+    error: 'URL path can only include lowercase letters, marks, numbers, and single "." or "-" separators',
     isValid: !1
   } : {
     code: "SLUG_EMPTY",
@@ -1557,7 +1633,7 @@ function validateSegment(slug, options) {
   };
 }
 function normalizeSlugSegmentInternal(input, options = {}) {
-  let maxSegmentLength = options.maxSegmentLength ?? 100, warnings = [], errors = [], trimmed = input.normalize("NFKC").trim(), rawLower = trimmed.toLowerCase();
+  let maxSegmentLength = options.maxSegmentLength ?? 100, warnings = [], errors = [], trimmed = input.normalize("NFC").trim(), rawLower = trimmed.toLowerCase();
   hasPercentEscape(trimmed) && errors.push(
     issue(
       "PATH_PERCENT_ESCAPE_INVALID",
@@ -1576,7 +1652,7 @@ function normalizeSlugSegmentInternal(input, options = {}) {
     )
   );
   let normalized = normalizeSegmentValue(trimmed), value = normalized.value;
-  value.length > maxSegmentLength && (errors.push(
+  value.length > maxSegmentLength && errors.push(
     issue(
       "SLUG_SEGMENT_TOO_LONG",
       `Path segments must be ${maxSegmentLength} characters or less`,
@@ -1585,7 +1661,7 @@ function normalizeSlugSegmentInternal(input, options = {}) {
         segment: input
       }
     )
-  ), value = value.slice(0, maxSegmentLength)), (normalized.sanitized || value !== trimmed) && warnings.push(
+  ), (normalized.sanitized || value !== trimmed) && warnings.push(
     issue("PATH_SEGMENT_NORMALIZED", "Path segment was normalized", {
       from: input,
       to: value
@@ -1606,7 +1682,7 @@ function normalizeSlugSegmentInternal(input, options = {}) {
   };
 }
 function normalizePathParts(input, options = {}) {
-  let warnings = [], errors = [], maxPathLength = options.maxPathLength ?? 512, trimmed = input.normalize("NFKC").trim();
+  let warnings = [], errors = [], maxPathLength = options.maxPathLength ?? 512, trimmed = input.normalize("NFC").trim();
   (/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(trimmed) || /^\/\/[^/]/.test(trimmed)) && errors.push(
     issue(
       "PATH_PROTOCOL_INVALID",
@@ -1653,6 +1729,12 @@ function normalizePathParts(input, options = {}) {
         value: input
       }
     )
+  ), encodeURI(value).length > 2044 && errors.push(
+    issue(
+      "PATH_ENCODED_TOO_LONG",
+      "Encoded path must leave room for the Markdown route within 2048 characters.",
+      { value: input }
+    )
   ), { errors, value, warnings };
 }
 function normalizeSlugPath(input, options = {}) {
@@ -1677,8 +1759,734 @@ function joinUrlPath(parentPath, childPath) {
   return normalizeUrlPath(`${parent}/${childPath}`).value;
 }
 
+// src/lib/runtime/metadata/authored-date.ts
+function authoredDate(value) {
+  if (typeof value != "string" || !/^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2}))?$/.test(
+    value
+  ))
+    return;
+  let day = value.slice(0, 10), midnight = /* @__PURE__ */ new Date(`${day}T00:00:00.000Z`);
+  if (!(!Number.isFinite(midnight.getTime()) || midnight.toISOString().slice(0, 10) !== day))
+    return Number.isFinite(Date.parse(value)) ? value : void 0;
+}
+
+// src/lib/assets/map-source-asset-url.ts
+var SOURCE_ASSET_PATH = "/assets/";
+function hasUnsafeControlCharacters2(value) {
+  for (let character of value) {
+    let code = character.codePointAt(0) ?? 0;
+    if (code <= 31 || code >= 127 && code <= 159) return !0;
+  }
+  return !1;
+}
+function assertSafeAssetPath(path) {
+  if (path.includes("\\") || hasUnsafeControlCharacters2(path))
+    throw new TypeError("Local asset URLs must use safe path segments.");
+  for (let segment of path.split("/")) {
+    if (!segment)
+      throw new TypeError("Local asset URLs must use safe path segments.");
+    let decoded;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+      throw new TypeError("Local asset URLs must use valid URL encoding.");
+    }
+    if (decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\") || hasUnsafeControlCharacters2(decoded))
+      throw new TypeError("Local asset URLs must use safe path segments.");
+  }
+}
+function mapSourceAssetUrl(value) {
+  if (typeof value != "string" || !value.startsWith(SOURCE_ASSET_PATH))
+    return value;
+  let suffixIndex = value.search(/[?#]/u), pathname = suffixIndex < 0 ? value : value.slice(0, suffixIndex), suffix = suffixIndex < 0 ? "" : value.slice(suffixIndex), path = pathname.slice(SOURCE_ASSET_PATH.length);
+  return assertSafeAssetPath(path), `${SOURCE_ASSET_PREFIX}/${path}${suffix}`;
+}
+
+// src/lib/compiler/markdown/convert-mdx-to-markdown.ts
+import remarkGfm from "remark-gfm";
+import remarkMdx2 from "remark-mdx";
+import remarkParse2 from "remark-parse";
+import remarkStringify from "remark-stringify";
+import { unified as unified2 } from "unified";
+
+// src/lib/compiler/markdown/utils.ts
+function text(value) {
+  return { type: "text", value };
+}
+function paragraph(children) {
+  if (children.length !== 0)
+    return { type: "paragraph", children };
+}
+function paragraphBlock(children) {
+  let node = paragraph(children);
+  return node ? [node] : [];
+}
+function strongLabel(value) {
+  return { type: "strong", children: [text(value)] };
+}
+function inlineCode(value) {
+  return { type: "inlineCode", value };
+}
+function normalizeComponentName(name) {
+  return (name ?? "").trim().toLowerCase();
+}
+function addDiagnostic(context, diagnostic) {
+  context.collectDiagnostics && context.diagnostics.push(diagnostic);
+}
+function getAttribute(node, name, context) {
+  let attribute = node.attributes?.find(
+    (candidate) => candidate.name === name
+  );
+  if (attribute) {
+    if (attribute.value === null || attribute.value === void 0) return "true";
+    if (typeof attribute.value == "string") return attribute.value;
+    if (attribute.value.type === "mdxJsxAttributeValueExpression")
+      return decodeExpressionValue(attribute.value.value, name, context);
+    addDiagnostic(context, {
+      code: "mdx-invalid-attribute",
+      componentName: node.name ?? void 0,
+      message: `Unsupported MDX attribute value for "${name}".`
+    });
+  }
+}
+function firstAttribute(node, names, context) {
+  for (let name of names) {
+    let value = getAttribute(node, name, context);
+    if (value?.trim()) return value.trim();
+  }
+}
+function decodeExpressionValue(value, attributeName, context) {
+  let trimmed = value.trim();
+  if (trimmed) {
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'"))
+      try {
+        return JSON.parse(
+          trimmed.startsWith("'") ? `"${trimmed.slice(1, -1).replace(/"/g, '\\"')}"` : trimmed
+        );
+      } catch {
+        return trimmed.slice(1, -1);
+      }
+    return trimmed.startsWith("`") && trimmed.endsWith("`") ? trimmed.slice(1, -1).replace(/\\`/g, "`").replace(/\\n/g, `
+`).replace(/\\t/g, "	") : (addDiagnostic(context, {
+      code: "mdx-invalid-attribute",
+      message: `MDX expression attribute "${attributeName}" was converted to literal text.`
+    }), trimmed);
+  }
+}
+function extractText(nodes) {
+  return nodes.map((node) => {
+    if (node.type === "break") return `
+`;
+    if (node.type === "html" || node.type === "yaml") return "";
+    if ("value" in node && typeof node.value == "string")
+      return node.type === "code" ? `${node.value}
+` : node.value;
+    if ("alt" in node && typeof node.alt == "string") return node.alt;
+    if ("children" in node && Array.isArray(node.children)) {
+      let value = extractText(node.children);
+      return [
+        "emphasis",
+        "strong",
+        "delete",
+        "link",
+        "linkReference"
+      ].includes(node.type) ? value : `${value}
+`;
+    }
+    return "";
+  }).join("").trim();
+}
+function asPhrasing(nodes) {
+  return nodes.flatMap((node) => {
+    if (node.type === "paragraph") return node.children;
+    if (node.type === "text" || node.type === "emphasis" || node.type === "strong" || node.type === "delete" || node.type === "inlineCode" || node.type === "break" || node.type === "link" || node.type === "image" || node.type === "html" || node.type === "footnoteReference")
+      return [node];
+    let label = extractText([node]);
+    return label ? [text(label)] : [];
+  });
+}
+function isBlockNode(node) {
+  return node.type === "paragraph" || node.type === "heading" || node.type === "thematicBreak" || node.type === "blockquote" || node.type === "list" || node.type === "code" || node.type === "html" || node.type === "yaml" || node.type === "definition" || node.type === "footnoteDefinition" || node.type === "table";
+}
+function asBlocks(nodes) {
+  let blocks = [], pendingPhrasing = [];
+  for (let node of nodes)
+    if (isBlockNode(node)) {
+      let pendingParagraph2 = paragraph(pendingPhrasing);
+      pendingParagraph2 && blocks.push(pendingParagraph2), pendingPhrasing = [], blocks.push(node);
+    } else
+      pendingPhrasing.push(node);
+  let pendingParagraph = paragraph(pendingPhrasing);
+  return pendingParagraph && blocks.push(pendingParagraph), blocks;
+}
+function handlerDiagnostic(node, context) {
+  addDiagnostic(context, {
+    code: "mdx-component-converted",
+    componentName: node.name ?? void 0,
+    message: `Converted MDX component "${node.name ?? "unknown"}" to Markdown.`
+  });
+}
+
+// src/lib/compiler/markdown/handlers/callout.ts
+function calloutHandler(node, context, kind) {
+  handlerDiagnostic(node, context);
+  let title = firstAttribute(node, ["title", "label", "type"], context);
+  if (kind === "inline") {
+    let children2 = context.transformChildrenAsPhrasing(node, context);
+    return [
+      ...title ? [strongLabel(`${title}:`), text(" ")] : [],
+      ...children2
+    ];
+  }
+  let children = [];
+  return title && children.push({ type: "paragraph", children: [strongLabel(title)] }), children.push(
+    ...context.transformChildrenAsBlocks(node, context)
+  ), children.length > 0 ? [{ type: "blockquote", children }] : [];
+}
+
+// src/lib/compiler/markdown/handlers/code-block.ts
+function codeBlockHandler(node, context) {
+  handlerDiagnostic(node, context);
+  let code = firstAttribute(node, ["code", "value"], context), language = firstAttribute(node, ["language", "lang"], context), title = firstAttribute(node, ["title"], context);
+  return code !== void 0 ? [{
+    type: "code",
+    lang: language,
+    meta: title === void 0 ? void 0 : `title="${title.replaceAll('"', "&quot;")}"`,
+    value: code
+  }] : context.transformChildrenAsBlocks(node, context);
+}
+function tabHandler(node, context) {
+  handlerDiagnostic(node, context);
+  let label = firstAttribute(
+    node,
+    ["title", "label", "value", "name"],
+    context
+  ), children = context.transformChildrenAsBlocks(node, context);
+  return label ? [
+    { type: "paragraph", children: [strongLabel(`Tab: ${label}`)] },
+    ...children
+  ] : children;
+}
+
+// src/lib/compiler/markdown/handlers/html.ts
+function inlineHtmlHandler(node, context) {
+  handlerDiagnostic(node, context);
+  let children = context.transformChildrenAsPhrasing(node, context);
+  switch (normalizeComponentName(node.name)) {
+    case "strong":
+    case "b":
+      return [{ type: "strong", children }];
+    case "em":
+    case "i":
+      return [{ type: "emphasis", children }];
+    case "code":
+      return [{ type: "inlineCode", value: extractText(children) }];
+    case "br":
+      return [{ type: "break" }];
+    default:
+      return children;
+  }
+}
+function blockquoteHtmlHandler(node, context) {
+  return handlerDiagnostic(node, context), [
+    {
+      type: "blockquote",
+      children: node.type === "mdxJsxTextElement" ? paragraphBlock(context.transformChildrenAsPhrasing(node, context)) : context.transformChildrenAsBlocks(node, context)
+    }
+  ];
+}
+function paragraphHtmlHandler(node, context) {
+  return handlerDiagnostic(node, context), paragraphBlock(context.transformChildrenAsPhrasing(node, context));
+}
+function preformattedText(node, context) {
+  if (node.type === "mdxTextExpression" || node.type === "mdxFlowExpression") {
+    let statement = node.data?.estree?.body?.[0], expression = statement?.type === "ExpressionStatement" ? statement.expression : void 0;
+    return expression?.type === "Literal" && typeof expression.value == "string" ? expression.value : expression?.type === "TemplateLiteral" && expression.expressions?.length === 0 ? expression.quasis?.[0]?.value.cooked ?? "" : (addDiagnostic(context, {
+      code: "mdx-expression-dropped",
+      message: "Dropped non-literal MDX expression from preformatted Markdown output."
+    }), "");
+  }
+  return typeof node.value == "string" ? node.value : (node.children ?? []).map((child, index) => (index > 0 && child.type === "paragraph" ? `
+
+` : "") + preformattedText(child, context)).join("");
+}
+function preHtmlHandler(node, context) {
+  handlerDiagnostic(node, context);
+  let code = node.children?.find((child) => child.name === "code");
+  return [
+    { type: "code", lang: code ? firstAttribute(code, ["className", "class"], context)?.match(
+      /(?:^|\s)language-([^\s]+)/
+    )?.[1] : void 0, value: preformattedText(node, context) }
+  ];
+}
+
+// src/lib/compiler/markdown/handlers/inline.ts
+function iconHandler(node, context) {
+  handlerDiagnostic(node, context);
+  let label = firstAttribute(
+    node,
+    ["aria-label", "label", "title", "alt"],
+    context
+  );
+  return label ? [text(label)] : [];
+}
+function linkHandler(node, context) {
+  let href = firstAttribute(node, ["href", "to", "url"], context);
+  if (!href) return context.transformChildrenAsPhrasing(node, context);
+  handlerDiagnostic(node, context);
+  let children = context.transformChildrenAsPhrasing(node, context);
+  return [{
+    type: "link",
+    url: context.resolveMediaUrl(href),
+    children: children.length > 0 ? children : [text(href)]
+  }];
+}
+function kbdHandler(node, context) {
+  handlerDiagnostic(node, context);
+  let label = extractText(context.transformChildrenAsPhrasing(node, context)) || firstAttribute(node, ["children", "label"], context);
+  return label ? [inlineCode(label)] : [];
+}
+function inlineComponentHandlers() {
+  return [
+    {
+      componentNames: ["icon"],
+      transform: iconHandler
+    },
+    {
+      componentNames: ["a", "link"],
+      transform: linkHandler
+    },
+    {
+      componentNames: ["kbd"],
+      transform: kbdHandler
+    }
+  ];
+}
+
+// src/lib/compiler/markdown/handlers/media.ts
+function imageHandler(node, context, kind) {
+  let src = firstAttribute(node, ["src", "href"], context);
+  if (!src) return [];
+  handlerDiagnostic(node, context);
+  let caption = firstAttribute(node, ["caption"], context), image = {
+    type: "image",
+    url: context.resolveMediaUrl(src),
+    alt: getAttribute(node, "alt", context) ?? firstAttribute(node, ["title", "aria-label"], context) ?? "",
+    title: firstAttribute(node, ["title"], context)
+  };
+  return kind === "inline" ? [image, ...caption ? [text(` ${caption}`)] : []] : [
+    ...paragraphBlock([image]),
+    ...caption ? paragraphBlock([text(caption)]) : []
+  ];
+}
+function figureCaptionHandler(node, context) {
+  return handlerDiagnostic(node, context), node.type === "mdxJsxTextElement" ? paragraphBlock(context.transformChildrenAsPhrasing(node, context)) : context.transformChildrenAsBlocks(node, context);
+}
+function isCaption(node) {
+  return ["figcaption", "figurecaption", "figure.caption"].includes(
+    normalizeComponentName(node.name)
+  );
+}
+function hasDirectCaption(node) {
+  return (node.children ?? []).some(
+    (child) => isCaption(child) || (child.type === "paragraph" || child.type.startsWith("mdxJsx") && child.name === null) && hasDirectCaption(child)
+  );
+}
+function figureHandler(node, context) {
+  handlerDiagnostic(node, context);
+  let children = context.transformChildrenAsBlocks(node, context);
+  if (hasDirectCaption(node)) return children;
+  let caption = firstAttribute(node, ["caption"], context);
+  return [...children, ...caption ? paragraphBlock([text(caption)]) : []];
+}
+function videoHandler(node, context, kind) {
+  let src = firstAttribute(node, ["src", "url", "href"], context);
+  if (!src) return context.transformChildrenAsBlocks(node, context);
+  handlerDiagnostic(node, context);
+  let label = firstAttribute(node, ["title", "alt", "aria-label"], context) ?? "Video", link = {
+    type: "link",
+    url: context.resolveMediaUrl(src),
+    children: [text(label)]
+  }, children = [text("Video: "), link], caption = firstAttribute(node, ["caption"], context);
+  return kind === "inline" ? [...children, ...caption ? [text(` ${caption}`)] : []] : [
+    ...paragraphBlock(children),
+    ...caption ? paragraphBlock([text(caption)]) : []
+  ];
+}
+
+// src/lib/compiler/markdown/handlers/passthrough.ts
+function passthroughBlockHandler(node, context) {
+  return handlerDiagnostic(node, context), context.transformChildrenAsBlocks(node, context);
+}
+function detailsHandler(node, context) {
+  handlerDiagnostic(node, context);
+  let summary = firstAttribute(node, ["summary", "title", "label"], context) ?? "Details";
+  return [
+    { type: "paragraph", children: [strongLabel(summary)] },
+    ...context.transformChildrenAsBlocks(node, context)
+  ];
+}
+
+// src/lib/compiler/markdown/handlers/registry.ts
+var defaultHandlers = [
+  {
+    componentNames: ["image", "img", "picture"],
+    transform: imageHandler
+  },
+  ...inlineComponentHandlers(),
+  {
+    componentNames: ["callout", "admonition", "note", "warning"],
+    transform: calloutHandler
+  },
+  {
+    componentNames: ["codeblock"],
+    transform: codeBlockHandler
+  },
+  {
+    componentNames: ["strong", "b", "em", "i", "code", "span", "br"],
+    transform: inlineHtmlHandler
+  },
+  {
+    componentNames: ["pre"],
+    transform: preHtmlHandler
+  },
+  {
+    componentNames: ["blockquote"],
+    transform: blockquoteHtmlHandler
+  },
+  {
+    componentNames: ["p"],
+    transform: paragraphHtmlHandler
+  },
+  {
+    componentNames: ["div"],
+    transform: passthroughBlockHandler
+  },
+  {
+    componentNames: [
+      "codetab",
+      "codetabs",
+      "tab",
+      "tabpanel",
+      "tabs",
+      "tabscontent"
+    ],
+    transform: tabHandler
+  },
+  {
+    componentNames: ["figure"],
+    transform: figureHandler
+  },
+  {
+    componentNames: ["figcaption", "figurecaption", "figure.caption"],
+    transform: figureCaptionHandler
+  },
+  {
+    componentNames: ["video", "videoiframe", "iframe"],
+    transform: videoHandler
+  },
+  {
+    componentNames: ["details", "accordion", "summary"],
+    transform: detailsHandler
+  },
+  {
+    componentNames: ["step", "steps"],
+    transform: passthroughBlockHandler
+  }
+], handlersByName = new Map(
+  defaultHandlers.flatMap(
+    (handler) => handler.componentNames.map((name) => [name, handler])
+  )
+);
+
+// src/lib/compiler/markdown/convert-mdx-to-markdown.ts
+var processor = unified2().use(remarkParse2).use(remarkMdx2).use(remarkGfm).use(remarkStringify, {
+  bullet: "-",
+  fences: !0,
+  incrementListMarker: !0,
+  listItemIndent: "one",
+  rule: "-"
+});
+function stripHtmlComments(source) {
+  return source.replace(/<!--[\s\S]*?-->/g, "");
+}
+function stripTopLevelImports(source) {
+  return source.split(`
+`).filter((line) => !/^\s*(?:import|export)\s/.test(line)).join(`
+`).trim();
+}
+function parseSource(source, context) {
+  try {
+    return processor.parse(source);
+  } catch (error) {
+    let withoutComments = stripHtmlComments(source);
+    if (withoutComments !== source)
+      try {
+        return processor.parse(withoutComments);
+      } catch {
+      }
+    addDiagnostic(context, {
+      code: "mdx-parse-failed",
+      message: error instanceof Error ? error.message : "Failed to parse MDX for Markdown output."
+    });
+    return;
+  }
+}
+function transformChildrenAsBlocks(node, context) {
+  return (node.children ?? []).flatMap(
+    (child) => transformBlockNode(child, context)
+  );
+}
+function transformChildrenAsPhrasing(node, context) {
+  return (node.children ?? []).flatMap(
+    (child) => transformInlineNode(child, context)
+  );
+}
+function transformMdxElement(node, context, kind) {
+  if (node.name === null)
+    return kind === "block" ? transformChildrenAsBlocks(node, context) : transformChildrenAsPhrasing(node, context);
+  if (node.name && context.importedIcons.has(node.name)) {
+    let label = firstAttribute(node, ["aria-hidden"], context) === "true" ? "" : firstAttribute(node, ["aria-label", "title"], context), children2 = label ? [{ type: "text", value: label }] : [];
+    return kind === "block" ? paragraphBlock(children2) : children2;
+  }
+  let componentName = normalizeComponentName(node.name), handler = handlersByName.get(componentName);
+  if (handler) {
+    let result = handler.transform(node, context, kind);
+    return kind === "block" ? asBlocks(result) : asPhrasing(result);
+  }
+  if (addDiagnostic(context, {
+    code: "mdx-component-unknown",
+    componentName: node.name ?? void 0,
+    message: `Unknown MDX component "${node.name ?? "unknown"}".`
+  }), context.unknownComponentMode === "error")
+    throw new Error(`Unknown MDX component "${node.name ?? "unknown"}".`);
+  if (context.unknownComponentMode === "html") {
+    let html = htmlFallback(node);
+    return html ? [{ type: "html", value: html }] : [];
+  }
+  let children = kind === "inline" ? transformChildrenAsPhrasing(node, context) : transformChildrenAsBlocks(node, context);
+  return kind === "block" ? asBlocks(children) : asPhrasing(children);
+}
+function htmlFallback(node) {
+  if (!node.name) return;
+  let attrs = (node.attributes ?? []).map((attr) => {
+    if (attr.value === null || attr.value === void 0) return attr.name;
+    if (typeof attr.value == "string")
+      return `${attr.name}="${attr.value.replace(/"/g, "&quot;")}"`;
+  }).filter((value) => !!value).join(" ");
+  return `<${node.name}${attrs ? ` ${attrs}` : ""} />`;
+}
+function transformInlineNode(node, context) {
+  if (node.type === "mdxJsxTextElement")
+    return asPhrasing(transformMdxElement(node, context, "inline"));
+  if (node.type === "mdxTextExpression")
+    return addDiagnostic(context, {
+      code: "mdx-expression-dropped",
+      message: "Dropped inline MDX expression from Markdown output."
+    }), [];
+  switch (node.type) {
+    case "text":
+    case "inlineCode":
+    case "break":
+    case "footnoteReference":
+      return [node];
+    case "emphasis":
+      return [{
+        ...node,
+        children: transformChildrenAsPhrasing(node, context)
+      }];
+    case "strong":
+      return [{
+        ...node,
+        children: transformChildrenAsPhrasing(node, context)
+      }];
+    case "delete":
+      return [{
+        ...node,
+        children: transformChildrenAsPhrasing(node, context)
+      }];
+    case "link":
+      return [{
+        ...node,
+        url: context.resolveMediaUrl(node.url),
+        children: transformChildrenAsPhrasing(node, context)
+      }];
+    case "image":
+      return [
+        {
+          ...node,
+          url: context.resolveMediaUrl(node.url)
+        }
+      ];
+    case "linkReference":
+    case "imageReference":
+      return [node];
+    case "html":
+      return [node];
+    default:
+      return [];
+  }
+}
+function transformListItem(node, context) {
+  return {
+    ...node,
+    children: transformChildrenAsBlocks(node, context)
+  };
+}
+function transformTableCell(node, context) {
+  return {
+    ...node,
+    children: transformChildrenAsPhrasing(node, context)
+  };
+}
+function transformTableRow(node, context) {
+  return {
+    ...node,
+    children: (node.children ?? []).map(
+      (child) => transformTableCell(child, context)
+    )
+  };
+}
+function isFigureBlock(node) {
+  if (node.type !== "mdxJsxTextElement" && node.type !== "mdxJsxFlowElement")
+    return !1;
+  if (node.name === null) return (node.children ?? []).some(isFigureBlock);
+  let name = normalizeComponentName(node.name);
+  return [
+    "figure",
+    "figcaption",
+    "figurecaption",
+    "figure.caption",
+    "pre",
+    "blockquote"
+  ].includes(name) || ["image", "img", "video", "videoiframe", "iframe"].includes(name) && (node.attributes ?? []).some((attribute) => attribute.name === "caption");
+}
+function transformBlockNode(node, context) {
+  if (node.type === "mdxjsEsm")
+    return addDiagnostic(context, {
+      code: "mdx-esm-dropped",
+      message: "Dropped MDX import/export from Markdown output."
+    }), [];
+  if (node.type === "mdxFlowExpression")
+    return addDiagnostic(context, {
+      code: "mdx-expression-dropped",
+      message: "Dropped flow MDX expression from Markdown output."
+    }), [];
+  if (node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement")
+    return transformMdxElement(node, context, "block");
+  switch (node.type) {
+    case "paragraph": {
+      if ((node.children ?? []).some(isFigureBlock)) {
+        let blocks = [], pending = [], flushPhrasing = () => {
+          let children = transformChildrenAsPhrasing(
+            { type: "paragraph", children: pending },
+            context
+          );
+          children.some(
+            (child) => child.type !== "text" || child.value.trim()
+          ) && blocks.push(...paragraphBlock(children)), pending = [];
+        };
+        for (let child of node.children ?? [])
+          isFigureBlock(child) ? (flushPhrasing(), blocks.push(...transformBlockNode(child, context))) : pending.push(child);
+        return flushPhrasing(), blocks;
+      }
+      let paragraphNode = paragraph(
+        transformChildrenAsPhrasing(node, context)
+      );
+      return paragraphNode ? [paragraphNode] : [];
+    }
+    case "heading":
+      return [{
+        ...node,
+        children: transformChildrenAsPhrasing(node, context)
+      }];
+    case "blockquote":
+      return [
+        {
+          ...node,
+          children: transformChildrenAsBlocks(node, context)
+        }
+      ];
+    case "list":
+      return [{
+        ...node,
+        children: (node.children ?? []).map(
+          (child) => transformListItem(child, context)
+        )
+      }];
+    case "table":
+      return [{
+        ...node,
+        children: (node.children ?? []).map(
+          (child) => transformTableRow(child, context)
+        )
+      }];
+    case "text":
+    case "inlineCode":
+    case "break":
+    case "emphasis":
+    case "strong":
+    case "delete":
+    case "link":
+    case "image":
+    case "footnoteReference":
+      return paragraphBlock(transformInlineNode(node, context));
+    case "code":
+    case "thematicBreak":
+    case "html":
+    case "yaml":
+    case "footnoteDefinition":
+      return [node];
+    case "definition":
+      return [
+        {
+          ...node,
+          url: context.resolveMediaUrl(node.url)
+        }
+      ];
+    default:
+      return [];
+  }
+}
+function convertMdxToMarkdown(options) {
+  let context = {
+    importedIcons: /* @__PURE__ */ new Set(),
+    collectDiagnostics: options.collectDiagnostics ?? !0,
+    diagnostics: [],
+    resolveMediaUrl: (url) => String(mapSourceAssetUrl(url)),
+    transformChildrenAsBlocks,
+    transformChildrenAsPhrasing,
+    unknownComponentMode: options.unknownComponentMode ?? "children"
+  }, parsed = parseSource(options.source, context);
+  if (!parsed)
+    return {
+      diagnostics: context.diagnostics,
+      markdown: stripTopLevelImports(options.source),
+      text: ""
+    };
+  for (let node of parsed.children)
+    if (node.type === "mdxjsEsm") {
+      for (let statement of node.data?.estree?.body ?? [])
+        if (!(statement.type !== "ImportDeclaration" || statement.source.value !== mdxIconPackage))
+          for (let specifier of statement.specifiers)
+            specifier.type === "ImportSpecifier" && context.importedIcons.add(specifier.local.name);
+    }
+  let transformed = {
+    type: "root",
+    children: parsed.children.flatMap(
+      (child) => transformBlockNode(child, context)
+    )
+  }, markdown = String(processor.stringify(transformed)).trim();
+  return {
+    diagnostics: context.diagnostics,
+    markdown,
+    text: extractText(transformed.children)
+  };
+}
+
 export {
-  UnsupportedFrontmatterLanguageError,
+  mapSourceAssetUrl,
+  FrontmatterParseError,
   parseSourceFrontmatter,
   groupedMdxExports,
   replacedMdxSourceFiles,
@@ -1689,6 +2497,7 @@ export {
   MdxIconImportError,
   readMdxIconImports,
   validateMdxIconImports,
+  convertMdxToMarkdown,
   ROOT_CONTENT_GROUP_KEY,
   ROOT_CONTENT_GROUP_TITLE,
   assertSourceDependency,
@@ -1705,5 +2514,6 @@ export {
   mediaManifestModule,
   normalizeSlugPath,
   normalizeUrlPath,
-  joinUrlPath
+  joinUrlPath,
+  authoredDate
 };