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

package/CodeHighlighter/maybeInitialData.d.ts

@@ -0,0 +1,10 @@
+import { Code, VariantExtraFiles, VariantSource } from "./types.js";
+export declare function maybeInitialData(variants: string[], variant: string, code?: Code, fileName?: string, needsHighlight?: boolean, needsAllFiles?: boolean, needsAllVariants?: boolean): {
+  initialData: false | {
+    code: Code;
+    initialFilename: string;
+    initialSource: VariantSource;
+    initialExtraFiles?: VariantExtraFiles;
+  };
+  reason?: string;
+};

package/CodeHighlighter/maybeInitialData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maybeInitialData.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/maybeInitialData.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAEjE,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,IAAI,EACX,QAAQ,CAAC,EAAE,MAAM,EACjB,cAAc,UAAQ,EACtB,aAAa,UAAQ,EACrB,gBAAgB,UAAQ,GACvB;IACD,WAAW,EACP,KAAK,GACL;QACE,IAAI,EAAE,IAAI,CAAC;QACX,eAAe,EAAE,MAAM,CAAC;QACxB,aAAa,EAAE,aAAa,CAAC;QAC7B,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;KACvC,CAAC;IACN,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAoGA"}

package/CodeHighlighter/maybeInitialData.js

@@ -0,0 +1,94 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import { hasAllVariants } from "./hasAllVariants.js";
+export function maybeInitialData(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;
+  if (!code) {
+    return {
+      initialData: false,
+      reason: 'No code provided'
+    };
+  }
+  if (needsAllVariants && !hasAllVariants(variants, code, needsHighlight)) {
+    return {
+      initialData: false,
+      reason: 'Not all variants are available'
+    };
+  }
+  var variantCode = code[variant];
+  if (!variantCode || typeof variantCode === 'string') {
+    return {
+      initialData: false,
+      reason: 'Variant code is not loaded yet'
+    };
+  }
+  if (needsAllFiles) {
+    if (!variantCode) {
+      return {
+        initialData: false,
+        reason: 'Variant code not found'
+      };
+    }
+    if (!variantCode.source) {
+      return {
+        initialData: false,
+        reason: 'Variant source not found'
+      };
+    }
+    if (variantCode.extraFiles && !Object.keys(variantCode.extraFiles).every(function (file) {
+      var _variantCode$extraFil;
+      var fileData = (_variantCode$extraFil = variantCode.extraFiles) == null ? void 0 : _variantCode$extraFil[file];
+      return _typeof(fileData) === 'object' && (fileData == null ? void 0 : fileData.source) !== undefined;
+    })) {
+      return {
+        initialData: false,
+        reason: 'Not all extra files are available'
+      };
+    }
+  }
+
+  // TODO, filename might need to be determined from filesOrder if provided?
+  var initialFilename = fileName || variantCode.fileName;
+  var fileSource;
+  if (fileName && fileName !== variantCode.fileName) {
+    var _variantCode$extraFil2;
+    var fileData = variantCode == null || (_variantCode$extraFil2 = variantCode.extraFiles) == null ? void 0 : _variantCode$extraFil2[fileName];
+    if (!fileData) {
+      return {
+        initialData: false,
+        reason: "File not found in code"
+      };
+    }
+    if (typeof fileData === 'string') {
+      // It's a URL, not actual source content
+      return {
+        initialData: false,
+        reason: "File is not loaded yet"
+      };
+    }
+    fileSource = fileData.source;
+  } else {
+    fileSource = variantCode.source;
+  }
+  if (!fileSource) {
+    return {
+      initialData: false,
+      reason: "File source not found"
+    };
+  }
+  if (needsHighlight && typeof fileSource === 'string') {
+    return {
+      initialData: false,
+      reason: 'File needs highlighting'
+    };
+  }
+  return {
+    initialData: {
+      code: code,
+      initialFilename: initialFilename,
+      initialSource: fileSource,
+      initialExtraFiles: variantCode == null ? void 0 : variantCode.extraFiles
+    }
+  };
+}

package/CodeHighlighter/parseCode.d.ts

@@ -0,0 +1,6 @@
+import type { Code, ParseSource } from "./types.js";
+/**
+ * Pure function to parse code variants and their extraFiles.
+ * Converts string sources to HAST nodes and handles hastJson parsing.
+ */
+export declare function parseCode(code: Code, parseSource: ParseSource): Code;

