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

package/build/esm/CodeHighlighter/hasAllVariants.js

@@ -0,0 +1,31 @@
+function isSourceLoaded(code, needsHighlight) {
+  if (!code.source) {
+    return false;
+  }
+  if (typeof code.source === 'string' && needsHighlight) {
+    // TODO: handle 'stream' case
+    return false;
+  }
+
+  // if it's a hast node or hastJson, we assume it's loaded
+  return true;
+}
+export function hasAllVariants(variants, code, needsHighlight) {
+  return variants.every(function (variant) {
+    var codeVariant = code == null ? void 0 : code[variant];
+    if (!codeVariant || typeof codeVariant === 'string' || !isSourceLoaded(codeVariant, needsHighlight)) {
+      return false;
+    }
+    var extraFiles = codeVariant.extraFiles;
+    if (!extraFiles) {
+      return true;
+    }
+    return Object.keys(extraFiles).every(function (file) {
+      var extraFile = extraFiles[file];
+      if (!extraFile || typeof extraFile === 'string' || !isSourceLoaded(extraFile, needsHighlight)) {
+        return false;
+      }
+      return true;
+    });
+  });
+}

package/build/esm/CodeHighlighter/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./CodeHighlighter.js";
+export * from "./CodeHighlighterClient.js";
+export * from "./types.js";
+export * from "./applyTransform.js";

package/build/esm/CodeHighlighter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,SAAS,CAAC;AACxB,cAAc,kBAAkB,CAAC"}

package/build/esm/CodeHighlighter/index.js

@@ -0,0 +1,4 @@
+export * from "./CodeHighlighter.js";
+export * from "./CodeHighlighterClient.js";
+export * from "./types.js";
+export * from "./applyTransform.js";

package/build/esm/CodeHighlighter/loadFallbackCode.d.ts

@@ -0,0 +1,9 @@
+import type { Code, VariantExtraFiles, ParseSource, LoadSource, LoadVariantMeta, VariantSource, LoadCodeMeta } from "./types.js";
+export type FallbackVariants = {
+  code: Code;
+  initialFilename: string;
+  initialSource: VariantSource;
+  initialExtraFiles?: VariantExtraFiles;
+  allFileNames: string[];
+};
+export declare function loadFallbackCode(url: string, initialVariant: string, loaded: Code | undefined, shouldHighlight?: boolean, fallbackUsesExtraFiles?: boolean, fallbackUsesAllVariants?: boolean, sourceParser?: Promise<ParseSource>, loadSource?: LoadSource, loadVariantMeta?: LoadVariantMeta, loadCodeMeta?: LoadCodeMeta, initialFilename?: string, variants?: string[]): Promise<FallbackVariants>;

package/build/esm/CodeHighlighter/loadFallbackCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadFallbackCode.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/loadFallbackCode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,iBAAiB,EACjB,WAAW,EACX,UAAU,EACV,eAAe,EACf,aAAa,EACb,YAAY,EAEb,MAAM,SAAS,CAAC;AAuCjB,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,IAAI,CAAC;IACX,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,aAAa,CAAC;IAC7B,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAEF,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,EACX,cAAc,EAAE,MAAM,EACtB,MAAM,EAAE,IAAI,GAAG,SAAS,EACxB,eAAe,CAAC,EAAE,OAAO,EACzB,sBAAsB,CAAC,EAAE,OAAO,EAChC,uBAAuB,CAAC,EAAE,OAAO,EACjC,YAAY,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,EACnC,UAAU,CAAC,EAAE,UAAU,EACvB,eAAe,CAAC,EAAE,eAAe,EACjC,YAAY,CAAC,EAAE,YAAY,EAC3B,eAAe,CAAC,EAAE,MAAM,EACxB,QAAQ,CAAC,EAAE,MAAM,EAAE,GAClB,OAAO,CAAC,gBAAgB,CAAC,CAmS3B"}

package/build/esm/CodeHighlighter/loadFallbackCode.js

