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

package/pipeline/transformMarkdownCode/transformMarkdownCode.js

@@ -0,0 +1,514 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { visit } from 'unist-util-visit';
+/**
+ * Remark plugin that transforms code blocks with variants into HTML pre/code structures.
+ *
+ * Transforms consecutive code blocks with variant metadata like:
+ *
+ * ```javascript variant=npm
+ * npm install @mui/internal-docs-infra
+ * ```
+ * ```javascript variant=pnpm
+ * pnpm install @mui/internal-docs-infra
+ * ```
+ * ```javascript variant=yarn
+ * yarn add @mui/internal-docs-infra
+ * ```
+ *
+ * OR with variant-group (with labels between):
+ *
+ * npm
+ * ```bash variant-group=install
+ * npm install @mui/internal-docs-infra
+ * ```
+ * pnpm
+ * ```bash variant-group=install
+ * pnpm install @mui/internal-docs-infra
+ * ```
+ * yarn
+ * ```bash variant-group=install
+ * yarn add @mui/internal-docs-infra
+ * ```
+ *
+ * OR individual code blocks with options:
+ *
+ * ```ts transform
+ * console.log('test' as const)
+ * ```
+ *
+ * Into HTML that the existing rehype plugin can process:
+ * <pre>
+ *   <code data-variant="npm">npm install @mui/internal-docs-infra</code>
+ *   <code data-variant="pnpm">pnpm install @mui/internal-docs-infra</code>
+ *   <code data-variant="yarn">yarn add @mui/internal-docs-infra</code>
+ * </pre>
+ *
+ * Or for individual blocks:
+ * <pre>
+ *   <code data-transform="true">console.log('test' as const)</code>
+ * </pre>
+ */
+
+/**
+ * Parse meta string to extract variant and other properties
+ */
+function parseMeta(meta) {
+  var result = {
+    props: {}
+  };
+
+  // Parse key=value pairs first, handling quoted values
+  var keyValueRegex = /([\w-]+)=("(?:[^"\\]|\\.)*"|[^\s]+)/g;
+  var match = keyValueRegex.exec(meta);
+  var processedPositions = [];
+  while (match !== null) {
+    var _match = match,
+      _match2 = _slicedToArray(_match, 3),
+      fullMatch = _match2[0],
+      key = _match2[1],
+      rawValue = _match2[2];
+    var startPos = match.index;
+    var endPos = match.index + fullMatch.length;
+    processedPositions.push([startPos, endPos]);
+
+    // Remove quotes if present
+    var value = rawValue.startsWith('"') && rawValue.endsWith('"') ? rawValue.slice(1, -1) : rawValue;
+    if (key === 'variant') {
+      result.variant = value;
+    } else if (key === 'variant-group') {
+      result.variantGroup = value;
+    } else {
+      result.props[key] = value;
+    }
+    match = keyValueRegex.exec(meta);
+  }
+
+  // Extract remaining parts as standalone flags
+  var remainingMeta = meta;
+  // Remove processed key=value pairs from the string (in reverse order to maintain positions)
+  processedPositions.sort(function (a, b) {
+    return b[0] - a[0];
+  }).forEach(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      start = _ref2[0],
+      end = _ref2[1];
+    remainingMeta = remainingMeta.slice(0, start) + remainingMeta.slice(end);
+  });
+
+  // Process remaining standalone flags
+  var remainingParts = remainingMeta.trim().split(/\s+/).filter(Boolean);
+  var _iterator = _createForOfIteratorHelper(remainingParts),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var part = _step.value;
+      if (part === 'variant') {
+        // This shouldn't happen, but just in case
+        result.variant = 'true';
+      } else if (part === 'variant-group') {
+        // This shouldn't happen, but just in case
+        result.variantGroup = 'true';
+      } else {
+        // Handle standalone flags (e.g., "transform" becomes "transform": "true")
+        result.props[part] = 'true';
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+}
+export var transformMarkdownCode = function transformMarkdownCode() {
+  return function (tree) {
+    var processedIndices = new Set();
+    visit(tree, function (node, index, parent) {
+      if (!parent || !Array.isArray(parent.children) || typeof index !== 'number') {
+        return;
+      }
+
+      // Skip if already processed
+      if (processedIndices.has(index)) {
+        return;
+      }
+      var parentNode = parent;
+
+      // Look for code blocks with variant metadata or options
+      if (node.type === 'code') {
+        var codeNode = node;
+
+        // Check if variant metadata is in meta field or lang field (when no language is specified)
+        var metaString = codeNode.meta;
+        var langFromMeta = codeNode.lang || null;
+
+        // If meta is empty but lang contains '=', it means variant info is in lang
+        if (!metaString && codeNode.lang && codeNode.lang.includes('=')) {
+          metaString = codeNode.lang;
+          langFromMeta = null;
+        }
+
+        // Check if we have variants/variant-groups or individual options
+        var metaData = {
+          props: {}
+        };
+        if (metaString) {
+          metaData = parseMeta(metaString);
+        }
+
+        // Use props from meta as the options for individual blocks
+        var allProps = metaData.props;
+
+        // Handle individual code blocks with options (but no variants)
+        if (!metaData.variant && !metaData.variantGroup && Object.keys(allProps).length > 0) {
+          // Create a simple pre/code element for individual blocks with options
+          var hProperties = {};
+
+          // Add language class if available
+          if (langFromMeta) {
+            hProperties.className = "language-".concat(langFromMeta);
+          }
+
+          // Add all props as data attributes (in camelCase)
+          Object.entries(allProps).forEach(function (_ref3) {
+            var _ref4 = _slicedToArray(_ref3, 2),
+              key = _ref4[0],
+              value = _ref4[1];
+            // Convert kebab-case to camelCase for data attributes
+            var camelKey = key.includes('-') ? "data".concat(key.split('-').map(function (part) {
+              return part.charAt(0).toUpperCase() + part.slice(1);
+            }).join('')) : "data".concat(key.charAt(0).toUpperCase() + key.slice(1));
+            hProperties[camelKey] = value;
+          });
+          var preElement = {
+            type: 'element',
+            tagName: 'pre',
+            data: {
+              hName: 'pre',
+              hProperties: {}
+            },
+            children: [{
+              type: 'element',
+              tagName: 'code',
+              data: {
+                hName: 'code',
+                hProperties: hProperties
+              },
+              children: [{
+                type: 'text',
+                value: codeNode.value
+              }]
+            }]
+          };
+
+          // Replace this individual code block immediately
+          parentNode.children[index] = preElement;
+          processedIndices.add(index);
+          return;
+        }
+
+        // Handle variant/variant-group logic (existing code)
+        if (!metaString) {
+          return;
+        }
+        if (metaData.variant || metaData.variantGroup) {
+          // Collect consecutive code blocks that belong together
+          var codeBlocks = [];
+          var currentIndex = index;
+
+          // For variant-group, look for pattern: [label] -> code block
+          // For variant, look for adjacent code blocks only
+
+          if (metaData.variantGroup) {
+            // Add the current code block as the first one for variant-group
+            var currentLabelFromPrevious;
+            if (index > 0) {
+              var prevNode = parentNode.children[index - 1];
+              if (prevNode.type === 'paragraph' && prevNode.children.length === 1 && prevNode.children[0].type === 'text') {
+                currentLabelFromPrevious = prevNode.children[0].value.trim();
+              }
+            }
+            codeBlocks.push({
+              node: codeNode,
+              index: index,
+              variant: currentLabelFromPrevious || metaData.variantGroup || 'default',
+              props: allProps,
+              actualLang: langFromMeta,
+              labelFromPrevious: currentLabelFromPrevious
+            });
+            processedIndices.add(index);
+
+            // Start looking from the next element
+            currentIndex = index + 1;
+
+            // Collect all blocks with the same variant-group
+            while (currentIndex < parentNode.children.length) {
+              var currentNode = parentNode.children[currentIndex];
+
+              // Check if this is a potential label paragraph
+              if (currentNode.type === 'paragraph' && currentNode.children.length === 1 && currentNode.children[0].type === 'text') {
+                // Look for a code block after this paragraph
+                if (currentIndex + 1 < parentNode.children.length) {
+                  var nextNode = parentNode.children[currentIndex + 1];
+                  if (nextNode.type === 'code') {
+                    // Check if this code block has the same variant-group
+                    var nextMetaString = nextNode.meta;
+                    var nextActualLang = nextNode.lang;
+                    if (!nextMetaString && nextActualLang && nextActualLang.includes('=')) {
+                      nextMetaString = nextActualLang;
+                      nextActualLang = null;
+                    }
+                    if (nextMetaString) {
+                      var nextMetaData = parseMeta(nextMetaString);
+                      if (nextMetaData.variantGroup === metaData.variantGroup) {
+                        var labelFromPrevious = currentNode.children[0].value.trim();
+                        codeBlocks.push({
+                          node: nextNode,
+                          index: currentIndex + 1,
+                          variant: labelFromPrevious || nextMetaData.variantGroup || 'default',
+                          props: nextMetaData.props,
+                          actualLang: nextActualLang,
+                          labelFromPrevious: labelFromPrevious
+                        });
+                        processedIndices.add(currentIndex + 1);
+
+                        // Skip the code block and move to next potential label
+                        currentIndex += 2;
+                        continue;
+                      }
+                    }
+                  }
+                }
+                // If we didn't find a matching code block, break
+                break;
+              }
+              if (currentNode.type === 'code') {
+                // Parse language and meta for current node
+                var currentMetaString = currentNode.meta;
+                var currentActualLang = currentNode.lang;
+                if (!currentMetaString && currentActualLang && currentActualLang.includes('=')) {
+                  currentMetaString = currentActualLang;
+                  currentActualLang = null;
+                }
+                if (currentMetaString) {
+                  var currentMetaData = parseMeta(currentMetaString);
+                  if (currentMetaData.variantGroup === metaData.variantGroup) {
+                    // Look for label before this code block
+                    var _labelFromPrevious = void 0;
+                    if (currentIndex > 0) {
+                      var _prevNode = parentNode.children[currentIndex - 1];
+                      if (_prevNode.type === 'paragraph' && _prevNode.children.length === 1 && _prevNode.children[0].type === 'text') {
+                        _labelFromPrevious = _prevNode.children[0].value.trim();
+                      }
+                    }
+                    codeBlocks.push({
+                      node: currentNode,
+                      index: currentIndex,
+                      variant: _labelFromPrevious || currentMetaData.variantGroup || 'default',
+                      props: currentMetaData.props,
+                      actualLang: currentActualLang,
+                      labelFromPrevious: _labelFromPrevious
+                    });
+                    processedIndices.add(currentIndex);
+
+                    // Skip the label and move to next potential code block
+                    currentIndex += 1;
+
+                    // Skip ahead past any paragraph that could be a label
+                    if (currentIndex < parentNode.children.length) {
+                      var _nextNode = parentNode.children[currentIndex];
+                      if (_nextNode.type === 'paragraph' && _nextNode.children.length === 1 && _nextNode.children[0].type === 'text') {
+                        currentIndex += 1; // Skip the potential label
+                      }
+                    }
+                  } else {
+                    break; // Different group, stop collecting
+                  }
+                } else {
+                  break; // No meta, stop collecting
+                }
+              } else {
+                break; // Not a code block, stop collecting
+              }
+            }
+          } else if (metaData.variant) {
+            // Add the current code block as the first one for variant
+            codeBlocks.push({
+              node: codeNode,
+              index: index,
+              variant: metaData.variant,
+              props: allProps,
+              actualLang: langFromMeta
+            });
+            processedIndices.add(index);
+
+            // Start looking from the next element
+            currentIndex = index + 1;
+
+            // Collect adjacent code blocks with variants
+            while (currentIndex < parentNode.children.length) {
+              var _currentNode = parentNode.children[currentIndex];
+              if (_currentNode.type === 'code') {
+                // Parse language and meta for current node
+                var _currentMetaString = _currentNode.meta;
+                var _currentActualLang = _currentNode.lang;
+                if (!_currentMetaString && _currentActualLang && _currentActualLang.includes('=')) {
+                  _currentMetaString = _currentActualLang;
+                  _currentActualLang = null;
+                }
+                if (_currentMetaString) {
+                  var _currentMetaData = parseMeta(_currentMetaString);
+                  if (_currentMetaData.variant) {
+                    codeBlocks.push({
+                      node: _currentNode,
+                      index: currentIndex,
+                      variant: _currentMetaData.variant,
+                      props: _currentMetaData.props,
+                      actualLang: _currentActualLang
+                    });
+                    processedIndices.add(currentIndex);
+                    currentIndex += 1;
+                  } else {
+                    break; // No variant, stop collecting
+                  }
+                } else {
+                  break; // No meta, stop collecting
+                }
+              } else {
+                break; // Not a code block, stop collecting
+              }
+            }
+          }
+
+          // Only process if we have multiple blocks
+          if (codeBlocks.length > 1) {
+            // Create proper HTML elements with hProperties for remark-rehype compatibility
+            var _preElement = {
+              type: 'element',
+              tagName: 'pre',
+              data: {
+                hName: 'pre',
+                hProperties: {}
+              },
+              children: codeBlocks.map(function (block) {
+                // Build hProperties for HTML attributes
+                var hProperties = {
+                  dataVariant: block.variant
+                };
+
+                // Add language class if available
+                if (block.actualLang) {
+                  hProperties.className = "language-".concat(block.actualLang);
+                }
+
+                // Add additional props as data attributes (in camelCase)
+                Object.entries(block.props).forEach(function (_ref5) {
+                  var _ref6 = _slicedToArray(_ref5, 2),
+                    key = _ref6[0],
+                    value = _ref6[1];
+                  // Convert kebab-case to camelCase for data attributes
+                  var camelKey = key.includes('-') ? "data".concat(key.split('-').map(function (part) {
+                    return part.charAt(0).toUpperCase() + part.slice(1);
+                  }).join('')) : "data".concat(key.charAt(0).toUpperCase() + key.slice(1));
+                  hProperties[camelKey] = value;
+                });
+                return {
+                  type: 'element',
+                  tagName: 'code',
+                  data: {
+                    hName: 'code',
+                    hProperties: hProperties,
+                    meta: "variant=".concat(block.variant).concat(Object.entries(block.props).map(function (_ref7) {
+                      var _ref8 = _slicedToArray(_ref7, 2),
+                        key = _ref8[0],
+                        value = _ref8[1];
+                      return " ".concat(key, "=").concat(value);
+                    }).join(''))
+                  },
+                  children: [{
+                    type: 'text',
+                    value: block.node.value
+                  }]
+                };
+              })
+            };
+
+            // Replace the first block with the group and mark others for removal
+            parentNode.children[codeBlocks[0].index] = _preElement;
+
+            // Remove all other code blocks and their labels (in reverse order to maintain indices)
+            var indicesToRemove = codeBlocks.slice(1).map(function (block) {
+              var indices = [block.index];
+              // Also include label paragraph if it exists
+              if (block.labelFromPrevious && block.index > 0) {
+                var _prevNode2 = parentNode.children[block.index - 1];
+                if (_prevNode2.type === 'paragraph') {
+                  indices.push(block.index - 1);
+                }
+              }
+              return indices;
+            }).flat().sort(function (a, b) {
+              return b - a;
+            }); // Sort in descending order
+
+            // Remove the marked indices
+            var _iterator2 = _createForOfIteratorHelper(indicesToRemove),
+              _step2;
+            try {
+              var _loop = function _loop() {
+                var removeIdx = _step2.value;
+                if (removeIdx < parentNode.children.length) {
+                  parentNode.children.splice(removeIdx, 1);
+                  // Update processed indices to account for removed elements
+                  var _updatedProcessedIndices = new Set();
+                  processedIndices.forEach(function (processedIdx) {
+                    if (processedIdx > removeIdx) {
+                      _updatedProcessedIndices.add(processedIdx - 1);
+                    } else if (processedIdx < removeIdx) {
+                      _updatedProcessedIndices.add(processedIdx);
+                    }
+                    // Don't add the removed index
+                  });
+                  processedIndices.clear();
+                  _updatedProcessedIndices.forEach(function (processedIdx) {
+                    processedIndices.add(processedIdx);
+                  });
+                }
+              };
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                _loop();
+              }
+
+              // Also remove the label of the first block if it exists
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+            if (codeBlocks[0].labelFromPrevious && codeBlocks[0].index > 0) {
+              var labelIndex = codeBlocks[0].index - 1;
+              var _prevNode3 = parentNode.children[labelIndex];
+              if (_prevNode3 && _prevNode3.type === 'paragraph') {
+                parentNode.children.splice(labelIndex, 1);
+                // Update processed indices
+                var updatedProcessedIndices = new Set();
+                processedIndices.forEach(function (processedIdx) {
+                  if (processedIdx > labelIndex) {
+                    updatedProcessedIndices.add(processedIdx - 1);
+                  } else if (processedIdx < labelIndex) {
+                    updatedProcessedIndices.add(processedIdx);
+                  }
+                });
+                processedIndices.clear();
+                updatedProcessedIndices.forEach(function (processedIdx) {
+                  processedIndices.add(processedIdx);
+                });
+              }
+            }
+          }
+        }
+      }
+    });
+  };
+};

