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

package/loadPrecomputedCodeHighlighter/loadPrecomputedCodeHighlighter.js

@@ -0,0 +1,194 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { loadVariant } from "../CodeHighlighter/loadVariant.js";
+import { parseSourceFactory } from "../parseSource/index.js";
+import { TsToJsTransformer } from "../transformTsToJs/index.js";
+import { parseCreateFactoryCall } from "./parseCreateFactoryCall.js";
+import { resolveVariantPathsWithFs } from "../loaderUtils/resolveModulePathWithFs.js";
+import { replacePrecomputeValue } from "./replacePrecomputeValue.js";
+import { createServerLoadSource } from "../loadServerSource/index.js";
+/**
+ * Webpack loader that processes demo files and precomputes variant data.
+ *
+ * This loader:
+ * 1. Parses demo files to find a single createDemo call with precompute: true
+ * 2. Resolves all variant entry point paths using resolveModulePathsWithFs
+ * 3. Uses loadVariant to handle all loading, parsing, and transformation:
+ *    - loadSource: Loads individual files and extracts dependencies
+ *    - loadVariantMeta: Creates basic variant structure
+ *    - parseSource: Applies syntax highlighting using Starry Night
+ *    - sourceTransformers: Handles TypeScript to JavaScript conversion
+ * 4. loadVariant handles recursive dependency loading automatically
+ * 5. Adds all dependencies to webpack's watch list
+ * 6. Replaces precompute: true with the actual precomputed data using replacePrecomputeValue
+ *
+ * Note: Only supports one createDemo call per file. Will throw an error if multiple calls are found.
+ *
+ * Features:
+ * - Proper variant entry point resolution using resolveModulePathsWithFs
+ * - Complete dependency tree loading handled by loadVariant
+ * - Syntax highlighting using Starry Night (via parseSource)
+ * - TypeScript to JavaScript transformation (via transformTsToJs)
+ * - Webpack dependency tracking for hot reloading
+ * - Precise precompute value replacement (via replacePrecomputeValue)
+ *
+ * Example input:
+ * ```typescript
+ * import { createDemo } from '@/functions/createDemo';
+ * import CssModules from './CssModules';
+ * import Tailwind from './Tailwind';
+ *
+ * export const CodeDemo = createDemo(
+ *   import.meta.url,
+ *   { CssModules, Tailwind },
+ *   {
+ *     name: 'Basic Code Block',
+ *     slug: 'code',
+ *     precompute: true,
+ *   },
+ * );
+ * ```
+ *
+ * Example output (precompute: true replaced with processed data):
+ * The precompute property is replaced with an object containing:
+ * - fileName: The main file name
+ * - source: HAST nodes with syntax highlighting applied
+ * - extraFiles: Object containing additional dependency files
+ * - transforms: Object with language variants (e.g., JavaScript version from TypeScript)
+ */
+export function loadPrecomputedCodeHighlighter(_x) {
+  return _loadPrecomputedCodeHighlighter.apply(this, arguments);
+}
+function _loadPrecomputedCodeHighlighter() {
+  _loadPrecomputedCodeHighlighter = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(source) {
+    var _this = this;
+    var callback, demoCall, variantData, allDependencies, resolvedVariantMap, loadSource, sourceTransformers, sourceParser, variantPromises, variantResults, _iterator, _step, result, modifiedSource;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          callback = this.async();
+          this.cacheable();
+          _context2.prev = 2;
+          _context2.next = 5;
+          return parseCreateFactoryCall(source, this.resourcePath);
+        case 5:
+          demoCall = _context2.sent;
+          if (demoCall) {
+            _context2.next = 9;
+            break;
+          }
+          callback(null, source);
+          return _context2.abrupt("return");
+        case 9:
+          if (demoCall.options.precompute) {
+            _context2.next = 12;
+            break;
+          }
+          callback(null, source);
+          return _context2.abrupt("return");
+        case 12:
+          // Load variant data for all variants
+          variantData = {};
+          allDependencies = []; // Resolve all variant entry point paths using resolveVariantPathsWithFs
+          _context2.next = 16;
+          return resolveVariantPathsWithFs(demoCall.variants);
+        case 16:
+          resolvedVariantMap = _context2.sent;
+          // Create loader functions
+          loadSource = createServerLoadSource({
+            includeDependencies: true,
+            storeAt: 'flat' // TODO: this should be configurable
+          }); // Setup source transformers for TypeScript to JavaScript conversion
+          sourceTransformers = [TsToJsTransformer]; // Create sourceParser promise for syntax highlighting
+          sourceParser = parseSourceFactory(); // Process variants in parallel
+          variantPromises = Array.from(resolvedVariantMap.entries()).map(/*#__PURE__*/function () {
+            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
+              var _ref3, variantName, fileUrl, _yield$loadVariant, processedVariant, dependencies;
+              return _regeneratorRuntime().wrap(function _callee$(_context) {
+                while (1) switch (_context.prev = _context.next) {
+                  case 0:
+                    _ref3 = _slicedToArray(_ref, 2), variantName = _ref3[0], fileUrl = _ref3[1];
+                    _context.prev = 1;
+                    _context.next = 4;
+                    return loadVariant(fileUrl,
+                    // URL for the variant entry point (already includes file://)
+                    variantName, fileUrl,
+                    // Let loadVariantMeta handle creating the initial variant
+                    sourceParser,
+                    // For syntax highlighting
+                    loadSource,
+                    // For loading source files and dependencies
+                    undefined, sourceTransformers,
+                    // For TypeScript to JavaScript conversion
+                    {
+                      maxDepth: 5
+                    });
+                  case 4:
+                    _yield$loadVariant = _context.sent;
+                    processedVariant = _yield$loadVariant.code;
+                    dependencies = _yield$loadVariant.dependencies;
+                    return _context.abrupt("return", {
+                      variantName: variantName,
+                      variantData: processedVariant,
+                      // processedVariant is a complete VariantCode
+                      dependencies: dependencies // All files that were loaded
+                    });
+                  case 10:
+                    _context.prev = 10;
+                    _context.t0 = _context["catch"](1);
+                    console.warn("Failed to load variant ".concat(variantName, " from ").concat(fileUrl, ":"), _context.t0);
+                    return _context.abrupt("return", null);
+                  case 14:
+                  case "end":
+                    return _context.stop();
+                }
+              }, _callee, null, [[1, 10]]);
+            }));
+            return function (_x2) {
+              return _ref2.apply(this, arguments);
+            };
+          }());
+          _context2.next = 23;
+          return Promise.all(variantPromises);
+        case 23:
+          variantResults = _context2.sent;
+          // Process results and collect dependencies
+          _iterator = _createForOfIteratorHelper(variantResults);
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              result = _step.value;
+              if (result) {
+                variantData[result.variantName] = result.variantData;
+                result.dependencies.forEach(function (file) {
+                  allDependencies.push(file);
+                });
+              }
+            }
+
+            // Replace 'precompute: true' with the actual precomputed data
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+          modifiedSource = replacePrecomputeValue(source, variantData); // Add all dependencies to webpack's watch list
+          allDependencies.forEach(function (dep) {
+            return _this.addDependency(dep);
+          });
+          callback(null, modifiedSource);
+          _context2.next = 34;
+          break;
+        case 31:
+          _context2.prev = 31;
+          _context2.t0 = _context2["catch"](2);
+          callback(_context2.t0 instanceof Error ? _context2.t0 : new Error(String(_context2.t0)));
+        case 34:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, this, [[2, 31]]);
+  }));
+  return _loadPrecomputedCodeHighlighter.apply(this, arguments);
+}

