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

package/esm/{CodeHighlighter/loadVariant.js → pipeline/loadCodeVariant/loadCodeVariant.js}

@@ -9,9 +9,10 @@ import * as path from 'path-module';
 import { compress, strToU8 } from 'fflate';
 import { encode } from 'uint8-to-base64';
 import { transformSource } from "./transformSource.js";
-import { transformParsedSource } from "./transformParsedSource.js";
-import { getFileNameFromUrl } from "../pipeline/loaderUtils/index.js";
-import { mergeExternals } from "../pipeline/loaderUtils/mergeExternals.js";
+import { diffHast } from "./diffHast.js";
+import { getFileNameFromUrl } from "../loaderUtils/index.js";
+import { mergeExternals } from "../loaderUtils/mergeExternals.js";
+import { performanceMeasure } from "../loadPrecomputedCodeHighlighter/performanceLogger.js";
 function compressAsync(input) {
   var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   return new Promise(function (resolve, reject) {
@@ -84,15 +85,28 @@ function convertKeyBasedOnDirectory(nestedKey, sourceFileKey) {
     processedNestedKey = "./".concat(nestedKey);
   }
 
-  // Use path module for clean path resolution
+  // Get the directory of the source file
   var sourceDir = path.dirname(sourceFileKey);
-  var resolvedPath = path.resolve(sourceDir, processedNestedKey);
 
-  // Convert back to relative path from current directory
-  var result = path.relative('.', resolvedPath);
+  // If sourceDir is '.' (current directory), just return the processed nested key
+  // This avoids path.resolve which can produce absolute paths on Windows
+  if (sourceDir === '.') {
+    // Remove leading './' if present for consistency
+    return processedNestedKey.startsWith('./') ? processedNestedKey.slice(2) : processedNestedKey;
+  }
+
+  // Use path.join instead of path.resolve to avoid producing absolute paths
+  // path.join keeps paths relative, while path.resolve can make them absolute
+  var joinedPath = path.join(sourceDir, processedNestedKey);
 
-  // Return empty string if result is '.' (current directory)
-  return result === '.' ? '' : result;
+  // Normalize the path to clean up any ../ or ./ segments
+  var normalizedPath = path.normalize(joinedPath);
+
+  // Ensure we return a clean relative path (remove leading './' if present after normalization)
+  if (normalizedPath.startsWith('./')) {
+    return normalizedPath.slice(2);
+  }
+  return normalizedPath === '.' ? '' : normalizedPath;
 }
 
 /**
@@ -138,6 +152,8 @@ function _loadSingleFile() {
       extraFilesFromSource,
       extraDependenciesFromSource,
       externalsFromSource,
+      functionName,
+      currentMark,
       loadPromise,
       loadResult,
       _i,
@@ -170,6 +186,11 @@ function _loadSingleFile() {
           knownExtraFiles = _args.length > 11 && _args[11] !== undefined ? _args[11] : new Set();
           _options$disableTrans = options.disableTransforms, disableTransforms = _options$disableTrans === void 0 ? false : _options$disableTrans, _options$disableParsi = options.disableParsing, disableParsing = _options$disableParsi === void 0 ? false : _options$disableParsi;
           finalSource = source;
+          functionName = 'Load Variant File';
+          currentMark = performanceMeasure(undefined, {
+            mark: 'Start',
+            measure: 'Start'
+          }, [functionName, url || fileName], true); // Load source if not provided
           if (finalSource) {
             _context.n = 20;
             break;
@@ -201,6 +222,10 @@ function _loadSingleFile() {
           extraFilesFromSource = loadResult.extraFiles;
           extraDependenciesFromSource = loadResult.extraDependencies;
           externalsFromSource = loadResult.externals;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Loaded File',
+            measure: 'File Loading'
+          }, [functionName, url]);
 
           // Validate that extraFiles from loadSource contain only absolute URLs as values
           if (!extraFilesFromSource) {
@@ -321,6 +346,10 @@ function _loadSingleFile() {
           return transformSource(finalSource, normalizePathKey(fileName), sourceTransformers);
         case 21:
           finalTransforms = _context.v;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Transformed File',
+            measure: 'File Transforming'
+          }, [functionName, url || fileName]);
         case 22:
           if (!(typeof finalSource === 'string' && !disableParsing)) {
             _context.n = 31;
@@ -339,14 +368,22 @@ function _loadSingleFile() {
         case 24:
           parseSource = _context.v;
           finalSource = parseSource(finalSource, fileName);
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Parsed File',
+            measure: 'File Parsing'
+          }, [functionName, url || fileName]);
           if (!(finalTransforms && !disableTransforms)) {
             _context.n = 26;
             break;
           }
           _context.n = 25;
-          return transformParsedSource(sourceString, finalSource, normalizePathKey(fileName), finalTransforms, parseSource);
+          return diffHast(sourceString, finalSource, normalizePathKey(fileName), finalTransforms, parseSource);
         case 25:
           finalTransforms = _context.v;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Transform Parsed File',
+            measure: 'Parsed File Transforming'
+          }, [functionName, url || fileName]);
         case 26:
           if (!(options.output === 'hastGzip' && process.env.NODE_ENV === 'production')) {
             _context.n = 28;
@@ -363,6 +400,10 @@ function _loadSingleFile() {
           finalSource = {
             hastGzip: hastGzip
           };
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Compressed File',
+            measure: 'File Compression'
+          }, [functionName, url || fileName]);
           _context.n = 29;
           break;
         case 28:
@@ -371,6 +412,10 @@ function _loadSingleFile() {
             finalSource = {
               hastJson: JSON.stringify(finalSource)
             };
+            performanceMeasure(currentMark, {
+              mark: 'JSON Stringified File',
+              measure: 'File Stringification'
+            }, [functionName, url || fileName]);
           }
         case 29:
           _context.n = 31;
@@ -656,11 +701,11 @@ function _loadExtraFiles() {
   }));
   return _loadExtraFiles.apply(this, arguments);
 }
-export function loadVariant(_x16, _x17, _x18) {
-  return _loadVariant.apply(this, arguments);
+export function loadCodeVariant(_x16, _x17, _x18) {
+  return _loadCodeVariant.apply(this, arguments);
 }
-function _loadVariant() {
-  _loadVariant = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(url, variantName, variant) {
+function _loadCodeVariant() {
+  _loadCodeVariant = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(url, variantName, variant) {
     var options,
       sourceParser,
       loadSource,
@@ -668,6 +713,8 @@ function _loadVariant() {
       sourceTransformers,
       globalsCode,
       loadSourceCache,
+      functionName,
+      currentMark,
       _getFileNameFromUrl,
       _fileName,
       loadedFiles,
@@ -680,11 +727,11 @@ function _loadVariant() {
       fileName,
       _finalVariant,
       mainFileResult,
-      allExtraFiles,
       _i5,
       _Object$keys3,
       _extraFileName,
       extraFilesToLoad,
+      externalsMergedMark,
       globalsFileKeys,
       existingFiles,
       _i6,
@@ -701,6 +748,7 @@ function _loadVariant() {
       _key,
       value,
       conflictFreeKey,
+      allExtraFiles,
       loadableFiles,
       _i8,
       _Object$entries4,
@@ -734,10 +782,15 @@ function _loadVariant() {
           }
           throw new Error("Variant is missing from code: ".concat(variantName));
         case 1:
-          sourceParser = options.sourceParser, loadSource = options.loadSource, loadVariantMeta = options.loadVariantMeta, sourceTransformers = options.sourceTransformers, globalsCode = options.globalsCode; // Create a cache for loadSource calls scoped to this loadVariant call
+          sourceParser = options.sourceParser, loadSource = options.loadSource, loadVariantMeta = options.loadVariantMeta, sourceTransformers = options.sourceTransformers, globalsCode = options.globalsCode; // Create a cache for loadSource calls scoped to this loadCodeVariant call
           loadSourceCache = new Map();
+          functionName = 'Load Variant';
+          currentMark = performanceMeasure(undefined, {
+            mark: 'Start',
+            measure: 'Start'
+          }, [functionName, url || variantName], true);
           if (!(typeof variant === 'string')) {
-            _context6.n = 6;
+            _context6.n = 7;
             break;
           }
           if (loadVariantMeta) {
@@ -756,7 +809,7 @@ function _loadVariant() {
             url: variant,
             fileName: _fileName
           };
-          _context6.n = 6;
+          _context6.n = 7;
           break;
         case 3:
           _context6.p = 3;
@@ -771,6 +824,11 @@ function _loadVariant() {
           _t9 = _context6.v;
           throw new Error("Failed to load variant code (variant: ".concat(variantName, ", url: ").concat(variant, "): ").concat(JSON.stringify(_t9)));
         case 6:
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Loaded Variant Meta',
+            measure: 'Variant Meta Loading'
+          }, [functionName, url || variantName]);
+        case 7:
           loadedFiles = new Set();
           if (url) {
             loadedFiles.add(url);
@@ -789,7 +847,7 @@ function _loadVariant() {
           // Load main file
           fileName = variant.fileName || (url ? getFileNameFromUrl(url).fileName : undefined); // If we don't have a fileName and no URL, we can't parse or transform but can still return the code
           if (!(!fileName && !url)) {
-            _context6.n = 7;
+            _context6.n = 8;
             break;
           }
           // Return the variant as-is without parsing or transforms
@@ -808,56 +866,66 @@ function _loadVariant() {
             // No dependencies without URL
             externals: {} // No externals without URL
           });
-        case 7:
+        case 8:
           if (fileName) {
-            _context6.n = 8;
+            _context6.n = 9;
             break;
           }
           throw new Error("No fileName available for variant \"".concat(variantName, "\". ") + "Please provide a fileName in the variant definition or ensure the URL has a valid file extension.");
-        case 8:
-          _context6.n = 9;
+        case 9:
+          _context6.n = 10;
           return loadSingleFile(variantName, fileName, variant.source, url, loadSource, sourceParser, sourceTransformers, loadSourceCache, variant.transforms, _extends(_extends({}, options), {}, {
             loadedFiles: loadedFiles
           }), variant.allFilesListed || false, knownExtraFiles);
-        case 9:
+        case 10:
           mainFileResult = _context6.v;
           // Add files used from main file loading
           if (mainFileResult.extraDependencies) {
             allFilesUsed.push.apply(allFilesUsed, _toConsumableArray(mainFileResult.extraDependencies));
           }
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Loaded Main File',
+            measure: 'Main File Loading'
+          }, [functionName, url || fileName], true);
 
-          // Add externals from main file loading
-          if (mainFileResult.externals) {
-            allExternals = mergeExternals([allExternals, mainFileResult.externals]);
-          }
-          allExtraFiles = {}; // Validate extraFiles keys from variant definition
+          // Validate extraFiles keys from variant definition
           if (!variant.extraFiles) {
-            _context6.n = 12;
+            _context6.n = 13;
             break;
           }
           _i5 = 0, _Object$keys3 = Object.keys(variant.extraFiles);
-        case 10:
+        case 11:
           if (!(_i5 < _Object$keys3.length)) {
-            _context6.n = 12;
+            _context6.n = 13;
             break;
           }
           _extraFileName = _Object$keys3[_i5];
           if (!isAbsolutePath(_extraFileName)) {
-            _context6.n = 11;
+            _context6.n = 12;
             break;
           }
           throw new Error("Invalid extraFiles key in variant: \"".concat(_extraFileName, "\" appears to be an absolute path. ") + "extraFiles keys in variant definition should be relative paths from the main file.");
-        case 11:
+        case 12:
           _i5++;
-          _context6.n = 10;
+          _context6.n = 11;
           break;
-        case 12:
+        case 13:
           // Collect extra files from variant definition and from loaded source
-          extraFilesToLoad = _extends(_extends({}, variant.extraFiles || {}), mainFileResult.extraFiles || {}); // Track which files come from globals for metadata marking
+          extraFilesToLoad = _extends(_extends({}, variant.extraFiles || {}), mainFileResult.extraFiles || {}); // Add externals from main file loading
+          if (mainFileResult.externals) {
+            allExternals = mergeExternals([allExternals, mainFileResult.externals]);
+          }
+          externalsMergedMark = performanceMeasure(currentMark, {
+            mark: 'Externals Merged',
+            measure: 'Merging Externals'
+          }, [functionName, url || fileName]);
+          currentMark = externalsMergedMark;
+
+          // Track which files come from globals for metadata marking
           globalsFileKeys = new Set(); // Track globals file keys for loadExtraFiles
           // Process globalsCode array and add to extraFiles if provided
           if (!(globalsCode && globalsCode.length > 0)) {
-            _context6.n = 14;
+            _context6.n = 15;
             break;
           }
           // Collect existing filenames to avoid conflicts
@@ -907,6 +975,10 @@ function _loadVariant() {
                     return loadVariantMeta(variantName, globalsItem);
                   case 3:
                     globalsVariant = _context5.v;
+                    currentMark = performanceMeasure(currentMark, {
+                      mark: 'Globals Variant Meta Loaded',
+                      measure: 'Globals Variant Meta Loading'
+                    }, [functionName, globalsItem, url || fileName]);
                     _context5.n = 5;
                     break;
                   case 4:
@@ -921,12 +993,16 @@ function _loadVariant() {
                   case 7:
                     _context5.p = 7;
                     _context5.n = 8;
-                    return loadVariant(globalsVariant.url, variantName, globalsVariant, _extends(_extends({}, options), {}, {
+                    return loadCodeVariant(globalsVariant.url, variantName, globalsVariant, _extends(_extends({}, options), {}, {
                       globalsCode: undefined
                     }) // Prevent infinite recursion
                     );
                   case 8:
                     globalsResult = _context5.v;
+                    currentMark = performanceMeasure(currentMark, {
+                      mark: 'Globals Variant Loaded',
+                      measure: 'Globals Variant Loading'
+                    }, [functionName, globalsVariant.url || variantName, url || fileName]);
                     return _context5.a(2, globalsResult);
                   case 9:
                     _context5.p = 9;
@@ -941,9 +1017,9 @@ function _loadVariant() {
               return _ref4.apply(this, arguments);
             };
           }()); // Wait for all globals to load
-          _context6.n = 13;
+          _context6.n = 14;
           return Promise.all(globalsPromises);
-        case 13:
+        case 14:
           globalsResults = _context6.v;
           // Merge results from all globals
           _iterator4 = _createForOfIteratorHelper(globalsResults);
@@ -981,13 +1057,18 @@ function _loadVariant() {
           } finally {
             _iterator4.f();
           }
-        case 14:
+        case 15:
+          currentMark = performanceMeasure(externalsMergedMark, {
+            mark: 'Globals Loaded',
+            measure: 'Globals Loading'
+          }, [functionName, url || fileName], true);
+          allExtraFiles = {}; // Load all extra files if any exist and we have a URL
           if (!(Object.keys(extraFilesToLoad).length > 0)) {
-            _context6.n = 19;
+            _context6.n = 21;
             break;
           }
           if (url) {
-            _context6.n = 17;
+            _context6.n = 18;
             break;
           }
           // If there's no URL, we can only load extra files that have inline source or absolute URLs
@@ -1005,7 +1086,7 @@ function _loadVariant() {
             }
           }
           if (!(Object.keys(loadableFiles).length > 0)) {
-            _context6.n = 16;
+            _context6.n = 17;
             break;
           }
           // Process loadable files: inline sources without URL-based loading, absolute URLs with loading
@@ -1032,10 +1113,10 @@ function _loadVariant() {
             }
           }
           if (!(Object.keys(urlFilesToLoad).length > 0)) {
-            _context6.n = 16;
+            _context6.n = 17;
             break;
           }
-          _context6.n = 15;
+          _context6.n = 16;
           return loadExtraFiles(variantName, urlFilesToLoad, '',
           // No base URL needed for absolute URLs
           '',
@@ -1044,28 +1125,33 @@ function _loadVariant() {
             loadedFiles: loadedFiles
           }), variant.allFilesListed || false, knownExtraFiles, globalsFileKeys // Pass globals file tracking
           );
-        case 15:
+        case 16:
           extraFilesResult = _context6.v;
           allExtraFiles = _extends(_extends({}, allExtraFiles), extraFilesResult.extraFiles);
           allFilesUsed.push.apply(allFilesUsed, _toConsumableArray(extraFilesResult.allFilesUsed));
           allExternals = mergeExternals([allExternals, extraFilesResult.allExternals]);
-        case 16:
-          _context6.n = 19;
-          break;
         case 17:
-          _context6.n = 18;
+          _context6.n = 20;
+          break;
+        case 18:
+          _context6.n = 19;
           return loadExtraFiles(variantName, extraFilesToLoad, url, url,
           // Entry URL is the same as the main file URL
           loadSource, sourceParser, sourceTransformers, loadSourceCache, _extends(_extends({}, options), {}, {
             loadedFiles: loadedFiles
           }), variant.allFilesListed || false, knownExtraFiles, globalsFileKeys // Pass globals file tracking
           );
-        case 18:
+        case 19:
           _extraFilesResult = _context6.v;
           allExtraFiles = _extraFilesResult.extraFiles;
           allFilesUsed.push.apply(allFilesUsed, _toConsumableArray(_extraFilesResult.allFilesUsed));
           allExternals = mergeExternals([allExternals, _extraFilesResult.allExternals]);
-        case 19:
+        case 20:
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Extra Files Loaded',
+            measure: 'Extra Files Loading'
+          }, [functionName, url || fileName], true);
+        case 21:
           // Note: metadata marking is now handled during loadExtraFiles processing
           finalVariant = _extends(_extends({}, variant), {}, {
             source: mainFileResult.source,
@@ -1082,5 +1168,5 @@ function _loadVariant() {
       }
     }, _callee5, null, [[3, 5]]);
   }));
-  return _loadVariant.apply(this, arguments);
+  return _loadCodeVariant.apply(this, arguments);
 }

package/esm/{CodeHighlighter/maybeInitialData.d.ts → pipeline/loadCodeVariant/maybeCodeInitialData.d.ts}

@@ -1,4 +1,4 @@
-import { Code, VariantExtraFiles, VariantSource } from "./types.js";
+import { Code, VariantExtraFiles, VariantSource } from "../../CodeHighlighter/types.js";
 /**
  * Type guard function that determines if we have sufficient data to render a code highlighter
  * component immediately, or if we need to start loading data first.
@@ -38,7 +38,7 @@ import { Code, VariantExtraFiles, VariantSource } from "./types.js";
  *   more predictable and easier to reason about
  *
  * When `initialData: false` is returned, the calling component is responsible for initiating
- * asynchronous loading operations (e.g., `loadFallbackCode`, `CodeInitialSourceLoader`).
+ * asynchronous loading operations (e.g., `loadCodeFallback`, `CodeInitialSourceLoader`).
  *
  * @param variants - Array of all available variant names for this code block (e.g., ['javascript', 'typescript'])
  * @param variant - The specific variant we want to display (must exist in variants array)
@@ -62,7 +62,7 @@ import { Code, VariantExtraFiles, VariantSource } from "./types.js";
  * @example
  * ```typescript
  * // Server-side: Check if we can render with initial source or need to load fallback
- * const { initialData, reason } = maybeInitialData(
+ * const { initialData, reason } = maybeCodeInitialData(
  *   variants,
  *   initialKey,
  *   code || props.precompute,
@@ -79,7 +79,7 @@ import { Code, VariantExtraFiles, VariantSource } from "./types.js";
  *
  * // Client-side: Check if we need to trigger loading effects
  * const { initialData, reason } = React.useMemo(() =>
- *   maybeInitialData(
+ *   maybeCodeInitialData(
  *     variants,
  *     variantName,
  *     code,
@@ -93,11 +93,11 @@ import { Code, VariantExtraFiles, VariantSource } from "./types.js";
  *   if (initialData || isControlled) {
  *     return; // No loading needed
  *   }
- *   // Trigger loadFallbackCode...
+ *   // Trigger loadCodeFallback...
  * }, [initialData, reason, ...]);
  * ```
  */
-export declare function maybeInitialData(variants: string[], variant: string, code?: Code, fileName?: string, needsHighlight?: boolean, needsAllFiles?: boolean, needsAllVariants?: boolean): {
+export declare function maybeCodeInitialData(variants: string[], variant: string, code?: Code, fileName?: string, needsHighlight?: boolean, needsAllFiles?: boolean, needsAllVariants?: boolean): {
   initialData: false | {
     code: Code;
     initialFilename: string | undefined;

package/esm/{CodeHighlighter/maybeInitialData.js → pipeline/loadCodeVariant/maybeCodeInitialData.js}

@@ -1,5 +1,5 @@
 import _typeof from "@babel/runtime/helpers/esm/typeof";
-import { hasAllVariants } from "./hasAllVariants.js";
+import { hasAllVariants } from "./hasAllCodeVariants.js";
 /**
  * Type guard function that determines if we have sufficient data to render a code highlighter
  * component immediately, or if we need to start loading data first.
@@ -39,7 +39,7 @@ import { hasAllVariants } from "./hasAllVariants.js";
  *   more predictable and easier to reason about
  *
  * When `initialData: false` is returned, the calling component is responsible for initiating
- * asynchronous loading operations (e.g., `loadFallbackCode`, `CodeInitialSourceLoader`).
+ * asynchronous loading operations (e.g., `loadCodeFallback`, `CodeInitialSourceLoader`).
  *
  * @param variants - Array of all available variant names for this code block (e.g., ['javascript', 'typescript'])
  * @param variant - The specific variant we want to display (must exist in variants array)
@@ -63,7 +63,7 @@ import { hasAllVariants } from "./hasAllVariants.js";
  * @example
  * ```typescript
  * // Server-side: Check if we can render with initial source or need to load fallback
- * const { initialData, reason } = maybeInitialData(
+ * const { initialData, reason } = maybeCodeInitialData(
  *   variants,
  *   initialKey,
  *   code || props.precompute,
@@ -80,7 +80,7 @@ import { hasAllVariants } from "./hasAllVariants.js";
  *
  * // Client-side: Check if we need to trigger loading effects
  * const { initialData, reason } = React.useMemo(() =>
- *   maybeInitialData(
+ *   maybeCodeInitialData(
  *     variants,
  *     variantName,
  *     code,
@@ -94,11 +94,11 @@ import { hasAllVariants } from "./hasAllVariants.js";
  *   if (initialData || isControlled) {
  *     return; // No loading needed
  *   }
- *   // Trigger loadFallbackCode...
+ *   // Trigger loadCodeFallback...
  * }, [initialData, reason, ...]);
  * ```
  */
-export function maybeInitialData(variants, variant, code, fileName) {
+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;

package/esm/{CodeHighlighter/mergeMetadata.d.ts → pipeline/loadCodeVariant/mergeCodeMetadata.d.ts}

@@ -1,7 +1,7 @@
 /**
  * Metadata merging utility for positioning metadata files relative to source files
  */
-import type { VariantCode, VariantExtraFiles } from "./types.js";
+import type { VariantCode, VariantExtraFiles } from "../../CodeHighlighter/types.js";
 /**
  * Options for merging metadata files
  */
@@ -32,9 +32,9 @@ interface MergeMetadataOptions {
  * @param variant - The variant containing mixed source and metadata files
  * @returns An object with the cleaned variant and extracted metadata
  */
-export declare function extractMetadata(variant: VariantCode): {
+export declare function extractCodeMetadata(variant: VariantCode): {
   variant: VariantCode;
   metadata: VariantExtraFiles;
 };
-export declare function mergeMetadata(variant: VariantCode, metadataFiles?: VariantExtraFiles, options?: MergeMetadataOptions): VariantCode;
+export declare function mergeCodeMetadata(variant: VariantCode, metadataFiles?: VariantExtraFiles, options?: MergeMetadataOptions): VariantCode;
 export {};

package/esm/{CodeHighlighter/mergeMetadata.js → pipeline/loadCodeVariant/mergeCodeMetadata.js}

@@ -26,7 +26,7 @@ import { calculateMaxSourceBackNavigation, removeBackNavigationPrefix, buildPath
  * @param variant - The variant containing mixed source and metadata files
  * @returns An object with the cleaned variant and extracted metadata
  */
-export function extractMetadata(variant) {
+export function extractCodeMetadata(variant) {
   var metadataPrefix = variant.metadataPrefix;
   var extractedMetadata = {};
   var nonMetadataFiles = {};
@@ -72,7 +72,7 @@ export function extractMetadata(variant) {
     metadata: extractedMetadata
   };
 }
-export function mergeMetadata(variant) {
+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] : {};
@@ -87,7 +87,7 @@ export function mergeMetadata(variant) {
   var existingMetadata = {};
   if (needsReextraction && variant.extraFiles) {
     // Extract existing metadata using the old metadataPrefix
-    var extracted = extractMetadata(variant);
+    var extracted = extractCodeMetadata(variant);
     workingVariant = extracted.variant;
     existingMetadata = extracted.metadata;
   }

package/esm/{CodeHighlighter → pipeline/loadCodeVariant}/parseCode.d.ts

@@ -1,4 +1,4 @@
-import type { Code, ParseSource } from "./types.js";
+import type { Code, ParseSource } from "../../CodeHighlighter/types.js";
 /**
  * Pure function to parse code variants and their extraFiles.
  * Converts string sources to HAST nodes and handles hastJson parsing.

package/esm/{CodeHighlighter → pipeline/loadCodeVariant}/transformSource.d.ts

@@ -1,2 +1,2 @@
-import type { VariantSource, SourceTransformers, Transforms } from "./types.js";
+import type { VariantSource, SourceTransformers, Transforms } from "../../CodeHighlighter/types.js";
 export declare function transformSource(source: VariantSource, fileName: string, sourceTransformers: SourceTransformers): Promise<Transforms | undefined>;

package/esm/pipeline/loadPrecomputedCodeHighlighter/loadPrecomputedCodeHighlighter.d.ts

@@ -1,5 +1,10 @@
 import type { LoaderContext } from 'webpack';
 export type LoaderOptions = {
+  performance?: {
+    logging?: boolean;
+    notableMs?: number;
+    showWrapperMeasures?: boolean;
+  };
   output?: 'hast' | 'hastJson' | 'hastGzip';
 };
 /**