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

package/esm/pipeline/loadCodeVariant/maybeCodeInitialData.js

@@ -1,4 +1,3 @@
-import _typeof from "@babel/runtime/helpers/esm/typeof";
 import { hasAllVariants } from "./hasAllCodeVariants.js";
 /**
  * Type guard function that determines if we have sufficient data to render a code highlighter
@@ -98,10 +97,7 @@ import { hasAllVariants } from "./hasAllCodeVariants.js";
  * }, [initialData, reason, ...]);
  * ```
  */
-export function maybeCodeInitialData(variants, variant, code, fileName) {
-  var needsHighlight = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
-  var needsAllFiles = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
-  var needsAllVariants = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
+export function maybeCodeInitialData(variants, variant, code, fileName, needsHighlight = false, needsAllFiles = false, needsAllVariants = false) {
   if (!code) {
     return {
       initialData: false,
@@ -114,7 +110,7 @@ export function maybeCodeInitialData(variants, variant, code, fileName) {
       reason: 'Not all variants are available'
     };
   }
-  var variantCode = code[variant];
+  const variantCode = code[variant];
   if (!variantCode || typeof variantCode === 'string') {
     return {
       initialData: false,
@@ -134,10 +130,9 @@ export function maybeCodeInitialData(variants, variant, code, fileName) {
         reason: 'Variant source not found'
       };
     }
-    if (variantCode.extraFiles && !Object.keys(variantCode.extraFiles).every(function (file) {
-      var _variantCode$extraFil;
-      var fileData = (_variantCode$extraFil = variantCode.extraFiles) == null ? void 0 : _variantCode$extraFil[file];
-      return _typeof(fileData) === 'object' && (fileData == null ? void 0 : fileData.source) !== undefined;
+    if (variantCode.extraFiles && !Object.keys(variantCode.extraFiles).every(file => {
+      const fileData = variantCode.extraFiles?.[file];
+      return typeof fileData === 'object' && fileData?.source !== undefined;
     })) {
       return {
         initialData: false,
@@ -147,22 +142,21 @@ export function maybeCodeInitialData(variants, variant, code, fileName) {
   }
 
   // TODO, filename might need to be determined from filesOrder if provided?
-  var initialFilename = fileName || variantCode.fileName;
-  var fileSource;
+  const initialFilename = fileName || variantCode.fileName;
+  let fileSource;
   if (fileName && fileName !== variantCode.fileName) {
-    var _variantCode$extraFil2;
-    var fileData = variantCode == null || (_variantCode$extraFil2 = variantCode.extraFiles) == null ? void 0 : _variantCode$extraFil2[fileName];
+    const fileData = variantCode?.extraFiles?.[fileName];
     if (!fileData) {
       return {
         initialData: false,
-        reason: "File not found in code"
+        reason: `File not found in code`
       };
     }
     if (typeof fileData === 'string') {
       // It's a URL, not actual source content
       return {
         initialData: false,
-        reason: "File is not loaded yet"
+        reason: `File is not loaded yet`
       };
     }
     fileSource = fileData.source;
@@ -172,7 +166,7 @@ export function maybeCodeInitialData(variants, variant, code, fileName) {
   if (!fileSource) {
     return {
       initialData: false,
-      reason: "File source not found"
+      reason: `File source not found`
     };
   }
   if (needsHighlight && typeof fileSource === 'string') {
@@ -183,10 +177,10 @@ export function maybeCodeInitialData(variants, variant, code, fileName) {
   }
   return {
     initialData: {
-      code: code,
-      initialFilename: initialFilename,
+      code,
+      initialFilename,
       initialSource: fileSource,
-      initialExtraFiles: variantCode == null ? void 0 : variantCode.extraFiles
+      initialExtraFiles: variantCode?.extraFiles
     }
   };
 }

package/esm/pipeline/loadCodeVariant/mergeCodeMetadata.js

@@ -1,7 +1,3 @@
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _extends from "@babel/runtime/helpers/esm/extends";
-var _excluded = ["metadata"];
 /**
  * Metadata merging utility for positioning metadata files relative to source files
  */
@@ -27,86 +23,83 @@ import { calculateMaxSourceBackNavigation, removeBackNavigationPrefix, buildPath
  * @returns An object with the cleaned variant and extracted metadata
  */
 export function extractCodeMetadata(variant) {
-  var metadataPrefix = variant.metadataPrefix;
-  var extractedMetadata = {};
-  var nonMetadataFiles = {};
+  const {
+    metadataPrefix
+  } = variant;
+  const extractedMetadata = {};
+  const nonMetadataFiles = {};
   if (!variant.extraFiles) {
     return {
-      variant: _extends(_extends({}, variant), {}, {
+      variant: {
+        ...variant,
         extraFiles: {}
-      }),
+      },
       metadata: {}
     };
   }
 
   // Calculate how much back navigation to remove using pathUtils
-  var backLevelsToRemove = calculateMaxSourceBackNavigation(variant.extraFiles || {});
+  let backLevelsToRemove = calculateMaxSourceBackNavigation(variant.extraFiles || {});
   if (metadataPrefix) {
     // Add metadataPrefix levels if present
     backLevelsToRemove += splitPath(metadataPrefix).length;
   }
 
   // Process all extraFiles
-  for (var _i = 0, _Object$entries = Object.entries(variant.extraFiles); _i < _Object$entries.length; _i++) {
-    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-      relativePath = _Object$entries$_i[0],
-      fileContent = _Object$entries$_i[1];
-    var file = typeof fileContent === 'string' ? {
+  for (const [relativePath, fileContent] of Object.entries(variant.extraFiles)) {
+    const file = typeof fileContent === 'string' ? {
       source: fileContent
     } : fileContent;
     if (file.metadata) {
-      var scopedPath = removeBackNavigationPrefix(relativePath, backLevelsToRemove);
+      const scopedPath = removeBackNavigationPrefix(relativePath, backLevelsToRemove);
 
       // Remove metadata flag when extracting
-      var metadataFlag = file.metadata,
-        cleanFile = _objectWithoutPropertiesLoose(file, _excluded);
+      const {
+        metadata: metadataFlag,
+        ...cleanFile
+      } = file;
       extractedMetadata[scopedPath] = cleanFile;
     } else {
       nonMetadataFiles[relativePath] = file;
     }
   }
   return {
-    variant: _extends(_extends({}, variant), {}, {
+    variant: {
+      ...variant,
       extraFiles: nonMetadataFiles
-    }),
+    },
     metadata: extractedMetadata
   };
 }
-export function mergeCodeMetadata(variant) {
-  var _options$metadataPref;
-  var metadataFiles = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+export function mergeCodeMetadata(variant, metadataFiles = {}, options = {}) {
   // Determine which metadataPrefix to use
-  var targetMetadataPrefix = (_options$metadataPref = options.metadataPrefix) != null ? _options$metadataPref : variant.metadataPrefix;
+  const targetMetadataPrefix = options.metadataPrefix ?? variant.metadataPrefix;
 
   // Check if we need to re-extract metadata due to metadataPrefix change
-  var needsReextraction = options.metadataPrefix !== undefined && options.metadataPrefix !== variant.metadataPrefix;
+  const needsReextraction = options.metadataPrefix !== undefined && options.metadataPrefix !== variant.metadataPrefix;
 
   // If metadataPrefix is changing, extract existing metadata and reposition everything
-  var workingVariant = variant;
-  var existingMetadata = {};
+  let workingVariant = variant;
+  let existingMetadata = {};
   if (needsReextraction && variant.extraFiles) {
     // Extract existing metadata using the old metadataPrefix
-    var extracted = extractCodeMetadata(variant);
+    const extracted = extractCodeMetadata(variant);
     workingVariant = extracted.variant;
     existingMetadata = extracted.metadata;
   }
 
   // Calculate the positioning level for metadata files
-  var metadataBackNavigation = calculateMetadataBackNavigation(workingVariant.extraFiles, targetMetadataPrefix);
+  const metadataBackNavigation = calculateMetadataBackNavigation(workingVariant.extraFiles, targetMetadataPrefix);
 
   // Collect all metadata files that need positioning
-  var allMetadataFiles = {};
-  var nonMetadataFiles = {};
-  var positionedMetadataFiles = {};
+  const allMetadataFiles = {};
+  const nonMetadataFiles = {};
+  const positionedMetadataFiles = {};
 
   // Process existing extraFiles from working variant
   if (workingVariant.extraFiles) {
-    for (var _i2 = 0, _Object$entries2 = Object.entries(workingVariant.extraFiles); _i2 < _Object$entries2.length; _i2++) {
-      var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
-        relativePath = _Object$entries2$_i[0],
-        fileContent = _Object$entries2$_i[1];
-      var file = typeof fileContent === 'string' ? {
+    for (const [relativePath, fileContent] of Object.entries(workingVariant.extraFiles)) {
+      const file = typeof fileContent === 'string' ? {
         source: fileContent
       } : fileContent;
       if (file.metadata) {
@@ -124,42 +117,39 @@ export function mergeCodeMetadata(variant) {
   }
 
   // Add extracted metadata (if any) for repositioning
-  for (var _i3 = 0, _Object$entries3 = Object.entries(existingMetadata); _i3 < _Object$entries3.length; _i3++) {
-    var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
-      filePath = _Object$entries3$_i[0],
-      _file = _Object$entries3$_i[1];
-    allMetadataFiles[filePath] = _extends(_extends({}, typeof _file === 'string' ? {
-      source: _file
-    } : _file), {}, {
+  for (const [filePath, file] of Object.entries(existingMetadata)) {
+    allMetadataFiles[filePath] = {
+      ...(typeof file === 'string' ? {
+        source: file
+      } : file),
       metadata: true
-    });
+    };
   }
 
   // Add additional metadata files for positioning
-  for (var _i4 = 0, _Object$entries4 = Object.entries(metadataFiles); _i4 < _Object$entries4.length; _i4++) {
-    var _Object$entries4$_i = _slicedToArray(_Object$entries4[_i4], 2),
-      _filePath = _Object$entries4$_i[0],
-      _file2 = _Object$entries4$_i[1];
-    allMetadataFiles[_filePath] = _extends(_extends({}, typeof _file2 === 'string' ? {
-      source: _file2
-    } : _file2), {}, {
+  for (const [filePath, file] of Object.entries(metadataFiles)) {
+    allMetadataFiles[filePath] = {
+      ...(typeof file === 'string' ? {
+        source: file
+      } : file),
       metadata: true
-    });
+    };
   }
 
   // Position new metadata files at the calculated level using buildPath
-  for (var _i5 = 0, _Object$entries5 = Object.entries(allMetadataFiles); _i5 < _Object$entries5.length; _i5++) {
-    var _Object$entries5$_i = _slicedToArray(_Object$entries5[_i5], 2),
-      originalPath = _Object$entries5$_i[0],
-      _file3 = _Object$entries5$_i[1];
-    var metadataPath = buildPath(metadataBackNavigation, originalPath);
-    positionedMetadataFiles[metadataPath] = _file3;
+  for (const [originalPath, file] of Object.entries(allMetadataFiles)) {
+    const metadataPath = buildPath(metadataBackNavigation, originalPath);
+    positionedMetadataFiles[metadataPath] = file;
   }
 
   // Combine all files
-  var finalExtraFiles = _extends(_extends({}, nonMetadataFiles), positionedMetadataFiles);
-  return _extends(_extends({}, workingVariant), {}, {
+  const finalExtraFiles = {
+    ...nonMetadataFiles,
+    ...positionedMetadataFiles
+  };
+  return {
+    ...workingVariant,
     extraFiles: finalExtraFiles,
     metadataPrefix: targetMetadataPrefix
-  });
+  };
 }

package/esm/pipeline/loadCodeVariant/parseCode.js

@@ -1,41 +1,33 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _typeof from "@babel/runtime/helpers/esm/typeof";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 /**
  * Pure function to parse code variants and their extraFiles.
  * Converts string sources to HAST nodes and handles hastJson parsing.
  */
 export function parseCode(code, parseSource) {
-  var parsed = {};
-  for (var _i = 0, _Object$entries = Object.entries(code); _i < _Object$entries.length; _i++) {
-    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-      variant = _Object$entries$_i[0],
-      variantCode = _Object$entries$_i[1];
+  const parsed = {};
+  for (const [variant, variantCode] of Object.entries(code)) {
     if (typeof variantCode === 'string') {
       // Already parsed/highlighted
       parsed[variant] = variantCode;
-    } else if (variantCode && _typeof(variantCode) === 'object') {
+    } else if (variantCode && typeof variantCode === 'object') {
       // Parse if source is available and not already parsed, and we have a filename to determine the file type
       if (variantCode.source && typeof variantCode.source === 'string' && variantCode.fileName) {
         try {
-          var hastRoot = parseSource(variantCode.source, variantCode.fileName);
+          const hastRoot = parseSource(variantCode.source, variantCode.fileName);
 
           // Also parse extraFiles if they contain sources that need parsing
-          var parsedExtraFiles = variantCode.extraFiles ? Object.fromEntries(Object.entries(variantCode.extraFiles).map(function (_ref) {
-            var _ref2 = _slicedToArray(_ref, 2),
-              fileName = _ref2[0],
-              fileContent = _ref2[1];
+          const parsedExtraFiles = variantCode.extraFiles ? Object.fromEntries(Object.entries(variantCode.extraFiles).map(([fileName, fileContent]) => {
             if (typeof fileContent === 'string') {
               return [fileName, fileContent]; // Keep string as-is
             }
-            if (fileContent && _typeof(fileContent) === 'object' && fileContent.source) {
+            if (fileContent && typeof fileContent === 'object' && fileContent.source) {
               if (typeof fileContent.source === 'string') {
                 // Parse string source in extraFile
                 try {
-                  var parsedHastRoot = parseSource(fileContent.source, fileName);
-                  return [fileName, _extends(_extends({}, fileContent), {}, {
+                  const parsedHastRoot = parseSource(fileContent.source, fileName);
+                  return [fileName, {
+                    ...fileContent,
                     source: parsedHastRoot
-                  })];
+                  }];
                 } catch (error) {
                   return [fileName, fileContent]; // Keep original if parsing fails
                 }
@@ -43,10 +35,11 @@ export function parseCode(code, parseSource) {
             }
             return [fileName, fileContent]; // Keep as-is for other cases
           })) : undefined;
-          parsed[variant] = _extends(_extends({}, variantCode), {}, {
+          parsed[variant] = {
+            ...variantCode,
             source: hastRoot,
             extraFiles: parsedExtraFiles
-          });
+          };
         } catch (error) {
           // Keep original if parsing fails
           parsed[variant] = variantCode;
@@ -54,7 +47,8 @@ export function parseCode(code, parseSource) {
       } else if (variantCode.source && typeof variantCode.source === 'string' && !variantCode.fileName) {
         // Return a basic HAST root node with the source text for unsupported file types
         // This indicates that the source has at least passed through the parsing pipeline
-        parsed[variant] = _extends(_extends({}, variantCode), {}, {
+        parsed[variant] = {
+          ...variantCode,
           source: {
             type: 'root',
             children: [{
@@ -62,28 +56,26 @@ export function parseCode(code, parseSource) {
               value: variantCode.source
             }]
           }
-        });
-      } else if (variantCode.source && _typeof(variantCode.source) === 'object' && 'hastJson' in variantCode.source) {
+        };
+      } else if (variantCode.source && typeof variantCode.source === 'object' && 'hastJson' in variantCode.source) {
         try {
           // Parse hastJson to HAST nodes
-          var _hastRoot = JSON.parse(variantCode.source.hastJson);
+          const hastRoot = JSON.parse(variantCode.source.hastJson);
 
           // Also parse extraFiles if they contain sources that need parsing
-          var _parsedExtraFiles = variantCode.extraFiles ? Object.fromEntries(Object.entries(variantCode.extraFiles).map(function (_ref3) {
-            var _ref4 = _slicedToArray(_ref3, 2),
-              fileName = _ref4[0],
-              fileContent = _ref4[1];
+          const parsedExtraFiles = variantCode.extraFiles ? Object.fromEntries(Object.entries(variantCode.extraFiles).map(([fileName, fileContent]) => {
             if (typeof fileContent === 'string') {
               return [fileName, fileContent]; // Keep string as-is
             }
-            if (fileContent && _typeof(fileContent) === 'object' && fileContent.source) {
+            if (fileContent && typeof fileContent === 'object' && fileContent.source) {
               if (typeof fileContent.source === 'string') {
                 // Parse string source in extraFile
                 try {
-                  var parsedHastRoot = parseSource(fileContent.source, fileName);
-                  return [fileName, _extends(_extends({}, fileContent), {}, {
+                  const parsedHastRoot = parseSource(fileContent.source, fileName);
+                  return [fileName, {
+                    ...fileContent,
                     source: parsedHastRoot
-                  })];
+                  }];
                 } catch (error) {
                   return [fileName, fileContent]; // Keep original if parsing fails
                 }
@@ -91,32 +83,31 @@ export function parseCode(code, parseSource) {
             }
             return [fileName, fileContent]; // Keep as-is for other cases
           })) : undefined;
-          parsed[variant] = _extends(_extends({}, variantCode), {}, {
-            source: _hastRoot,
-            extraFiles: _parsedExtraFiles
-          });
+          parsed[variant] = {
+            ...variantCode,
+            source: hastRoot,
+            extraFiles: parsedExtraFiles
+          };
         } catch (error) {
           // Keep original if parsing fails
-          console.error("Failed to parse hastJson for variant ".concat(variant, ":"), error);
+          console.error(`Failed to parse hastJson for variant ${variant}:`, error);
           parsed[variant] = variantCode;
         }
       } else {
         // Already parsed or no source to parse - but still check extraFiles
-        var _parsedExtraFiles2 = variantCode.extraFiles ? Object.fromEntries(Object.entries(variantCode.extraFiles).map(function (_ref5) {
-          var _ref6 = _slicedToArray(_ref5, 2),
-            fileName = _ref6[0],
-            fileContent = _ref6[1];
+        const parsedExtraFiles = variantCode.extraFiles ? Object.fromEntries(Object.entries(variantCode.extraFiles).map(([fileName, fileContent]) => {
           if (typeof fileContent === 'string') {
             return [fileName, fileContent]; // Keep string as-is
           }
-          if (fileContent && _typeof(fileContent) === 'object' && fileContent.source) {
+          if (fileContent && typeof fileContent === 'object' && fileContent.source) {
             if (typeof fileContent.source === 'string') {
               // Parse string source in extraFile
               try {
-                var parsedHastRoot = parseSource(fileContent.source, fileName);
-                return [fileName, _extends(_extends({}, fileContent), {}, {
+                const parsedHastRoot = parseSource(fileContent.source, fileName);
+                return [fileName, {
+                  ...fileContent,
                   source: parsedHastRoot
-                })];
+                }];
               } catch (error) {
                 return [fileName, fileContent]; // Keep original if parsing fails
               }
@@ -124,9 +115,10 @@ export function parseCode(code, parseSource) {
           }
           return [fileName, fileContent]; // Keep as-is for other cases
         })) : undefined;
-        parsed[variant] = _extends(_extends({}, variantCode), {}, {
-          extraFiles: _parsedExtraFiles2
-        });
+        parsed[variant] = {
+          ...variantCode,
+          extraFiles: parsedExtraFiles
+        };
       }
     }
   }

package/esm/pipeline/loadCodeVariant/pathUtils.js

@@ -1,7 +1,3 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _typeof from "@babel/runtime/helpers/esm/typeof";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 /**
  * Shared path utilities for CodeHighlighter components
  *
@@ -22,38 +18,29 @@ import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIt
  */
 export function resolveRelativePath(relativePath) {
   // Split the path into segments
-  var segments = relativePath.split('/');
-  var resolved = [];
-  var backSteps = 0;
-  var _iterator = _createForOfIteratorHelper(segments),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var segment = _step.value;
-      if (segment === '' || segment === '.') {
-        // Skip empty and current directory segments
-        continue;
-      } else if (segment === '..') {
-        if (resolved.length > 0) {
-          // Remove the last segment (go back one directory)
-          resolved.pop();
-        } else {
-          // Count back steps that go beyond the current directory
-          backSteps += 1;
-        }
+  const segments = relativePath.split('/');
+  const resolved = [];
+  let backSteps = 0;
+  for (const segment of segments) {
+    if (segment === '' || segment === '.') {
+      // Skip empty and current directory segments
+      continue;
+    } else if (segment === '..') {
+      if (resolved.length > 0) {
+        // Remove the last segment (go back one directory)
+        resolved.pop();
       } else {
-        // Regular directory or file segment
-        resolved.push(segment);
+        // Count back steps that go beyond the current directory
+        backSteps += 1;
       }
+    } else {
+      // Regular directory or file segment
+      resolved.push(segment);
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
   }
   return {
     resolvedPath: resolved.join('/'),
-    backSteps: backSteps
+    backSteps
   };
 }
 
@@ -82,8 +69,8 @@ export function removeTrailingSlash(path) {
  * Remove a specific number of back navigation prefixes from a path
  */
 export function removeBackNavigationPrefix(path, count) {
-  var result = path;
-  for (var i = 0; i < count; i += 1) {
+  let result = path;
+  for (let i = 0; i < count; i += 1) {
     if (result.startsWith('../')) {
       result = result.slice(3);
     } else {
@@ -118,24 +105,22 @@ export function removeBackNavigationPrefix(path, count) {
  * ```
  */
 export function calculateMaxBackNavigation(files) {
-  var maxBackNavigation = 0;
-  var maxSourceBackNavigation = 0;
-  for (var _i = 0, _Object$entries = Object.entries(files); _i < _Object$entries.length; _i++) {
-    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-      relativePath = _Object$entries$_i[0],
-      fileContent = _Object$entries$_i[1];
+  let maxBackNavigation = 0;
+  let maxSourceBackNavigation = 0;
+  for (const [relativePath, fileContent] of Object.entries(files)) {
     // Check if this is a metadata file
-    var isMetadata = _typeof(fileContent) === 'object' && fileContent.metadata;
-    var _resolveRelativePath = resolveRelativePath(relativePath),
-      backSteps = _resolveRelativePath.backSteps;
+    const isMetadata = typeof fileContent === 'object' && fileContent.metadata;
+    const {
+      backSteps
+    } = resolveRelativePath(relativePath);
     if (!isMetadata) {
       maxSourceBackNavigation = Math.max(maxSourceBackNavigation, backSteps);
     }
     maxBackNavigation = Math.max(maxBackNavigation, backSteps);
   }
   return {
-    maxBackNavigation: maxBackNavigation,
-    maxSourceBackNavigation: maxSourceBackNavigation
+    maxBackNavigation,
+    maxSourceBackNavigation
   };
 }
 
@@ -163,13 +148,10 @@ export function calculateMaxBackNavigation(files) {
  * ```
  */
 export function calculateMaxSourceBackNavigation(files) {
-  var maxSourceBackNavigation = 0;
-  for (var _i2 = 0, _Object$entries2 = Object.entries(files); _i2 < _Object$entries2.length; _i2++) {
-    var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
-      relativePath = _Object$entries2$_i[0],
-      fileContent = _Object$entries2$_i[1];
+  let maxSourceBackNavigation = 0;
+  for (const [relativePath, fileContent] of Object.entries(files)) {
     // Check if this is a metadata file
-    var isMetadata = _typeof(fileContent) === 'object' && fileContent.metadata;
+    const isMetadata = typeof fileContent === 'object' && fileContent.metadata;
 
     // Skip metadata files - only consider non-metadata files for maxSourceBackNavigation
     if (isMetadata) {
@@ -177,8 +159,9 @@ export function calculateMaxSourceBackNavigation(files) {
     }
 
     // Use path resolution to get the net back steps (most accurate)
-    var _resolveRelativePath2 = resolveRelativePath(relativePath),
-      backSteps = _resolveRelativePath2.backSteps;
+    const {
+      backSteps
+    } = resolveRelativePath(relativePath);
     maxSourceBackNavigation = Math.max(maxSourceBackNavigation, backSteps);
   }
   return maxSourceBackNavigation;
@@ -187,18 +170,14 @@ export function calculateMaxSourceBackNavigation(files) {
 /**
  * Build a path from multiple components, filtering out empty parts
  */
-export function buildPath() {
-  var parts = [];
-  for (var _len = arguments.length, segments = new Array(_len), _key = 0; _key < _len; _key++) {
-    segments[_key] = arguments[_key];
-  }
-  for (var _i3 = 0, _segments = segments; _i3 < _segments.length; _i3++) {
-    var segment = _segments[_i3];
+export function buildPath(...segments) {
+  const parts = [];
+  for (const segment of segments) {
     if (segment === undefined) {
       continue;
     }
     if (Array.isArray(segment)) {
-      parts.push.apply(parts, _toConsumableArray(segment));
+      parts.push(...segment);
     } else {
       parts.push(segment);
     }
@@ -215,9 +194,9 @@ export function buildPath() {
 export function createSyntheticDirectories(count) {
   return Array.from({
     length: count
-  }, function (_, i) {
-    var result = '';
-    var num = i + 1; // 1-based for Excel-style naming
+  }, (_, i) => {
+    let result = '';
+    let num = i + 1; // 1-based for Excel-style naming
 
     while (num > 0) {
       num -= 1; // Adjust for 0-based indexing
@@ -245,13 +224,13 @@ export function createSyntheticDirectories(count) {
  */
 export function calculateMetadataBackNavigation(files, metadataPrefix) {
   // Get the maxSourceBackNavigation from the file structure
-  var backLevels = 0;
+  let backLevels = 0;
   if (files) {
     backLevels = calculateMaxSourceBackNavigation(files);
   }
   if (metadataPrefix) {
     // When a prefix is provided, add additional back navigation based on prefix depth
-    var prefixSegments = metadataPrefix.split('/').filter(Boolean);
+    const prefixSegments = metadataPrefix.split('/').filter(Boolean);
     backLevels += prefixSegments.length;
   }
   return '../'.repeat(backLevels);