@mui/internal-docs-infra 0.1.1-alpha.1 → 0.1.1-alpha.11

package/{loaderUtils → pipeline/loaderUtils}/resolveModulePathWithFs.d.ts

@@ -1,13 +1,15 @@
-import { type DirectoryEntry, type DirectoryReader, type ResolveModulePathOptions } from "./resolveModulePath.js";
+import { type DirectoryEntry, type DirectoryReader, type ResolveModulePathOptions, type TypeAwareResolveResult } from "./resolveModulePath.js";
 /**
  * Resolves a module path using Node.js filesystem APIs.
  * This is a convenience wrapper around the generic resolveModulePath function.
  *
  * @param modulePath - The module path to resolve (without file extension)
  * @param options - Configuration options
- * @returns Promise<string> - The resolved file path, or throws if not found
+ * @param includeTypeDefs - If true, returns both import and typeImport paths with different extension priorities
+ * @returns Promise<string | TypeAwareResolveResult> - The resolved file path(s), or throws if not found
  */
 export declare function resolveModulePathWithFs(modulePath: string, options?: ResolveModulePathOptions): Promise<string>;
+export declare function resolveModulePathWithFs(modulePath: string, options: ResolveModulePathOptions, includeTypeDefs: true): Promise<TypeAwareResolveResult>;
 /**
  * Resolves multiple module paths using Node.js filesystem APIs.
  * This is a convenience wrapper around the generic resolveModulePaths function.
@@ -23,13 +25,14 @@ export declare function resolveModulePathsWithFs(modulePaths: string[], options?
  * This is a convenience wrapper around the generic resolveImportResult function
  * that uses Node.js filesystem APIs.
  *
- * @param importResult - The result from resolveImports containing all imports
+ * @param importResult - The result from parseImports containing all imports
  * @param options - Configuration options for module resolution
  * @returns Promise<Map<string, string>> - Map from import path to resolved file path
  */
 export declare function resolveImportResultWithFs(importResult: Record<string, {
   path: string;
   names: string[];
+  includeTypeDefs?: true;
 }>, options?: ResolveModulePathOptions): Promise<Map<string, string>>;
 /**
  * Resolves variant paths from a variants object mapping variant names to their file paths.

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolveModulePathWithFs.d.ts","sourceRoot":"","sources":["../../../src/pipeline/loaderUtils/resolveModulePathWithFs.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC5B,MAAM,qBAAqB,CAAC;AAe7B;;;;;;;;GAQG;AACH,wBAAsB,uBAAuB,CAC3C,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,MAAM,CAAC,CAAC;AACnB,wBAAsB,uBAAuB,CAC3C,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,wBAAwB,EACjC,eAAe,EAAE,IAAI,GACpB,OAAO,CAAC,sBAAsB,CAAC,CAAC;AASnC;;;;;;;GAOG;AACH,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,MAAM,EAAE,EACrB,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAE9B;AAED;;;;;;;;;GASG;AACH,wBAAsB,yBAAyB,CAC7C,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,eAAe,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC,EACvF,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAE9B;AAED;;;;;;;;GAQG;AACH,wBAAsB,yBAAyB,CAC7C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAE9B;AAGD,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,wBAAwB,EAAE,CAAC"}

package/{loaderUtils → pipeline/loaderUtils}/resolveModulePathWithFs.js

@@ -43,8 +43,10 @@ var nodeDirectoryReader = /*#__PURE__*/function () {
  *
  * @param modulePath - The module path to resolve (without file extension)
  * @param options - Configuration options
- * @returns Promise<string> - The resolved file path, or throws if not found
+ * @param includeTypeDefs - If true, returns both import and typeImport paths with different extension priorities
+ * @returns Promise<string | TypeAwareResolveResult> - The resolved file path(s), or throws if not found
  */
+
 export function resolveModulePathWithFs(_x2) {
   return _resolveModulePathWithFs.apply(this, arguments);
 }
@@ -60,13 +62,15 @@ export function resolveModulePathWithFs(_x2) {
 function _resolveModulePathWithFs() {
   _resolveModulePathWithFs = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(modulePath) {
     var options,
+      includeTypeDefs,
       _args2 = arguments;
     return _regeneratorRuntime().wrap(function _callee2$(_context2) {
       while (1) switch (_context2.prev = _context2.next) {
         case 0:
           options = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {};
-          return _context2.abrupt("return", resolveModulePath(modulePath, nodeDirectoryReader, options));
-        case 2:
+          includeTypeDefs = _args2.length > 2 ? _args2[2] : undefined;
+          return _context2.abrupt("return", resolveModulePath(modulePath, nodeDirectoryReader, options, includeTypeDefs));
+        case 3:
         case "end":
           return _context2.stop();
       }
@@ -84,7 +88,7 @@ export function resolveModulePathsWithFs(_x3) {
  * This is a convenience wrapper around the generic resolveImportResult function
  * that uses Node.js filesystem APIs.
  *
- * @param importResult - The result from resolveImports containing all imports
+ * @param importResult - The result from parseImports containing all imports
  * @param options - Configuration options for module resolution
  * @returns Promise<Map<string, string>> - Map from import path to resolved file path
  */

package/pipeline/loaderUtils/rewriteImports.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Rewrites relative imports in source code based on a provided mapping.
+ * Converts imports like '../utils/helper' or './components/Button' to their mapped equivalents
+ *
+ * @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
+ */
+export declare function rewriteImportsToSameDirectory(source: string, importPathMapping: Map<string, string>): string;

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

@@ -0,0 +1 @@
+{"version":3,"file":"rewriteImports.d.ts","sourceRoot":"","sources":["../../../src/pipeline/loaderUtils/rewriteImports.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACrC,MAAM,CA+BR"}

package/pipeline/loaderUtils/rewriteImports.js

@@ -0,0 +1,35 @@
+/**
+ * Rewrites relative imports in source code based on a provided mapping.
+ * Converts imports like '../utils/helper' or './components/Button' to their mapped equivalents
+ *
+ * @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
+ */
+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)
+
+  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, "'");
+      }
+    }
+    return match;
+  });
+}

package/pipeline/parseSource/grammars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammars.d.ts","sourceRoot":"","sources":["../../../src/pipeline/parseSource/grammars.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,QAAQ,0CAWpB,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAY/C,CAAC"}

package/pipeline/parseSource/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/pipeline/parseSource/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/pipeline/parseSource/parseSource.d.ts

@@ -0,0 +1,3 @@
+import { ParseSource } from "../../CodeHighlighter/index.js";
+export declare const parseSource: ParseSource;
+export declare const createParseSource: () => Promise<ParseSource>;

package/pipeline/parseSource/parseSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseSource.d.ts","sourceRoot":"","sources":["../../../src/pipeline/parseSource/parseSource.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAOpD,eAAO,MAAM,WAAW,EAAE,WAsBzB,CAAC;AAEF,eAAO,MAAM,iBAAiB,QAAa,OAAO,CAAC,WAAW,CAM7D,CAAC"}

package/{parseSource → pipeline/parseSource}/parseSource.js

@@ -5,12 +5,22 @@ import { grammars, extensionMap } from "./grammars.js";
 var starryNight = null;
 export var parseSource = function parseSource(source, fileName) {
   if (!starryNight) {
-    throw new Error('Starry Night not initialized. Use parseSourceFactory to create an initialized parseSource function.');
+    throw new Error('Starry Night not initialized. Use createParseSource to create an initialized parseSource function.');
   }
-  var fileType = fileName.slice(fileName.lastIndexOf('.')) || 'plaintext';
-  return starryNight.highlight(source, extensionMap[fileType] || 'plaintext');
+  var fileType = fileName.slice(fileName.lastIndexOf('.'));
+  if (!extensionMap[fileType]) {
+    // Return a basic HAST root node with the source text for unsupported file types
+    return {
+      type: 'root',
+      children: [{
+        type: 'text',
+        value: source
+      }]
+    };
+  }
+  return starryNight.highlight(source, extensionMap[fileType]);
 };
-export var parseSourceFactory = /*#__PURE__*/function () {
+export var createParseSource = /*#__PURE__*/function () {
   var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
     return _regeneratorRuntime().wrap(function _callee$(_context) {
       while (1) switch (_context.prev = _context.next) {
@@ -31,7 +41,7 @@ export var parseSourceFactory = /*#__PURE__*/function () {
       }
     }, _callee);
   }));
-  return function parseSourceFactory() {
+  return function createParseSource() {
     return _ref.apply(this, arguments);
   };
 }();

package/pipeline/transformHtmlCode/index.d.ts

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

package/pipeline/transformHtmlCode/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/pipeline/transformHtmlCode/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,eAAe,iBAAiB,CAAC"}

package/pipeline/transformHtmlCode/index.js

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

package/pipeline/transformHtmlCode/transformHtmlCode.d.ts

@@ -0,0 +1,13 @@
+import type { Plugin } from 'unified';
+/**
+ * Rehype plugin that transforms pre > code elements to use loadVariant
+ *
+ * This plugin:
+ * 1. Finds pre elements in the HTML AST
+ * 2. Collects all code children within each pre element
+ * 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 pre element
+ * 6. Clears all code element contents
+ */
+export declare const transformHtmlCode: Plugin;

package/pipeline/transformHtmlCode/transformHtmlCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformHtmlCode.d.ts","sourceRoot":"","sources":["../../../src/pipeline/transformHtmlCode/transformHtmlCode.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AA4KtC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAoF/B,CAAC"}

package/pipeline/transformHtmlCode/transformHtmlCode.js

@@ -0,0 +1,303 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { visit } from 'unist-util-visit';
+import { loadVariant } from "../../CodeHighlighter/loadVariant.js";
+import { createParseSource } from "../parseSource/index.js";
+import { TypescriptToJavascriptTransformer } from "../transformTypescriptToJavascript/index.js";
+/**
+ * Maps common language class names to file extensions
+ * Only includes languages that have corresponding grammars in parseSource/grammars.ts
+ */
+var LANGUAGE_TO_EXTENSION = {
+  // JavaScript
+  javascript: 'js',
+  js: 'js',
+  // TypeScript
+  typescript: 'ts',
+  ts: 'ts',
+  // TSX/JSX
+  tsx: 'tsx',
+  jsx: 'jsx',
+  // Maps to .jsx but uses tsx grammar
+
+  // JSON
+  json: 'json',
+  // Markdown
+  markdown: 'md',
+  md: 'md',
+  // MDX
+  mdx: 'mdx',
+  // HTML
+  html: 'html',
+  // CSS
+  css: 'css',
+  // Shell
+  shell: 'sh',
+  bash: 'sh',
+  sh: 'sh',
+  // YAML
+  yaml: 'yaml',
+  yml: 'yaml'
+};
+
+/**
+ * Extracts the language from className attribute
+ */
+function extractLanguageFromClassName(className) {
+  if (!className) {
+    return null;
+  }
+
+  // Handle array of class names (HAST format)
+  var classString = Array.isArray(className) ? className.join(' ') : className;
+  var match = classString.match(/(?:^|\s)language-(\w+)(?:\s|$)/);
+  return match ? match[1] : null;
+}
+
+/**
+ * Gets the filename from data-filename attribute or derives it from language
+ * Returns undefined if no explicit filename and no recognizable language
+ */
+function getFileName(codeElement) {
+  var _codeElement$properti, _codeElement$properti2;
+  // Check for explicit data-filename attribute
+  var dataFilename = (_codeElement$properti = codeElement.properties) == null ? void 0 : _codeElement$properti.dataFilename;
+  if (dataFilename && typeof dataFilename === 'string') {
+    return dataFilename;
+  }
+
+  // Extract language from className
+  var className = (_codeElement$properti2 = codeElement.properties) == null ? void 0 : _codeElement$properti2.className;
+  var language = extractLanguageFromClassName(className);
+  if (language && LANGUAGE_TO_EXTENSION[language]) {
+    return "index.".concat(LANGUAGE_TO_EXTENSION[language]);
+  }
+
+  // Return undefined instead of a fallback - let the system handle gracefully
+  return undefined;
+}
+
+/**
+ * Extracts text content from HAST nodes
+ */
+function extractTextContent(node) {
+  if (node.type === 'text') {
+    return node.value;
+  }
+  if (node.type === 'element' && node.children) {
+    return node.children.map(function (child) {
+      return extractTextContent(child);
+    }).join('');
+  }
+  return '';
+}
+
+/**
+ * Creates variants from multiple code elements within a pre element
+ */
+function createVariantsFromCodeElements(codeElements) {
+  var variants = {};
+  if (codeElements.length === 1) {
+    var _codeElement$properti3;
+    // Single code element - use "Default" as variant name
+    var codeElement = codeElements[0];
+    var sourceCode = extractTextContent(codeElement);
+    var fileName = getFileName(codeElement);
+    var variant = {
+      source: sourceCode,
+      skipTransforms: !((_codeElement$properti3 = codeElement.properties) != null && _codeElement$properti3.dataTransform)
+    };
+
+    // Only add fileName if we have one
+    if (fileName) {
+      variant.fileName = fileName;
+    }
+    variants.Default = variant;
+  } else {
+    // Multiple code elements - create appropriate variant names
+    var languages = codeElements.map(function (element) {
+      var _element$properties;
+      var className = (_element$properties = element.properties) == null ? void 0 : _element$properties.className;
+      return extractLanguageFromClassName(className);
+    });
+
+    // Check if all languages are the same (or all null)
+    var uniqueLanguages = Array.from(new Set(languages.filter(Boolean)));
+    var shouldUseLanguageNames = uniqueLanguages.length > 1;
+    codeElements.forEach(function (codeElement, index) {
+      var _codeElement$properti4, _codeElement$properti5;
+      var sourceCode = extractTextContent(codeElement);
+      var fileName = getFileName(codeElement);
+
+      // Check for explicit variant name
+      var dataVariant = (_codeElement$properti4 = codeElement.properties) == null ? void 0 : _codeElement$properti4.dataVariant;
+      var variantName;
+      if (dataVariant && typeof dataVariant === 'string') {
+        variantName = dataVariant;
+      } else if (shouldUseLanguageNames && languages[index]) {
+        // Use language name if languages differ
+        variantName = languages[index].charAt(0).toUpperCase() + languages[index].slice(1);
+      } else {
+        // Use numbered variants if languages are the same or unknown
+        variantName = "Variant ".concat(index + 1);
+      }
+      var variant = {
+        source: sourceCode,
+        skipTransforms: !((_codeElement$properti5 = codeElement.properties) != null && _codeElement$properti5.dataTransform)
+      };
+
+      // Only add fileName if we have one
+      if (fileName) {
+        variant.fileName = fileName;
+      }
+      variants[variantName] = variant;
+    });
+  }
+  return variants;
+}
+
+/**
+ * Rehype plugin that transforms pre > code elements to use loadVariant
+ *
+ * This plugin:
+ * 1. Finds pre elements in the HTML AST
+ * 2. Collects all code children within each pre element
+ * 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 pre element
+ * 6. Clears all code element contents
+ */
+export var transformHtmlCode = function transformHtmlCode() {
+  return /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(tree) {
+      var transformPromises, sourceParser, sourceTransformers;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            transformPromises = []; // Get the source parser and transformers
+            sourceParser = createParseSource();
+            sourceTransformers = [TypescriptToJavascriptTransformer];
+            visit(tree, 'element', function (node) {
+              // Look for pre elements
+              if (node.tagName === 'pre' && node.children && node.children.length > 0) {
+                // Find all code elements within this pre
+                var codeElements = node.children.filter(function (child) {
+                  return child.type === 'element' && child.tagName === 'code';
+                });
+                if (codeElements.length > 0) {
+                  var transformPromise = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+                    var variants, processedCode, variantPromises, variantResults, _iterator, _step, result;
+                    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+                      while (1) switch (_context2.prev = _context2.next) {
+                        case 0:
+                          _context2.prev = 0;
+                          // Create variants from all code elements
+                          variants = createVariantsFromCodeElements(codeElements); // Process each variant with loadVariant
+                          processedCode = {};
+                          variantPromises = Object.entries(variants).map(/*#__PURE__*/function () {
+                            var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref3) {
+                              var _ref5, variantName, variantData, result;
+                              return _regeneratorRuntime().wrap(function _callee$(_context) {
+                                while (1) switch (_context.prev = _context.next) {
+                                  case 0:
+                                    _ref5 = _slicedToArray(_ref3, 2), variantName = _ref5[0], variantData = _ref5[1];
+                                    if (!(variantData && _typeof(variantData) === 'object')) {
+                                      _context.next = 6;
+                                      break;
+                                    }
+                                    _context.next = 4;
+                                    return loadVariant(undefined,
+                                    // url - not needed for inline code
+                                    variantName, variantData, sourceParser, undefined,
+                                    // loadSource - not needed since we have the data
+                                    undefined,
+                                    // loadVariantMeta - not needed since we have the data
+                                    sourceTransformers, {
+                                      disableTransforms: variantData.skipTransforms || false
+                                    });
+                                  case 4:
+                                    result = _context.sent;
+                                    return _context.abrupt("return", {
+                                      variantName: variantName,
+                                      processedVariant: result.code
+                                    });
+                                  case 6:
+                                    return _context.abrupt("return", null);
+                                  case 7:
+                                  case "end":
+                                    return _context.stop();
+                                }
+                              }, _callee);
+                            }));
+                            return function (_x2) {
+                              return _ref4.apply(this, arguments);
+                            };
+                          }());
+                          _context2.next = 6;
+                          return Promise.all(variantPromises);
+                        case 6:
+                          variantResults = _context2.sent;
+                          _iterator = _createForOfIteratorHelper(variantResults);
+                          try {
+                            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                              result = _step.value;
+                              if (result) {
+                                processedCode[result.variantName] = result.processedVariant;
+                              }
+                            }
+
+                            // Clear all code element contents and replace with error message
+                          } catch (err) {
+                            _iterator.e(err);
+                          } finally {
+                            _iterator.f();
+                          }
+                          codeElements.forEach(function (codeElement) {
+                            codeElement.children = [];
+                          });
+
+                          // Replace pre element children with error message for CodeHighlighter
+                          node.children = [{
+                            type: 'text',
+                            value: 'Error: expected pre tag to be handled by CodeHighlighter'
+                          }];
+
+                          // Set the precompute data on the pre element directly on properties for immediate HTML serialization
+                          if (!node.properties) {
+                            node.properties = {};
+                          }
+                          node.properties.dataPrecompute = JSON.stringify(processedCode);
+                          _context2.next = 18;
+                          break;
+                        case 15:
+                          _context2.prev = 15;
+                          _context2.t0 = _context2["catch"](0);
+                          console.warn('Failed to transform code block:', _context2.t0);
+                        case 18:
+                        case "end":
+                          return _context2.stop();
+                      }
+                    }, _callee2, null, [[0, 15]]);
+                  }))();
+                  transformPromises.push(transformPromise);
+                }
+              }
+            });
+
+            // Wait for all transformations to complete
+            _context3.next = 6;
+            return Promise.all(transformPromises);
+          case 6:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }));
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};

package/pipeline/transformMarkdownCode/index.d.ts

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

package/pipeline/transformMarkdownCode/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/pipeline/transformMarkdownCode/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,eAAe,qBAAqB,CAAC"}

package/pipeline/transformMarkdownCode/index.js

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

package/pipeline/transformMarkdownCode/transformMarkdownCode.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'unified';
+export declare const transformMarkdownCode: Plugin;

package/pipeline/transformMarkdownCode/transformMarkdownCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformMarkdownCode.d.ts","sourceRoot":"","sources":["../../../src/pipeline/transformMarkdownCode/transformMarkdownCode.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAiHtC,eAAO,MAAM,qBAAqB,EAAE,MA8anC,CAAC"}