package/CodeHighlighter/parseCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseCode.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/parseCode.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEjD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,WAAW,GAAG,IAAI,CAwHpE"}

package/CodeHighlighter/parseCode.js

@@ -0,0 +1,122 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+/**
+ * Pure function to parse code variants and their extraFiles.
+ * Converts string sources to HAST nodes and handles hastJson parsing.
+ */
+export function parseCode(code, parseSource) {
+  var parsed = {};
+  for (var _i = 0, _Object$entries = Object.entries(code); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      variant = _Object$entries$_i[0],
+      variantCode = _Object$entries$_i[1];
+    if (typeof variantCode === 'string') {
+      // Already parsed/highlighted
+      parsed[variant] = variantCode;
+    } else if (variantCode && _typeof(variantCode) === 'object') {
+      // Parse if source is available and not already parsed
+      if (variantCode.source && typeof variantCode.source === 'string') {
+        try {
+          var hastNodes = parseSource(variantCode.source, variantCode.fileName);
+
+          // Also parse extraFiles if they contain sources that need parsing
+          var parsedExtraFiles = variantCode.extraFiles ? Object.fromEntries(Object.entries(variantCode.extraFiles).map(function (_ref) {
+            var _ref2 = _slicedToArray(_ref, 2),
+              fileName = _ref2[0],
+              fileContent = _ref2[1];
+            if (typeof fileContent === 'string') {
+              return [fileName, fileContent]; // Keep string as-is
+            }
+            if (fileContent && _typeof(fileContent) === 'object' && fileContent.source) {
+              if (typeof fileContent.source === 'string') {
+                // Parse string source in extraFile
+                try {
+                  var parsedHastNodes = parseSource(fileContent.source, fileName);
+                  return [fileName, _objectSpread(_objectSpread({}, fileContent), {}, {
+                    source: parsedHastNodes
+                  })];
+                } catch (error) {
+                  return [fileName, fileContent]; // Keep original if parsing fails
+                }
+              }
+            }
+            return [fileName, fileContent]; // Keep as-is for other cases
+          })) : undefined;
+          parsed[variant] = _objectSpread(_objectSpread({}, variantCode), {}, {
+            source: hastNodes,
+            extraFiles: parsedExtraFiles
+          });
+        } catch (error) {
+          // Keep original if parsing fails
+          parsed[variant] = variantCode;
+        }
+      } else if (variantCode.source && _typeof(variantCode.source) === 'object' && 'hastJson' in variantCode.source) {
+        try {
+          // Parse hastJson to HAST nodes
+          var _hastNodes = JSON.parse(variantCode.source.hastJson);
+
+          // Also parse extraFiles if they contain sources that need parsing
+          var _parsedExtraFiles = variantCode.extraFiles ? Object.fromEntries(Object.entries(variantCode.extraFiles).map(function (_ref3) {
+            var _ref4 = _slicedToArray(_ref3, 2),
+              fileName = _ref4[0],
+              fileContent = _ref4[1];
+            if (typeof fileContent === 'string') {
+              return [fileName, fileContent]; // Keep string as-is
+            }
+            if (fileContent && _typeof(fileContent) === 'object' && fileContent.source) {
+              if (typeof fileContent.source === 'string') {
+                // Parse string source in extraFile
+                try {
+                  var parsedHastNodes = parseSource(fileContent.source, fileName);
+                  return [fileName, _objectSpread(_objectSpread({}, fileContent), {}, {
+                    source: parsedHastNodes
+                  })];
+                } catch (error) {
+                  return [fileName, fileContent]; // Keep original if parsing fails
+                }
+              }
+            }
+            return [fileName, fileContent]; // Keep as-is for other cases
+          })) : undefined;
+          parsed[variant] = _objectSpread(_objectSpread({}, variantCode), {}, {
+            source: _hastNodes,
+            extraFiles: _parsedExtraFiles
+          });
+        } catch (error) {
+          // Keep original if parsing fails
+          console.error("Failed to parse hastJson for variant ".concat(variant, ":"), error);
+          parsed[variant] = variantCode;
+        }
+      } else {
+        // Already parsed or no source to parse - but still check extraFiles
+        var _parsedExtraFiles2 = variantCode.extraFiles ? Object.fromEntries(Object.entries(variantCode.extraFiles).map(function (_ref5) {
+          var _ref6 = _slicedToArray(_ref5, 2),
+            fileName = _ref6[0],
+            fileContent = _ref6[1];
+          if (typeof fileContent === 'string') {
+            return [fileName, fileContent]; // Keep string as-is
+          }
+          if (fileContent && _typeof(fileContent) === 'object' && fileContent.source) {
+            if (typeof fileContent.source === 'string') {
+              // Parse string source in extraFile
+              try {
+                var parsedHastNodes = parseSource(fileContent.source, fileName);
+                return [fileName, _objectSpread(_objectSpread({}, fileContent), {}, {
+                  source: parsedHastNodes
+                })];
+              } catch (error) {
+                return [fileName, fileContent]; // Keep original if parsing fails
+              }
+            }
+          }
+          return [fileName, fileContent]; // Keep as-is for other cases
+        })) : undefined;
+        parsed[variant] = _objectSpread(_objectSpread({}, variantCode), {}, {
+          extraFiles: _parsedExtraFiles2
+        });
+      }
+    }
+  }
+  return parsed;
+}