package/pipeline/transformTypescriptToJavascript/index.d.ts

@@ -0,0 +1 @@
+export * from "./transformTypescriptToJavascript.js";

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

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

package/pipeline/transformTypescriptToJavascript/index.js

@@ -0,0 +1 @@
+export * from "./transformTypescriptToJavascript.js";

package/pipeline/transformTypescriptToJavascript/removeTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeTypes.d.ts","sourceRoot":"","sources":["../../../src/pipeline/transformTypescriptToJavascript/removeTypes.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,UAAU,CAAC;AAG3D;;;;;;;;;;GAUG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,QAAQ,SAAY,EACpB,cAAc,GAAE,eAAe,GAAG,OAAc,GAC/C,OAAO,CAAC,MAAM,CAAC,CAkGjB"}

package/pipeline/transformTypescriptToJavascript/transformTypescriptToJavascript.d.ts

@@ -0,0 +1,3 @@
+import type { SourceTransformer, TransformSource } from "../../CodeHighlighter/index.js";
+export declare const transformTypescriptToJavascript: TransformSource;
+export declare const TypescriptToJavascriptTransformer: SourceTransformer;

package/pipeline/transformTypescriptToJavascript/transformTypescriptToJavascript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformTypescriptToJavascript.d.ts","sourceRoot":"","sources":["../../../src/pipeline/transformTypescriptToJavascript/transformTypescriptToJavascript.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAEhF,eAAO,MAAM,+BAA+B,EAAE,eAO7C,CAAC;AAEF,eAAO,MAAM,iCAAiC,EAAE,iBAG/C,CAAC"}