@@ -0,0 +1,468 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { loadVariant } from "./loadVariant.js";
+import { getFileNameFromUrl } from "../loaderUtils/index.js";
+
+// Helper function to get the source for a specific filename from a variant
+function getFileSource(_x, _x2, _x3) {
+  return _getFileSource.apply(this, arguments);
+}
+function _getFileSource() {
+  _getFileSource = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(variant, requestedFilename, loadSource) {
+    var filename, extraFile, loadResult;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          filename = requestedFilename || variant.fileName; // If requesting the main file and we have its source
+          if (!(filename === variant.fileName && variant.source !== undefined)) {
+            _context.next = 3;
+            break;
+          }
+          return _context.abrupt("return", {
+            source: variant.source,
+            filename: filename
+          });
+        case 3:
+          if (!(filename !== variant.fileName && variant.extraFiles)) {
+            _context.next = 14;
+            break;
+          }
+          extraFile = variant.extraFiles[filename];
+          if (!(extraFile && typeof extraFile !== 'string' && extraFile.source !== undefined)) {
+            _context.next = 7;
+            break;
+          }
+          return _context.abrupt("return", {
+            source: extraFile.source,
+            filename: filename
+          });
+        case 7:
+          if (!(typeof extraFile === 'string' && loadSource)) {
+            _context.next = 12;
+            break;
+          }
+          _context.next = 10;
+          return loadSource(extraFile);
+        case 10:
+          loadResult = _context.sent;
+          return _context.abrupt("return", {
+            source: loadResult.source,
+            filename: filename
+          });
+        case 12:
+          if (!(extraFile && typeof extraFile !== 'string' && !extraFile.source && loadSource)) {
+            _context.next = 14;
+            break;
+          }
+          throw new Error("Extra file ".concat(filename, " has no source or URL to load from"));
+        case 14:
+          throw new Error("File ".concat(filename, " not found in variant or cannot be loaded"));
+        case 15:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _getFileSource.apply(this, arguments);
+}
+export function loadFallbackCode(_x4, _x5, _x6, _x7, _x8, _x9, _x0, _x1, _x10, _x11, _x12, _x13) {
+  return _loadFallbackCode.apply(this, arguments);
+}
+function _loadFallbackCode() {
+  _loadFallbackCode = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(url, initialVariant, loaded, shouldHighlight, fallbackUsesExtraFiles, fallbackUsesAllVariants, sourceParser, loadSource, loadVariantMeta, loadCodeMeta, initialFilename, variants) {
+    var initial, _allFileNames, fileSource, actualFilename, result, parseSource, quickVariant, _allFileNames2, _fileSource, _actualFilename, _result, _parseSource, _yield$loadVariant, loadedVariant, allFileNames, allVariants, variantPromises, variantResults, finalInitial, finalFileSource, finalFilename, _result2;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          loaded = _objectSpread({}, loaded);
+
+          // Step 1: Ensure we have the initial variant loaded
+          initial = loaded[initialVariant];
+          if (initial) {
+            _context3.next = 17;
+            break;
+          }
+          if (loadCodeMeta) {
+            _context3.next = 5;
+            break;
+          }
+          throw new Error('"loadCodeMeta" function is required when initial variant is not provided');
+        case 5:
+          _context3.prev = 5;
+          _context3.next = 8;
+          return loadCodeMeta(url);
+        case 8:
+          loaded = _context3.sent;
+          _context3.next = 14;
+          break;
+        case 11:
+          _context3.prev = 11;
+          _context3.t0 = _context3["catch"](5);
+          throw new Error("Failed to load code from URL: ".concat(url, ". Error: ").concat(JSON.stringify(_context3.t0)));
+        case 14:
+          initial = loaded[initialVariant];
+          if (initial) {
+            _context3.next = 17;
+            break;
+          }
+          throw new Error("Initial variant \"".concat(initialVariant, "\" not found in loaded code."));
+        case 17:
+          if (!(typeof initial !== 'string' && initial.allFilesListed && !fallbackUsesExtraFiles && !fallbackUsesAllVariants)) {
+            _context3.next = 45;
+            break;
+          }
+          // Collect all file names from the loaded code
+          _allFileNames = new Set();
+          _allFileNames.add(initial.fileName);
+          if (initial.extraFiles) {
+            Object.keys(initial.extraFiles).forEach(function (fileName) {
+              return _allFileNames.add(fileName);
+            });
+          }
+
+          // Get the source for the requested filename (or main file if not specified)
+          _context3.prev = 21;
+          _context3.next = 24;
+          return getFileSource(initial, initialFilename, loadSource);
+        case 24:
+          result = _context3.sent;
+          fileSource = result.source;
+          actualFilename = result.filename;
+          _context3.next = 32;
+          break;
+        case 29:
+          _context3.prev = 29;
+          _context3.t1 = _context3["catch"](21);
+          throw new Error("Failed to get source for file ".concat(initialFilename || initial.fileName, " in variant ").concat(initialVariant, ": ").concat(_context3.t1));
+        case 32:
+          if (!(shouldHighlight && typeof fileSource === 'string' && sourceParser)) {
+            _context3.next = 43;
+            break;
+          }
+          _context3.prev = 33;
+          _context3.next = 36;
+          return sourceParser;
+        case 36:
+          parseSource = _context3.sent;
+          fileSource = parseSource(fileSource, actualFilename);
+          _context3.next = 43;
+          break;
+        case 40:
+          _context3.prev = 40;
+          _context3.t2 = _context3["catch"](33);
+          throw new Error("Failed to parse source for highlighting (variant: ".concat(initialVariant, ", file: ").concat(actualFilename, "): ").concat(JSON.stringify(_context3.t2)));
+        case 43:
+          // Update the loaded code with any changes we made
+          if (actualFilename === initial.fileName) {
+            initial = _objectSpread(_objectSpread({}, initial), {}, {
+              source: fileSource
+            });
+            loaded = _objectSpread(_objectSpread({}, loaded), {}, _defineProperty({}, initialVariant, initial));
+          }
+
+          // Early return - we have all the info we need
+          return _context3.abrupt("return", {
+            code: loaded,
+            initialFilename: actualFilename,
+            initialSource: fileSource,
+            initialExtraFiles: initial.extraFiles || {},
+            allFileNames: Array.from(_allFileNames)
+          });
+        case 45:
+          if (!(typeof initial === 'string')) {
+            _context3.next = 89;
+            break;
+          }
+          _context3.prev = 46;
+          if (!loadVariantMeta) {
+            _context3.next = 53;
+            break;
+          }
+          _context3.next = 50;
+          return loadVariantMeta(initialVariant, initial);
+        case 50:
+          quickVariant = _context3.sent;
+          _context3.next = 54;
+          break;
+        case 53:
+          // Create a basic variant using fallback logic
+          quickVariant = {
+            url: initial,
+            fileName: getFileNameFromUrl(initial).fileName
+          };
+        case 54:
+          loaded = _objectSpread(_objectSpread({}, loaded), {}, _defineProperty({}, initialVariant, quickVariant));
+          initial = quickVariant;
+
+          // If we have all files listed and don't need extra file processing, we can optimize
+          if (!(quickVariant.allFilesListed && !fallbackUsesExtraFiles && !fallbackUsesAllVariants)) {
+            _context3.next = 84;
+            break;
+          }
+          // Collect all file names from the quick load
+          _allFileNames2 = new Set();
+          _allFileNames2.add(quickVariant.fileName);
+          if (quickVariant.extraFiles) {
+            Object.keys(quickVariant.extraFiles).forEach(function (fileName) {
+              return _allFileNames2.add(fileName);
+            });
+          }
+
+          // Get the source for the requested filename (or main file if not specified)
+          _context3.prev = 60;
+          _context3.next = 63;
+          return getFileSource(quickVariant, initialFilename, loadSource);
+        case 63:
+          _result = _context3.sent;
+          _fileSource = _result.source;
+          _actualFilename = _result.filename;
+          _context3.next = 71;
+          break;
+        case 68:
+          _context3.prev = 68;
+          _context3.t3 = _context3["catch"](60);
+          throw new Error("Failed to get source for file ".concat(initialFilename || quickVariant.fileName, " in variant ").concat(initialVariant, ": ").concat(_context3.t3));
+        case 71:
+          if (!(shouldHighlight && typeof _fileSource === 'string' && sourceParser)) {
+            _context3.next = 82;
+            break;
+          }
+          _context3.prev = 72;
+          _context3.next = 75;
+          return sourceParser;
+        case 75:
+          _parseSource = _context3.sent;
+          _fileSource = _parseSource(_fileSource, _actualFilename);
+          _context3.next = 82;
+          break;
+        case 79:
+          _context3.prev = 79;
+          _context3.t4 = _context3["catch"](72);
+          throw new Error("Failed to parse source for highlighting (variant: ".concat(initialVariant, ", file: ").concat(_actualFilename, "): ").concat(JSON.stringify(_context3.t4)));
+        case 82:
+          // Update the loaded code with any changes we made
+          if (_actualFilename === quickVariant.fileName) {
+            initial = _objectSpread(_objectSpread({}, quickVariant), {}, {
+              source: _fileSource
+            });
+            loaded = _objectSpread(_objectSpread({}, loaded), {}, _defineProperty({}, initialVariant, initial));
+          }
+
+          // Early return - we have all the info we need
+          return _context3.abrupt("return", {
+            code: loaded,
+            initialFilename: _actualFilename,
+            initialSource: _fileSource,
+            initialExtraFiles: quickVariant.extraFiles || {},
+            allFileNames: Array.from(_allFileNames2)
+          });
+        case 84:
+          _context3.next = 89;
+          break;
+        case 86:
+          _context3.prev = 86;
+          _context3.t5 = _context3["catch"](46);
+          throw new Error("Failed to load initial variant code (variant: ".concat(initialVariant, ", url: ").concat(initial, "): ").concat(JSON.stringify(_context3.t5)));
+        case 89:
+          _context3.prev = 89;
+          _context3.next = 92;
+          return loadVariant(url, initialVariant, initial, sourceParser, loadSource, loadVariantMeta, undefined,
+          // sourceTransformers - skip transforms for fallback
+          {
+            disableTransforms: true,
+            // Don't apply transforms for fallback
+            disableParsing: !shouldHighlight // Only parse if highlighting is needed
+          });
+        case 92:
+          _yield$loadVariant = _context3.sent;
+          loadedVariant = _yield$loadVariant.code;
+          // Update the loaded code with the processed variant
+          loaded = _objectSpread(_objectSpread({}, loaded), {}, _defineProperty({}, initialVariant, loadedVariant));
+          initial = loadedVariant;
+          _context3.next = 101;
+          break;
+        case 98:
+          _context3.prev = 98;
+          _context3.t6 = _context3["catch"](89);
+          throw new Error("Failed to load initial variant using loadVariant (variant: ".concat(initialVariant, ", url: ").concat(url, "): ").concat(JSON.stringify(_context3.t6)));
+        case 101:
+          // Step 3: Collect all file names
+          allFileNames = new Set();
+          allFileNames.add(initial.fileName);
+
+          // Add extra files from the initial variant
+          if (initial.extraFiles) {
+            Object.keys(initial.extraFiles).forEach(function (fileName) {
+              return allFileNames.add(fileName);
+            });
+          }
+
+          // Step 4: Handle fallbackUsesAllVariants - load all variants to get all possible files
+          if (!fallbackUsesAllVariants) {
+            _context3.next = 115;
+            break;
+          }
+          // Determine all variants to process - use provided variants or infer from loaded code
+          allVariants = variants || Object.keys(loaded || {});
+          if (!(allVariants.length === 0)) {
+            _context3.next = 110;
+            break;
+          }
+          console.warn('No variants found for fallbackUsesAllVariants processing');
+          _context3.next = 115;
+          break;
+        case 110:
+          // Process all required variants, not just the ones already loaded
+          variantPromises = allVariants.map(/*#__PURE__*/function () {
+            var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(variantName) {
+              var _loaded;
+              var variant, allCode, _yield$loadVariant2, _loadedVariant, fileNames;
+              return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+                while (1) switch (_context2.prev = _context2.next) {
+                  case 0:
+                    if (!(variantName === initialVariant)) {
+                      _context2.next = 2;
+                      break;
+                    }
+                    return _context2.abrupt("return", {
+                      variantName: variantName,
+                      loadedVariant: null,
+                      fileNames: []
+                    });
+                  case 2:
+                    variant = (_loaded = loaded) == null ? void 0 : _loaded[variantName]; // If variant is not loaded yet, load it first using loadCodeMeta
+                    if (!(!variant && loadCodeMeta)) {
+                      _context2.next = 16;
+                      break;
+                    }
+                    _context2.prev = 4;
+                    _context2.next = 7;
+                    return loadCodeMeta(url);
+                  case 7:
+                    allCode = _context2.sent;
+                    variant = allCode[variantName];
+                    // Update loaded with all variants from loadCodeMeta
+                    loaded = _objectSpread(_objectSpread({}, loaded), allCode);
+                    _context2.next = 16;
+                    break;
+                  case 12:
+                    _context2.prev = 12;
+                    _context2.t0 = _context2["catch"](4);
+                    console.warn("Failed to load code meta for variant ".concat(variantName, ": ").concat(_context2.t0));
+                    return _context2.abrupt("return", {
+                      variantName: variantName,
+                      loadedVariant: null,
+                      fileNames: []
+                    });
+                  case 16:
+                    if (variant) {
+                      _context2.next = 19;
+                      break;
+                    }
+                    console.warn("Variant ".concat(variantName, " not found after loading code meta"));
+                    return _context2.abrupt("return", {
+                      variantName: variantName,
+                      loadedVariant: null,
+                      fileNames: []
+                    });
+                  case 19:
+                    _context2.prev = 19;
+                    _context2.next = 22;
+                    return loadVariant(url, variantName, variant, sourceParser, loadSource, loadVariantMeta, undefined,
+                    // sourceTransformers
+                    {
+                      disableTransforms: true,
+                      disableParsing: !shouldHighlight
+                    });
+                  case 22:
+                    _yield$loadVariant2 = _context2.sent;
+                    _loadedVariant = _yield$loadVariant2.code;
+                    // Collect file names from this variant
+                    fileNames = [_loadedVariant.fileName];
+                    if (_loadedVariant.extraFiles) {
+                      fileNames.push.apply(fileNames, _toConsumableArray(Object.keys(_loadedVariant.extraFiles)));
+                    }
+                    return _context2.abrupt("return", {
+                      variantName: variantName,
+                      loadedVariant: _loadedVariant,
+                      fileNames: fileNames
+                    });
+                  case 29:
+                    _context2.prev = 29;
+                    _context2.t1 = _context2["catch"](19);
+                    // Log but don't fail - we want to get as many file names as possible
+                    console.warn("Failed to load variant ".concat(variantName, " for file listing: ").concat(_context2.t1));
+                    return _context2.abrupt("return", {
+                      variantName: variantName,
+                      loadedVariant: null,
+                      fileNames: []
+                    });
+                  case 33:
+                  case "end":
+                    return _context2.stop();
+                }
+              }, _callee2, null, [[4, 12], [19, 29]]);
+            }));
+            return function (_x14) {
+              return _ref.apply(this, arguments);
+            };
+          }());
+          _context3.next = 113;
+          return Promise.all(variantPromises);
+        case 113:
+          variantResults = _context3.sent;
+          // Update loaded code and collect file names
+          variantResults.forEach(function (_ref2) {
+            var variantName = _ref2.variantName,
+              loadedVariant = _ref2.loadedVariant,
+              fileNames = _ref2.fileNames;
+            if (loadedVariant) {
+              loaded = _objectSpread(_objectSpread({}, loaded), {}, _defineProperty({}, variantName, loadedVariant));
+            }
+            fileNames.forEach(function (fileName) {
+              return allFileNames.add(fileName);
+            });
+          });
+        case 115:
+          // Ensure we have the latest initial variant data
+          finalInitial = loaded[initialVariant];
+          if (!(!finalInitial || typeof finalInitial === 'string')) {
+            _context3.next = 118;
+            break;
+          }
+          throw new Error("Failed to process initial variant: ".concat(initialVariant));
+        case 118:
+          _context3.prev = 118;
+          _context3.next = 121;
+          return getFileSource(finalInitial, initialFilename, loadSource);
+        case 121:
+          _result2 = _context3.sent;
+          finalFileSource = _result2.source;
+          finalFilename = _result2.filename;
+          _context3.next = 130;
+          break;
+        case 126:
+          _context3.prev = 126;
+          _context3.t7 = _context3["catch"](118);
+          // If we can't get the specific file, fall back to the main file
+          finalFileSource = finalInitial.source || '';
+          finalFilename = finalInitial.fileName;
+        case 130:
+          return _context3.abrupt("return", {
+            code: loaded,
+            initialFilename: finalFilename,
+            initialSource: finalFileSource,
+            initialExtraFiles: finalInitial.extraFiles || {},
+            allFileNames: Array.from(allFileNames)
+          });
+        case 131:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[5, 11], [21, 29], [33, 40], [46, 86], [60, 68], [72, 79], [89, 98], [118, 126]]);
+  }));
+  return _loadFallbackCode.apply(this, arguments);
+}