package/CodeHighlighter/parseControlledCode.d.ts

@@ -0,0 +1,6 @@
+import type { Code, ControlledCode, ParseSource } from "./types.js";
+/**
+ * Pure function to parse controlled code and convert it to regular Code format.
+ * Handles the conversion from ControlledCode (string|null sources) to Code (HAST nodes).
+ */
+export declare function parseControlledCode(controlledCode: ControlledCode, parseSource: ParseSource): Code;

package/CodeHighlighter/parseControlledCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseControlledCode.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/parseControlledCode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEjE;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,cAAc,EAC9B,WAAW,EAAE,WAAW,GACvB,IAAI,CAiEN"}

package/CodeHighlighter/parseControlledCode.js

@@ -0,0 +1,76 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+/**
+ * Pure function to parse controlled code and convert it to regular Code format.
+ * Handles the conversion from ControlledCode (string|null sources) to Code (HAST nodes).
+ */
+export function parseControlledCode(controlledCode, parseSource) {
+  var parsed = {};
+  for (var _i = 0, _Object$entries = Object.entries(controlledCode); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      variant = _Object$entries$_i[0],
+      variantCode = _Object$entries$_i[1];
+    if (variantCode === null) {
+      // Explicitly deleted - skip this variant
+      continue;
+    }
+    if (variantCode && _typeof(variantCode) === 'object') {
+      var mainSource = void 0;
+
+      // Convert null to empty string, then parse
+      var sourceToProcess = variantCode.source === null ? '' : variantCode.source;
+      if (typeof sourceToProcess === 'string') {
+        try {
+          mainSource = parseSource(sourceToProcess, variantCode.fileName);
+        } catch (error) {
+          // Keep original string if parsing fails
+          mainSource = sourceToProcess;
+        }
+      } else {
+        // Handle undefined or other non-string values
+        mainSource = sourceToProcess;
+      }
+
+      // Parse extraFiles if present
+      var extraFiles = void 0;
+      if (variantCode.extraFiles) {
+        var parsedExtraFiles = {};
+        for (var _i2 = 0, _Object$entries2 = Object.entries(variantCode.extraFiles); _i2 < _Object$entries2.length; _i2++) {
+          var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+            fileName = _Object$entries2$_i[0],
+            fileData = _Object$entries2$_i[1];
+          // Convert null to empty string, then parse
+          var fileSourceToProcess = fileData.source === null ? '' : fileData.source;
+          if (typeof fileSourceToProcess === 'string') {
+            // Parse string sources
+            try {
+              var parsedSource = parseSource(fileSourceToProcess, fileName);
+              parsedExtraFiles[fileName] = {
+                source: parsedSource
+              };
+            } catch (error) {
+              // Keep original if parsing fails
+              parsedExtraFiles[fileName] = {
+                source: fileSourceToProcess
+              };
+            }
+          } else {
+            // Keep other values as-is
+            parsedExtraFiles[fileName] = {
+              source: fileSourceToProcess
+            };
+          }
+        }
+        extraFiles = parsedExtraFiles;
+      }
+      parsed[variant] = {
+        fileName: variantCode.fileName,
+        url: variantCode.url,
+        source: mainSource,
+        extraFiles: extraFiles,
+        filesOrder: variantCode.filesOrder
+      };
+    }
+  }
+  return parsed;
+}

