@mui/internal-docs-infra 0.2.0-alpha.1 → 0.2.0

package/esm/pipeline/loaderUtils/processRelativeImports.d.ts

@@ -5,15 +5,20 @@ export interface ProcessImportsResult {
 }
 /**
  * Processes imports based on the specified storage mode, automatically handling
- * source rewriting when needed (e.g., for 'flat' mode).
+ * source rewriting when needed (e.g., for 'flat' mode). Works for both JavaScript and simple file types.
  *
  * @param source - The original source code
  * @param importResult - The result from parseImports
- * @param resolvedPathsMap - Map from import paths to resolved file paths
  * @param storeAt - How to process the imports
+ * @param isJsFile - Whether this is a JavaScript file (false = basic processing for CSS/JSON/etc.)
+ * @param resolvedPathsMap - Map from import paths to resolved file paths (only needed for JavaScript files)
  * @returns Object with processed source and extraFiles mapping
  */
 export declare function processRelativeImports(source: string, importResult: Record<string, {
   path: string;
   names: string[];
-}>, resolvedPathsMap: Map<string, string>, storeAt: StoreAtMode): ProcessImportsResult;
+  positions?: Array<{
+    start: number;
+    end: number;
+  }>;
+}>, storeAt: StoreAtMode, isJsFile?: boolean, resolvedPathsMap?: Map<string, string>): ProcessImportsResult;

package/esm/pipeline/loaderUtils/processRelativeImports.js

@@ -1,122 +1,9 @@
 import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import { rewriteImportsToSameDirectory } from "./rewriteImports.js";
+import { rewriteImports } from "./rewriteImports.js";
 import { isJavaScriptModule } from "./resolveModulePath.js";
 import { getFileNameFromUrl } from "./getFileNameFromUrl.js";
-/**
- * Processes imports based on the specified storage mode, automatically handling
- * source rewriting when needed (e.g., for 'flat' mode).
- *
- * @param source - The original source code
- * @param importResult - The result from parseImports
- * @param resolvedPathsMap - Map from import paths to resolved file paths
- * @param storeAt - How to process the imports
- * @returns Object with processed source and extraFiles mapping
- */
-export function processRelativeImports(source, importResult, resolvedPathsMap, storeAt) {
-  var extraFiles = {};
-
-  // For flat mode, we need to handle naming conflicts intelligently
-  if (storeAt === 'flat') {
-    var result = processFlatMode(importResult, resolvedPathsMap);
-
-    // Create import path mapping for rewriting
-    var importPathMapping = new Map();
-
-    // Build a reverse mapping from resolved paths to extraFiles keys
-    var resolvedToExtraFile = new Map();
-    Object.entries(result.extraFiles).forEach(function (_ref) {
-      var _ref2 = _slicedToArray(_ref, 2),
-        extraFileKey = _ref2[0],
-        fileUrl = _ref2[1];
-      var resolvedPath = fileUrl.replace('file://', '');
-      resolvedToExtraFile.set(resolvedPath, extraFileKey);
-    });
-
-    // For each import, find its resolved path and map to the corresponding extraFile key
-    Object.entries(importResult).forEach(function (_ref3) {
-      var _ref4 = _slicedToArray(_ref3, 2),
-        relativePath = _ref4[0],
-        importInfo = _ref4[1];
-      var resolvedPath = resolvedPathsMap.get(importInfo.path);
-      if (resolvedPath) {
-        var extraFileKey = resolvedToExtraFile.get(resolvedPath);
-        if (extraFileKey) {
-          // For JavaScript modules, remove the extension; for other files (CSS, JSON, etc.), keep it
-          var isJavascriptModule = isJavaScriptModule(relativePath);
-          var newPath = extraFileKey;
-          if (isJavascriptModule) {
-            // Handle TypeScript declaration files (.d.ts) properly
-            if (newPath.endsWith('.d.ts')) {
-              newPath = newPath.replace(/\.d\.ts$/, '');
-            } else {
-              newPath = newPath.replace(/\.[^/.]+$/, '');
-            }
-          }
-          // For non-JS modules (CSS, JSON, etc.), keep the full path with extension
-
-          importPathMapping.set(relativePath, newPath);
-        }
-      }
-    });
-
-    // Rewrite the source with the mapping
-    var rewrittenSource = rewriteImportsToSameDirectory(source, importPathMapping);
-    return {
-      processedSource: rewrittenSource,
-      extraFiles: result.extraFiles
-    };
-  }
-
-  // Process each import and generate extraFiles for non-flat modes
-  Object.entries(importResult).forEach(function (_ref5) {
-    var _ref6 = _slicedToArray(_ref5, 2),
-      relativePath = _ref6[0],
-      importInfo = _ref6[1];
-    var resolvedPath = resolvedPathsMap.get(importInfo.path);
-    if (resolvedPath) {
-      var fileExtension = getFileNameFromUrl(resolvedPath).extension;
-      var isJavascriptModule = isJavaScriptModule(relativePath);
-      var keyPath;
-      if (!isJavascriptModule) {
-        // For static assets (CSS, JSON, etc.), use the original import path as-is since it already has the extension
-        switch (storeAt) {
-          case 'canonical':
-          case 'import':
-            keyPath = relativePath;
-            break;
-          default:
-            keyPath = relativePath;
-        }
-      } else {
-        // For JS/TS modules, apply the existing logic
-        switch (storeAt) {
-          case 'canonical':
-            // Show the full resolved path including index files when they exist
-            // e.g., import '../Component' resolved to '/src/Component/index.js'
-            // becomes extraFiles: { '../Component/index.js': 'file:///src/Component/index.js' }
-            keyPath = "".concat(relativePath).concat(resolvedPath.endsWith("/index".concat(fileExtension)) ? "/index".concat(fileExtension) : fileExtension);
-            break;
-          case 'import':
-            // Use the original import path with the actual file extension
-            // e.g., import '../Component' with '/src/Component/index.js'
-            // becomes extraFiles: { '../Component.js': 'file:///src/Component/index.js' }
-            keyPath = "".concat(relativePath).concat(fileExtension);
-            break;
-          default:
-            keyPath = "".concat(relativePath).concat(fileExtension);
-        }
-      }
-      extraFiles[keyPath] = "file://".concat(resolvedPath);
-    }
-  });
-  return {
-    processedSource: source,
-    extraFiles: extraFiles
-  };
-}
-
 /**
  * Processes flat mode with intelligent conflict resolution
  */
