@mui/internal-docs-infra 0.2.3-canary.13 → 0.2.3-canary.15

package/esm/pipeline/loadCodeVariant/loadCodeVariant.js

@@ -12,6 +12,7 @@ import { transformSource } from "./transformSource.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) {
@@ -138,6 +139,8 @@ function _loadSingleFile() {
       extraFilesFromSource,
       extraDependenciesFromSource,
       externalsFromSource,
+      functionName,
+      currentMark,
       loadPromise,
       loadResult,
       _i,
@@ -170,6 +173,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 +209,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 +333,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,6 +355,10 @@ 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;
@@ -347,6 +367,10 @@ function _loadSingleFile() {
           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 +387,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 +399,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;
@@ -668,6 +700,8 @@ function _loadCodeVariant() {
       sourceTransformers,
       globalsCode,
       loadSourceCache,
+      functionName,
+      currentMark,
       _getFileNameFromUrl,
       _fileName,
       loadedFiles,
@@ -680,11 +714,11 @@ function _loadCodeVariant() {
       fileName,
       _finalVariant,
       mainFileResult,
-      allExtraFiles,
       _i5,
       _Object$keys3,
       _extraFileName,
       extraFilesToLoad,
+      externalsMergedMark,
       globalsFileKeys,
       existingFiles,
       _i6,
@@ -701,6 +735,7 @@ function _loadCodeVariant() {
       _key,
       value,
       conflictFreeKey,
+      allExtraFiles,
       loadableFiles,
       _i8,
       _Object$entries4,
@@ -736,8 +771,13 @@ function _loadCodeVariant() {
         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 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 +796,7 @@ function _loadCodeVariant() {
             url: variant,
             fileName: _fileName
           };
-          _context6.n = 6;
+          _context6.n = 7;
           break;
         case 3:
           _context6.p = 3;
@@ -771,6 +811,11 @@ function _loadCodeVariant() {
           _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 +834,7 @@ function _loadCodeVariant() {
           // 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 +853,66 @@ function _loadCodeVariant() {
             // 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 +962,10 @@ function _loadCodeVariant() {
                     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:
@@ -927,6 +986,10 @@ function _loadCodeVariant() {
                     );
                   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 +1004,9 @@ function _loadCodeVariant() {
               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 +1044,18 @@ function _loadCodeVariant() {
           } 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 +1073,7 @@ function _loadCodeVariant() {
             }
           }
           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 +1100,10 @@ function _loadCodeVariant() {
             }
           }
           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 +1112,33 @@ function _loadCodeVariant() {
             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,

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';
 };
 /**

package/esm/pipeline/loadPrecomputedCodeHighlighter/loadPrecomputedCodeHighlighter.js

@@ -2,6 +2,9 @@ import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIt
 import _regenerator from "@babel/runtime/helpers/esm/regenerator";
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+// webpack does not like node: imports
+// eslint-disable-next-line n/prefer-node-protocol
+import path from 'path';
 import { loadCodeVariant } from "../loadCodeVariant/loadCodeVariant.js";
 import { createParseSource } from "../parseSource/index.js";
 // TODO: re-enable following benchmarking
@@ -12,6 +15,9 @@ import { resolveVariantPathsWithFs } from "../loadServerCodeMeta/resolveModulePa
 import { replacePrecomputeValue } from "./replacePrecomputeValue.js";
 import { createLoadServerSource } from "../loadServerSource/index.js";
 import { getFileNameFromUrl } from "../loaderUtils/index.js";
+import { createPerformanceLogger, logPerformance, performanceMeasure } from "./performanceLogger.js";
+var functionName = 'Load Precomputed Code Highlighter';
+
 /**
  * Webpack loader that processes demo files and precomputes variant data.
  *
@@ -28,18 +34,44 @@ export function loadPrecomputedCodeHighlighter(_x) {
 }
 function _loadPrecomputedCodeHighlighter() {
   _loadPrecomputedCodeHighlighter = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(source) {
-    var _this = this;
-    var callback, demoCall, variantData, allDependencies, resolvedVariantMap, loadSource, sourceTransformers, sourceParser, variantPromises, variantResults, _iterator, _step, result, modifiedSource, _t2;
+    var _options$performance$,
+      _options$performance,
+      _options$performance$2,
+      _options$performance2,
+      _options$performance3,
+      _this = this;
+    var callback, options, performanceNotableMs, performanceShowWrapperMeasures, relativePath, observer, currentMark, _observer, _observer2, demoCall, variantData, allDependencies, resolvedVariantMap, loadSource, sourceTransformers, sourceParser, functionsInitMark, variantPromises, variantResults, _iterator, _step, result, modifiedSource, _observer3, _observer4, _t2;
     return _regenerator().w(function (_context2) {
       while (1) switch (_context2.p = _context2.n) {
         case 0:
           callback = this.async();
           this.cacheable();
+          options = this.getOptions();
+          performanceNotableMs = (_options$performance$ = (_options$performance = options.performance) == null ? void 0 : _options$performance.notableMs) != null ? _options$performance$ : 100;
+          performanceShowWrapperMeasures = (_options$performance$2 = (_options$performance2 = options.performance) == null ? void 0 : _options$performance2.showWrapperMeasures) != null ? _options$performance$2 : false;
+          relativePath = path.relative(this.rootContext || process.cwd(), this.resourcePath);
+          observer = undefined;
+          if ((_options$performance3 = options.performance) != null && _options$performance3.logging) {
+            observer = new PerformanceObserver(createPerformanceLogger(performanceNotableMs, performanceShowWrapperMeasures, relativePath));
+            observer.observe({
+              entryTypes: ['measure']
+            });
+          }
+          currentMark = performanceMeasure(undefined, {
+            mark: 'Start',
+            measure: 'Start'
+          }, [functionName, relativePath], true);
           _context2.p = 1;
           _context2.n = 2;
           return parseCreateFactoryCall(source, this.resourcePath);
         case 2:
           demoCall = _context2.v;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Parsed Factory',
+            measure: 'Factory Parsing'
+          }, [functionName, relativePath]);
+
+          // If no createDemo call found, return the source unchanged
           if (demoCall) {
             _context2.n = 3;
             break;
@@ -61,6 +93,11 @@ function _loadPrecomputedCodeHighlighter() {
           return resolveVariantPathsWithFs(demoCall.variants || {});
         case 5:
           resolvedVariantMap = _context2.v;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Paths Resolved',
+            measure: 'Path Resolution'
+          }, [functionName, relativePath]);
+
           // Create loader functions
           loadSource = createLoadServerSource({
             includeDependencies: true,
@@ -69,15 +106,26 @@ function _loadPrecomputedCodeHighlighter() {
           // const sourceTransformers: SourceTransformers = [TypescriptToJavascriptTransformer];
           // TODO: maybe we should have `loadPrecomputedCodeHighlighterWithJsToTs`
           sourceTransformers = []; // Create sourceParser promise for syntax highlighting
-          sourceParser = createParseSource(); // Process variants in parallel
+          sourceParser = createParseSource();
+          functionsInitMark = performanceMeasure(currentMark, {
+            mark: 'Functions Init',
+            measure: 'Functions Init'
+          }, [functionName, relativePath]);
+          currentMark = functionsInitMark;
+
+          // Process variants in parallel
           variantPromises = Array.from(resolvedVariantMap.entries()).map(/*#__PURE__*/function () {
             var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref) {
               var _demoCall$namedExport;
-              var _ref3, variantName, fileUrl, namedExport, variant, _getFileNameFromUrl, fileName, _yield$loadCodeVarian, processedVariant, dependencies, _t;
+              var _ref3, variantName, fileUrl, variantMark, namedExport, variant, _getFileNameFromUrl, fileName, _yield$loadCodeVarian, processedVariant, dependencies, _t;
               return _regenerator().w(function (_context) {
                 while (1) switch (_context.p = _context.n) {
                   case 0:
                     _ref3 = _slicedToArray(_ref, 2), variantName = _ref3[0], fileUrl = _ref3[1];
+                    variantMark = performanceMeasure(functionsInitMark, {
+                      mark: 'Variant Started',
+                      measure: 'Variant Start'
+                    }, [functionName, variantName, relativePath], true);
                     namedExport = (_demoCall$namedExport = demoCall.namedExports) == null ? void 0 : _demoCall$namedExport[variantName];
                     variant = fileUrl;
                     if (!namedExport) {
@@ -116,6 +164,10 @@ function _loadPrecomputedCodeHighlighter() {
                     _yield$loadCodeVarian = _context.v;
                     processedVariant = _yield$loadCodeVarian.code;
                     dependencies = _yield$loadCodeVarian.dependencies;
+                    performanceMeasure(variantMark, {
+                      mark: 'Variant Loaded',
+                      measure: 'Variant Loading'
+                    }, [functionName, variantName, relativePath], true);
                     return _context.a(2, {
                       variantName: variantName,
                       variantData: processedVariant,
@@ -151,24 +203,45 @@ function _loadPrecomputedCodeHighlighter() {
                 });
               }
             }
-
-            // Replace the factory function call with the actual precomputed data
           } catch (err) {
             _iterator.e(err);
           } finally {
             _iterator.f();
           }
-          modifiedSource = replacePrecomputeValue(source, variantData, demoCall); // Add all dependencies to webpack's watch list
+          currentMark = performanceMeasure(functionsInitMark, {
+            mark: 'All Variants Loaded',
+            measure: 'Complete Variants Loading'
+          }, [functionName, relativePath], true);
+
+          // Replace the factory function call with the actual precomputed data
+          modifiedSource = replacePrecomputeValue(source, variantData, demoCall);
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Replaced Precompute',
+            measure: 'Precompute Replacement'
+          }, [functionName, relativePath]);
+
+          // Add all dependencies to webpack's watch list
           allDependencies.forEach(function (dep) {
             // Strip 'file://' prefix if present before adding to webpack's dependency tracking
             _this.addDependency(dep.startsWith('file://') ? dep.slice(7) : dep);
           });
+
+          // log any pending performance entries before completing
+          (_observer = observer) == null || (_observer = _observer.takeRecords()) == null || _observer.forEach(function (entry) {
+            return logPerformance(entry, performanceNotableMs, performanceShowWrapperMeasures, relativePath);
+          });
+          (_observer2 = observer) == null || _observer2.disconnect();
           callback(null, modifiedSource);
           _context2.n = 8;
           break;
         case 7:
           _context2.p = 7;
           _t2 = _context2.v;
+          // log any pending performance entries before completing
+          (_observer3 = observer) == null || (_observer3 = _observer3.takeRecords()) == null || _observer3.forEach(function (entry) {
+            return logPerformance(entry, performanceNotableMs, performanceShowWrapperMeasures, relativePath);
+          });
+          (_observer4 = observer) == null || _observer4.disconnect();
           callback(_t2 instanceof Error ? _t2 : new Error(String(_t2)));
         case 8:
           return _context2.a(2);

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

@@ -0,0 +1,30 @@
+export declare function logPerformance(entry: PerformanceEntry, notableMs: number, showWrapperMeasures: boolean, filterContext?: string): void;
+export declare function createPerformanceLogger(notableMs: number, showWrapperMeasures: boolean, filterContext?: string): PerformanceObserverCallback;
+export declare function nameMark(functionName: string, event: string, context: string[], wrapper?: boolean): string;
+/**
+ * Helper to create a performance mark and measure in one call.
+ *
+ * @param startMark - Optional start mark name for the measure (typically currentMark)
+ * @param names - Object with mark and measure names
+ * @param context - Array of context strings [functionName, ...context]
+ * @param wrapper - Whether this is a wrapper measure (uses pipe delimiter)
+ * @returns The mark name that was created
+ *
+ * @example
+ * ```ts
+ * currentMark = performanceMeasure(
+ *   currentMark,
+ *   { mark: 'processed', measure: 'processing' },
+ *   [functionName, relativePath],
+ *   true,
+ * );
+ * ```
+ */
+export declare function performanceMeasure(startMark: string | undefined, names: {
+  mark: string;
+  measure: string;
+} | {
+  prefix?: string;
+  mark: string;
+  measure: string;
+}, context: string[], wrapper?: boolean): string;

package/esm/pipeline/loadPrecomputedCodeHighlighter/performanceLogger.js

@@ -0,0 +1,77 @@
+import _arrayLikeToArray from "@babel/runtime/helpers/esm/arrayLikeToArray";
+import _toArray from "@babel/runtime/helpers/esm/toArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+export function logPerformance(entry, notableMs, showWrapperMeasures, filterContext) {
+  if (entry.duration < notableMs) {
+    return;
+  }
+
+  // If filterContext is provided, only log entries that include it
+  if (filterContext && !entry.name.includes(filterContext)) {
+    return;
+  }
+  var delim = '-';
+  var message = entry.name;
+  if (message.startsWith('| ')) {
+    if (!showWrapperMeasures) {
+      return;
+    }
+    delim = '|';
+    message = message.slice(2);
+  }
+  var duration = Math.round(entry.duration).toString().padStart(4, ' ');
+  console.warn("".concat(duration, "ms ").concat(delim, " ").concat(message));
+}
+export function createPerformanceLogger(notableMs, showWrapperMeasures, filterContext) {
+  var performanceLogger = function performanceLogger(list) {
+    var _iterator = _createForOfIteratorHelper(list.getEntries()),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var entry = _step.value;
+        logPerformance(entry, notableMs, showWrapperMeasures, filterContext);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  };
+  return performanceLogger;
+}
+export function nameMark(functionName, event, context) {
+  var wrapper = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  return "".concat(wrapper ? '| ' : '').concat(functionName, " ").concat(wrapper ? '|' : '-', " ").concat(event, " - ").concat(context.join(' - '));
+}
+
+/**
+ * Helper to create a performance mark and measure in one call.
+ *
+ * @param startMark - Optional start mark name for the measure (typically currentMark)
+ * @param names - Object with mark and measure names
+ * @param context - Array of context strings [functionName, ...context]
+ * @param wrapper - Whether this is a wrapper measure (uses pipe delimiter)
+ * @returns The mark name that was created
+ *
+ * @example
+ * ```ts
+ * currentMark = performanceMeasure(
+ *   currentMark,
+ *   { mark: 'processed', measure: 'processing' },
+ *   [functionName, relativePath],
+ *   true,
+ * );
+ * ```
+ */
+export function performanceMeasure(startMark, names, context) {
+  var wrapper = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var _context = _toArray(context),
+    functionName = _context[0],
+    restContext = _arrayLikeToArray(_context).slice(1);
+  var prefix = 'prefix' in names && names.prefix ? "".concat(names.prefix, " ") : '';
+  var markName = nameMark(functionName, "".concat(prefix).concat(names.mark), restContext, wrapper);
+  var measureName = nameMark(functionName, "".concat(prefix).concat(names.measure), restContext, wrapper);
+  performance.mark(markName);
+  performance.measure(measureName, startMark, markName);
+  return markName;
+}

package/esm/pipeline/transformMarkdownBlockquoteCallouts/index.d.ts

@@ -0,0 +1,2 @@
+import { transformMarkdownBlockquoteCallouts } from "./transformMarkdownBlockquoteCallouts.js";
+export default transformMarkdownBlockquoteCallouts;

package/esm/pipeline/transformMarkdownBlockquoteCallouts/index.js

@@ -0,0 +1,4 @@
+// This is the export format expected by a remark plugin.
+
+import { transformMarkdownBlockquoteCallouts } from "./transformMarkdownBlockquoteCallouts.js";
+export default transformMarkdownBlockquoteCallouts;