package/loadPrecomputedCodeHighlighter/parseCreateFactoryCall.d.ts

@@ -0,0 +1,20 @@
+export interface FactoryOptions {
+  name?: string;
+  slug?: string;
+  precompute?: boolean;
+}
+export interface ParsedCreateFactory {
+  functionName: string;
+  url: string;
+  variants: Record<string, string>;
+  options: FactoryOptions;
+  fullMatch: string;
+  variantsObjectStr: string;
+  optionsObjectStr: string;
+}
+/**
+ * Parses a file to extract a single create* factory call and its variants and options
+ * Only supports one create* call per file - will throw an error if multiple are found
+ * Returns null if no create* call is found
+ */
+export declare function parseCreateFactoryCall(code: string, filePath: string): Promise<ParsedCreateFactory | null>;

package/loadPrecomputedCodeHighlighter/parseCreateFactoryCall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseCreateFactoryCall.d.ts","sourceRoot":"","sources":["../../../src/loadPrecomputedCodeHighlighter/parseCreateFactoryCall.ts"],"names":[],"mappings":"AAqBA,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,OAAO,EAAE,cAAc,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAgFD;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAiErC"}

package/loadPrecomputedCodeHighlighter/parseCreateFactoryCall.js

@@ -0,0 +1,243 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { resolveImports } from "../loaderUtils/index.js";
+import { parseFunctionParameters } from "./parseFunctionParameters.js";
+
+/**
+ * Helper function to convert the new resolveImports format to a Map
+ * that maps import names to their resolved paths
+ */
+function buildImportMap(importResult) {
+  var importMap = new Map();
+  Object.values(importResult).forEach(function (_ref) {
+    var path = _ref.path,
+      names = _ref.names;
+    names.forEach(function (name) {
+      importMap.set(name, path);
+    });
+  });
+  return importMap;
+}
+/**
+ * Parses a variants object string and maps variant names to their import paths
+ */
+function parseVariantsObject(variantsObjectStr, importMap) {
+  var demoImports = {};
+
+  // Parse the demo object to extract key-value pairs
+  // Handle both { Default: BasicCode } and { Default } syntax
+  var objectContentRegex = /(\w+)(?:\s*:\s*(\w+))?/g;
+  var objectMatch = objectContentRegex.exec(variantsObjectStr);
+  while (objectMatch !== null) {
+    var _objectMatch = objectMatch,
+      _objectMatch2 = _slicedToArray(_objectMatch, 3),
+      key = _objectMatch2[1],
+      value = _objectMatch2[2];
+    var importName = value || key; // Use value if provided, otherwise use key (shorthand syntax)
+
+    if (importMap.has(importName)) {
+      demoImports[key] = importMap.get(importName);
+    }
+    objectMatch = objectContentRegex.exec(variantsObjectStr);
+  }
+  return demoImports;
+}
+
+/**
+ * Validates that a URL parameter follows the expected convention
+ */
+function validateUrlParameter(url, functionName, filePath) {
+  var trimmedUrl = url.trim();
+
+  // Check for import.meta.url
+  if (trimmedUrl === 'import.meta.url') {
+    return;
+  }
+
+  // Check for CJS equivalent: require('url').pathToFileURL(__filename).toString()
+  // https://github.com/javiertury/babel-plugin-transform-import-meta#importmetaurl
+  var cjsPattern = /require\s*\(\s*['"`]url['"`]\s*\)\s*\.\s*pathToFileURL\s*\(\s*__filename\s*\)\s*\.\s*toString\s*\(\s*\)/;
+  if (cjsPattern.test(trimmedUrl)) {
+    return;
+  }
+  throw new Error("Invalid URL parameter in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected 'import.meta.url' or 'require('url').pathToFileURL(__filename).toString()' but got: ".concat(trimmedUrl));
+}
+
+/**
+ * Validates that a variants parameter is an object mapping to imports
+ */
+function validateVariantsParameter(variantsObjectStr, functionName, filePath) {
+  if (!variantsObjectStr || variantsObjectStr.trim() === '') {
+    throw new Error("Invalid variants parameter in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected an object mapping variant names to imports.");
+  }
+
+  // Basic validation that it looks like an object
+  var trimmed = variantsObjectStr.trim();
+  if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
+    throw new Error("Invalid variants parameter in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected an object but got: ".concat(trimmed));
+  }
+}
+
+/**
+ * Parses a file to extract a single create* factory call and its variants and options
+ * Only supports one create* call per file - will throw an error if multiple are found
+ * Returns null if no create* call is found
+ */
+export function parseCreateFactoryCall(_x, _x2) {
+  return _parseCreateFactoryCall.apply(this, arguments);
+}
+
+/**
+ * Finds create* factory calls in code, handling multiline cases
+ */
+function _parseCreateFactoryCall() {
+  _parseCreateFactoryCall = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(code, filePath) {
+    var importResult, importMap, createFactoryMatches, match, functionName, fullMatch, urlParam, variantsObjectStr, optionsObjectStr, url, variants, options, nameMatch, slugMatch, precomputeMatch;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return resolveImports(code, filePath);
+        case 2:
+          importResult = _context.sent;
+          importMap = buildImportMap(importResult); // Find all create* calls in the code
+          createFactoryMatches = findCreateFactoryCalls(code, filePath); // Enforce single create* call per file
+          if (!(createFactoryMatches.length > 1)) {
+            _context.next = 7;
+            break;
+          }
+          throw new Error("Multiple create* factory calls found in ".concat(filePath, ". Only one create* call per file is supported. Found ").concat(createFactoryMatches.length, " calls."));
+        case 7:
+          if (!(createFactoryMatches.length === 0)) {
+            _context.next = 9;
+            break;
+          }
+          return _context.abrupt("return", null);
+        case 9:
+          match = createFactoryMatches[0];
+          functionName = match.functionName, fullMatch = match.fullMatch, urlParam = match.urlParam, variantsObjectStr = match.variantsObjectStr, optionsObjectStr = match.optionsObjectStr; // Validate URL parameter
+          validateUrlParameter(urlParam, functionName, filePath);
+
+          // Validate variants parameter
+          validateVariantsParameter(variantsObjectStr, functionName, filePath);
+
+          // Extract URL (typically import.meta.url)
+          url = urlParam.trim(); // Resolve variants for this specific create* call
+          variants = parseVariantsObject(variantsObjectStr, importMap); // Parse options object
+          options = {}; // Extract name
+          nameMatch = optionsObjectStr.match(/name\s*:\s*['"`]([^'"`]+)['"`]/);
+          if (nameMatch) {
+            options.name = nameMatch[1];
+          }
+
+          // Extract slug
+          slugMatch = optionsObjectStr.match(/slug\s*:\s*['"`]([^'"`]+)['"`]/);
+          if (slugMatch) {
+            options.slug = slugMatch[1];
+          }
+
+          // Extract precompute
+          precomputeMatch = optionsObjectStr.match(/precompute\s*:\s*(true|false)/);
+          if (precomputeMatch) {
+            options.precompute = precomputeMatch[1] === 'true';
+          }
+          return _context.abrupt("return", {
+            functionName: functionName,
+            url: url,
+            variants: variants,
+            options: options,
+            fullMatch: fullMatch,
+            variantsObjectStr: variantsObjectStr,
+            optionsObjectStr: optionsObjectStr
+          });
+        case 23:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _parseCreateFactoryCall.apply(this, arguments);
+}
+function findCreateFactoryCalls(code, filePath) {
+  var results = [];
+
+  // Find all create* function calls
+  var createFactoryRegex = /\b(create\w*)\s*\(/g;
+  var match = createFactoryRegex.exec(code);
+  while (match !== null) {
+    var functionName = match[1];
+    var startIndex = match.index;
+    var parenIndex = match.index + match[0].length - 1; // Position of opening parenthesis
+
+    // Find the matching closing parenthesis
+    var parenCount = 0;
+    var endIndex = -1;
+    for (var i = parenIndex; i < code.length; i += 1) {
+      if (code[i] === '(') {
+        parenCount += 1;
+      } else if (code[i] === ')') {
+        parenCount -= 1;
+        if (parenCount === 0) {
+          endIndex = i;
+          break;
+        }
+      }
+    }
+    if (endIndex === -1) {
+      match = createFactoryRegex.exec(code);
+      continue;
+    }
+    var fullMatch = code.substring(startIndex, endIndex + 1);
+    var content = code.substring(parenIndex + 1, endIndex);
+
+    // Split by commas at the top level, handling nested structures and comments
+    var _parseFunctionParamet = parseFunctionParameters(content),
+      parts = _parseFunctionParamet.parts,
+      objects = _parseFunctionParamet.objects;
+
+    // Validate the function follows the convention
+    if (parts.length < 2 || parts.length > 3) {
+      throw new Error("Invalid ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected 2-3 parameters (url, variants, options?) but got ".concat(parts.length, " parameters. ") + "Functions starting with 'create' must follow the convention: create*(url, variants, options?)");
+    }
+    if (parts.length === 2) {
+      var _parts = _slicedToArray(parts, 1),
+        urlParam = _parts[0];
+
+      // Extract the actual object string for variants
+      var variantsObjectStr = objects[1];
+      if (!variantsObjectStr) {
+        throw new Error("Invalid variants parameter in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected an object but could not parse: ".concat(parts[1].trim()));
+      }
+      results.push({
+        functionName: functionName,
+        fullMatch: fullMatch,
+        urlParam: urlParam.trim(),
+        variantsObjectStr: variantsObjectStr,
+        optionsObjectStr: '{}' // Default empty options
+      });
+    } else if (parts.length === 3) {
+      var _parts2 = _slicedToArray(parts, 1),
+        _urlParam = _parts2[0];
+
+      // Extract the actual object strings
+      var _variantsObjectStr = objects[1];
+      var optionsObjectStr = objects[2];
+      if (!_variantsObjectStr) {
+        throw new Error("Invalid variants parameter in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected an object but could not parse: ".concat(parts[1].trim()));
+      }
+      if (!optionsObjectStr) {
+        throw new Error("Invalid options parameter in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected an object but could not parse: ".concat(parts[2].trim()));
+      }
+      results.push({
+        functionName: functionName,
+        fullMatch: fullMatch,
+        urlParam: _urlParam.trim(),
+        variantsObjectStr: _variantsObjectStr,
+        optionsObjectStr: optionsObjectStr
+      });
+    }
+    match = createFactoryRegex.exec(code);
+  }
+  return results;
+}

package/loadPrecomputedCodeHighlighter/parseFunctionParameters.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Utility function for parsing function parameters and handling nested structures
+ * in JavaScript/TypeScript code.
+ */
+export interface ParsedParameters {
+  /** The raw parameter strings split by top-level commas */
+  parts: string[];
+  /** Extracted balanced brace objects from each part (null if not an object) */
+  objects: (string | null)[];
+}
+/**
+ * Parses function parameters, splitting by top-level commas and extracting object literals.
+ * This combines comma-splitting with object extraction for common use cases.
+ */
+export declare function parseFunctionParameters(str: string): ParsedParameters;

package/loadPrecomputedCodeHighlighter/parseFunctionParameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseFunctionParameters.d.ts","sourceRoot":"","sources":["../../../src/loadPrecomputedCodeHighlighter/parseFunctionParameters.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,0DAA0D;IAC1D,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,8EAA8E;IAC9E,OAAO,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;CAC5B;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CA8FrE"}

package/loadPrecomputedCodeHighlighter/parseFunctionParameters.js

@@ -0,0 +1,168 @@
+/**
+ * Utility function for parsing function parameters and handling nested structures
+ * in JavaScript/TypeScript code.
+ */
+
+/**
+ * Parses function parameters, splitting by top-level commas and extracting object literals.
+ * This combines comma-splitting with object extraction for common use cases.
+ */
+export function parseFunctionParameters(str) {
+  var parts = [];
+  var objects = [];
+  var current = '';
+  var parenCount = 0;
+  var braceCount = 0;
+  var inSingleLineComment = false;
+  var inMultiLineComment = false;
+  var inString = false;
+  var stringChar = '';
+  for (var i = 0; i < str.length; i += 1) {
+    var _char = str[i];
+    var nextChar = str[i + 1];
+
+    // Handle comments
+    if (!inString && !inSingleLineComment && !inMultiLineComment) {
+      if (_char === '/' && nextChar === '/') {
+        inSingleLineComment = true;
+        current += _char;
+        continue;
+      }
+      if (_char === '/' && nextChar === '*') {
+        inMultiLineComment = true;
+        current += _char;
+        continue;
+      }
+    }
+    if (inSingleLineComment && _char === '\n') {
+      inSingleLineComment = false;
+      current += _char;
+      continue;
+    }
+    if (inMultiLineComment && _char === '*' && nextChar === '/') {
+      inMultiLineComment = false;
+      current += _char + nextChar;
+      i += 1; // Skip next character
+      continue;
+    }
+    if (inSingleLineComment || inMultiLineComment) {
+      current += _char;
+      continue;
+    }
+
+    // Handle strings
+    if (!inString && (_char === '"' || _char === "'" || _char === '`')) {
+      inString = true;
+      stringChar = _char;
+      current += _char;
+      continue;
+    }
+    if (inString && _char === stringChar && str[i - 1] !== '\\') {
+      inString = false;
+      stringChar = '';
+      current += _char;
+      continue;
+    }
+    if (inString) {
+      current += _char;
+      continue;
+    }
+
+    // Handle brackets and parentheses
+    if (_char === '(') {
+      parenCount += 1;
+    } else if (_char === ')') {
+      parenCount -= 1;
+    } else if (_char === '{') {
+      braceCount += 1;
+    } else if (_char === '}') {
+      braceCount -= 1;
+    } else if (_char === ',' && parenCount === 0 && braceCount === 0) {
+      var trimmedPart = current.trim();
+      parts.push(trimmedPart);
+      objects.push(extractBalancedBraces(trimmedPart));
+      current = '';
+      continue;
+    }
+    current += _char;
+  }
+  if (current.trim()) {
+    var _trimmedPart = current.trim();
+    parts.push(_trimmedPart);
+    objects.push(extractBalancedBraces(_trimmedPart));
+  }
+  return {
+    parts: parts,
+    objects: objects
+  };
+}
+
+/**
+ * Extracts a balanced brace object from a string, handling leading whitespace and comments
+ */
+function extractBalancedBraces(str) {
+  // Find the first opening brace, skipping whitespace and comments
+  var startIndex = -1;
+  var inSingleLineComment = false;
+  var inMultiLineComment = false;
+  for (var i = 0; i < str.length; i += 1) {
+    var _char2 = str[i];
+    var nextChar = str[i + 1];
+
+    // Handle comments
+    if (!inSingleLineComment && !inMultiLineComment) {
+      if (_char2 === '/' && nextChar === '/') {
+        inSingleLineComment = true;
+        continue;
+      }
+      if (_char2 === '/' && nextChar === '*') {
+        inMultiLineComment = true;
+        i += 1; // Skip next character
+        continue;
+      }
+    }
+    if (inSingleLineComment && _char2 === '\n') {
+      inSingleLineComment = false;
+      continue;
+    }
+    if (inMultiLineComment && _char2 === '*' && nextChar === '/') {
+      inMultiLineComment = false;
+      i += 1; // Skip next character
+      continue;
+    }
+    if (inSingleLineComment || inMultiLineComment) {
+      continue;
+    }
+
+    // Skip whitespace
+    if (_char2 === ' ' || _char2 === '\t' || _char2 === '\n' || _char2 === '\r') {
+      continue;
+    }
+
+    // Found first non-whitespace, non-comment character
+    if (_char2 === '{') {
+      startIndex = i;
+      break;
+    } else {
+      // If it's not a brace, this isn't a valid object
+      return null;
+    }
+  }
+  if (startIndex === -1) {
+    return null;
+  }
+  var braceCount = 0;
+  var endIndex = -1;
+  for (var _i = startIndex; _i < str.length; _i += 1) {
+    if (str[_i] === '{') {
+      braceCount += 1;
+    } else if (str[_i] === '}') {
+      braceCount -= 1;
+      if (braceCount === 0) {
+        endIndex = _i;
+        break;
+      }
+    }
+  }
+  return endIndex !== -1 ? str.substring(startIndex, endIndex + 1) : null;
+}

package/loadPrecomputedCodeHighlighter/replacePrecomputeValue.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Replaces 'precompute: true' with the actual precomputed data in source code.
+ *
+ * This function performs a precise replacement of the boolean true value in
+ * 'precompute: true' expressions with the provided data object, keeping the
+ * rest of the source code unchanged.
+ *
+ * @param source - The source code string containing 'precompute: true'
+ * @param precomputeData - The data object to replace the true value with
+ * @returns The modified source code with precompute data injected
+ *
+ * @example
+ * ```typescript
+ * const source = `
+ * export const demo = createDemo(
+ *   import.meta.url,
+ *   { Component },
+ *   { precompute: true }
+ * );
+ * `;
+ *
+ * const data = { variants: { default: { code: "..." } } };
+ * const result = replacePrecomputeValue(source, data);
+ * // Result will have 'precompute: true' replaced with 'precompute: { variants: { default: { code: "..." } } }'
+ * ```
+ */
+export declare function replacePrecomputeValue(source: string, precomputeData: Record<string, any>): string;

package/loadPrecomputedCodeHighlighter/replacePrecomputeValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replacePrecomputeValue.d.ts","sourceRoot":"","sources":["../../../src/loadPrecomputedCodeHighlighter/replacePrecomputeValue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAClC,MAAM,CAUR"}