package/{build/esm/transformTsToJs/transformTsToJs.js → pipeline/transformTypescriptToJavascript/transformTypescriptToJavascript.js}

@@ -1,7 +1,7 @@
 import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { removeTypes } from "./removeTypes.js";
-export var transformTsToJs = /*#__PURE__*/function () {
+export var transformTypescriptToJavascript = /*#__PURE__*/function () {
   var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(source, fileName) {
     var transformed, transformedFileName;
     return _regeneratorRuntime().wrap(function _callee$(_context) {
@@ -24,11 +24,11 @@ export var transformTsToJs = /*#__PURE__*/function () {
       }
     }, _callee);
   }));
-  return function transformTsToJs(_x, _x2) {
+  return function transformTypescriptToJavascript(_x, _x2) {
     return _ref.apply(this, arguments);
   };
 }();
-export var TsToJsTransformer = {
+export var TypescriptToJavascriptTransformer = {
   extensions: ['ts', 'tsx'],
-  transformer: transformTsToJs
+  transformer: transformTypescriptToJavascript
 };

package/useCode/index.d.ts.map

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

package/{build/useCode → useCode}/useCode.d.ts

@@ -1,37 +1,39 @@
 import * as React from 'react';
-import { UseCopierOpts } from "../useCopier/index.js";
-import { ContentProps } from "../CodeHighlighter/types.js";
+import type { ContentProps } from "../CodeHighlighter/types.js";
 type UseCodeOpts = {
   defaultOpen?: boolean;
-  copy?: UseCopierOpts;
+  copy?: any;
   githubUrlPrefix?: string;
   codeSandboxUrlPrefix?: string;
   stackBlitzPrefix?: string;
   initialVariant?: string;
   initialTransform?: string;
 };
-export interface UseCodeResult {
-  component: React.ReactNode;
-  ref: React.RefObject<HTMLDivElement | null>;
+type UserProps<T extends {} = {}> = T & {
+  name?: string;
+  slug?: string;
+};
+export interface UseCodeResult<T extends {} = {}> {
   variants: string[];
   selectedVariant: string;
   selectVariant: React.Dispatch<React.SetStateAction<string>>;
   files: Array<{
     name: string;
+    slug?: string;
     component: React.ReactNode;
   }>;
   selectedFile: React.ReactNode;
-  selectedFileName: string;
-  selectFileName: React.Dispatch<React.SetStateAction<string>>;
+  selectedFileName: string | undefined;
+  selectFileName: (fileName: string) => void;
   expanded: boolean;
   expand: () => void;
   setExpanded: React.Dispatch<React.SetStateAction<boolean>>;
-  resetFocus: () => void;
   copy: (event: React.MouseEvent<HTMLButtonElement>) => Promise<void>;
-  copyDisabled: boolean;
   availableTransforms: string[];
   selectedTransform: string | null | undefined;
   selectTransform: (transformName: string | null) => void;
+  setSource?: (source: string) => void;
+  userProps: UserProps<T>;
 }
-export declare function useCode(contentProps: ContentProps, opts?: UseCodeOpts): UseCodeResult;
+export declare function useCode<T extends {} = {}>(contentProps: ContentProps<T>, opts?: UseCodeOpts): UseCodeResult<T>;
 export {};

package/useCode/useCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCode.d.ts","sourceRoot":"","sources":["../../src/useCode/useCode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAS7D,KAAK,WAAW,GAAG;IACjB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,KAAK,SAAS,CAAC,CAAC,SAAS,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,EAAE,GAAG,EAAE;IAC9C,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5D,KAAK,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,KAAK,CAAC,SAAS,CAAA;KAAE,CAAC,CAAC;IAC1E,YAAY,EAAE,KAAK,CAAC,SAAS,CAAC;IAC9B,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,cAAc,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,WAAW,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;IAC3D,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,iBAAiB,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC7C,eAAe,EAAE,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IACxD,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;CACzB;AAED,wBAAgB,OAAO,CAAC,CAAC,SAAS,EAAE,GAAG,EAAE,EACvC,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,EAC7B,IAAI,CAAC,EAAE,WAAW,GACjB,aAAa,CAAC,CAAC,CAAC,CA4GlB"}