package/CodeHighlighter/transformCode.d.ts

@@ -0,0 +1,20 @@
+import type { Code, ParseSource } from "./types.js";
+/**
+ * Pure function to identify which variants need transformation.
+ * Returns entries of variants that have transforms requiring processing.
+ */
+export declare function getVariantsToTransform(parsedCode: Code): Array<[string, any]>;
+/**
+ * Pure function to get available transforms from a specific variant.
+ */
+export declare function getAvailableTransforms(parsedCode: Code | undefined, variantName: string): string[];
+/**
+ * Pure async function to transform a single variant's code and extraFiles.
+ * Returns the transformed variant or the original if transformation fails.
+ */
+export declare function transformVariant(variant: string, variantCode: any, parseSource: ParseSource): Promise<any>;
+/**
+ * Pure async function to apply transformations to all variants that need them.
+ * Returns the enhanced code with computed transforms.
+ */
+export declare function applyTransforms(parsedCode: Code, parseSource: ParseSource): Promise<Code>;

package/CodeHighlighter/transformCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformCode.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/transformCode.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGjD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,IAAI,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CA4B7E;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,IAAI,GAAG,SAAS,EAC5B,WAAW,EAAE,MAAM,GAClB,MAAM,EAAE,CAQV;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,GAAG,EAChB,WAAW,EAAE,WAAW,GACvB,OAAO,CAAC,GAAG,CAAC,CA6Ed;AAED;;;GAGG;AACH,wBAAsB,eAAe,CAAC,UAAU,EAAE,IAAI,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CA8B/F"}

package/CodeHighlighter/transformCode.js