package/build/esm/CodeHighlighter/loadVariant.d.ts

@@ -0,0 +1,11 @@
+import type { VariantCode, ParseSource, LoadSource, LoadVariantMeta, SourceTransformers, LoadFileOptions } from "./types.js";
+/**
+ * Loads a variant with support for recursive extra file loading.
+ * The loadSource function can now return extraFiles that will be loaded recursively.
+ * Supports both relative and absolute paths for extra files.
+ * Uses Promise.all for efficient parallel loading of extra files.
+ */
+export declare function loadVariant(url: string, variantName: string, variant: VariantCode | string | undefined, sourceParser?: Promise<ParseSource>, loadSource?: LoadSource, loadVariantMeta?: LoadVariantMeta, sourceTransformers?: SourceTransformers, options?: LoadFileOptions): Promise<{
+  code: VariantCode;
+  dependencies: string[];
+}>;

package/build/esm/CodeHighlighter/loadVariant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadVariant.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/loadVariant.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,WAAW,EAIX,WAAW,EACX,UAAU,EACV,eAAe,EACf,kBAAkB,EAClB,eAAe,EAChB,MAAM,SAAS,CAAC;AA4ajB;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,EACzC,YAAY,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,EACnC,UAAU,CAAC,EAAE,UAAU,EACvB,eAAe,CAAC,EAAE,eAAe,EACjC,kBAAkB,CAAC,EAAE,kBAAkB,EACvC,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAiHxD"}