@mui/internal-docs-infra 0.3.1-canary.3 → 0.3.1-canary.4

package/esm/pipeline/syncPageIndex/metadataToMarkdown.js

@@ -1,10 +1,3 @@
-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';
@@ -16,30 +9,21 @@ import { heading, paragraph, text, link, comment } from "./createMarkdownNodes.j
  * 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);
-      }
+  let result = '';
+  for (const node of nodes) {
+    if (node.type === 'text') {
+      result += node.value;
+    } else if (node.type === 'inlineCode') {
+      result += `\`${node.value}\``;
+    } else if (node.type === 'emphasis') {
+      result += `*${astNodesToMarkdown(node.children)}*`;
+    } else if (node.type === 'strong') {
+      result += `**${astNodesToMarkdown(node.children)}**`;
+    } else if (node.type === 'link') {
+      result += `[${astNodesToMarkdown(node.children)}](${node.url})`;
+    } else if ('children' in node) {
+      result += astNodesToMarkdown(node.children);
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
   }
   return result;
 }
@@ -51,21 +35,21 @@ function astNodesToMarkdown(nodes) {
 /**
  * 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;
+function headingHierarchyToMarkdown(hierarchy, basePath, depth = 0) {
+  let result = '';
+  const indent = '  '.repeat(depth);
+  for (const node of Object.values(hierarchy)) {
+    const {
+      titleMarkdown,
+      children
+    } = node;
     // Convert AST nodes back to markdown string with preserved formatting
-    var titleString = astNodesToMarkdown(titleMarkdown);
+    let 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");
+    result += `${indent}- ${titleString}\n`;
     if (Object.keys(children).length > 0) {
       result += headingHierarchyToMarkdown(children, basePath, depth + 1);
     }
@@ -77,12 +61,13 @@ function headingHierarchyToMarkdown(hierarchy, basePath) {
  * 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 = {
+  const listItems = [];
+  for (const node of Object.values(hierarchy)) {
+    const {
+      titleMarkdown,
+      children
+    } = node;
+    const listItem = {
       type: 'listItem',
       children: [{
         type: 'paragraph',
@@ -92,7 +77,7 @@ function headingHierarchyToListNodes(hierarchy, basePath) {
 
     // Add nested children if they exist
     if (Object.keys(children).length > 0) {
-      var nestedList = {
+      const nestedList = {
         type: 'list',
         ordered: false,
         children: headingHierarchyToListNodes(children, basePath)
@@ -108,9 +93,11 @@ function headingHierarchyToListNodes(hierarchy, basePath) {
  * Strips position metadata from AST nodes recursively
  */
 function stripPositions(nodes) {
-  return nodes.map(function (node) {
-    var position = node.position,
-      rest = _objectWithoutPropertiesLoose(node, _excluded);
+  return nodes.map(node => {
+    const {
+      position,
+      ...rest
+    } = node;
     if (rest.children) {
       rest.children = stripPositions(rest.children);
     }
@@ -128,121 +115,84 @@ function stripPositions(nodes) {
  *     - CSS Variables: --var1, --var2
  */
 function parseExportsFromListItem(listItem) {
-  var _listItem$children;
-  var exports = {};
-  var parts = {};
+  const exports = {};
+  const 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)) {
+  const nestedList = listItem.children?.find(child => child.type === 'list');
+  if (!nestedList?.children) {
     return {
-      exports: 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;
-      }
+  for (const exportListItem of nestedList.children) {
+    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;
-      }
+    // Find the paragraph with the export/part name
+    const exportParagraph = exportListItem.children?.find(child => 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 || '';
+    // Extract the name from the text node
+    const textNode = exportParagraph.children?.find(child => child.type === 'text');
+    if (!textNode) {
+      continue;
+    }
+    const fullName = textNode.value || '';
 
-      // Check if this is a part (has dash) or export (no dash)
-      var hasDash = fullName.includes(' - ');
+    // Check if this is a part (has dash) or export (no dash)
+    const 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';
-      });
+    // Find the nested list with props/dataAttributes/cssVariables
+    const metadataList = exportListItem.children?.find(child => 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();
-                });
-              }
-            }
+    // Initialize the metadata (only add properties that have content)
+    const metadata = {};
+    if (metadataList) {
+      // Parse each metadata item
+      for (const metadataItem of metadataList.children) {
+        if (metadataItem.type !== 'listItem') {
+          continue;
+        }
+        const metadataParagraph = metadataItem.children?.find(child => child.type === 'paragraph');
+        if (!metadataParagraph) {
+          continue;
+        }
+        const metadataText = extractPlainTextFromNode(metadataParagraph);
+        if (metadataText.startsWith('Props:')) {
+          const propsText = metadataText.replace('Props:', '').trim();
+          if (propsText) {
+            metadata.props = propsText.split(',').map(p => p.trim());
+          }
+        } else if (metadataText.startsWith('Data Attributes:')) {
+          const dataAttributesText = metadataText.replace('Data Attributes:', '').trim();
+          if (dataAttributesText) {
+            metadata.dataAttributes = dataAttributesText.split(',').map(attr => attr.trim());
+          }
+        } else if (metadataText.startsWith('CSS Variables:')) {
+          const cssVariablesText = metadataText.replace('CSS Variables:', '').trim();
+          if (cssVariablesText) {
+            metadata.cssVariables = cssVariablesText.split(',').map(cssVar => 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();
+    if (hasDash) {
+      // This is a part name (e.g., "ComponentName - PartName")
+      const 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)
+      const exportName = fullName;
+      // Always add the export, even if it has no properties
+      exports[exportName] = metadata;
+    }
   }
   return {
     exports: Object.keys(exports).length > 0 ? exports : undefined,
@@ -256,45 +206,37 @@ function parseExportsFromListItem(listItem) {
  * OR plain text in the format: Title
  */
 function parseHeadingSections(listNode) {
-  var hierarchy = {};
-  var stack = [{
+  const hierarchy = {};
+  const 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];
+  function processListItems(items, baseDepth, parentIsOrdered = false, startIndex = 1) {
+    for (let i = 0; i < items.length; i += 1) {
+      const 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';
-      });
+      const itemParagraph = item.children?.find(child => 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 = '';
+      const itemLink = itemParagraph?.children?.find(child => child.type === 'link');
+      let title = '';
+      let titleMarkdown = [];
+      let 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) || '';
+        title = itemLink.children?.[0]?.value || '';
         // Strip position metadata from titleMarkdown
         titleMarkdown = stripPositions(itemLink.children || []);
-        var url = itemLink.url || '';
+        const url = itemLink.url || '';
         slug = url.split('#')[1] || '';
       } else {
         // Plain text format: extract all children (preserves formatting)
@@ -302,7 +244,7 @@ function parseHeadingSections(listNode) {
         titleMarkdown = stripPositions(itemParagraph.children || []);
 
         // Extract plain text for slug generation
-        var rawTitle = itemParagraph.children.map(function (child) {
+        let rawTitle = itemParagraph.children.map(child => {
           if (child.type === 'text') {
             return child.value;
           }
@@ -322,8 +264,8 @@ function parseHeadingSections(listNode) {
 
         // If this is from an ordered list, prepend the number
         if (parentIsOrdered) {
-          var itemNumber = startIndex + i;
-          title = "".concat(itemNumber, ". ").concat(rawTitle);
+          const itemNumber = startIndex + i;
+          title = `${itemNumber}. ${rawTitle}`;
           // Update titleMarkdown to include the number
           titleMarkdown = [{
             type: 'text',
@@ -337,15 +279,14 @@ function parseHeadingSections(listNode) {
         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,
+        const parent = stack[stack.length - 1].node;
+        const newNode = {
+          title,
+          titleMarkdown,
           children: {}
         };
         parent[slug] = newNode;
@@ -355,46 +296,38 @@ function parseHeadingSections(listNode) {
         });
 
         // 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);
-            }
+        const nestedLists = item.children?.filter(child => child.type === 'list');
+        for (const nestedList of nestedLists || []) {
+          if (nestedList.children) {
+            const nestedIsOrdered = nestedList.ordered === true;
+            const 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) {
+  if (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 = [];
+export function metadataToMarkdownAst(data, options = {}) {
+  const {
+    editableMarker,
+    indexWrapperComponent,
+    path
+  } = options;
+  const {
+    title: mainTitle,
+    description: mainDescription,
+    pages,
+    pageMetadata
+  } = data;
+  const children = [];
 
   // Add main title
   children.push(heading(1, mainTitle));
@@ -406,11 +339,11 @@ export function metadataToMarkdownAst(data) {
 
   // 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;
+  const defaultMarkerText = 'This file is autogenerated, but the following list can be modified.';
+  let markerText = defaultMarkerText;
   if (editableMarker) {
     // Extract text between single quotes: [//]: # 'text'
-    var match = editableMarker.match(/\[\/\/\]: # '(.+)'/);
+    const match = editableMarker.match(/\[\/\/\]: # '(.+)'/);
     markerText = match ? match[1] : defaultMarkerText;
   }
   children.push(comment(markerText));
@@ -419,78 +352,51 @@ export function metadataToMarkdownAst(data) {
   if (indexWrapperComponent) {
     children.push({
       type: 'html',
-      value: "<".concat(indexWrapperComponent, ">")
+      value: `<${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 = _step5.value;
-      var pageTitle = 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();
-          }
+  const listItems = [];
+  for (const page of pages) {
+    const pageTitle = page.title || page.slug;
+
+    // Check if this is a single-link entry (external link or no detail section)
+    const isSingleLink = page.skipDetailSection || false;
+    let paragraphChildren;
+    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) {
+        for (const tag of page.tags) {
+          paragraphChildren.push(text(` [${tag}]`));
         }
-      } 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();
-          }
+      }
+    } else {
+      // Format: - [Title](#slug) [Tag1] [Tag2] - [Full Docs](./path/page.mdx)
+      paragraphChildren = [link(`#${page.slug}`, pageTitle)];
+
+      // Add tags if present (directly after component name)
+      if (page.tags && page.tags.length > 0) {
+        for (const tag of page.tags) {
+          paragraphChildren.push(text(` [${tag}]`));
         }
-
-        // 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();
+      // 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
   children.push({
     type: 'list',
     ordered: false,
@@ -500,248 +406,237 @@ export function metadataToMarkdownAst(data) {
 
   // 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';
+  const trimmedPath = path?.replace(/^(src\/app\/|app\/)/, '').replace(/\/page\.mdx$/, '');
+  const quotedPath = trimmedPath && /[()]/.test(trimmedPath) ? `"${trimmedPath}"` : trimmedPath;
+  const doNotEditComment = quotedPath ? `This file is autogenerated, DO NOT EDIT AFTER THIS LINE, run: pnpm docs:validate ${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 = _step6.value;
-      var _pageTitle = _page.title || _page.slug;
-      // Note: We don't replace newlines here to allow natural line breaks in detailed sections
-      var description = _page.description || 'No description available';
-      var keywords = _page.keywords || [];
-      var image = _page.image;
-
-      // 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
+  for (const page of pages) {
+    const pageTitle = page.title || page.slug;
+    // Note: We don't replace newlines here to allow natural line breaks in detailed sections
+    const description = page.description || 'No description available';
+    const keywords = page.keywords || [];
+    const image = page.image;
+
+    // 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)
+    const hasKeywords = keywords.length > 0;
+    const hasSections = page.sections && Object.keys(page.sections).length > 0;
+    const hasParts = page.parts && Object.keys(page.parts).length > 0;
+    const hasExports = page.exports && Object.keys(page.exports).length > 0;
+    if (hasKeywords || hasSections || hasParts || hasExports) {
+      const metadataListItems = [];
+      if (hasKeywords) {
+        metadataListItems.push({
+          type: 'listItem',
+          children: [paragraph(`Keywords: ${keywords.join(', ')}`)]
+        });
+      }
+      if (hasSections && page.sections) {
+        const sectionListItems = headingHierarchyToListNodes(page.sections, page.path);
+        metadataListItems.push({
+          type: 'listItem',
+          children: [paragraph('Sections:'), {
+            type: 'list',
+            ordered: false,
+            children: sectionListItems
           }]
         });
       }
+      if (hasParts || hasExports) {
+        const exportsListItems = [];
+
+        // First, add all parts with their metadata (use dash format)
+        if (hasParts && page.parts) {
+          for (const [partName, partMetadata] of Object.entries(page.parts)) {
+            const partListItems = [];
+            if (partMetadata.props && partMetadata.props.length > 0) {
+              partListItems.push({
+                type: 'listItem',
+                children: [paragraph(`Props: ${partMetadata.props.join(', ')}`)]
+              });
+            }
+            if (partMetadata.dataAttributes && partMetadata.dataAttributes.length > 0) {
+              partListItems.push({
+                type: 'listItem',
+                children: [paragraph(`Data Attributes: ${partMetadata.dataAttributes.join(', ')}`)]
+              });
+            }
+            if (partMetadata.cssVariables && partMetadata.cssVariables.length > 0) {
+              partListItems.push({
+                type: 'listItem',
+                children: [paragraph(`CSS Variables: ${partMetadata.cssVariables.join(', ')}`)]
+              });
+            }
 
-      // 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',
+            // Add the part with dash separator
+            if (partListItems.length > 0) {
+              exportsListItems.push({
+                type: 'listItem',
+                children: [{
+                  type: 'paragraph',
                   children: [{
-                    type: 'paragraph',
-                    children: [{
-                      type: 'text',
-                      value: "".concat(_page.title, " - ").concat(partName)
-                    }]
-                  }, {
-                    type: 'list',
-                    ordered: false,
-                    children: partListItems
+                    type: 'text',
+                    value: `${page.title} - ${partName}`
                   }]
-                });
-              } else {
-                // Part with no properties - just add the part name with dash
-                exportsListItems.push({
-                  type: 'listItem',
+                }, {
+                  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: 'paragraph',
-                    children: [{
-                      type: 'text',
-                      value: "".concat(_page.title, " - ").concat(partName)
-                    }]
+                    type: 'text',
+                    value: `${page.title} - ${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(', ')))]
-                });
-              }
+        // Then add all exports with their metadata (no dash format)
+        if (hasExports && page.exports) {
+          for (const [exportName, exportMetadata] of Object.entries(page.exports)) {
+            const exportListItems = [];
+            if (exportMetadata.props && exportMetadata.props.length > 0) {
+              exportListItems.push({
+                type: 'listItem',
+                children: [paragraph(`Props: ${exportMetadata.props.join(', ')}`)]
+              });
+            }
+            if (exportMetadata.dataAttributes && exportMetadata.dataAttributes.length > 0) {
+              exportListItems.push({
+                type: 'listItem',
+                children: [paragraph(`Data Attributes: ${exportMetadata.dataAttributes.join(', ')}`)]
+              });
+            }
+            if (exportMetadata.cssVariables && exportMetadata.cssVariables.length > 0) {
+              exportListItems.push({
+                type: 'listItem',
+                children: [paragraph(`CSS Variables: ${exportMetadata.cssVariables.join(', ')}`)]
+              });
+            }
 
-              // Always add the export, even if it has no properties
-              if (exportListItems.length > 0) {
-                exportsListItems.push({
-                  type: 'listItem',
+            // Always add the export, even if it has no properties
+            if (exportListItems.length > 0) {
+              exportsListItems.push({
+                type: 'listItem',
+                children: [{
+                  type: 'paragraph',
                   children: [{
-                    type: 'paragraph',
-                    children: [{
-                      type: 'text',
-                      value: exportName
-                    }]
-                  }, {
-                    type: 'list',
-                    ordered: false,
-                    children: exportListItems
+                    type: 'text',
+                    value: exportName
                   }]
-                });
-              } else {
-                // Export with no properties - just add the export name
-                exportsListItems.push({
-                  type: 'listItem',
+                }, {
+                  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: 'paragraph',
-                    children: [{
-                      type: 'text',
-                      value: exportName
-                    }]
+                    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>'
-        });
+        if (exportsListItems.length > 0) {
+          metadataListItems.push({
+            type: 'listItem',
+            children: [paragraph('Exports:'), {
+              type: 'list',
+              ordered: false,
+              children: exportsListItems
+            }]
+          });
+        }
       }
 
-      // Add embeddings as a comment if available
-      if (_page.embeddings && _page.embeddings.length > 0) {
-        children.push(comment("Embeddings: ".concat(JSON.stringify(_page.embeddings))));
-      }
+      // 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 read more link
-      children.push(paragraph([link(_page.path, 'Read more')]));
+    // Add embeddings as a comment if available
+    if (page.embeddings && page.embeddings.length > 0) {
+      children.push(comment(`Embeddings: ${JSON.stringify(page.embeddings)}`));
     }
 
-    // Close wrapper component if provided
-  } catch (err) {
-    _iterator6.e(err);
-  } finally {
-    _iterator6.f();
+    // Add read more link
+    children.push(paragraph([link(page.path, 'Read more')]));
   }
+
+  // Close wrapper component if provided
   if (indexWrapperComponent) {
     children.push({
       type: 'html',
-      value: "</".concat(indexWrapperComponent, ">")
+      value: `</${indexWrapperComponent}>`
     });
   }
 
   // Add metadata export at the end
   children.push(comment('This file is autogenerated, but the following metadata can be modified.'));
-  var metadataCode;
+  let metadataCode;
   if (pageMetadata && Object.keys(pageMetadata).length > 0) {
-    metadataCode = "export const metadata = ".concat(JSON.stringify(pageMetadata, null, 2), ";");
+    metadataCode = `export const metadata = ${JSON.stringify(pageMetadata, null, 2)};`;
   } else {
     // Default metadata with robots noindex
-    metadataCode = "export const metadata = {\n  robots: {\n    index: false,\n  },\n};";
+    metadataCode = `export const metadata = {
+  robots: {
+    index: false,
+  },
+};`;
   }
   // Output as raw MDX/JSX code (mdxjsEsm node type)
   children.push({
@@ -750,30 +645,33 @@ export function metadataToMarkdownAst(data) {
   });
   return {
     type: 'root',
-    children: 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] : {};
+export function metadataToMarkdown(data, options = {}) {
   // Support legacy signature where second param was editableMarker string
-  var normalizedOptions = typeof options === 'string' ? {
+  const 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 = [];
+  const {
+    editableMarker,
+    indexWrapperComponent,
+    path
+  } = normalizedOptions;
+  const {
+    title,
+    description,
+    pages,
+    pageMetadata
+  } = data;
+  const lines = [];
 
   // Add main title
-  lines.push("# ".concat(title));
+  lines.push(`# ${title}`);
   lines.push('');
 
   // Add description if provided (editable section)
@@ -783,224 +681,182 @@ export function metadataToMarkdown(data) {
   }
 
   // Add editable section marker
-  var marker = editableMarker != null ? editableMarker : "[//]: # 'This file is autogenerated, but the following list can be modified.'";
+  const marker = 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(`<${indexWrapperComponent}>`);
     lines.push('');
   }
 
   // Add page list (editable section)
-  var _iterator9 = _createForOfIteratorHelper(pages),
-    _step9;
-  try {
-    for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
-      var page = _step9.value;
-      var pageTitle = 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();
-          }
+  for (const page of pages) {
+    const pageTitle = page.title || page.slug;
+
+    // Check if this is a single-link entry (external link or no detail section)
+    const isSingleLink = page.skipDetailSection || false;
+    let line;
+    if (isSingleLink) {
+      // Format: - [Title](./path) [Tag1] [Tag2]
+      line = `- [${pageTitle}](${page.path})`;
+
+      // Add tags if present (directly after link)
+      if (page.tags && page.tags.length > 0) {
+        for (const tag of page.tags) {
+          line += ` [${tag}]`;
         }
-      } 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();
-          }
+      }
+    } else {
+      // Format: - [Title](#slug) [Tag1] [Tag2] - [Full Docs](./path/page.mdx)
+      line = `- [${pageTitle}](#${page.slug})`;
+
+      // Add tags if present (directly after component name)
+      if (page.tags && page.tags.length > 0) {
+        for (const tag of page.tags) {
+          line += ` [${tag}]`;
         }
-
-        // Add separator and Full Docs link
-        line += " - [Full Docs](".concat(page.path, ")");
       }
-      lines.push(line);
+
+      // Add separator and Full Docs link
+      line += ` - [Full Docs](${page.path})`;
     }
-  } catch (err) {
-    _iterator9.e(err);
-  } finally {
-    _iterator9.f();
+    lines.push(line);
   }
   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'";
+  const trimmedPath = path?.replace(/^(src\/app\/|app\/)/, '').replace(/\/page\.mdx$/, '');
+  const quotedPath = trimmedPath && /[()]/.test(trimmedPath) ? `"${trimmedPath}"` : trimmedPath;
+  const doNotEditMarker = quotedPath ? `[//]: # 'This file is autogenerated, DO NOT EDIT AFTER THIS LINE, run: pnpm docs:validate ${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 = _step0.value;
-      // Skip detail section for single-link entries (external links)
-      if (_page2.skipDetailSection) {
-        continue;
-      }
-      var _pageTitle2 = _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 {
-        pageDescription = _page2.description || 'No description available';
-      }
-      var keywords = _page2.keywords || [];
-      var image = _page2.image;
+  for (const page of pages) {
+    // Skip detail section for single-link entries (external links)
+    if (page.skipDetailSection) {
+      continue;
+    }
+    const pageTitle = page.title || page.slug;
+    // Use descriptionMarkdown to preserve formatting if available
+    // Note: We don't replace newlines here to allow natural line breaks in detailed sections
+    let pageDescription;
+    if (page.descriptionMarkdown && page.descriptionMarkdown.length > 0) {
+      pageDescription = astNodesToMarkdown(page.descriptionMarkdown);
+    } else {
+      pageDescription = page.description || 'No description available';
+    }
+    const keywords = page.keywords || [];
+    const image = page.image;
 
-      // Add page heading
-      lines.push("## ".concat(_pageTitle2));
-      lines.push('');
+    // Add page heading
+    lines.push(`## ${pageTitle}`);
+    lines.push('');
 
-      // Add description
-      lines.push(pageDescription);
-      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 image if available
+    if (image) {
+      lines.push(`![${image.alt || pageTitle}](${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;
+    // Add metadata list (keywords, sections, parts, and exports)
+    const hasKeywords = keywords.length > 0;
+    const hasSections = page.sections && Object.keys(page.sections).length > 0;
+    const hasParts = page.parts && Object.keys(page.parts).length > 0;
+    const hasExports = page.exports && Object.keys(page.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(', ')));
-              }
+    // Track if we actually add any metadata content
+    let hasMetadataContent = false;
+    if (hasKeywords || hasSections || hasParts || hasExports) {
+      lines.push('<details>');
+      lines.push('');
+      lines.push('<summary>Outline</summary>');
+      lines.push('');
+      if (hasKeywords) {
+        lines.push(`- Keywords: ${keywords.join(', ')}`);
+        hasMetadataContent = true;
+      }
+      if (hasSections && page.sections) {
+        const sectionLines = headingHierarchyToMarkdown(page.sections, page.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 && page.parts) {
+          for (const [partName, partMetadata] of Object.entries(page.parts)) {
+            const hasProps = partMetadata.props && partMetadata.props.length > 0;
+            const hasDataAttributes = partMetadata.dataAttributes && partMetadata.dataAttributes.length > 0;
+            const hasCssVariables = partMetadata.cssVariables && partMetadata.cssVariables.length > 0;
+            lines.push(`  - ${page.title} - ${partName}`);
+            if (hasProps) {
+              lines.push(`    - Props: ${partMetadata.props.join(', ')}`);
+            }
+            if (hasDataAttributes) {
+              lines.push(`    - Data Attributes: ${partMetadata.dataAttributes.join(', ')}`);
+            }
+            if (hasCssVariables) {
+              lines.push(`    - CSS Variables: ${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(', ')));
-              }
+        // Then list all exports with their metadata (no dash format)
+        if (hasExports && page.exports) {
+          for (const [exportName, exportMetadata] of Object.entries(page.exports)) {
+            const hasProps = exportMetadata.props && exportMetadata.props.length > 0;
+            const hasDataAttributes = exportMetadata.dataAttributes && exportMetadata.dataAttributes.length > 0;
+            const hasCssVariables = exportMetadata.cssVariables && exportMetadata.cssVariables.length > 0;
+            lines.push(`  - ${exportName}`);
+            if (hasProps) {
+              lines.push(`    - Props: ${exportMetadata.props.join(', ')}`);
+            }
+            if (hasDataAttributes) {
+              lines.push(`    - Data Attributes: ${exportMetadata.dataAttributes.join(', ')}`);
+            }
+            if (hasCssVariables) {
+              lines.push(`    - CSS Variables: ${exportMetadata.cssVariables.join(', ')}`);
             }
           }
-          hasMetadataContent = true;
-        }
-        lines.push('');
-        lines.push('</details>');
-        // Only add blank line if we actually added metadata content
-        if (hasMetadataContent) {
-          lines.push('');
         }
+        hasMetadataContent = true;
       }
-
-      // Add embeddings as a comment if available
-      if (_page2.embeddings && _page2.embeddings.length > 0) {
-        lines.push("[//]: # 'Embeddings: ".concat(JSON.stringify(_page2.embeddings), "'"));
+      lines.push('');
+      lines.push('</details>');
+      // Only add blank line if we actually added metadata content
+      if (hasMetadataContent) {
         lines.push('');
       }
+    }
 
-      // Add read more link
-      lines.push("[Read more](".concat(_page2.path, ")"));
+    // Add embeddings as a comment if available
+    if (page.embeddings && page.embeddings.length > 0) {
+      lines.push(`[//]: # 'Embeddings: ${JSON.stringify(page.embeddings)}'`);
       lines.push('');
     }
 
-    // Close wrapper component if provided
-  } catch (err) {
-    _iterator0.e(err);
-  } finally {
-    _iterator0.f();
+    // Add read more link
+    lines.push(`[Read more](${page.path})`);
+    lines.push('');
   }
+
+  // Close wrapper component if provided
   if (indexWrapperComponent) {
-    lines.push("</".concat(indexWrapperComponent, ">"));
+    lines.push(`</${indexWrapperComponent}>`);
     lines.push('');
   }
 
@@ -1008,389 +864,356 @@ export function metadataToMarkdown(data) {
   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), ";"));
+    lines.push(`export const metadata = ${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(`export const metadata = {
+  robots: {
+    index: false,
+  },
+};`);
   }
   lines.push('');
 
   // Remove trailing empty line
-  return "".concat(lines.join('\n').trimEnd(), "\n");
+  return `${lines.join('\n').trimEnd()}\n`;
 }
 
 /**
  * Parses markdown content and extracts page metadata using unified
  */
-export function markdownToMetadata(_x) {
-  return _markdownToMetadata.apply(this, arguments);
-}
+export async function markdownToMetadata(markdown) {
+  const tree = unified().use(remarkParse).parse(markdown);
+  let title = null;
+  let description;
+  let pageMetadata;
+  let indexWrapperComponent;
+  const pages = [];
+  let currentSection = 'header';
+  let currentPage = null;
+
+  // Visit all nodes in the AST
+  visit(tree, (node, index, parent) => {
+    // Track sections based on definition nodes (HTML-style comments)
+    if (node.type === 'definition') {
+      const defNode = node;
+      if (defNode.title?.includes('following list can be modified')) {
+        currentSection = 'editable';
+        return;
+      }
+      if (defNode.title?.includes('DO NOT EDIT AFTER THIS LINE')) {
+        currentSection = 'details';
+        return;
+      }
+      if (defNode.title?.includes('following metadata can be modified')) {
+        currentSection = 'metadata';
+        return;
+      }
+      // Parse embeddings from comment
+      if (currentPage && defNode.title?.includes('Embeddings:')) {
+        const embeddingsText = defNode.title.replace('Embeddings:', '').trim();
+        try {
+          currentPage.embeddings = JSON.parse(embeddingsText);
+        } catch (error) {
+          console.error('Failed to parse embeddings:', error);
+        }
+        return;
+      }
+    }
 
-/**
- * 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) {
+      const htmlNode = node;
+      // Match opening tag like <PagesIndex> or <ComponentsIndex>
+      const openingTagMatch = htmlNode.value.match(/^<([A-Z][a-zA-Z0-9]*)>$/);
+      if (openingTagMatch) {
+        indexWrapperComponent = openingTagMatch[1];
+      }
+    }
 
-            // 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') {
+      const headingNode = node;
+      if (headingNode.depth === 1) {
+        title = extractPlainTextFromNode(headingNode);
+        currentSection = 'header';
+        return;
+      }
+    }
 
-            // 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?.type === 'root') {
+      const paragraphNode = node;
+      const paragraphText = extractPlainTextFromNode(paragraphNode);
+      if (paragraphText && !description) {
+        description = paragraphText;
+      }
+      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?.type === 'listItem') {
+      const paragraphNode = node;
+      if (paragraphNode.children) {
+        // Look for links in the paragraph
+        const links = paragraphNode.children.filter(child => 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
+          const singleLink = links[0];
+          const pageTitle = extractPlainTextFromNode(singleLink);
+          const path = singleLink.url;
+
+          // Generate slug from title for consistency
+          const 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.
+          const tags = [];
+          let foundLink = false;
+          for (const child of paragraphNode.children) {
+            if (child === singleLink) {
+              foundLink = true;
+              continue;
             }
-
-            // 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
-                  });
-                } 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
-                  });
-                }
+            if (foundLink && child.type === 'text') {
+              // Match [Tag] patterns in the text
+              const tagRegex = /\[(\w+)\]/g;
+              let match = tagRegex.exec(child.value);
+              while (match !== null) {
+                tags.push(match[1]);
+                match = tagRegex.exec(child.value);
               }
-              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;
-                }
+          // These entries are preserved as-is in the editable section
+          // They won't have detail sections generated
+          pages.push({
+            slug,
+            path,
+            title: pageTitle,
+            description: 'No description available',
+            tags: tags.length > 0 ? tags : undefined,
+            skipDetailSection: true // Mark as external/single-link entry
+          });
+        } else if (links.length >= 2) {
+          // Two-link format: - [Title](#slug) [Tag1] [Tag2] - [Full Docs](./path/page.mdx)
+          const sectionLink = links[0];
+          const docsLink = links[1];
+          const pageTitle = extractPlainTextFromNode(sectionLink);
+          const slug = sectionLink.url.replace('#', ''); // Extract slug from #slug
+          const 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.
+          const tags = [];
+          let foundSectionLink = false;
+          let foundDocsLink = false;
+          for (const child of paragraphNode.children) {
+            if (child === sectionLink) {
+              foundSectionLink = true;
+              continue;
+            }
+            if (child === docsLink) {
+              foundDocsLink = true;
+              break;
+            }
+            if (foundSectionLink && !foundDocsLink && child.type === 'text') {
+              // Match [Tag] patterns in the text
+              const tagRegex = /\[(\w+)\]/g;
+              let match = tagRegex.exec(child.value);
+              while (match !== null) {
+                tags.push(match[1]);
+                match = tagRegex.exec(child.value);
               }
+            }
+          }
 
-              // 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);
-                  }
-                  return;
-                }
-              }
+          // Only extract slug, path, title, and tags from the editable list
+          // The description will be filled in from the details section
+          pages.push({
+            slug,
+            path,
+            title: pageTitle,
+            description: 'No description available',
+            // Will be updated from details section
+            tags: tags.length > 0 ? tags : undefined
+          });
+        }
+      }
+      return;
+    }
 
-              // Parse image
-              if (currentPage && node.type === 'image') {
-                var imageNode = node;
-                currentPage.image = {
-                  url: imageNode.url,
-                  alt: imageNode.alt || currentPage.title || currentPage.slug || ''
-                };
-                return;
-              }
+    // Parse detail sections
+    if (currentSection === 'details') {
+      // Start of a new page section (H2)
+      if (node.type === 'heading') {
+        const headingNode = node;
+        if (headingNode.depth === 2) {
+          // Save previous page if exists
+          if (currentPage?.slug) {
+            const savedSlug = currentPage.slug;
+            const foundIndex = pages.findIndex(c => c.slug === savedSlug);
+            if (foundIndex !== -1) {
+              pages[foundIndex] = {
+                ...pages[foundIndex],
+                ...currentPage
+              };
             }
+          }
+          const pageTitle = extractPlainTextFromNode(headingNode);
+          // Find the page in the existing pages array by matching the title
+          const existingPage = pages.find(p => p.title === pageTitle);
+          if (existingPage) {
+            // Start updating this existing page
+            currentPage = {
+              slug: existingPage.slug,
+              title: pageTitle
+            };
+          } else {
+            // If no matching page found, create a new one with slug from title
+            const slug = titleToSlug(pageTitle);
+            currentPage = {
+              slug,
+              title: pageTitle
+            };
+          }
+          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;
-            }
-          });
+      // Parse description (first paragraph after title) and keywords/sections
+      if (currentPage && node.type === 'paragraph') {
+        const paragraphNode = node;
+        const paragraphText = extractTextFromNode(paragraphNode);
+
+        // Check if we're in a list item
+        if (parent?.type === 'listItem') {
+          // Parse keywords
+          if (paragraphText.startsWith('Keywords:')) {
+            const keywordsText = paragraphText.replace('Keywords:', '').trim();
+            currentPage.keywords = keywordsText.split(',').map(k => k.trim());
+            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);
+          // Parse exports - they're in a nested list within the same parent list item
+          if (paragraphText.startsWith('Exports:')) {
+            const result = parseExportsFromListItem(parent);
+            if (result.exports) {
+              currentPage.exports = result.exports;
+            }
+            if (result.parts) {
+              currentPage.parts = result.parts;
             }
+            return;
           }
 
-          // 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);
-              }
+          // Parse sections - now they're in a nested list within the same parent list item
+          if (paragraphText.startsWith('Sections:')) {
+            // Find the nested list within this list item
+            const listItem = parent;
+            const nestedList = listItem.children?.find(child => child.type === 'list');
+            if (nestedList && nestedList.children) {
+              currentPage.sections = parseHeadingSections(nestedList);
+            } else {
+              currentPage.sections = {};
             }
+            return;
           }
-          if (title) {
-            _context.n = 1;
-            break;
+        }
+
+        // Skip read more links
+        if (paragraphText.startsWith('[Read more]')) {
+          return;
+        }
+
+        // Parse description (first paragraph after title, not in a list)
+        if (!currentPage.description && parent?.type !== 'listItem') {
+          currentPage.description = paragraphText;
+          // Store the AST nodes with position info stripped for clean serialization
+          if (paragraphNode.children) {
+            currentPage.descriptionMarkdown = stripPositions(paragraphNode.children);
           }
-          return _context.a(2, null);
-        case 1:
-          return _context.a(2, {
-            title: title,
-            description: description,
-            pages: pages,
-            pageMetadata: pageMetadata,
-            indexWrapperComponent: indexWrapperComponent
-          });
+          return;
+        }
+      }
+
+      // Parse image
+      if (currentPage && node.type === 'image') {
+        const imageNode = node;
+        currentPage.image = {
+          url: imageNode.url,
+          alt: imageNode.alt || currentPage.title || currentPage.slug || ''
+        };
+        return;
       }
-    }, _callee);
-  }));
-  return _markdownToMetadata.apply(this, arguments);
+    }
+
+    // Parse metadata export section (code block or raw export statement after metadata comment)
+    if (currentSection === 'metadata' && node.type === 'code') {
+      const codeNode = node;
+      const codeValue = codeNode.value;
+      // Parse the export const metadata = { ... } statement
+      const 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 ${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
+  const 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 ${metadataExportMatch[1]}`)();
+    } catch (error) {
+      console.error('Failed to parse page metadata from raw export:', error);
+    }
+  }
+
+  // Save last page if exists
+  if (currentPage) {
+    const partialPage = currentPage;
+    if (partialPage.slug) {
+      const foundIndex = pages.findIndex(c => c.slug === partialPage.slug);
+      if (foundIndex !== -1) {
+        pages[foundIndex] = {
+          ...pages[foundIndex],
+          ...partialPage
+        };
+      }
+    }
+  }
+  if (!title) {
+    return null;
+  }
+  return {
+    title,
+    description,
+    pages,
+    pageMetadata,
+    indexWrapperComponent
+  };
 }
+
+/**
+ * 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 extractPlainTextFromNode(node) {
   if (node.type === 'text') {
     return node.value;
@@ -1399,9 +1222,7 @@ function extractPlainTextFromNode(node) {
     return node.value;
   }
   if (node.children) {
-    var extractedText = node.children.map(function (child) {
-      return extractPlainTextFromNode(child);
-    }).join('');
+    const extractedText = node.children.map(child => 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') {
@@ -1421,30 +1242,22 @@ function extractTextFromNode(node) {
     return node.value;
   }
   if (node.type === 'inlineCode') {
-    return "`".concat(node.value, "`");
+    return `\`${node.value}\``;
   }
   if (node.type === 'link') {
-    var linkText = node.children.map(function (child) {
-      return extractTextFromNode(child);
-    }).join('');
-    return "[".concat(linkText, "](").concat(node.url, ")");
+    const linkText = node.children.map(child => extractTextFromNode(child)).join('');
+    return `[${linkText}](${node.url})`;
   }
   if (node.type === 'emphasis') {
-    var emphasisText = node.children.map(function (child) {
-      return extractTextFromNode(child);
-    }).join('');
-    return "*".concat(emphasisText, "*");
+    const emphasisText = node.children.map(child => extractTextFromNode(child)).join('');
+    return `*${emphasisText}*`;
   }
   if (node.type === 'strong') {
-    var strongText = node.children.map(function (child) {
-      return extractTextFromNode(child);
-    }).join('');
-    return "**".concat(strongText, "**");
+    const strongText = node.children.map(child => extractTextFromNode(child)).join('');
+    return `**${strongText}**`;
   }
   if (node.children) {
-    var extractedText = node.children.map(function (child) {
-      return extractTextFromNode(child);
-    }).join('');
+    const extractedText = node.children.map(child => 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') {