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

package/esm/pipeline/transformMarkdownMetadata/transformMarkdownMetadata.js

@@ -0,0 +1,1010 @@
+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 _typeof from "@babel/runtime/helpers/esm/typeof";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import { visit } from 'unist-util-visit';
+import { dirname, relative } from 'node:path';
+import { syncPageIndex } from "../syncPageIndex/index.js";
+import { markdownToMetadata } from "../syncPageIndex/metadataToMarkdown.js";
+/**
+ * Extracts text content from paragraph nodes
+ */
+function extractParagraphText(node) {
+  var text = '';
+  var _iterator = _createForOfIteratorHelper(node.children),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var child = _step.value;
+      if (child.type === 'text') {
+        text += child.value;
+      } else if (child.type === 'inlineCode') {
+        // Preserve backticks for inline code
+        text += "`".concat(child.value, "`");
+      } else if ('children' in child) {
+        // Handle nested elements like strong, emphasis, etc.
+        text += extractTextFromChildren(child.children);
+      }
+    }
+    // Replace newlines with spaces and normalize whitespace, preserving non-breaking spaces
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return text.replace(/[ \t\n\r]+/g, ' ').trim();
+}
+
+/**
+ * Recursively extracts text from children nodes
+ */
+function extractTextFromChildren(children) {
+  var text = '';
+  var _iterator2 = _createForOfIteratorHelper(children),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var child = _step2.value;
+      if (child.type === 'text') {
+        text += child.value;
+      } else if (child.type === 'inlineCode') {
+        // Preserve backticks for inline code
+        text += "`".concat(child.value, "`");
+      } else if ('children' in child) {
+        // Recursively extract from nested elements (strong, emphasis, etc.)
+        text += extractTextFromChildren(child.children);
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return text;
+}
+
+/**
+ * Extracts plain text from children nodes (without formatting markers)
+ */
+function extractPlainTextFromChildren(children) {
+  var text = '';
+  var _iterator3 = _createForOfIteratorHelper(children),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var child = _step3.value;
+      if (child.type === 'text') {
+        text += child.value;
+      } else if (child.type === 'inlineCode') {
+        // Include inline code without backticks
+        text += child.value;
+      } else if ('children' in child) {
+        // Recursively extract from nested elements
+        text += extractPlainTextFromChildren(child.children);
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return text;
+}
+
+/**
+ * Slugify function for generating URL-friendly slugs from heading text.
+ * Lowercases text and replaces non-alphanumeric characters with hyphens.
+ */
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+}
+
+/**
+ * Builds a hierarchical structure from flat headings array
+ * Skips the first H1 (page title) and starts from H2
+ */
+function buildHeadingHierarchy(headings) {
+  // Skip the first heading (H1 - page title)
+  var contentHeadings = headings.slice(1);
+  if (contentHeadings.length === 0) {
+    return {};
+  }
+  var root = {};
+  var stack = [{
+    depth: 0,
+    node: root
+  }];
+  var _iterator4 = _createForOfIteratorHelper(contentHeadings),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var heading = _step4.value;
+      // Pop from stack until we find the parent level
+      while (stack.length > 0 && stack[stack.length - 1].depth >= heading.depth) {
+        stack.pop();
+      }
+
+      // Get the current parent node
+      var parent = stack[stack.length - 1].node;
+
+      // Create slug from heading text using the provided slugify function
+      var slug = slugify(heading.text);
+
+      // Create new node for this heading
+      var newNode = {
+        title: heading.text,
+        // Plain text for display
+        titleMarkdown: heading.children,
+        // AST nodes preserving formatting
+        children: {}
+      };
+      parent[slug] = newNode;
+
+      // Push this heading onto the stack
+      stack.push({
+        depth: heading.depth,
+        node: newNode.children
+      });
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  return root;
+}
+
+/**
+ * Parses the metadata object from an ESTree node
+ */
+function parseMetadataFromEstree(estree) {
+  try {
+    var body = (estree == null ? void 0 : estree.body) || [];
+    var _iterator5 = _createForOfIteratorHelper(body),
+      _step5;
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var _node$declaration;
+        var node = _step5.value;
+        if (node.type === 'ExportNamedDeclaration' && ((_node$declaration = node.declaration) == null ? void 0 : _node$declaration.type) === 'VariableDeclaration') {
+          var declarations = node.declaration.declarations || [];
+          var _iterator6 = _createForOfIteratorHelper(declarations),
+            _step6;
+          try {
+            for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+              var _decl$id, _decl$init;
+              var decl = _step6.value;
+              if (((_decl$id = decl.id) == null ? void 0 : _decl$id.type) === 'Identifier' && decl.id.name === 'metadata' && ((_decl$init = decl.init) == null ? void 0 : _decl$init.type) === 'ObjectExpression') {
+                // Convert ESTree ObjectExpression to plain object
+                return convertEstreeObjectToPlain(decl.init);
+              }
+            }
+          } catch (err) {
+            _iterator6.e(err);
+          } finally {
+            _iterator6.f();
+          }
+        }
+      }
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+  } catch (error) {
+    console.error('Error parsing metadata from estree:', error);
+  }
+  return null;
+}
+
+/**
+ * Converts an ESTree ObjectExpression to a plain JavaScript object
+ */
+function convertEstreeObjectToPlain(node) {
+  if (_typeof(node) === 'object' && node !== null && 'type' in node && node.type === 'ObjectExpression') {
+    var obj = {};
+    if ('properties' in node && Array.isArray(node.properties)) {
+      var _iterator7 = _createForOfIteratorHelper(node.properties),
+        _step7;
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var prop = _step7.value;
+          if (_typeof(prop) === 'object' && prop !== null && 'type' in prop && prop.type === 'Property' && 'key' in prop && prop.key) {
+            var key = '';
+            if ('name' in prop.key && typeof prop.key.name === 'string') {
+              key = prop.key.name;
+            } else if ('value' in prop.key) {
+              key = String(prop.key.value);
+            }
+            if (key && 'value' in prop) {
+              obj[key] = convertEstreeObjectToPlain(prop.value);
+            }
+          }
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
+    }
+    return obj;
+  }
+  if (_typeof(node) === 'object' && node !== null && 'type' in node && node.type === 'ArrayExpression' && 'elements' in node && Array.isArray(node.elements)) {
+    return node.elements.map(function (el) {
+      return convertEstreeObjectToPlain(el);
+    });
+  }
+  if (_typeof(node) === 'object' && node !== null && 'type' in node && node.type === 'Literal' && 'value' in node) {
+    return node.value;
+  }
+  if (_typeof(node) === 'object' && node !== null && 'type' in node && node.type === 'Identifier' && 'name' in node) {
+    return node.name;
+  }
+  return undefined;
+}
+
+/**
+ * Checks if a directory name is a Next.js route group (wrapped in parentheses)
+ */
+function isRouteGroup(dirName) {
+  return dirName.startsWith('(') && dirName.endsWith(')');
+}
+
+/**
+ * Gets the parent directory, skipping over Next.js route groups if requested
+ */
+function getParentDir(path) {
+  var skipRouteGroups = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var parent = dirname(path);
+  if (skipRouteGroups) {
+    while (parent !== dirname(parent) && isRouteGroup(parent.split('/').pop() || '')) {
+      parent = dirname(parent);
+    }
+  }
+  return parent;
+}
+/**
+ * Converts extracted metadata to PageMetadata format for index updates
+ */
+function toPageMetadata(metadata, filePath) {
+  var _options$visibleDescr, _options$visibleDescr2;
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  // Extract the slug from the file path (directory name containing the page)
+  var parts = filePath.split('/');
+  var pageFileName = parts[parts.length - 1]; // e.g., 'page.mdx'
+
+  // Get the directory containing the page file
+  var pageDir = dirname(filePath);
+
+  // Find the directory name by looking backwards for the first non-route-group directory
+  var dirName = '';
+  for (var i = parts.length - 2; i >= 0; i -= 1) {
+    if (!isRouteGroup(parts[i])) {
+      dirName = parts[i];
+      break;
+    }
+  }
+
+  // Generate slug from title if available, otherwise from directory name
+  // This ensures consistency with section slug generation (kebab-case for multi-word, lowercase for camelCase)
+  var slug = metadata.title ? metadata.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') : dirName;
+
+  // Calculate parent directory (skipping route groups, matching syncPageIndex behavior)
+  var parentDir = getParentDir(pageDir, true);
+
+  // Create relative path from parent to page
+  var relativePath = relative(parentDir, pageDir);
+  var path = "./".concat(relativePath, "/").concat(pageFileName);
+  return {
+    slug: slug,
+    path: path,
+    title: metadata.title,
+    description: (_options$visibleDescr = options.visibleDescription) != null ? _options$visibleDescr : metadata.description,
+    descriptionMarkdown: (_options$visibleDescr2 = options.visibleDescriptionMarkdown) != null ? _options$visibleDescr2 : metadata.descriptionMarkdown,
+    keywords: metadata.keywords,
+    sections: metadata.sections,
+    openGraph: metadata.openGraph,
+    embeddings: metadata.embeddings
+  };
+}
+
+/**
+ * Converts a plain value to an ESTree literal or expression
+ */
+function valueToEstree(value) {
+  if (value === null || value === undefined) {
+    return {
+      type: 'Literal',
+      value: null
+    };
+  }
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    return {
+      type: 'Literal',
+      value: value
+    };
+  }
+  if (Array.isArray(value)) {
+    return {
+      type: 'ArrayExpression',
+      elements: value.map(function (item) {
+        return valueToEstree(item);
+      })
+    };
+  }
+  if (_typeof(value) === 'object') {
+    return {
+      type: 'ObjectExpression',
+      properties: Object.entries(value).filter(function (_ref) {
+        var _ref2 = _slicedToArray(_ref, 2),
+          val = _ref2[1];
+        return val !== undefined;
+      }).map(function (_ref3) {
+        var _ref4 = _slicedToArray(_ref3, 2),
+          key = _ref4[0],
+          val = _ref4[1];
+        // Check if key is a valid JavaScript identifier
+        var isValidIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key);
+        return {
+          type: 'Property',
+          key: isValidIdentifier ? {
+            type: 'Identifier',
+            name: key
+          } : {
+            type: 'Literal',
+            value: key
+          },
+          value: valueToEstree(val),
+          kind: 'init',
+          method: false,
+          shorthand: false,
+          computed: false
+        };
+      })
+    };
+  }
+  return {
+    type: 'Literal',
+    value: null
+  };
+}
+
+/**
+ * Updates the metadata object in an existing ESTree
+ */
+function updateMetadataInEstree(estree, metadata) {
+  var body = (estree == null ? void 0 : estree.body) || [];
+  var _iterator8 = _createForOfIteratorHelper(body),
+    _step8;
+  try {
+    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+      var _node$declaration2;
+      var node = _step8.value;
+      if (node.type === 'ExportNamedDeclaration' && ((_node$declaration2 = node.declaration) == null ? void 0 : _node$declaration2.type) === 'VariableDeclaration') {
+        var declarations = node.declaration.declarations || [];
+        var _iterator9 = _createForOfIteratorHelper(declarations),
+          _step9;
+        try {
+          for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+            var _decl$id2, _decl$init2;
+            var decl = _step9.value;
+            if (((_decl$id2 = decl.id) == null ? void 0 : _decl$id2.type) === 'Identifier' && decl.id.name === 'metadata' && ((_decl$init2 = decl.init) == null ? void 0 : _decl$init2.type) === 'ObjectExpression') {
+              // Merge new metadata into existing object
+              var existingProps = decl.init.properties || [];
+              var existingKeys = new Set(existingProps.filter(function (prop) {
+                return prop.type === 'Property';
+              }).map(function (prop) {
+                if ('name' in prop.key) {
+                  return prop.key.name;
+                }
+                if ('value' in prop.key) {
+                  return String(prop.key.value || '');
+                }
+                return '';
+              }));
+
+              // Add missing properties
+              var metadataObj = valueToEstree(metadata);
+              if (_typeof(metadataObj) === 'object' && metadataObj !== null && 'properties' in metadataObj && Array.isArray(metadataObj.properties)) {
+                var _iterator0 = _createForOfIteratorHelper(metadataObj.properties),
+                  _step0;
+                try {
+                  for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
+                    var prop = _step0.value;
+                    if (_typeof(prop) === 'object' && prop !== null && 'key' in prop && _typeof(prop.key) === 'object' && prop.key !== null && 'name' in prop.key) {
+                      var key = prop.key.name;
+                      if (key && !existingKeys.has(String(key))) {
+                        existingProps.push(prop);
+                      }
+                    }
+                  }
+                } catch (err) {
+                  _iterator0.e(err);
+                } finally {
+                  _iterator0.f();
+                }
+              }
+              return;
+            }
+          }
+        } catch (err) {
+          _iterator9.e(err);
+        } finally {
+          _iterator9.f();
+        }
+      }
+    }
+  } catch (err) {
+    _iterator8.e(err);
+  } finally {
+    _iterator8.f();
+  }
+}
+
+/**
+ * Creates a new metadata export node
+ */
+function createMetadataExport(metadata) {
+  var metadataObj = valueToEstree(metadata);
+  return {
+    type: 'mdxjsEsm',
+    value: '',
+    data: {
+      estree: {
+        type: 'Program',
+        sourceType: 'module',
+        body: [{
+          type: 'ExportNamedDeclaration',
+          declaration: {
+            type: 'VariableDeclaration',
+            declarations: [{
+              type: 'VariableDeclarator',
+              id: {
+                type: 'Identifier',
+                name: 'metadata'
+              },
+              init: metadataObj
+            }],
+            kind: 'const'
+          },
+          specifiers: [],
+          source: null,
+          attributes: []
+        }]
+      }
+    }
+  };
+}
+export var transformMarkdownMetadata = function transformMarkdownMetadata() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return /*#__PURE__*/function () {
+    var _ref5 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(tree, file) {
+      var root, headings, metadata, firstH1, firstParagraphAfterH1, metadataNode, metaDescription, metaKeywords, foundFirstH1, nextNodeAfterH1, firstParagraphMarkdown, fullTextParts, shouldUpdateMetadata, mutableMetadata, hasSections, _esmNode$data, esmNode, exportMetadata, descriptionValue, descriptionMarkdownValue, _exportMetadata, metadataExport, wrapperComponent, extractBaseDir, fileContent, pagesMetadata, prefix, filePath, dirPath, segments, srcIndex, appIndex, sitemapData, shouldExtract, _options$extractToInd, _options$extractToInd2, include, _options$extractToInd3, exclude, baseDir, _filePath, normalizedPath, isIndexFile, matchedIncludePattern, isIncluded, matchedExcludePattern, isExcluded, useVisibleDescription, pageMetadataOptions, pageMetadata, updateOptions, _t;
+      return _regenerator().w(function (_context) {
+        while (1) switch (_context.p = _context.n) {
+          case 0:
+            root = tree;
+            headings = [];
+            metadata = null;
+            firstH1 = null;
+            firstParagraphAfterH1 = null;
+            metadataNode = null; // Track the ESM node containing metadata
+            metaDescription = null; // Track meta tag description
+            metaKeywords = null; // Track meta tag keywords
+            foundFirstH1 = false;
+            nextNodeAfterH1 = null;
+            fullTextParts = []; // Collect text parts for fullText - headings and content alternating
+            // Single pass: extract metadata export, meta tags, headings, first paragraph, and full text
+            visit(root, function (node, index, parent) {
+              // Extract metadata export if it exists
+              if (node.type === 'mdxjsEsm' && 'data' in node && node.data && _typeof(node.data) === 'object' && 'estree' in node.data && node.data.estree) {
+                var extracted = parseMetadataFromEstree(node.data.estree);
+                if (extracted) {
+                  metadata = extracted;
+                  metadataNode = node;
+                }
+              }
+
+              // Look for meta tags (can appear anywhere in the document)
+              if ((node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') && 'name' in node && (node.name === 'meta' || node.name === 'Meta')) {
+                // Check attributes to find the meta tag type
+                var attributes = 'attributes' in node && Array.isArray(node.attributes) ? node.attributes : [];
+                var metaName = null;
+                var contentValue = null;
+                var _iterator1 = _createForOfIteratorHelper(attributes),
+                  _step1;
+                try {
+                  for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
+                    var attr = _step1.value;
+                    if (_typeof(attr) === 'object' && attr !== null && 'type' in attr && attr.type === 'mdxJsxAttribute' && 'name' in attr) {
+                      if (attr.name === 'name' && 'value' in attr) {
+                        metaName = typeof attr.value === 'string' ? attr.value : null;
+                      }
+                      if (attr.name === 'content' && 'value' in attr) {
+                        // Extract the content value
+                        if (typeof attr.value === 'string') {
+                          contentValue = attr.value;
+                        } else if (_typeof(attr.value) === 'object' && attr.value !== null && 'type' in attr.value && attr.value.type === 'mdxJsxAttributeValueExpression' && 'value' in attr.value && typeof attr.value.value === 'string') {
+                          // Handle expression values if needed
+                          contentValue = attr.value.value;
+                        }
+                      }
+                    }
+                  }
+
+                  // Process based on meta tag name
+                } catch (err) {
+                  _iterator1.e(err);
+                } finally {
+                  _iterator1.f();
+                }
+                if (metaName === 'description' && contentValue) {
+                  metaDescription = contentValue;
+                } else if (metaName === 'keywords' && contentValue) {
+                  // Parse keywords CSV into array
+                  metaKeywords = contentValue.split(',').map(function (keyword) {
+                    return keyword.trim();
+                  });
+                }
+              }
+
+              // Extract headings
+              if (node.type === 'heading') {
+                var heading = node;
+                var text = extractTextFromChildren(heading.children);
+                headings.push({
+                  depth: heading.depth,
+                  text: text,
+                  children: heading.children // Preserve AST nodes for formatting
+                });
+
+                // Track first h1
+                if (heading.depth === 1 && !foundFirstH1) {
+                  firstH1 = text;
+                  foundFirstH1 = true;
+
+                  // Mark that we need to check the next node
+                  if (parent && index !== undefined && 'children' in parent && Array.isArray(parent.children)) {
+                    if (index + 1 < parent.children.length) {
+                      nextNodeAfterH1 = parent.children[index + 1];
+                    }
+                  }
+                }
+              }
+
+              // Check if this is the paragraph right after the first h1
+              if (foundFirstH1 && !firstParagraphAfterH1 && nextNodeAfterH1 && node === nextNodeAfterH1 && node.type === 'paragraph') {
+                var paragraphNode = node;
+                firstParagraphAfterH1 = extractParagraphText(paragraphNode);
+
+                // If the paragraph contains a single JSX element wrapper, unwrap it
+                // This handles cases like <Description>text</Description>
+                if (paragraphNode.children.length === 1 && paragraphNode.children[0].type === 'mdxJsxTextElement' && 'children' in paragraphNode.children[0] && Array.isArray(paragraphNode.children[0].children)) {
+                  // Use the children of the JSX element instead of the wrapper
+                  firstParagraphMarkdown = paragraphNode.children[0].children;
+                } else {
+                  // Preserve AST nodes for formatting
+                  firstParagraphMarkdown = paragraphNode.children;
+                }
+                nextNodeAfterH1 = null; // Clear the marker
+              }
+
+              // Check if this is a JSX flow element right after the first h1 (multi-line JSX like <Subtitle>...</Subtitle>)
+              // This handles cases where the JSX element spans multiple lines and becomes a block-level element
+              if (foundFirstH1 && !firstParagraphAfterH1 && nextNodeAfterH1 && node === nextNodeAfterH1 && node.type === 'mdxJsxFlowElement' && 'name' in node && node.name !== 'meta' && node.name !== 'Meta' && 'children' in node && Array.isArray(node.children)) {
+                // Extract text from the JSX element's children, preserving non-breaking spaces
+                var textContent = extractPlainTextFromChildren(node.children).replace(/[ \t\n\r]+/g, ' ').trim();
+                if (textContent) {
+                  firstParagraphAfterH1 = textContent;
+                  firstParagraphMarkdown = node.children;
+                }
+                nextNodeAfterH1 = null; // Clear the marker
+              }
+
+              // Extract full text content (excluding code blocks and metadata)
+              // When we encounter a heading, push the heading text and then create a new empty slot for content
+              if (node.type === 'heading') {
+                var _heading = node;
+                // Preserve non-breaking spaces in heading text
+                var _text = extractPlainTextFromChildren(_heading.children).replace(/[ \t\n\r]+/g, ' ').trim();
+                if (_text) {
+                  fullTextParts.push(_text); // Add heading
+                  fullTextParts.push(''); // Create slot for content after this heading
+                }
+                return;
+              }
+
+              // Skip multiline code blocks
+              if (node.type === 'code') {
+                return;
+              }
+
+              // Skip metadata exports
+              if (node.type === 'mdxjsEsm') {
+                return;
+              }
+
+              // Skip meta tags (they don't contribute to page content)
+              if ((node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') && 'name' in node && (node.name === 'meta' || node.name === 'Meta')) {
+                return;
+              }
+
+              // Handle paragraphs for full text, preserving non-breaking spaces
+              if (node.type === 'paragraph') {
+                var _text2 = extractPlainTextFromChildren(node.children).replace(/[ \t\n\r]+/g, ' ').trim();
+                if (_text2) {
+                  // Append to the last slot (current section's content)
+                  if (fullTextParts.length === 0) {
+                    fullTextParts.push(_text2);
+                  } else {
+                    var lastIndex = fullTextParts.length - 1;
+                    fullTextParts[lastIndex] = fullTextParts[lastIndex] ? "".concat(fullTextParts[lastIndex], " ").concat(_text2) : _text2;
+                  }
+                }
+              }
+
+              // Handle lists - condense into comma-separated items
+              if (node.type === 'list' && 'children' in node && Array.isArray(node.children)) {
+                var listItems = [];
+                var _iterator10 = _createForOfIteratorHelper(node.children),
+                  _step10;
+                try {
+                  for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+                    var item = _step10.value;
+                    if (item.type === 'listItem' && 'children' in item && Array.isArray(item.children)) {
+                      // Preserve non-breaking spaces in list item text
+                      var itemText = extractPlainTextFromChildren(item.children).replace(/[ \t\n\r]+/g, ' ').trim();
+                      if (itemText) {
+                        listItems.push(itemText);
+                      }
+                    }
+                  }
+                } catch (err) {
+                  _iterator10.e(err);
+                } finally {
+                  _iterator10.f();
+                }
+                if (listItems.length > 0) {
+                  var _text3 = listItems.join(', ');
+                  // Append to the last slot (current section's content)
+                  if (fullTextParts.length === 0) {
+                    fullTextParts.push(_text3);
+                  } else {
+                    var _lastIndex = fullTextParts.length - 1;
+                    fullTextParts[_lastIndex] = fullTextParts[_lastIndex] ? "".concat(fullTextParts[_lastIndex], " ").concat(_text3) : _text3;
+                  }
+                }
+              }
+
+              // Handle blockquotes - their paragraphs will be picked up by the paragraph handler above
+            });
+
+            // Fill in missing title and description if we have them from content
+            shouldUpdateMetadata = false;
+            if (metadata) {
+              mutableMetadata = metadata; // Add title if missing
+              if (firstH1 && !mutableMetadata.title) {
+                mutableMetadata.title = firstH1;
+                shouldUpdateMetadata = true;
+              }
+
+              // Add description - prioritize meta tag over paragraph
+              if (!mutableMetadata.description) {
+                if (metaDescription) {
+                  mutableMetadata.description = metaDescription;
+                  shouldUpdateMetadata = true;
+                } else if (firstParagraphAfterH1) {
+                  mutableMetadata.description = firstParagraphAfterH1;
+                  shouldUpdateMetadata = true;
+                }
+              }
+
+              // Add descriptionMarkdown if missing
+              // If we used meta tag, set to empty array since meta has no children
+              // Otherwise use the paragraph markdown nodes
+              if (!mutableMetadata.descriptionMarkdown) {
+                if (metaDescription) {
+                  mutableMetadata.descriptionMarkdown = [];
+                  shouldUpdateMetadata = true;
+                } else if (firstParagraphMarkdown) {
+                  mutableMetadata.descriptionMarkdown = firstParagraphMarkdown;
+                  shouldUpdateMetadata = true;
+                }
+              }
+
+              // Add keywords from meta tag if present
+              if (metaKeywords && !mutableMetadata.keywords) {
+                mutableMetadata.keywords = metaKeywords;
+                shouldUpdateMetadata = true;
+              }
+
+              // Fill in openGraph title and description if missing
+              if (!mutableMetadata.openGraph) {
+                mutableMetadata.openGraph = {};
+              }
+              if (firstH1 && !mutableMetadata.openGraph.title) {
+                mutableMetadata.openGraph.title = firstH1;
+                shouldUpdateMetadata = true;
+              }
+
+              // Prioritize meta tag description over paragraph for openGraph
+              if (!mutableMetadata.openGraph.description) {
+                if (metaDescription) {
+                  mutableMetadata.openGraph.description = metaDescription;
+                  shouldUpdateMetadata = true;
+                } else if (firstParagraphAfterH1) {
+                  mutableMetadata.openGraph.description = firstParagraphAfterH1;
+                  shouldUpdateMetadata = true;
+                }
+              }
+
+              // Add sections hierarchy if we have headings
+              hasSections = mutableMetadata.sections && Object.keys(mutableMetadata.sections).length > 0;
+              if (headings.length > 1 && !hasSections) {
+                mutableMetadata.sections = buildHeadingHierarchy(headings);
+                shouldUpdateMetadata = true;
+              }
+
+              // Update the metadata in the ESTree if we added any fields
+              if (shouldUpdateMetadata && metadataNode) {
+                esmNode = metadataNode;
+                if ((_esmNode$data = esmNode.data) != null && _esmNode$data.estree) {
+                  // Apply titleSuffix only to the exported metadata, not to the internal metadata
+                  exportMetadata = options.titleSuffix && mutableMetadata.title ? _extends(_extends({}, mutableMetadata), {}, {
+                    title: mutableMetadata.title + options.titleSuffix
+                  }) : mutableMetadata;
+                  updateMetadataInEstree(esmNode.data.estree, exportMetadata);
+                }
+              }
+            } else if (firstH1 || firstParagraphAfterH1 || metaDescription || metaKeywords) {
+              // Create metadata if we found h1, paragraph, or meta tags but no metadata export exists
+              // Prioritize meta tag description over paragraph
+              descriptionValue = metaDescription || firstParagraphAfterH1 || undefined;
+              descriptionMarkdownValue = metaDescription ? [] : firstParagraphMarkdown || undefined;
+              metadata = {
+                title: firstH1 || undefined,
+                description: descriptionValue,
+                descriptionMarkdown: descriptionMarkdownValue,
+                keywords: metaKeywords || undefined,
+                sections: headings.length > 1 ? buildHeadingHierarchy(headings) : undefined,
+                openGraph: {
+                  title: firstH1 || undefined,
+                  description: descriptionValue
+                }
+              };
+
+              // Create a new metadata export and add it to the tree
+              // Apply titleSuffix only to the exported metadata, not to the internal metadata
+              _exportMetadata = options.titleSuffix && metadata.title ? _extends(_extends({}, metadata), {}, {
+                title: metadata.title + options.titleSuffix
+              }) : metadata;
+              metadataExport = createMetadataExport(_exportMetadata);
+              root.children.unshift(metadataExport);
+            }
+
+            // Inject sitemap data into wrapper components in autogenerated index files
+            // This uses the indexWrapperComponent from extractToIndex options
+            wrapperComponent = _typeof(options.extractToIndex) === 'object' ? options.extractToIndex.indexWrapperComponent : undefined;
+            extractBaseDir = _typeof(options.extractToIndex) === 'object' ? options.extractToIndex.baseDir : undefined;
+            if (!(wrapperComponent && file.path)) {
+              _context.n = 2;
+              break;
+            }
+            fileContent = null;
+            if (typeof file.value === 'string') {
+              fileContent = file.value;
+            } else if (file.value instanceof Buffer) {
+              fileContent = file.value.toString('utf-8');
+            }
+
+            // Check if this is an autogenerated index file
+            if (!(fileContent && fileContent.includes("[//]: # 'This file is autogenerated"))) {
+              _context.n = 2;
+              break;
+            }
+            _context.n = 1;
+            return markdownToMetadata(fileContent);
+          case 1:
+            pagesMetadata = _context.v;
+            if (pagesMetadata) {
+              // Compute prefix from file path
+              prefix = '/';
+              filePath = file.path; // Strip baseDir if provided
+              if (extractBaseDir && filePath.startsWith(extractBaseDir)) {
+                filePath = filePath.substring(extractBaseDir.length);
+                if (filePath.startsWith('/')) {
+                  filePath = filePath.substring(1);
+                }
+              }
+              // Get directory path and convert to URL prefix
+              dirPath = dirname(filePath); // Filter out src, app, and route groups from the path
+              // First, split and filter to find meaningful segments
+              segments = dirPath.split('/').filter(function (seg) {
+                if (seg.startsWith('(') && seg.endsWith(')')) {
+                  return false;
+                }
+                if (seg === '.' || seg === '') {
+                  return false;
+                }
+                return true;
+              }); // Find and remove 'src' followed by 'app' pattern (common in Next.js projects)
+              srcIndex = segments.indexOf('src');
+              if (srcIndex !== -1) {
+                // Remove 'src'
+                segments.splice(srcIndex, 1);
+                // Check if 'app' now follows where 'src' was
+                if (segments[srcIndex] === 'app') {
+                  segments.splice(srcIndex, 1);
+                }
+              } else {
+                // No 'src', check for standalone 'app' at the same position pattern
+                appIndex = segments.indexOf('app');
+                if (appIndex !== -1 && (appIndex === 0 || appIndex === srcIndex)) {
+                  segments.splice(appIndex, 1);
+                }
+              }
+              prefix = segments.length > 0 ? "/".concat(segments.join('/'), "/") : '/';
+
+              // Convert PagesMetadata to SitemapSectionData
+              sitemapData = {
+                title: pagesMetadata.title,
+                prefix: prefix,
+                pages: pagesMetadata.pages.map(function (page) {
+                  return {
+                    title: page.title,
+                    slug: page.slug,
+                    path: page.path,
+                    description: page.description,
+                    keywords: page.keywords,
+                    sections: page.sections,
+                    parts: page.parts,
+                    exports: page.exports,
+                    tags: page.tags,
+                    skipDetailSection: page.skipDetailSection,
+                    openGraph: page.openGraph
+                  };
+                })
+              }; // Find and update the wrapper component in the AST
+              visit(root, function (node) {
+                if (node.type === 'mdxJsxFlowElement' && 'name' in node && node.name === wrapperComponent) {
+                  // Create the data attribute with expression value
+                  var dataAttr = {
+                    type: 'mdxJsxAttribute',
+                    name: 'data',
+                    value: {
+                      type: 'mdxJsxAttributeValueExpression',
+                      value: JSON.stringify(sitemapData),
+                      data: {
+                        estree: {
+                          type: 'Program',
+                          sourceType: 'module',
+                          body: [{
+                            type: 'ExpressionStatement',
+                            expression: valueToEstree(sitemapData)
+                          }]
+                        }
+                      }
+                    }
+                  };
+
+                  // Add the attribute to the element
+                  if ('attributes' in node && Array.isArray(node.attributes)) {
+                    // Remove existing data attribute if present
+                    var existingIndex = node.attributes.findIndex(function (attr) {
+                      return attr && _typeof(attr) === 'object' && 'type' in attr && attr.type === 'mdxJsxAttribute' && 'name' in attr && attr.name === 'data';
+                    });
+                    if (existingIndex !== -1) {
+                      node.attributes.splice(existingIndex, 1);
+                    }
+                    node.attributes.push(dataAttr);
+                  }
+                }
+              });
+            }
+          case 2:
+            if (!(options.extractToIndex && metadata && file.path)) {
+              _context.n = 6;
+              break;
+            }
+            // Normalize extractToIndex options
+            shouldExtract = false;
+            if (typeof options.extractToIndex === 'boolean') {
+              shouldExtract = options.extractToIndex;
+            } else {
+              _options$extractToInd = options.extractToIndex, _options$extractToInd2 = _options$extractToInd.include, include = _options$extractToInd2 === void 0 ? [] : _options$extractToInd2, _options$extractToInd3 = _options$extractToInd.exclude, exclude = _options$extractToInd3 === void 0 ? [] : _options$extractToInd3, baseDir = _options$extractToInd.baseDir;
+              _filePath = file.path; // Strip base directory if provided
+              if (baseDir && _filePath.startsWith(baseDir)) {
+                _filePath = _filePath.substring(baseDir.length);
+                // Remove leading slash if present
+                if (_filePath.startsWith('/')) {
+                  _filePath = _filePath.substring(1);
+                }
+              }
+
+              // Normalize path by removing Next.js route groups (parentheses)
+              // e.g., "app/(shared)/page.mdx" becomes "app/page.mdx"
+              normalizedPath = _filePath.replace(/\/\([^)]+\)/g, ''); // Skip if the file is an index file (pattern/page.mdx)
+              // This prevents index files from extracting metadata to their parent
+              isIndexFile = include.some(function (pattern) {
+                return normalizedPath === "".concat(pattern, "/page.mdx");
+              });
+              if (isIndexFile) {
+                shouldExtract = false;
+              } else {
+                // Check if file matches any include pattern (must be inside the directory and not the index itself)
+                // The file must start with "pattern/" to ensure it's a child, not a sibling
+                // and must not be "pattern/page.mdx" to ensure it's not the index file itself
+                matchedIncludePattern = include.find(function (pattern) {
+                  return normalizedPath.startsWith("".concat(pattern, "/")) && normalizedPath !== "".concat(pattern, "/page.mdx");
+                });
+                isIncluded = include.length === 0 || matchedIncludePattern !== undefined; // Check if file matches any exclude pattern
+                matchedExcludePattern = exclude.find(function (pattern) {
+                  return normalizedPath.startsWith("".concat(pattern, "/"));
+                });
+                isExcluded = matchedExcludePattern !== undefined;
+                shouldExtract = isIncluded && !isExcluded;
+              }
+            }
+            if (!shouldExtract) {
+              _context.n = 6;
+              break;
+            }
+            _context.p = 3;
+            // Determine if we should use visible description instead of meta tag
+            useVisibleDescription = typeof options.extractToIndex !== 'boolean' && options.extractToIndex.useVisibleDescription;
+            pageMetadataOptions = {};
+            if (useVisibleDescription && firstParagraphAfterH1) {
+              pageMetadataOptions.visibleDescription = firstParagraphAfterH1;
+              pageMetadataOptions.visibleDescriptionMarkdown = firstParagraphMarkdown;
+            }
+            pageMetadata = toPageMetadata(metadata, file.path, pageMetadataOptions);
+            updateOptions = {
+              pagePath: file.path,
+              metadata: pageMetadata,
+              updateParents: true
+            }; // Pass through baseDir, include, exclude, onlyUpdateIndexes, and markerDir if they were configured
+            if (typeof options.extractToIndex !== 'boolean') {
+              if (options.extractToIndex.baseDir) {
+                updateOptions.baseDir = options.extractToIndex.baseDir;
+              }
+              if (options.extractToIndex.include) {
+                updateOptions.include = options.extractToIndex.include;
+              }
+              if (options.extractToIndex.exclude) {
+                updateOptions.exclude = options.extractToIndex.exclude;
+              }
+              if (options.extractToIndex.onlyUpdateIndexes !== undefined) {
+                updateOptions.onlyUpdateIndexes = options.extractToIndex.onlyUpdateIndexes;
+              }
+              if (options.extractToIndex.markerDir !== undefined) {
+                updateOptions.markerDir = options.extractToIndex.markerDir;
+              }
+              if (options.extractToIndex.errorIfOutOfDate !== undefined) {
+                updateOptions.errorIfOutOfDate = options.extractToIndex.errorIfOutOfDate;
+              }
+              if (options.extractToIndex.indexWrapperComponent) {
+                updateOptions.indexWrapperComponent = options.extractToIndex.indexWrapperComponent;
+              }
+            }
+            _context.n = 4;
+            return syncPageIndex(updateOptions);
+          case 4:
+            _context.n = 6;
+            break;
+          case 5:
+            _context.p = 5;
+            _t = _context.v;
+            // Don't fail the build if index update fails
+            console.error('Failed to update page index for', file.path, _t);
+          case 6:
+            return _context.a(2);
+        }
+      }, _callee, null, [[3, 5]]);
+    }));
+    return function (_x, _x2) {
+      return _ref5.apply(this, arguments);
+    };
+  }();
+};