@@ -0,0 +1,223 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { toText } from 'hast-util-to-text';
+import { transformParsedSource } from "./transformParsedSource.js";
+
+/**
+ * Pure function to identify which variants need transformation.
+ * Returns entries of variants that have transforms requiring processing.
+ */
+export function getVariantsToTransform(parsedCode) {
+  return Object.entries(parsedCode).filter(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      variantCode = _ref2[1];
+    if (!variantCode || _typeof(variantCode) !== 'object') {
+      return false;
+    }
+
+    // Check if main source has transforms and needs processing
+    var mainSourceNeedsTransform = variantCode.transforms && variantCode.source && typeof variantCode.source !== 'string' && !('hastJson' in variantCode.source);
+
+    // Check if any extraFiles have transforms and need processing
+    var extraFilesNeedTransform = variantCode.extraFiles ? Object.values(variantCode.extraFiles).some(function (fileContent) {
+      return _typeof(fileContent) === 'object' && fileContent && fileContent.transforms && fileContent.source && typeof fileContent.source !== 'string' && !('hastJson' in fileContent.source);
+    }) : false;
+    return mainSourceNeedsTransform || extraFilesNeedTransform;
+  });
+}
+
+/**
+ * Pure function to get available transforms from a specific variant.
+ */
+export function getAvailableTransforms(parsedCode, variantName) {
+  var currentVariant = parsedCode == null ? void 0 : parsedCode[variantName];
+  if (currentVariant && _typeof(currentVariant) === 'object' && currentVariant.transforms) {
+    return Object.keys(currentVariant.transforms);
+  }
+  return [];
+}
+
+/**
+ * Pure async function to transform a single variant's code and extraFiles.
+ * Returns the transformed variant or the original if transformation fails.
+ */
+export function transformVariant(_x, _x2, _x3) {
+  return _transformVariant.apply(this, arguments);
+}
+
+/**
+ * Pure async function to apply transformations to all variants that need them.
+ * Returns the enhanced code with computed transforms.
+ */
+function _transformVariant() {
+  _transformVariant = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(variant, variantCode, parseSource) {
+    var mainTransformResult, transformedExtraFiles, hastNodes, sourceString, transformedVariant;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          if (!(_typeof(variantCode) !== 'object' || !variantCode)) {
+            _context2.next = 2;
+            break;
+          }
+          return _context2.abrupt("return", variantCode);
+        case 2:
+          if (!(variantCode.transforms && variantCode.source && typeof variantCode.source !== 'string' && !('hastJson' in variantCode.source))) {
+            _context2.next = 8;
+            break;
+          }
+          hastNodes = variantCode.source;
+          sourceString = toText(hastNodes, {
+            whitespace: 'pre'
+          });
+          _context2.next = 7;
+          return transformParsedSource(sourceString, hastNodes, variant,
+          // fileName
+          variantCode.transforms, parseSource);
+        case 7:
+          mainTransformResult = _context2.sent;
+        case 8:
+          if (!variantCode.extraFiles) {
+            _context2.next = 12;
+            break;
+          }
+          _context2.next = 11;
+          return Promise.all(Object.entries(variantCode.extraFiles).map(/*#__PURE__*/function () {
+            var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref3) {
+              var _ref5, fileName, fileContent, extraHastNodes, extraSourceString, extraTransformResult;
+              return _regeneratorRuntime().wrap(function _callee$(_context) {
+                while (1) switch (_context.prev = _context.next) {
+                  case 0:
+                    _ref5 = _slicedToArray(_ref3, 2), fileName = _ref5[0], fileContent = _ref5[1];
+                    if (!(_typeof(fileContent) === 'object' && fileContent && fileContent.transforms && fileContent.source && typeof fileContent.source !== 'string' && !('hastJson' in fileContent.source))) {
+                      _context.next = 15;
+                      break;
+                    }
+                    _context.prev = 2;
+                    extraHastNodes = fileContent.source;
+                    extraSourceString = toText(extraHastNodes, {
+                      whitespace: 'pre'
+                    });
+                    _context.next = 7;
+                    return transformParsedSource(extraSourceString, extraHastNodes, fileName, fileContent.transforms, parseSource);
+                  case 7:
+                    extraTransformResult = _context.sent;
+                    return _context.abrupt("return", [fileName, _objectSpread(_objectSpread({}, fileContent), {}, {
+                      transforms: extraTransformResult
+                    })]);
+                  case 11:
+                    _context.prev = 11;
+                    _context.t0 = _context["catch"](2);
+                    console.error("Failed to transform extraFile ".concat(fileName, ":"), _context.t0);
+                    return _context.abrupt("return", [fileName, fileContent]);
+                  case 15:
+                    return _context.abrupt("return", [fileName, fileContent]);
+                  case 16:
+                  case "end":
+                    return _context.stop();
+                }
+              }, _callee, null, [[2, 11]]);
+            }));
+            return function (_x6) {
+              return _ref4.apply(this, arguments);
+            };
+          }())).then(function (entries) {
+            return Object.fromEntries(entries);
+          });
+        case 11:
+          transformedExtraFiles = _context2.sent;
+        case 12:
+          // Update the variant with the computed results
+          transformedVariant = _objectSpread(_objectSpread(_objectSpread({}, variantCode), mainTransformResult && {
+            transforms: mainTransformResult
+          }), transformedExtraFiles && {
+            extraFiles: transformedExtraFiles
+          });
+          return _context2.abrupt("return", transformedVariant);
+        case 14:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _transformVariant.apply(this, arguments);
+}
+export function applyTransforms(_x4, _x5) {
+  return _applyTransforms.apply(this, arguments);
+}
+function _applyTransforms() {
+  _applyTransforms = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(parsedCode, parseSource) {
+    var variantsToTransform, results, enhancedCode, _iterator, _step, _step$value, variant, transformedVariant;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          variantsToTransform = getVariantsToTransform(parsedCode);
+          if (!(variantsToTransform.length === 0)) {
+            _context4.next = 3;
+            break;
+          }
+          return _context4.abrupt("return", parsedCode);
+        case 3:
+          _context4.next = 5;
+          return Promise.all(variantsToTransform.map(/*#__PURE__*/function () {
+            var _ref7 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_ref6) {
+              var _ref8, variant, variantCode, transformedVariant;
+              return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+                while (1) switch (_context3.prev = _context3.next) {
+                  case 0:
+                    _ref8 = _slicedToArray(_ref6, 2), variant = _ref8[0], variantCode = _ref8[1];
+                    _context3.prev = 1;
+                    _context3.next = 4;
+                    return transformVariant(variant, variantCode, parseSource);
+                  case 4:
+                    transformedVariant = _context3.sent;
+                    return _context3.abrupt("return", {
+                      variant: variant,
+                      transformedVariant: transformedVariant
+                    });
+                  case 8:
+                    _context3.prev = 8;
+                    _context3.t0 = _context3["catch"](1);
+                    // Keep original variant if transformation fails
+                    console.error("Failed to transform variant ".concat(variant, ":"), _context3.t0);
+                    return _context3.abrupt("return", {
+                      variant: variant,
+                      transformedVariant: variantCode
+                    });
+                  case 12:
+                  case "end":
+                    return _context3.stop();
+                }
+              }, _callee3, null, [[1, 8]]);
+            }));
+            return function (_x7) {
+              return _ref7.apply(this, arguments);
+            };
+          }()));
+        case 5:
+          results = _context4.sent;
+          // Apply the transformations to create the enhanced code
+          enhancedCode = _objectSpread({}, parsedCode);
+          _iterator = _createForOfIteratorHelper(results);
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              _step$value = _step.value, variant = _step$value.variant, transformedVariant = _step$value.transformedVariant;
+              enhancedCode[variant] = transformedVariant;
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+          return _context4.abrupt("return", enhancedCode);
+        case 10:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return _applyTransforms.apply(this, arguments);
+}

