@mui/internal-docs-infra 0.2.3-canary.9 → 0.3.1-canary.0

package/esm/pipeline/syncPageIndex/metadataToMarkdown.js

@@ -0,0 +1,1486 @@
+import _regenerator from "@babel/runtime/helpers/esm/regenerator";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+var _excluded = ["position"];
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import { visit } from 'unist-util-visit';
+import { heading, paragraph, text, link, comment } from "./createMarkdownNodes.js";
+
+// Definition nodes are used for markdown-style comments like [//]: # "Comment text"
+
+/**
+ * Converts AST nodes (from heading.children) back to markdown string
+ */
+function astNodesToMarkdown(nodes) {
+  var result = '';
+  var _iterator = _createForOfIteratorHelper(nodes),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var node = _step.value;
+      if (node.type === 'text') {
+        result += node.value;
+      } else if (node.type === 'inlineCode') {
+        result += "`".concat(node.value, "`");
+      } else if (node.type === 'emphasis') {
+        result += "*".concat(astNodesToMarkdown(node.children), "*");
+      } else if (node.type === 'strong') {
+        result += "**".concat(astNodesToMarkdown(node.children), "**");
+      } else if (node.type === 'link') {
+        result += "[".concat(astNodesToMarkdown(node.children), "](").concat(node.url, ")");
+      } else if ('children' in node) {
+        result += astNodesToMarkdown(node.children);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+}
+
+/**
+ * Options for metadataToMarkdown and metadataToMarkdownAst functions
+ */
+
+/**
+ * Converts a HeadingHierarchy into markdown list format
+ */
+function headingHierarchyToMarkdown(hierarchy, basePath) {
+  var depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var result = '';
+  var indent = '  '.repeat(depth);
+  for (var _i = 0, _Object$values = Object.values(hierarchy); _i < _Object$values.length; _i++) {
+    var node = _Object$values[_i];
+    var titleMarkdown = node.titleMarkdown,
+      children = node.children;
+    // Convert AST nodes back to markdown string with preserved formatting
+    var titleString = astNodesToMarkdown(titleMarkdown);
+
+    // Escape numbered list syntax (e.g., "1. Text" -> "1\. Text")
+    // This prevents markdown from treating "- 1. Text" as a nested ordered list
+    titleString = titleString.replace(/^(\d+)\.\s/, '$1\\. ');
+    result += "".concat(indent, "- ").concat(titleString, "\n");
+    if (Object.keys(children).length > 0) {
+      result += headingHierarchyToMarkdown(children, basePath, depth + 1);
+    }
+  }
+  return result;
+}
+
+/**
+ * Converts a HeadingHierarchy into markdown AST list nodes
+ */
+function headingHierarchyToListNodes(hierarchy, basePath) {
+  var listItems = [];
+  for (var _i2 = 0, _Object$values2 = Object.values(hierarchy); _i2 < _Object$values2.length; _i2++) {
+    var node = _Object$values2[_i2];
+    var titleMarkdown = node.titleMarkdown,
+      children = node.children;
+    var listItem = {
+      type: 'listItem',
+      children: [{
+        type: 'paragraph',
+        children: titleMarkdown // Use the preserved AST nodes directly
+      }]
+    };
+
+    // Add nested children if they exist
+    if (Object.keys(children).length > 0) {
+      var nestedList = {
+        type: 'list',
+        ordered: false,
+        children: headingHierarchyToListNodes(children, basePath)
+      };
+      listItem.children.push(nestedList);
+    }
+    listItems.push(listItem);
+  }
+  return listItems;
+}
+
+/**
+ * Strips position metadata from AST nodes recursively
+ */
+function stripPositions(nodes) {
+  return nodes.map(function (node) {
+    var position = node.position,
+      rest = _objectWithoutPropertiesLoose(node, _excluded);
+    if (rest.children) {
+      rest.children = stripPositions(rest.children);
+    }
+    return rest;
+  });
+}
+
+/**
+ * Parses exports metadata from a nested list structure
+ * Expects format:
+ * - Exports:
+ *   - ComponentName - PartName
+ *     - Props: a, b, c
+ *     - Data Attributes: x, y
+ *     - CSS Variables: --var1, --var2
+ */
+function parseExportsFromListItem(listItem) {
+  var _listItem$children;
+  var exports = {};
+  var parts = {};
+
+  // Find the nested list within this list item
+  var nestedList = (_listItem$children = listItem.children) == null ? void 0 : _listItem$children.find(function (child) {
+    return child.type === 'list';
+  });
+  if (!(nestedList != null && nestedList.children)) {
+    return {
+      exports: exports
+    };
+  }
+
+  // Parse each export/part item from the nested list
+  var _iterator2 = _createForOfIteratorHelper(nestedList.children),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _exportListItem$child, _exportParagraph$chil, _exportListItem$child2;
+      var exportListItem = _step2.value;
+      if (exportListItem.type !== 'listItem') {
+        continue;
+      }
+
+      // Find the paragraph with the export/part name
+      var exportParagraph = (_exportListItem$child = exportListItem.children) == null ? void 0 : _exportListItem$child.find(function (child) {
+        return child.type === 'paragraph';
+      });
+      if (!exportParagraph) {
+        continue;
+      }
+
+      // Extract the name from the text node
+      var textNode = (_exportParagraph$chil = exportParagraph.children) == null ? void 0 : _exportParagraph$chil.find(function (child) {
+        return child.type === 'text';
+      });
+      if (!textNode) {
+        continue;
+      }
+      var fullName = textNode.value || '';
+
+      // Check if this is a part (has dash) or export (no dash)
+      var hasDash = fullName.includes(' - ');
+
+      // Find the nested list with props/dataAttributes/cssVariables
+      var metadataList = (_exportListItem$child2 = exportListItem.children) == null ? void 0 : _exportListItem$child2.find(function (child) {
+        return child.type === 'list';
+      });
+
+      // Initialize the metadata (only add properties that have content)
+      var metadata = {};
+      if (metadataList) {
+        // Parse each metadata item
+        var _iterator3 = _createForOfIteratorHelper(metadataList.children),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var _metadataItem$childre;
+            var metadataItem = _step3.value;
+            if (metadataItem.type !== 'listItem') {
+              continue;
+            }
+            var metadataParagraph = (_metadataItem$childre = metadataItem.children) == null ? void 0 : _metadataItem$childre.find(function (child) {
+              return child.type === 'paragraph';
+            });
+            if (!metadataParagraph) {
+              continue;
+            }
+            var metadataText = extractPlainTextFromNode(metadataParagraph);
+            if (metadataText.startsWith('Props:')) {
+              var propsText = metadataText.replace('Props:', '').trim();
+              if (propsText) {
+                metadata.props = propsText.split(',').map(function (p) {
+                  return p.trim();
+                });
+              }
+            } else if (metadataText.startsWith('Data Attributes:')) {
+              var dataAttributesText = metadataText.replace('Data Attributes:', '').trim();
+              if (dataAttributesText) {
+                metadata.dataAttributes = dataAttributesText.split(',').map(function (attr) {
+                  return attr.trim();
+                });
+              }
+            } else if (metadataText.startsWith('CSS Variables:')) {
+              var cssVariablesText = metadataText.replace('CSS Variables:', '').trim();
+              if (cssVariablesText) {
+                metadata.cssVariables = cssVariablesText.split(',').map(function (cssVar) {
+                  return cssVar.trim();
+                });
+              }
+            }
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+      }
+      if (hasDash) {
+        // This is a part name (e.g., "ComponentName - PartName")
+        var partName = fullName.split(' - ').pop() || fullName;
+        // Always add the part, even if it has no properties
+        parts[partName] = metadata;
+      } else {
+        // This is an export name (no dash)
+        var exportName = fullName;
+        // Always add the export, even if it has no properties
+        exports[exportName] = metadata;
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return {
+    exports: Object.keys(exports).length > 0 ? exports : undefined,
+    parts: Object.keys(parts).length > 0 ? parts : undefined
+  };
+}
+
+/**
+ * Parses a list of section links back into a HeadingHierarchy structure
+ * Expects list items with links in the format: [Title](path#slug)
+ * OR plain text in the format: Title
+ */
+function parseHeadingSections(listNode) {
+  var hierarchy = {};
+  var stack = [{
+    depth: -1,
+    node: hierarchy
+  }];
+
+  // Helper to calculate depth from list nesting
+  function processListItems(items, baseDepth) {
+    var parentIsOrdered = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var startIndex = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
+    for (var i = 0; i < items.length; i += 1) {
+      var _item$children, _itemParagraph$childr;
+      var item = items[i];
+      if (item.type !== 'listItem') {
+        continue;
+      }
+
+      // Find the paragraph content
+      var itemParagraph = (_item$children = item.children) == null ? void 0 : _item$children.find(function (child) {
+        return child.type === 'paragraph';
+      });
+      if (!itemParagraph) {
+        continue;
+      }
+
+      // Try to find a link first (linked format)
+      var itemLink = itemParagraph == null || (_itemParagraph$childr = itemParagraph.children) == null ? void 0 : _itemParagraph$childr.find(function (child) {
+        return child.type === 'link';
+      });
+      var title = '';
+      var titleMarkdown = [];
+      var slug = '';
+      if (itemLink) {
+        var _itemLink$children;
+        // Linked format: [Title](path#slug)
+        title = ((_itemLink$children = itemLink.children) == null || (_itemLink$children = _itemLink$children[0]) == null ? void 0 : _itemLink$children.value) || '';
+        // Strip position metadata from titleMarkdown
+        titleMarkdown = stripPositions(itemLink.children || []);
+        var url = itemLink.url || '';
+        slug = url.split('#')[1] || '';
+      } else {
+        // Plain text format: extract all children (preserves formatting)
+        // Strip position metadata from titleMarkdown
+        titleMarkdown = stripPositions(itemParagraph.children || []);
+
+        // Extract plain text for slug generation
+        var rawTitle = itemParagraph.children.map(function (child) {
+          if (child.type === 'text') {
+            return child.value;
+          }
+          if (child.type === 'inlineCode') {
+            return child.value;
+          }
+          if ('children' in child) {
+            // Recursively extract text from nested nodes
+            return astNodesToMarkdown(child.children).replace(/[*`_]/g, '');
+          }
+          return '';
+        }).join('').trim();
+
+        // Unescape numbered list syntax (e.g., "1\. Text" -> "1. Text")
+        // This handles titles that were escaped during serialization
+        rawTitle = rawTitle.replace(/^(\d+)\\\.\s/, '$1. ');
+
+        // If this is from an ordered list, prepend the number
+        if (parentIsOrdered) {
+          var itemNumber = startIndex + i;
+          title = "".concat(itemNumber, ". ").concat(rawTitle);
+          // Update titleMarkdown to include the number
+          titleMarkdown = [{
+            type: 'text',
+            value: title
+          }];
+        } else {
+          title = rawTitle;
+        }
+
+        // Generate slug from the title (with number if applicable)
+        slug = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+      }
+      if (title && slug && titleMarkdown.length > 0) {
+        var _item$children2;
+        // Pop stack until we find the parent at the right depth
+        while (stack.length > 0 && stack[stack.length - 1].depth >= baseDepth) {
+          stack.pop();
+        }
+        var parent = stack[stack.length - 1].node;
+        var newNode = {
+          title: title,
+          titleMarkdown: titleMarkdown,
+          children: {}
+        };
+        parent[slug] = newNode;
+        stack.push({
+          depth: baseDepth,
+          node: newNode.children
+        });
+
+        // Check for nested lists (can be ordered or unordered)
+        var nestedLists = (_item$children2 = item.children) == null ? void 0 : _item$children2.filter(function (child) {
+          return child.type === 'list';
+        });
+        var _iterator4 = _createForOfIteratorHelper(nestedLists || []),
+          _step4;
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var nestedList = _step4.value;
+            if (nestedList.children) {
+              var nestedIsOrdered = nestedList.ordered === true;
+              var nestedStart = nestedList.start || 1;
+              // Always increment depth for true nesting
+              processListItems(nestedList.children, baseDepth + 1, nestedIsOrdered, nestedStart);
+            }
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+      }
+    }
+  }
+  if ((listNode == null ? void 0 : listNode.type) === 'list' && listNode.children) {
+    processListItems(listNode.children, 0);
+  }
+  return hierarchy;
+} /**
+  * Converts an array of page metadata into a markdown AST
+  */
+export function metadataToMarkdownAst(data) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var editableMarker = options.editableMarker,
+    indexWrapperComponent = options.indexWrapperComponent,
+    path = options.path;
+  var mainTitle = data.title,
+    mainDescription = data.description,
+    pages = data.pages,
+    pageMetadata = data.pageMetadata;
+  var children = [];
+
+  // Add main title
+  children.push(heading(1, mainTitle));
+
+  // Add description if provided (editable section)
+  if (mainDescription) {
+    children.push(paragraph(mainDescription));
+  }
+
+  // Add editable section marker
+  // Extract just the comment text from the marker (strip [//]: # 'text' wrapper)
+  var defaultMarkerText = 'This file is autogenerated, but the following list can be modified.';
+  var markerText = defaultMarkerText;
+  if (editableMarker) {
+    // Extract text between single quotes: [//]: # 'text'
+    var match = editableMarker.match(/\[\/\/\]: # '(.+)'/);
+    markerText = match ? match[1] : defaultMarkerText;
+  }
+  children.push(comment(markerText));
+
+  // Open wrapper component if provided
+  if (indexWrapperComponent) {
+    children.push({
+      type: 'html',
+      value: "<".concat(indexWrapperComponent, ">")
+    });
+  }
+
+  // Add page list (editable section) as proper list items
+  var listItems = [];
+  var _iterator5 = _createForOfIteratorHelper(pages),
+    _step5;
+  try {
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var _page$openGraph;
+      var page = _step5.value;
+      var pageTitle = ((_page$openGraph = page.openGraph) == null ? void 0 : _page$openGraph.title) || page.title || page.slug;
+
+      // Check if this is a single-link entry (external link or no detail section)
+      var isSingleLink = page.skipDetailSection || false;
+      var paragraphChildren = void 0;
+      if (isSingleLink) {
+        // Format: - [Title](./path) [Tag1] [Tag2]
+        paragraphChildren = [link(page.path, pageTitle)];
+
+        // Add tags if present (directly after link)
+        if (page.tags && page.tags.length > 0) {
+          var _iterator7 = _createForOfIteratorHelper(page.tags),
+            _step7;
+          try {
+            for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+              var tag = _step7.value;
+              paragraphChildren.push(text(" [".concat(tag, "]")));
+            }
+          } catch (err) {
+            _iterator7.e(err);
+          } finally {
+            _iterator7.f();
+          }
+        }
+      } else {
+        // Format: - [Title](#slug) [Tag1] [Tag2] - [Full Docs](./path/page.mdx)
+        paragraphChildren = [link("#".concat(page.slug), pageTitle)];
+
+        // Add tags if present (directly after component name)
+        if (page.tags && page.tags.length > 0) {
+          var _iterator8 = _createForOfIteratorHelper(page.tags),
+            _step8;
+          try {
+            for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+              var _tag = _step8.value;
+              paragraphChildren.push(text(" [".concat(_tag, "]")));
+            }
+          } catch (err) {
+            _iterator8.e(err);
+          } finally {
+            _iterator8.f();
+          }
+        }
+
+        // Add separator and Full Docs link
+        paragraphChildren.push(text(' - '));
+        paragraphChildren.push(link(page.path, 'Full Docs'));
+      }
+      listItems.push({
+        type: 'listItem',
+        spread: false,
+        children: [paragraph(paragraphChildren)]
+      });
+    }
+
+    // Add the list to children
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
+  }
+  children.push({
+    type: 'list',
+    ordered: false,
+    spread: false,
+    children: listItems
+  });
+
+  // Add non-editable section marker
+  // Trim common prefixes and suffixes from path, quote if contains parentheses for shell safety
+  var trimmedPath = path == null ? void 0 : path.replace(/^(src\/app\/|app\/)/, '').replace(/\/page\.mdx$/, '');
+  var quotedPath = trimmedPath && /[()]/.test(trimmedPath) ? "\"".concat(trimmedPath, "\"") : trimmedPath;
+  var doNotEditComment = quotedPath ? "This file is autogenerated, DO NOT EDIT AFTER THIS LINE, run: pnpm docs:validate ".concat(quotedPath) : 'This file is autogenerated, DO NOT EDIT AFTER THIS LINE';
+  children.push(comment(doNotEditComment));
+
+  // Add detailed page sections (non-editable)
+  var _iterator6 = _createForOfIteratorHelper(pages),
+    _step6;
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var _page$openGraph2, _page$openGraph3, _page$openGraph4;
+      var _page = _step6.value;
+      var _pageTitle = ((_page$openGraph2 = _page.openGraph) == null ? void 0 : _page$openGraph2.title) || _page.title || _page.slug;
+      // Note: We don't replace newlines here to allow natural line breaks in detailed sections
+      var description = ((_page$openGraph3 = _page.openGraph) == null ? void 0 : _page$openGraph3.description) || _page.description || 'No description available';
+      var keywords = _page.keywords || [];
+      var image = (_page$openGraph4 = _page.openGraph) == null || (_page$openGraph4 = _page$openGraph4.images) == null ? void 0 : _page$openGraph4[0];
+
+      // Add page heading
+      children.push(heading(2, _pageTitle));
+
+      // Add description
+      children.push(paragraph(description));
+
+      // Add image if available
+      if (image) {
+        children.push({
+          type: 'paragraph',
+          children: [{
+            type: 'image',
+            url: image.url,
+            alt: image.alt || _pageTitle
+          }]
+        });
+      }
+
+      // Add metadata list (keywords, sections, parts, and exports combined)
+      var hasKeywords = keywords.length > 0;
+      var hasSections = _page.sections && Object.keys(_page.sections).length > 0;
+      var hasParts = _page.parts && Object.keys(_page.parts).length > 0;
+      var hasExports = _page.exports && Object.keys(_page.exports).length > 0;
+      if (hasKeywords || hasSections || hasParts || hasExports) {
+        var metadataListItems = [];
+        if (hasKeywords) {
+          metadataListItems.push({
+            type: 'listItem',
+            children: [paragraph("Keywords: ".concat(keywords.join(', ')))]
+          });
+        }
+        if (hasSections && _page.sections) {
+          var sectionListItems = headingHierarchyToListNodes(_page.sections, _page.path);
+          metadataListItems.push({
+            type: 'listItem',
+            children: [paragraph('Sections:'), {
+              type: 'list',
+              ordered: false,
+              children: sectionListItems
+            }]
+          });
+        }
+        if (hasParts || hasExports) {
+          var exportsListItems = [];
+
+          // First, add all parts with their metadata (use dash format)
+          if (hasParts && _page.parts) {
+            for (var _i3 = 0, _Object$entries = Object.entries(_page.parts); _i3 < _Object$entries.length; _i3++) {
+              var _Object$entries$_i = _slicedToArray(_Object$entries[_i3], 2),
+                partName = _Object$entries$_i[0],
+                partMetadata = _Object$entries$_i[1];
+              var partListItems = [];
+              if (partMetadata.props && partMetadata.props.length > 0) {
+                partListItems.push({
+                  type: 'listItem',
+                  children: [paragraph("Props: ".concat(partMetadata.props.join(', ')))]
+                });
+              }
+              if (partMetadata.dataAttributes && partMetadata.dataAttributes.length > 0) {
+                partListItems.push({
+                  type: 'listItem',
+                  children: [paragraph("Data Attributes: ".concat(partMetadata.dataAttributes.join(', ')))]
+                });
+              }
+              if (partMetadata.cssVariables && partMetadata.cssVariables.length > 0) {
+                partListItems.push({
+                  type: 'listItem',
+                  children: [paragraph("CSS Variables: ".concat(partMetadata.cssVariables.join(', ')))]
+                });
+              }
+
+              // Add the part with dash separator
+              if (partListItems.length > 0) {
+                exportsListItems.push({
+                  type: 'listItem',
+                  children: [{
+                    type: 'paragraph',
+                    children: [{
+                      type: 'text',
+                      value: "".concat(_page.title, " - ").concat(partName)
+                    }]
+                  }, {
+                    type: 'list',
+                    ordered: false,
+                    children: partListItems
+                  }]
+                });
+              } else {
+                // Part with no properties - just add the part name with dash
+                exportsListItems.push({
+                  type: 'listItem',
+                  children: [{
+                    type: 'paragraph',
+                    children: [{
+                      type: 'text',
+                      value: "".concat(_page.title, " - ").concat(partName)
+                    }]
+                  }]
+                });
+              }
+            }
+          }
+
+          // Then add all exports with their metadata (no dash format)
+          if (hasExports && _page.exports) {
+            for (var _i4 = 0, _Object$entries2 = Object.entries(_page.exports); _i4 < _Object$entries2.length; _i4++) {
+              var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i4], 2),
+                exportName = _Object$entries2$_i[0],
+                exportMetadata = _Object$entries2$_i[1];
+              var exportListItems = [];
+              if (exportMetadata.props && exportMetadata.props.length > 0) {
+                exportListItems.push({
+                  type: 'listItem',
+                  children: [paragraph("Props: ".concat(exportMetadata.props.join(', ')))]
+                });
+              }
+              if (exportMetadata.dataAttributes && exportMetadata.dataAttributes.length > 0) {
+                exportListItems.push({
+                  type: 'listItem',
+                  children: [paragraph("Data Attributes: ".concat(exportMetadata.dataAttributes.join(', ')))]
+                });
+              }
+              if (exportMetadata.cssVariables && exportMetadata.cssVariables.length > 0) {
+                exportListItems.push({
+                  type: 'listItem',
+                  children: [paragraph("CSS Variables: ".concat(exportMetadata.cssVariables.join(', ')))]
+                });
+              }
+
+              // Always add the export, even if it has no properties
+              if (exportListItems.length > 0) {
+                exportsListItems.push({
+                  type: 'listItem',
+                  children: [{
+                    type: 'paragraph',
+                    children: [{
+                      type: 'text',
+                      value: exportName
+                    }]
+                  }, {
+                    type: 'list',
+                    ordered: false,
+                    children: exportListItems
+                  }]
+                });
+              } else {
+                // Export with no properties - just add the export name
+                exportsListItems.push({
+                  type: 'listItem',
+                  children: [{
+                    type: 'paragraph',
+                    children: [{
+                      type: 'text',
+                      value: exportName
+                    }]
+                  }]
+                });
+              }
+            }
+          }
+          if (exportsListItems.length > 0) {
+            metadataListItems.push({
+              type: 'listItem',
+              children: [paragraph('Exports:'), {
+                type: 'list',
+                ordered: false,
+                children: exportsListItems
+              }]
+            });
+          }
+        }
+
+        // Wrap metadata in details/summary tags
+        children.push({
+          type: 'html',
+          value: '<details>'
+        });
+        children.push(paragraph(''));
+        children.push({
+          type: 'html',
+          value: '<summary>Outline</summary>'
+        });
+        children.push(paragraph(''));
+        children.push({
+          type: 'list',
+          ordered: false,
+          children: metadataListItems
+        });
+        children.push(paragraph(''));
+        children.push({
+          type: 'html',
+          value: '</details>'
+        });
+      }
+
+      // Add embeddings as a comment if available
+      if (_page.embeddings && _page.embeddings.length > 0) {
+        children.push(comment("Embeddings: ".concat(JSON.stringify(_page.embeddings))));
+      }
+
+      // Add read more link
+      children.push(paragraph([link(_page.path, 'Read more')]));
+    }
+
+    // Close wrapper component if provided
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
+  }
+  if (indexWrapperComponent) {
+    children.push({
+      type: 'html',
+      value: "</".concat(indexWrapperComponent, ">")
+    });
+  }
+
+  // Add metadata export at the end
+  children.push(comment('This file is autogenerated, but the following metadata can be modified.'));
+  var metadataCode;
+  if (pageMetadata && Object.keys(pageMetadata).length > 0) {
+    metadataCode = "export const metadata = ".concat(JSON.stringify(pageMetadata, null, 2), ";");
+  } else {
+    // Default metadata with robots noindex
+    metadataCode = "export const metadata = {\n  robots: {\n    index: false,\n  },\n};";
+  }
+  // Output as raw MDX/JSX code (mdxjsEsm node type)
+  children.push({
+    type: 'mdxjsEsm',
+    value: metadataCode
+  });
+  return {
+    type: 'root',
+    children: children
+  };
+}
+
+/**
+ * Converts an array of page metadata into the markdown format (string)
+ */
+export function metadataToMarkdown(data) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  // Support legacy signature where second param was editableMarker string
+  var normalizedOptions = typeof options === 'string' ? {
+    editableMarker: options
+  } : options;
+  var editableMarker = normalizedOptions.editableMarker,
+    indexWrapperComponent = normalizedOptions.indexWrapperComponent,
+    path = normalizedOptions.path;
+  var title = data.title,
+    description = data.description,
+    pages = data.pages,
+    pageMetadata = data.pageMetadata;
+  var lines = [];
+
+  // Add main title
+  lines.push("# ".concat(title));
+  lines.push('');
+
+  // Add description if provided (editable section)
+  if (description) {
+    lines.push(description);
+    lines.push('');
+  }
+
+  // Add editable section marker
+  var marker = editableMarker != null ? editableMarker : "[//]: # 'This file is autogenerated, but the following list can be modified.'";
+  lines.push(marker);
+  lines.push('');
+
+  // Open wrapper component if provided
+  if (indexWrapperComponent) {
+    lines.push("<".concat(indexWrapperComponent, ">"));
+    lines.push('');
+  }
+
+  // Add page list (editable section)
+  var _iterator9 = _createForOfIteratorHelper(pages),
+    _step9;
+  try {
+    for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+      var _page$openGraph5;
+      var page = _step9.value;
+      var pageTitle = ((_page$openGraph5 = page.openGraph) == null ? void 0 : _page$openGraph5.title) || page.title || page.slug;
+
+      // Check if this is a single-link entry (external link or no detail section)
+      var isSingleLink = page.skipDetailSection || false;
+      var line = void 0;
+      if (isSingleLink) {
+        // Format: - [Title](./path) [Tag1] [Tag2]
+        line = "- [".concat(pageTitle, "](").concat(page.path, ")");
+
+        // Add tags if present (directly after link)
+        if (page.tags && page.tags.length > 0) {
+          var _iterator1 = _createForOfIteratorHelper(page.tags),
+            _step1;
+          try {
+            for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
+              var tag = _step1.value;
+              line += " [".concat(tag, "]");
+            }
+          } catch (err) {
+            _iterator1.e(err);
+          } finally {
+            _iterator1.f();
+          }
+        }
+      } else {
+        // Format: - [Title](#slug) [Tag1] [Tag2] - [Full Docs](./path/page.mdx)
+        line = "- [".concat(pageTitle, "](#").concat(page.slug, ")");
+
+        // Add tags if present (directly after component name)
+        if (page.tags && page.tags.length > 0) {
+          var _iterator10 = _createForOfIteratorHelper(page.tags),
+            _step10;
+          try {
+            for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+              var _tag2 = _step10.value;
+              line += " [".concat(_tag2, "]");
+            }
+          } catch (err) {
+            _iterator10.e(err);
+          } finally {
+            _iterator10.f();
+          }
+        }
+
+        // Add separator and Full Docs link
+        line += " - [Full Docs](".concat(page.path, ")");
+      }
+      lines.push(line);
+    }
+  } catch (err) {
+    _iterator9.e(err);
+  } finally {
+    _iterator9.f();
+  }
+  lines.push('');
+
+  // Add non-editable section marker
+  // Trim common prefixes and suffixes from path, quote if contains parentheses for shell safety
+  var trimmedPath = path == null ? void 0 : path.replace(/^(src\/app\/|app\/)/, '').replace(/\/page\.mdx$/, '');
+  var quotedPath = trimmedPath && /[()]/.test(trimmedPath) ? "\"".concat(trimmedPath, "\"") : trimmedPath;
+  var doNotEditMarker = quotedPath ? "[//]: # 'This file is autogenerated, DO NOT EDIT AFTER THIS LINE, run: pnpm docs:validate ".concat(quotedPath, "'") : "[//]: # 'This file is autogenerated, DO NOT EDIT AFTER THIS LINE'";
+  lines.push(doNotEditMarker);
+  lines.push('');
+
+  // Add detailed page sections (non-editable)
+  var _iterator0 = _createForOfIteratorHelper(pages),
+    _step0;
+  try {
+    for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
+      var _page2$openGraph, _page2$openGraph3;
+      var _page2 = _step0.value;
+      // Skip detail section for single-link entries (external links)
+      if (_page2.skipDetailSection) {
+        continue;
+      }
+      var _pageTitle2 = ((_page2$openGraph = _page2.openGraph) == null ? void 0 : _page2$openGraph.title) || _page2.title || _page2.slug;
+      // Use descriptionMarkdown to preserve formatting if available
+      // Note: We don't replace newlines here to allow natural line breaks in detailed sections
+      var pageDescription = void 0;
+      if (_page2.descriptionMarkdown && _page2.descriptionMarkdown.length > 0) {
+        pageDescription = astNodesToMarkdown(_page2.descriptionMarkdown);
+      } else {
+        var _page2$openGraph2;
+        pageDescription = ((_page2$openGraph2 = _page2.openGraph) == null ? void 0 : _page2$openGraph2.description) || _page2.description || 'No description available';
+      }
+      var keywords = _page2.keywords || [];
+      var image = (_page2$openGraph3 = _page2.openGraph) == null || (_page2$openGraph3 = _page2$openGraph3.images) == null ? void 0 : _page2$openGraph3[0];
+
+      // Add page heading
+      lines.push("## ".concat(_pageTitle2));
+      lines.push('');
+
+      // Add description
+      lines.push(pageDescription);
+      lines.push('');
+
+      // Add image if available
+      if (image) {
+        lines.push("![".concat(image.alt || _pageTitle2, "](").concat(image.url, ")"));
+        lines.push('');
+      }
+
+      // Add metadata list (keywords, sections, parts, and exports)
+      var hasKeywords = keywords.length > 0;
+      var hasSections = _page2.sections && Object.keys(_page2.sections).length > 0;
+      var hasParts = _page2.parts && Object.keys(_page2.parts).length > 0;
+      var hasExports = _page2.exports && Object.keys(_page2.exports).length > 0;
+
+      // Track if we actually add any metadata content
+      var hasMetadataContent = false;
+      if (hasKeywords || hasSections || hasParts || hasExports) {
+        lines.push('<details>');
+        lines.push('');
+        lines.push('<summary>Outline</summary>');
+        lines.push('');
+        if (hasKeywords) {
+          lines.push("- Keywords: ".concat(keywords.join(', ')));
+          hasMetadataContent = true;
+        }
+        if (hasSections && _page2.sections) {
+          var sectionLines = headingHierarchyToMarkdown(_page2.sections, _page2.path, 1); // Start at depth 1 for indentation
+          lines.push('- Sections:');
+          lines.push(sectionLines.trimEnd());
+          hasMetadataContent = true;
+        }
+        // Handle both parts and exports
+        // Parts and exports are combined into a single "Exports:" section
+        // Parts use format "ComponentName - PartName" (written with dash)
+        // Exports use just "ExportName" (written without dash)
+        if (hasParts || hasExports) {
+          lines.push('- Exports:');
+
+          // First, list all parts with their metadata (use dash format)
+          if (hasParts && _page2.parts) {
+            for (var _i5 = 0, _Object$entries3 = Object.entries(_page2.parts); _i5 < _Object$entries3.length; _i5++) {
+              var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i5], 2),
+                partName = _Object$entries3$_i[0],
+                partMetadata = _Object$entries3$_i[1];
+              var hasProps = partMetadata.props && partMetadata.props.length > 0;
+              var hasDataAttributes = partMetadata.dataAttributes && partMetadata.dataAttributes.length > 0;
+              var hasCssVariables = partMetadata.cssVariables && partMetadata.cssVariables.length > 0;
+              lines.push("  - ".concat(_page2.title, " - ").concat(partName));
+              if (hasProps) {
+                lines.push("    - Props: ".concat(partMetadata.props.join(', ')));
+              }
+              if (hasDataAttributes) {
+                lines.push("    - Data Attributes: ".concat(partMetadata.dataAttributes.join(', ')));
+              }
+              if (hasCssVariables) {
+                lines.push("    - CSS Variables: ".concat(partMetadata.cssVariables.join(', ')));
+              }
+            }
+          }
+
+          // Then list all exports with their metadata (no dash format)
+          if (hasExports && _page2.exports) {
+            for (var _i6 = 0, _Object$entries4 = Object.entries(_page2.exports); _i6 < _Object$entries4.length; _i6++) {
+              var _Object$entries4$_i = _slicedToArray(_Object$entries4[_i6], 2),
+                exportName = _Object$entries4$_i[0],
+                exportMetadata = _Object$entries4$_i[1];
+              var _hasProps = exportMetadata.props && exportMetadata.props.length > 0;
+              var _hasDataAttributes = exportMetadata.dataAttributes && exportMetadata.dataAttributes.length > 0;
+              var _hasCssVariables = exportMetadata.cssVariables && exportMetadata.cssVariables.length > 0;
+              lines.push("  - ".concat(exportName));
+              if (_hasProps) {
+                lines.push("    - Props: ".concat(exportMetadata.props.join(', ')));
+              }
+              if (_hasDataAttributes) {
+                lines.push("    - Data Attributes: ".concat(exportMetadata.dataAttributes.join(', ')));
+              }
+              if (_hasCssVariables) {
+                lines.push("    - CSS Variables: ".concat(exportMetadata.cssVariables.join(', ')));
+              }
+            }
+          }
+          hasMetadataContent = true;
+        }
+        lines.push('');
+        lines.push('</details>');
+        // Only add blank line if we actually added metadata content
+        if (hasMetadataContent) {
+          lines.push('');
+        }
+      }
+
+      // Add embeddings as a comment if available
+      if (_page2.embeddings && _page2.embeddings.length > 0) {
+        lines.push("[//]: # 'Embeddings: ".concat(JSON.stringify(_page2.embeddings), "'"));
+        lines.push('');
+      }
+
+      // Add read more link
+      lines.push("[Read more](".concat(_page2.path, ")"));
+      lines.push('');
+    }
+
+    // Close wrapper component if provided
+  } catch (err) {
+    _iterator0.e(err);
+  } finally {
+    _iterator0.f();
+  }
+  if (indexWrapperComponent) {
+    lines.push("</".concat(indexWrapperComponent, ">"));
+    lines.push('');
+  }
+
+  // Add metadata export at the end
+  lines.push("[//]: # 'This file is autogenerated, but the following metadata can be modified.'");
+  lines.push('');
+  if (pageMetadata && Object.keys(pageMetadata).length > 0) {
+    lines.push("export const metadata = ".concat(JSON.stringify(pageMetadata, null, 2), ";"));
+  } else {
+    // Default metadata with robots noindex
+    lines.push("export const metadata = {\n  robots: {\n    index: false,\n  },\n};");
+  }
+  lines.push('');
+
+  // Remove trailing empty line
+  return "".concat(lines.join('\n').trimEnd(), "\n");
+}
+
+/**
+ * Parses markdown content and extracts page metadata using unified
+ */
+export function markdownToMetadata(_x) {
+  return _markdownToMetadata.apply(this, arguments);
+}
+
+/**
+ * Extracts plain text content from any mdast node without markdown formatting
+ * Used for titles and other places where we don't want markdown syntax
+ */
+function _markdownToMetadata() {
+  _markdownToMetadata = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(markdown) {
+    var tree, title, description, pageMetadata, indexWrapperComponent, pages, currentSection, currentPage, metadataExportMatch, partialPage, foundIndex;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          tree = unified().use(remarkParse).parse(markdown);
+          title = null;
+          pages = [];
+          currentSection = 'header';
+          currentPage = null; // Visit all nodes in the AST
+          visit(tree, function (node, index, parent) {
+            // Track sections based on definition nodes (HTML-style comments)
+            if (node.type === 'definition') {
+              var _defNode$title, _defNode$title2, _defNode$title3, _defNode$title4;
+              var defNode = node;
+              if ((_defNode$title = defNode.title) != null && _defNode$title.includes('following list can be modified')) {
+                currentSection = 'editable';
+                return;
+              }
+              if ((_defNode$title2 = defNode.title) != null && _defNode$title2.includes('DO NOT EDIT AFTER THIS LINE')) {
+                currentSection = 'details';
+                return;
+              }
+              if ((_defNode$title3 = defNode.title) != null && _defNode$title3.includes('following metadata can be modified')) {
+                currentSection = 'metadata';
+                return;
+              }
+              // Parse embeddings from comment
+              if (currentPage && (_defNode$title4 = defNode.title) != null && _defNode$title4.includes('Embeddings:')) {
+                var embeddingsText = defNode.title.replace('Embeddings:', '').trim();
+                try {
+                  currentPage.embeddings = JSON.parse(embeddingsText);
+                } catch (error) {
+                  console.error('Failed to parse embeddings:', error);
+                }
+                return;
+              }
+            }
+
+            // Extract wrapper component from HTML nodes (e.g., <PagesIndex>)
+            if (node.type === 'html' && !indexWrapperComponent) {
+              var htmlNode = node;
+              // Match opening tag like <PagesIndex> or <ComponentsIndex>
+              var openingTagMatch = htmlNode.value.match(/^<([A-Z][a-zA-Z0-9]*)>$/);
+              if (openingTagMatch) {
+                indexWrapperComponent = openingTagMatch[1];
+              }
+            }
+
+            // Extract main title (H1)
+            if (node.type === 'heading') {
+              var headingNode = node;
+              if (headingNode.depth === 1) {
+                title = extractPlainTextFromNode(headingNode);
+                currentSection = 'header';
+                return;
+              }
+            }
+
+            // Parse description in header section (paragraph after H1, before editable marker)
+            if (currentSection === 'header' && node.type === 'paragraph' && (parent == null ? void 0 : parent.type) === 'root') {
+              var paragraphNode = node;
+              var paragraphText = extractPlainTextFromNode(paragraphNode);
+              if (paragraphText && !description) {
+                description = paragraphText;
+              }
+              return;
+            }
+
+            // Parse editable list items - check if we're in a paragraph that's a child of a listItem
+            if (currentSection === 'editable' && node.type === 'paragraph' && (parent == null ? void 0 : parent.type) === 'listItem') {
+              var _paragraphNode = node;
+              if (_paragraphNode.children) {
+                // Look for links in the paragraph
+                var links = _paragraphNode.children.filter(function (child) {
+                  return child.type === 'link';
+                });
+                if (links.length === 0) {
+                  // No links found, skip this item
+                  return;
+                }
+                if (links.length === 1) {
+                  // Single link format: - [Title](./path) [Tag1] [Tag2]
+                  // This is for external links or pages that don't have detail sections
+                  var singleLink = links[0];
+                  var pageTitle = extractPlainTextFromNode(singleLink);
+                  var path = singleLink.url;
+
+                  // Generate slug from title for consistency
+                  var slug = titleToSlug(pageTitle);
+
+                  // Extract tags from text nodes after the link
+                  // Tags are in the format [Tag] where Tag can be New, Hot, Beta, External, etc.
+                  var tags = [];
+                  var foundLink = false;
+                  var _iterator11 = _createForOfIteratorHelper(_paragraphNode.children),
+                    _step11;
+                  try {
+                    for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+                      var child = _step11.value;
+                      if (child === singleLink) {
+                        foundLink = true;
+                        continue;
+                      }
+                      if (foundLink && child.type === 'text') {
+                        // Match [Tag] patterns in the text
+                        var tagRegex = /\[(\w+)\]/g;
+                        var match = tagRegex.exec(child.value);
+                        while (match !== null) {
+                          tags.push(match[1]);
+                          match = tagRegex.exec(child.value);
+                        }
+                      }
+                    }
+
+                    // These entries are preserved as-is in the editable section
+                    // They won't have detail sections generated
+                  } catch (err) {
+                    _iterator11.e(err);
+                  } finally {
+                    _iterator11.f();
+                  }
+                  pages.push({
+                    slug: slug,
+                    path: path,
+                    title: pageTitle,
+                    description: 'No description available',
+                    tags: tags.length > 0 ? tags : undefined,
+                    skipDetailSection: true,
+                    // Mark as external/single-link entry
+                    openGraph: {
+                      title: pageTitle,
+                      description: 'No description available'
+                    }
+                  });
+                } else if (links.length >= 2) {
+                  // Two-link format: - [Title](#slug) [Tag1] [Tag2] - [Full Docs](./path/page.mdx)
+                  var sectionLink = links[0];
+                  var docsLink = links[1];
+                  var _pageTitle3 = extractPlainTextFromNode(sectionLink);
+                  var _slug = sectionLink.url.replace('#', ''); // Extract slug from #slug
+                  var _path = docsLink.url; // Get path from full docs link
+
+                  // Extract tags from text nodes between the section link and full docs link
+                  // Tags are in the format [Tag] where Tag can be New, Hot, Beta, etc.
+                  var _tags = [];
+                  var foundSectionLink = false;
+                  var foundDocsLink = false;
+                  var _iterator12 = _createForOfIteratorHelper(_paragraphNode.children),
+                    _step12;
+                  try {
+                    for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+                      var _child = _step12.value;
+                      if (_child === sectionLink) {
+                        foundSectionLink = true;
+                        continue;
+                      }
+                      if (_child === docsLink) {
+                        foundDocsLink = true;
+                        break;
+                      }
+                      if (foundSectionLink && !foundDocsLink && _child.type === 'text') {
+                        // Match [Tag] patterns in the text
+                        var _tagRegex = /\[(\w+)\]/g;
+                        var _match = _tagRegex.exec(_child.value);
+                        while (_match !== null) {
+                          _tags.push(_match[1]);
+                          _match = _tagRegex.exec(_child.value);
+                        }
+                      }
+                    }
+
+                    // Only extract slug, path, title, and tags from the editable list
+                    // The description will be filled in from the details section
+                  } catch (err) {
+                    _iterator12.e(err);
+                  } finally {
+                    _iterator12.f();
+                  }
+                  pages.push({
+                    slug: _slug,
+                    path: _path,
+                    title: _pageTitle3,
+                    description: 'No description available',
+                    // Will be updated from details section
+                    tags: _tags.length > 0 ? _tags : undefined,
+                    openGraph: {
+                      title: _pageTitle3,
+                      description: 'No description available' // Will be updated from details section
+                    }
+                  });
+                }
+              }
+              return;
+            }
+
+            // Parse detail sections
+            if (currentSection === 'details') {
+              // Start of a new page section (H2)
+              if (node.type === 'heading') {
+                var _headingNode = node;
+                if (_headingNode.depth === 2) {
+                  var _currentPage;
+                  // Save previous page if exists
+                  if ((_currentPage = currentPage) != null && _currentPage.slug) {
+                    var savedSlug = currentPage.slug;
+                    var foundIndex = pages.findIndex(function (c) {
+                      return c.slug === savedSlug;
+                    });
+                    if (foundIndex !== -1) {
+                      pages[foundIndex] = _extends(_extends({}, pages[foundIndex]), currentPage);
+                    }
+                  }
+                  var _pageTitle4 = extractPlainTextFromNode(_headingNode);
+                  // Find the page in the existing pages array by matching the title
+                  var existingPage = pages.find(function (p) {
+                    return p.title === _pageTitle4;
+                  });
+                  if (existingPage) {
+                    // Start updating this existing page
+                    currentPage = {
+                      slug: existingPage.slug,
+                      title: _pageTitle4
+                    };
+                  } else {
+                    // If no matching page found, create a new one with slug from title
+                    var _slug2 = titleToSlug(_pageTitle4);
+                    currentPage = {
+                      slug: _slug2,
+                      title: _pageTitle4
+                    };
+                  }
+                  return;
+                }
+              }
+
+              // Parse description (first paragraph after title) and keywords/sections
+              if (currentPage && node.type === 'paragraph') {
+                var _paragraphNode2 = node;
+                var _paragraphText = extractTextFromNode(_paragraphNode2);
+
+                // Check if we're in a list item
+                if ((parent == null ? void 0 : parent.type) === 'listItem') {
+                  // Parse keywords
+                  if (_paragraphText.startsWith('Keywords:')) {
+                    var keywordsText = _paragraphText.replace('Keywords:', '').trim();
+                    currentPage.keywords = keywordsText.split(',').map(function (k) {
+                      return k.trim();
+                    });
+                    return;
+                  }
+
+                  // Parse exports - they're in a nested list within the same parent list item
+                  if (_paragraphText.startsWith('Exports:')) {
+                    var result = parseExportsFromListItem(parent);
+                    if (result.exports) {
+                      currentPage.exports = result.exports;
+                    }
+                    if (result.parts) {
+                      currentPage.parts = result.parts;
+                    }
+                    return;
+                  }
+
+                  // Parse sections - now they're in a nested list within the same parent list item
+                  if (_paragraphText.startsWith('Sections:')) {
+                    var _listItem$children2;
+                    // Find the nested list within this list item
+                    var listItem = parent;
+                    var nestedList = (_listItem$children2 = listItem.children) == null ? void 0 : _listItem$children2.find(function (child) {
+                      return child.type === 'list';
+                    });
+                    if (nestedList && nestedList.children) {
+                      currentPage.sections = parseHeadingSections(nestedList);
+                    } else {
+                      currentPage.sections = {};
+                    }
+                    return;
+                  }
+                }
+
+                // Skip read more links
+                if (_paragraphText.startsWith('[Read more]')) {
+                  return;
+                }
+
+                // Parse description (first paragraph after title, not in a list)
+                if (!currentPage.description && (parent == null ? void 0 : parent.type) !== 'listItem') {
+                  currentPage.description = _paragraphText;
+                  // Store the AST nodes with position info stripped for clean serialization
+                  if (_paragraphNode2.children) {
+                    currentPage.descriptionMarkdown = stripPositions(_paragraphNode2.children);
+                  }
+                  if (!currentPage.openGraph) {
+                    currentPage.openGraph = {};
+                  }
+                  currentPage.openGraph.description = _paragraphText;
+                  return;
+                }
+              }
+
+              // Parse image
+              if (currentPage && node.type === 'image') {
+                var imageNode = node;
+                if (!currentPage.openGraph) {
+                  currentPage.openGraph = {};
+                }
+                currentPage.openGraph.images = [{
+                  url: imageNode.url,
+                  width: 800,
+                  height: 600,
+                  alt: imageNode.alt || currentPage.title || currentPage.slug || ''
+                }];
+                return;
+              }
+            }
+
+            // Parse metadata export section (code block or raw export statement after metadata comment)
+            if (currentSection === 'metadata' && node.type === 'code') {
+              var codeNode = node;
+              var codeValue = codeNode.value;
+              // Parse the export const metadata = { ... } statement
+              var metadataMatch = codeValue.match(/export\s+const\s+metadata\s*=\s*(\{[\s\S]*\})/);
+              if (metadataMatch) {
+                try {
+                  // Use Function constructor to safely parse the object literal
+                  // eslint-disable-next-line no-new-func
+                  pageMetadata = new Function("return ".concat(metadataMatch[1]))();
+                } catch (error) {
+                  console.error('Failed to parse page metadata:', error);
+                }
+              }
+              return;
+            }
+          });
+
+          // Also try to parse metadata from raw export statement in the markdown
+          // This handles MDX files where the export is not in a code block
+          metadataExportMatch = markdown.match(/\[\/\/\]: # 'This file is autogenerated, but the following metadata can be modified\.'\s*\n\s*\n\s*export\s+const\s+metadata\s*=\s*(\{[\s\S]*?\n\})/);
+          if (metadataExportMatch && !pageMetadata) {
+            try {
+              // eslint-disable-next-line no-new-func
+              pageMetadata = new Function("return ".concat(metadataExportMatch[1]))();
+            } catch (error) {
+              console.error('Failed to parse page metadata from raw export:', error);
+            }
+          }
+
+          // Save last page if exists
+          if (currentPage) {
+            partialPage = currentPage;
+            if (partialPage.slug) {
+              foundIndex = pages.findIndex(function (c) {
+                return c.slug === partialPage.slug;
+              });
+              if (foundIndex !== -1) {
+                pages[foundIndex] = _extends(_extends({}, pages[foundIndex]), partialPage);
+              }
+            }
+          }
+          if (title) {
+            _context.n = 1;
+            break;
+          }
+          return _context.a(2, null);
+        case 1:
+          return _context.a(2, {
+            title: title,
+            description: description,
+            pages: pages,
+            pageMetadata: pageMetadata,
+            indexWrapperComponent: indexWrapperComponent
+          });
+      }
+    }, _callee);
+  }));
+  return _markdownToMetadata.apply(this, arguments);
+}
+function extractPlainTextFromNode(node) {
+  if (node.type === 'text') {
+    return node.value;
+  }
+  if (node.type === 'inlineCode') {
+    return node.value;
+  }
+  if (node.children) {
+    var extractedText = node.children.map(function (child) {
+      return extractPlainTextFromNode(child);
+    }).join('');
+    // For paragraph nodes, replace sequences of regular whitespace (spaces, tabs, newlines)
+    // with a single space, but preserve non-breaking spaces and other special whitespace
+    if (node.type === 'paragraph') {
+      return extractedText.replace(/[ \t\n\r]+/g, ' ').trim();
+    }
+    return extractedText;
+  }
+  return '';
+}
+
+/**
+ * Extracts text content from any mdast node
+ * Preserves markdown formatting like inline code and links
+ */
+function extractTextFromNode(node) {
+  if (node.type === 'text') {
+    return node.value;
+  }
+  if (node.type === 'inlineCode') {
+    return "`".concat(node.value, "`");
+  }
+  if (node.type === 'link') {
+    var linkText = node.children.map(function (child) {
+      return extractTextFromNode(child);
+    }).join('');
+    return "[".concat(linkText, "](").concat(node.url, ")");
+  }
+  if (node.type === 'emphasis') {
+    var emphasisText = node.children.map(function (child) {
+      return extractTextFromNode(child);
+    }).join('');
+    return "*".concat(emphasisText, "*");
+  }
+  if (node.type === 'strong') {
+    var strongText = node.children.map(function (child) {
+      return extractTextFromNode(child);
+    }).join('');
+    return "**".concat(strongText, "**");
+  }
+  if (node.children) {
+    var extractedText = node.children.map(function (child) {
+      return extractTextFromNode(child);
+    }).join('');
+    // For paragraph nodes, replace sequences of regular whitespace (spaces, tabs, newlines)
+    // with a single space, but preserve non-breaking spaces and other special whitespace
+    if (node.type === 'paragraph') {
+      return extractedText.replace(/[ \t\n\r]+/g, ' ').trim();
+    }
+    return extractedText;
+  }
+  return '';
+}
+
+/**
+ * Converts a title to a slug (simple version)
+ */
+function titleToSlug(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}