@@ -125,10 +12,10 @@ function processFlatMode(importResult, resolvedPathsMap) {
   var fileMapping = [];
 
   // First pass: collect all files and their path segments
-  Object.entries(importResult).forEach(function (_ref7) {
-    var _ref8 = _slicedToArray(_ref7, 2),
-      relativePath = _ref8[0],
-      importInfo = _ref8[1];
+  Object.entries(importResult).forEach(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      relativePath = _ref2[0],
+      importInfo = _ref2[1];
     var resolvedPath = resolvedPathsMap.get(importInfo.path);
     if (resolvedPath) {
       var fileExtension = getFileNameFromUrl(resolvedPath).extension;
@@ -349,4 +236,236 @@ function processFlatMode(importResult, resolvedPathsMap) {
     // Will be set by caller after rewriting
     extraFiles: extraFiles
   };
+}
+
+/**
+ * Processes imports with basic conflict resolution based on filenames.
+ * Used for CSS, JSON, and other simple file types that don't require complex module resolution.
+ */
+function processBasicImports(source, importResult, storeAt) {
+  var extraFiles = {};
+  if (storeAt === 'flat') {
+    var finalNames = new Map();
+    var usedNames = new Set();
+
+    // Process each import to determine final names with simple conflict resolution
+    Object.entries(importResult).forEach(function (_ref3) {
+      var _ref4 = _slicedToArray(_ref3, 2),
+        _relativePath = _ref4[0],
+        importInfo = _ref4[1];
+      var resolvedPath = importInfo.path; // For CSS, this is already resolved by parseImports
+      var fileUrl = resolvedPath.startsWith('http') ? resolvedPath : "file://".concat(resolvedPath);
+      var _getFileNameFromUrl = getFileNameFromUrl(fileUrl),
+        fileName = _getFileNameFromUrl.fileName,
+        extension = _getFileNameFromUrl.extension;
+      var finalName = fileName;
+      var counter = 1;
+
+      // Handle naming conflicts by appending numbers
+      while (usedNames.has(finalName)) {
+        var baseName = fileName.replace(extension, '');
+        finalName = "".concat(baseName, "-").concat(counter).concat(extension);
+        counter += 1;
+      }
+      usedNames.add(finalName);
+      finalNames.set(resolvedPath, finalName);
+    });
+
+    // Create the import path mapping for rewriting
+    var importPathMapping = new Map();
+    Object.entries(importResult).forEach(function (_ref5) {
+      var _ref6 = _slicedToArray(_ref5, 2),
+        relativePath = _ref6[0],
+        importInfo = _ref6[1];
+      var resolvedPath = importInfo.path;
+      var finalName = finalNames.get(resolvedPath);
+      if (finalName) {
+        importPathMapping.set(relativePath, finalName);
+      }
+    });
+
+    // Create extraFiles entries
+    finalNames.forEach(function (finalName, resolvedPath) {
+      var fileUrl = resolvedPath.startsWith('http') ? resolvedPath : "file://".concat(resolvedPath);
+      extraFiles["./".concat(finalName)] = fileUrl;
+    });
+
+    // Apply import path replacements using position-based rewriting
+    // Only rewrite if positions are available
+    var hasPositions = Object.values(importResult).some(function (imp) {
+      return imp.positions && imp.positions.length > 0;
+    });
+    var processedSource = hasPositions ? rewriteImports(source, importPathMapping, importResult) : source;
+    return {
+      processedSource: processedSource,
+      extraFiles: extraFiles
+    };
+  }
+  if (storeAt === 'import') {
+    // Create a mapping for import mode: remove ./ prefix from relative paths
+    var importModeMapping = new Map();
+    Object.keys(importResult).forEach(function (relativePath) {
+      if (relativePath.startsWith('./')) {
+        importModeMapping.set(relativePath, relativePath.slice(2));
+      }
+      // Keep other paths (../, absolute URLs) unchanged
+    });
+
+    // Process each import for extraFiles
+    Object.entries(importResult).forEach(function (_ref7) {
+      var _ref8 = _slicedToArray(_ref7, 2),
+        relativePath = _ref8[0],
+        importInfo = _ref8[1];
+      var resolvedPath = importInfo.path;
+      var fileUrl = resolvedPath.startsWith('http') ? resolvedPath : "file://".concat(resolvedPath);
+      extraFiles[relativePath] = fileUrl; // Always use original path for extraFiles
+    });
+
+    // Apply import path replacements using position-based rewriting
+    // Only rewrite if positions are available
+    var _hasPositions = Object.values(importResult).some(function (imp) {
+      return imp.positions && imp.positions.length > 0;
+    });
+    var _processedSource = _hasPositions ? rewriteImports(source, importModeMapping, importResult) : source;
+    return {
+      processedSource: _processedSource,
+      extraFiles: extraFiles
+    };
+  }
+
+  // Canonical mode - no rewriting needed
+  Object.entries(importResult).forEach(function (_ref9) {
+    var _ref0 = _slicedToArray(_ref9, 2),
+      relativePath = _ref0[0],
+      importInfo = _ref0[1];
+    var resolvedPath = importInfo.path;
+    var fileUrl = resolvedPath.startsWith('http') ? resolvedPath : "file://".concat(resolvedPath);
+    extraFiles[relativePath] = fileUrl; // Use original import path
+  });
+  return {
+    processedSource: source,
+    // No rewriting needed for canonical mode
+    extraFiles: extraFiles
+  };
+}
+
+/**
+ * Processes JavaScript imports with complex conflict resolution and module handling
+ */
+function processJsImports(source, importResult, storeAt, resolvedPathsMap) {
+  var extraFiles = {};
+  if (storeAt === 'flat') {
+    var result = processFlatMode(importResult, resolvedPathsMap);
+
+    // Build a reverse mapping from resolved paths to extraFiles keys
+    var resolvedToExtraFile = new Map();
+    Object.entries(result.extraFiles).forEach(function (_ref1) {
+      var _ref10 = _slicedToArray(_ref1, 2),
+        extraFileKey = _ref10[0],
+        fileUrl = _ref10[1];
+      var resolvedPath = fileUrl.replace('file://', '');
+      resolvedToExtraFile.set(resolvedPath, extraFileKey);
+    });
+
+    // For each import, find its resolved path and map to the corresponding extraFile key
+    var importPathMapping = new Map();
+    Object.entries(importResult).forEach(function (_ref11) {
+      var _ref12 = _slicedToArray(_ref11, 2),
+        relativePath = _ref12[0],
+        importInfo = _ref12[1];
+      var resolvedPath = resolvedPathsMap.get(importInfo.path);
+      if (resolvedPath) {
+        var extraFileKey = resolvedToExtraFile.get(resolvedPath);
+        if (extraFileKey) {
+          // For JavaScript modules, remove the extension; for other files (CSS, JSON, etc.), keep it
+          var isJavascriptModule = isJavaScriptModule(relativePath);
+          var newPath = extraFileKey;
+          if (isJavascriptModule) {
+            // Handle TypeScript declaration files (.d.ts) properly
+            if (newPath.endsWith('.d.ts')) {
+              newPath = newPath.replace(/\.d\.ts$/, '');
+            } else {
+              newPath = newPath.replace(/\.[^/.]+$/, '');
+            }
+          }
+          // For non-JS modules (CSS, JSON, etc.), keep the full path with extension
+
+          importPathMapping.set(relativePath, newPath);
+        }
+      }
+    });
+
+    // Apply import path replacements using position-based rewriting
+    var processedSource = rewriteImports(source, importPathMapping, importResult);
+    return {
+      processedSource: processedSource,
+      extraFiles: result.extraFiles
+    };
+  }
+
+  // Non-flat modes (canonical and import)
+  Object.entries(importResult).forEach(function (_ref13) {
+    var _ref14 = _slicedToArray(_ref13, 2),
+      relativePath = _ref14[0],
+      importInfo = _ref14[1];
+    var resolved = resolvedPathsMap.get(importInfo.path);
+    if (!resolved) {
+      return;
+    }
+    var resolvedPath = resolved;
+    var fileExtension = getFileNameFromUrl(resolvedPath).extension;
+    var isJavascriptModule = isJavaScriptModule(relativePath);
+    var keyPath;
+    if (!isJavascriptModule) {
+      // For static assets (CSS, JSON, etc.), use the original import path as-is
+      keyPath = relativePath;
+    } else {
+      // For JS/TS modules, apply the existing logic
+      switch (storeAt) {
+        case 'canonical':
+          // Show the full resolved path including index files when they exist
+          keyPath = "".concat(relativePath).concat(resolvedPath.endsWith("/index".concat(fileExtension)) ? "/index".concat(fileExtension) : fileExtension);
+          break;
+        case 'import':
+          // Use the original import path with the actual file extension
+          keyPath = "".concat(relativePath).concat(fileExtension);
+          break;
+        default:
+          keyPath = "".concat(relativePath).concat(fileExtension);
+      }
+    }
+    var fileUrl = resolvedPath.startsWith('http') ? resolvedPath : "file://".concat(resolvedPath);
+    extraFiles[keyPath] = fileUrl;
+  });
+  return {
+    processedSource: source,
+    // No rewriting needed for non-flat modes
+    extraFiles: extraFiles
+  };
+}
+
+/**
+ * Processes imports based on the specified storage mode, automatically handling
+ * source rewriting when needed (e.g., for 'flat' mode). Works for both JavaScript and simple file types.
+ *
+ * @param source - The original source code
+ * @param importResult - The result from parseImports
+ * @param storeAt - How to process the imports
+ * @param isJsFile - Whether this is a JavaScript file (false = basic processing for CSS/JSON/etc.)
+ * @param resolvedPathsMap - Map from import paths to resolved file paths (only needed for JavaScript files)
+ * @returns Object with processed source and extraFiles mapping
+ */
+export function processRelativeImports(source, importResult, storeAt) {
+  var isJsFile = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var resolvedPathsMap = arguments.length > 4 ? arguments[4] : undefined;
+  if (!isJsFile) {
+    // Use basic processing mode for CSS, JSON, and other simple file types
+    return processBasicImports(source, importResult, storeAt);
+  }
+
+  // Use complex JavaScript processing mode
+  if (!resolvedPathsMap) {
+    throw new Error('resolvedPathsMap is required for JavaScript files');
+  }
+  return processJsImports(source, importResult, storeAt, resolvedPathsMap);
 }

package/esm/pipeline/loaderUtils/resolveModulePath.d.ts

@@ -1,15 +1,15 @@
 /**
  * Default file extensions for JavaScript/TypeScript modules that can be resolved
  */
-export declare const JAVASCRIPT_MODULE_EXTENSIONS: readonly [".ts", ".tsx", ".js", ".jsx", ".d.ts"];
+export declare const JAVASCRIPT_MODULE_EXTENSIONS: readonly [".ts", ".tsx", ".js", ".jsx", ".mdx", ".d.ts"];
 /**
  * Extension priority for type-only imports - prioritize .d.ts first
  */
-export declare const TYPE_IMPORT_EXTENSIONS: readonly [".d.ts", ".ts", ".tsx", ".js", ".jsx"];
+export declare const TYPE_IMPORT_EXTENSIONS: readonly [".d.ts", ".ts", ".tsx", ".js", ".jsx", ".mdx"];
 /**
  * Extension priority for value imports - standard priority with .d.ts last
  */
-export declare const VALUE_IMPORT_EXTENSIONS: readonly [".ts", ".tsx", ".js", ".jsx", ".d.ts"];
+export declare const VALUE_IMPORT_EXTENSIONS: readonly [".ts", ".tsx", ".js", ".jsx", ".mdx", ".d.ts"];
 /**
  * Checks if a file path or import path represents a JavaScript/TypeScript module
  * @param path - The file path or import path to check
@@ -73,6 +73,10 @@ export declare function resolveImportResult(importResult: Record<string, {
   path: string;
   names: string[];
   includeTypeDefs?: true;
+  positions?: Array<{
+    start: number;
+    end: number;
+  }>;
 }>, readDirectory: DirectoryReader, options?: ResolveModulePathOptions): Promise<Map<string, string>>;
 /**
  * Resolves variant paths from a variants object mapping variant names to their file paths.

package/esm/pipeline/loaderUtils/resolveModulePath.js

@@ -34,17 +34,17 @@ function joinPath(basePath) {
 /**
  * Default file extensions for JavaScript/TypeScript modules that can be resolved
  */
-export var JAVASCRIPT_MODULE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.d.ts'];
+export var JAVASCRIPT_MODULE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mdx', '.d.ts'];
 
 /**
  * Extension priority for type-only imports - prioritize .d.ts first
  */
-export var TYPE_IMPORT_EXTENSIONS = ['.d.ts', '.ts', '.tsx', '.js', '.jsx'];
+export var TYPE_IMPORT_EXTENSIONS = ['.d.ts', '.ts', '.tsx', '.js', '.jsx', '.mdx'];
 
 /**
  * Extension priority for value imports - standard priority with .d.ts last
  */
-export var VALUE_IMPORT_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.d.ts'];
+export var VALUE_IMPORT_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mdx', '.d.ts'];
 
 /**
  * Checks if a file path or import path represents a JavaScript/TypeScript module

package/esm/pipeline/loaderUtils/resolveModulePathWithFs.d.ts

@@ -33,6 +33,10 @@ export declare function resolveImportResultWithFs(importResult: Record<string, {
   path: string;
   names: string[];
   includeTypeDefs?: true;
+  positions?: Array<{
+    start: number;
+    end: number;
+  }>;
 }>, options?: ResolveModulePathOptions): Promise<Map<string, string>>;
 /**
  * Resolves variant paths from a variants object mapping variant names to their file paths.

package/esm/pipeline/loaderUtils/rewriteImports.d.ts

@@ -1,9 +1,16 @@
 /**
- * Rewrites relative imports in source code based on a provided mapping.
- * Converts imports like '../utils/helper' or './components/Button' to their mapped equivalents
+ * Efficiently rewrites import paths using position data.
+ * This avoids regex parsing and uses precise position information for replacement.
+ * Works for both JavaScript/TypeScript and CSS imports.
  *
  * @param source - The source code to process
- * @param importPathMapping - Map from original import paths to new import paths (without extensions)
- * @returns The source code with rewritten imports
+ * @param importPathMapping - Map from original import paths to new import paths
+ * @param importResult - Import result with position data
+ * @returns The source code with rewritten import paths
  */
-export declare function rewriteImportsToSameDirectory(source: string, importPathMapping: Map<string, string>): string;
+export declare function rewriteImports(source: string, importPathMapping: Map<string, string>, importResult: Record<string, {
+  positions: Array<{
+    start: number;
+    end: number;
+  }>;
+}>): string;

package/esm/pipeline/loaderUtils/rewriteImports.js

@@ -1,35 +1,65 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 /**
- * Rewrites relative imports in source code based on a provided mapping.
- * Converts imports like '../utils/helper' or './components/Button' to their mapped equivalents
+ * Interface for rewrite replacement operations.
+ */
+
+/**
+ * Efficiently rewrites import paths using position data.
+ * This avoids regex parsing and uses precise position information for replacement.
+ * Works for both JavaScript/TypeScript and CSS imports.
  *
  * @param source - The source code to process
- * @param importPathMapping - Map from original import paths to new import paths (without extensions)
- * @returns The source code with rewritten imports
+ * @param importPathMapping - Map from original import paths to new import paths
+ * @param importResult - Import result with position data
+ * @returns The source code with rewritten import paths
  */
-export function rewriteImportsToSameDirectory(source, importPathMapping) {
-  // Handle both types of imports:
-  // 1. import [something] from 'path' (including import type)
-  // 2. import 'path' (side-effect imports like CSS)
+export function rewriteImports(source, importPathMapping, importResult) {
+  var replacements = [];
 
-  return source.replace(/import\s+((?:type\s+)?(?:\w+|\*\s+as\s+\w+|{[^}]+})\s+from\s+)['"]([^'"]+)['"]/g, function (match, importPart, modulePath) {
-    // Only process relative imports
-    if (modulePath.startsWith('.')) {
-      // Check if we have a mapping for this import path
-      if (importPathMapping.has(modulePath)) {
-        var newPath = importPathMapping.get(modulePath);
-        return "import ".concat(importPart, "'").concat(newPath, "'");
-      }
-    }
-    return match;
-  }).replace(/import\s+['"]([^'"]+)['"]/g, function (match, modulePath) {
-    // Only process relative imports
-    if (modulePath.startsWith('.')) {
-      // Check if we have a mapping for this import path
-      if (importPathMapping.has(modulePath)) {
-        var newPath = importPathMapping.get(modulePath);
-        return "import '".concat(newPath, "'");
+  // Use precise position-based replacement
+  importPathMapping.forEach(function (newPath, originalPath) {
+    var _importResult$origina;
+    var positions = (_importResult$origina = importResult[originalPath]) == null ? void 0 : _importResult$origina.positions;
+    if (positions && positions.length > 0) {
+      // Process all positions where this import path appears
+      var _iterator = _createForOfIteratorHelper(positions),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var position = _step.value;
+          // Validate position bounds
+          if (position.start >= 0 && position.end <= source.length && position.start < position.end) {
+            // The positions include the quotes, so we need to preserve them
+            var originalText = source.slice(position.start, position.end);
+            if (originalText.length > 0) {
+              var quote = originalText.charAt(0); // Get the original quote character
+              var newText = "".concat(quote).concat(newPath).concat(quote);
+              replacements.push({
+                start: position.start,
+                end: position.end,
+                newText: newText
+              });
+            }
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
       }
     }
-    return match;
   });
+
+  // Sort replacements by position (descending) to avoid position shifts
+  replacements.sort(function (a, b) {
+    return b.start - a.start;
+  });
+
+  // Apply replacements from right to left
+  var result = source;
+  for (var _i = 0, _replacements = replacements; _i < _replacements.length; _i++) {
+    var replacement = _replacements[_i];
+    result = result.slice(0, replacement.start) + replacement.newText + result.slice(replacement.end);
+  }
+  return result;
 }

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

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

package/esm/pipeline/transformHtmlCodePrecomputed/index.js

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

package/esm/pipeline/transformHtmlCodePrecomputed/transformHtmlCodePrecomputed.d.ts

@@ -0,0 +1,13 @@
+import type { Plugin } from 'unified';
+/**
+ * Rehype plugin that transforms semantic HTML code structures to use loadVariant
+ *
+ * This plugin:
+ * 1. Finds section and dl elements in the HTML AST
+ * 2. Extracts code elements from the semantic structure (figure/dl/dd/pre/code)
+ * 3. Creates variants from multiple code elements or single Default variant
+ * 4. Uses loadVariant to process each variant
+ * 5. Stores the combined precompute data on the root element
+ * 6. Clears all code element contents and replaces with error message
+ */
+export declare const transformHtmlCodePrecomputed: Plugin;