package/CodeHighlighter/transformParsedSource.d.ts

@@ -0,0 +1,3 @@
+import type { Nodes } from 'hast';
+import { ParseSource, Transforms } from "./types.js";
+export declare function transformParsedSource(source: string, parsedSource: Nodes, filename: string, transforms: Transforms, parseSource: ParseSource): Promise<Record<string, any>>;

package/CodeHighlighter/transformParsedSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformParsedSource.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/transformParsedSource.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAClC,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAIlD,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,KAAK,EACnB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,WAAW,GACvB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAwB9B"}

package/CodeHighlighter/transformParsedSource.js

@@ -0,0 +1,66 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { create, patch } from 'jsondiffpatch';
+var differ = create({
+  omitRemovedValues: true,
+  cloneDiffValues: true
+});
+export function transformParsedSource(_x, _x2, _x3, _x4, _x5) {
+  return _transformParsedSource.apply(this, arguments);
+}
+function _transformParsedSource() {
+  _transformParsedSource = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(source, parsedSource, filename, transforms, parseSource) {
+    var transformed;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.next = 2;
+          return Promise.all(Object.entries(transforms).map(/*#__PURE__*/function () {
+            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
+              var _ref3, key, transform, patched, transformedSource, parsedTransform, delta;
+              return _regeneratorRuntime().wrap(function _callee$(_context) {
+                while (1) switch (_context.prev = _context.next) {
+                  case 0:
+                    _ref3 = _slicedToArray(_ref, 2), key = _ref3[0], transform = _ref3[1];
+                    patched = patch(source.split('\n'), transform.delta);
+                    if (Array.isArray(patched)) {
+                      _context.next = 4;
+                      break;
+                    }
+                    throw new Error("Patch for ".concat(key, " did not return an array"));
+                  case 4:
+                    transformedSource = patched.join('\n');
+                    _context.next = 7;
+                    return parseSource(transformedSource, transform.fileName || filename);
+                  case 7:
+                    parsedTransform = _context.sent;
+                    // TODO: further optimize this delta, it looks a little noisy
+                    delta = differ.diff(parsedSource, parsedTransform);
+                    return _context.abrupt("return", _defineProperty({}, key, _objectSpread(_objectSpread({}, transform), {}, {
+                      delta: delta
+                    })));
+                  case 10:
+                  case "end":
+                    return _context.stop();
+                }
+              }, _callee);
+            }));
+            return function (_x6) {
+              return _ref2.apply(this, arguments);
+            };
+          }()));
+        case 2:
+          transformed = _context2.sent;
+          return _context2.abrupt("return", Object.assign.apply(Object, [{}].concat(_toConsumableArray(transformed))));
+        case 4:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _transformParsedSource.apply(this, arguments);
+}

package/CodeHighlighter/transformSource.d.ts

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

package/CodeHighlighter/transformSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformSource.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/transformSource.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAI7E,wBAAsB,eAAe,CACnC,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,MAAM,EAChB,kBAAkB,EAAE,kBAAkB,GACrC,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAuDjC"}