@sheinx/base 3.6.0-beta.2 → 3.6.0-beta.21

package/esm/tree/tree-simple-node.js

@@ -0,0 +1,286 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { useRef, createElement } from 'react';
+import classNames from 'classnames';
+import TreeContent from "./tree-content";
+import { useTreeContext } from "./tree-context";
+import { useTreeNode, util } from '@sheinx/hooks';
+import { useConfig } from "../config";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var placeElement = null;
+var innerPlaceElement = null;
+var placeInfo = {
+  start: '',
+  target: ''
+};
+var dragLock = false;
+var initPlaceElement = function initPlaceElement() {
+  if (util.isBrowser() && !(placeElement && innerPlaceElement)) {
+    placeElement = document.createElement('div');
+    innerPlaceElement = document.createElement('div');
+    placeElement.appendChild(innerPlaceElement);
+  }
+};
+initPlaceElement();
+var Node = function Node(props) {
+  var jssStyle = props.jssStyle,
+    id = props.id,
+    data = props.data,
+    line = props.line,
+    isControlled = props.isControlled,
+    index = props.index,
+    renderItem = props.renderItem,
+    parentClickExpand = props.parentClickExpand,
+    doubleClickExpand = props.doubleClickExpand,
+    iconClass = props.iconClass,
+    leafClass = props.leafClass,
+    nodeClass = props.nodeClass,
+    contentClass = props.contentClass,
+    expandIcons = props.expandIcons,
+    keygen = props.keygen,
+    mode = props.mode,
+    childrenKey = props.childrenKey,
+    inlineNode = props.inlineNode,
+    highlight = props.highlight,
+    dragSibling = props.dragSibling,
+    dragHoverExpand = props.dragHoverExpand,
+    dragImageSelector = props.dragImageSelector,
+    dragImageStyle = props.dragImageStyle,
+    childrenClass = props.childrenClass,
+    bindNode = props.bindNode,
+    loader = props.loader,
+    onChange = props.onChange,
+    onNodeClick = props.onNodeClick,
+    onToggle = props.onToggle,
+    onDrop = props.onDrop,
+    onDragOver = props.onDragOver,
+    onDragLeave = props.onDragLeave,
+    onDragStart = props.onDragStart,
+    onDragEnd = props.onDragEnd,
+    List = props.listComponent,
+    actionOnClick = props.actionOnClick;
+  initPlaceElement();
+  var config = useConfig();
+  var element = useRef(null);
+  var content = useRef(null);
+  var dragImage = useRef(null);
+  var _useTreeContext = useTreeContext(),
+    getPath = _useTreeContext.getPath;
+  var _useTreeNode = useTreeNode({
+      id: id,
+      data: data,
+      bindNode: bindNode,
+      loader: loader,
+      onToggle: onToggle,
+      childrenKey: childrenKey,
+      element: element,
+      content: content.current,
+      dragImageSelector: dragImageSelector,
+      dragImageStyle: dragImageStyle
+    }),
+    active = _useTreeNode.active,
+    isLeaf = _useTreeNode.isLeaf,
+    fetching = _useTreeNode.fetching,
+    setFetching = _useTreeNode.setFetching,
+    expanded = _useTreeNode.expanded,
+    setExpanded = _useTreeNode.setExpanded;
+  var children = data[childrenKey];
+  var hasChildren = children && children.length > 0;
+  var contentStyle = (jssStyle === null || jssStyle === void 0 ? void 0 : jssStyle.tree()) || {};
+  var rootClass = classNames(contentStyle.node, isLeaf() && (util.isString(leafClass) ? leafClass : util.isFunc(leafClass) && leafClass(data)), util.isString(nodeClass) && nodeClass, util.isFunc(nodeClass) && nodeClass(data), _defineProperty({}, contentStyle.leaf, !hasChildren));
+  if (placeElement) {
+    placeElement.className = contentStyle.placement;
+  }
+  var handleFetch = function handleFetch() {};
+  var handleToggle = function handleToggle() {
+    var nextExpanded = !expanded;
+    setExpanded(nextExpanded);
+    if (onToggle) onToggle(id, nextExpanded);
+  };
+  var handleDragOver = function handleDragOver(e) {
+    if (!dragLock) return;
+    var current = getPath(placeInfo.start);
+    var target = getPath(id);
+    if (!current || !target) return;
+    var currentPathStr = current.path.join('/');
+    var targetPathStr = target.path.join('/');
+    if (dragSibling && targetPathStr !== currentPathStr) return;
+    if (dragHoverExpand && !expanded) {
+      onToggle === null || onToggle === void 0 || onToggle(id);
+    }
+    var hover = element.current;
+    var rect = hover.getBoundingClientRect();
+    var clientHeight = e.target.getBoundingClientRect().height || 20;
+    var hoverMiddleY = (rect.bottom - rect.top) / 2;
+    var hoverClientY = e.clientY - rect.top;
+    var position = index;
+    if (innerPlaceElement) {
+      innerPlaceElement.style.height = '0px';
+    }
+    if (placeElement && innerPlaceElement) {
+      if (hoverClientY < hoverMiddleY + clientHeight * 0.2) {
+        hover.parentNode.insertBefore(placeElement, hover);
+        if (hoverClientY > clientHeight * 0.3) {
+          if (!dragSibling) {
+            position = -1;
+            innerPlaceElement.style.height = "".concat(rect.height, "px");
+          } else {
+            position += 1;
+            hover.parentNode.insertBefore(placeElement, hover.nextElementSibling);
+          }
+        }
+      } else {
+        position += 1;
+        hover.parentNode.insertBefore(placeElement, hover.nextElementSibling);
+      }
+      placeInfo.target = id;
+      // @ts-ignore
+      placeElement.setAttribute('data-position', position);
+    }
+    if (onDragOver) onDragOver(e, data);
+  };
+  var handleDragStart = function handleDragStart(e) {
+    if (dragLock) return;
+    dragLock = true;
+    e.dataTransfer.effectAllowed = 'copyMove';
+    e.dataTransfer.setData('text/plain', id);
+    placeInfo.start = id;
+    var el = document.querySelector(dragImageSelector(data));
+    var dragEl = el || content.current;
+    var rect = dragEl.getBoundingClientRect();
+    dragImage.current = dragEl.cloneNode(true);
+    document.body.appendChild(dragImage.current);
+    dragImage.current.style.position = 'absolute';
+    dragImage.current.style.top = '-1000px';
+    dragImage.current.style.left = '-1000px';
+    dragImage.current.style.width = "".concat(rect.width, "px");
+    dragImage.current.style.background = '#fff';
+    dragImage.current.style.boxShadow = '0 0 5px 0 rgba(0, 0, 0, 0.1)';
+    if (dragImageStyle) {
+      Object.keys(dragImageStyle).forEach(function (k) {
+        var _dragImage$current;
+        var styleKey = k;
+        ((_dragImage$current = dragImage.current) === null || _dragImage$current === void 0 ? void 0 : _dragImage$current.style)[styleKey] = dragImageStyle[styleKey];
+      });
+    }
+    e.dataTransfer.setDragImage(dragImage.current, e.clientX - rect.left, e.clientY - rect.top);
+    setTimeout(function () {
+      element.current.style.display = 'none';
+    }, 0);
+    if (onDragStart) onDragStart(e, data);
+  };
+  var handleDragEnd = function handleDragEnd(e) {
+    element.current.style.display = '';
+    if (!dragLock) return;
+    dragLock = false;
+    if (!placeElement || !placeElement.parentNode) return;
+    if (dragImage.current && dragImage.current.parentNode) dragImage.current.parentNode.removeChild(dragImage.current);
+    var position = parseInt(placeElement.getAttribute('data-position') || '', 10);
+    var target = placeInfo.target;
+    placeElement.parentNode.removeChild(placeElement);
+    if (onDrop && (target !== id || index !== position)) {
+      onDrop(id, target, position);
+    }
+    if (onDragEnd) onDragEnd(e, data);
+  };
+  var handleDragLeave = function handleDragLeave(e) {
+    if (onDragLeave) onDragLeave(e, data);
+  };
+  var getChildrenListProps = function getChildrenListProps() {
+    return {
+      id: id,
+      keygen: keygen,
+      jssStyle: jssStyle,
+      renderItem: renderItem,
+      expandIcons: expandIcons,
+      iconClass: iconClass,
+      leafClass: leafClass,
+      nodeClass: nodeClass,
+      isControlled: isControlled,
+      contentClass: contentClass,
+      parentClickExpand: parentClickExpand,
+      doubleClickExpand: doubleClickExpand,
+      expanded: expanded,
+      line: line,
+      data: children,
+      mode: mode,
+      index: index,
+      loader: loader,
+      inlineNode: inlineNode,
+      highlight: highlight,
+      onDrop: onDrop,
+      onChange: onChange,
+      onToggle: onToggle,
+      onNodeClick: onNodeClick,
+      onDragOver: onDragOver,
+      onDragLeave: onDragLeave,
+      onDragStart: onDragStart,
+      onDragEnd: onDragEnd,
+      bindNode: bindNode,
+      childrenClassName: util.isFunc(childrenClass) ? childrenClass === null || childrenClass === void 0 ? void 0 : childrenClass(data) : childrenClass,
+      childrenKey: childrenKey,
+      childrenClass: childrenClass,
+      dragSibling: dragSibling,
+      dragHoverExpand: dragHoverExpand,
+      dragImageStyle: dragImageStyle,
+      dragImageSelector: dragImageSelector,
+      actionOnClick: actionOnClick
+    };
+  };
+  var getDropProps = function getDropProps() {
+    var dropEvents = {};
+    if (onDrop) {
+      Object.assign(dropEvents, {
+        draggable: true,
+        onDragStart: handleDragStart,
+        onDragEnd: handleDragEnd,
+        onDragLeave: handleDragLeave
+      });
+    }
+    return dropEvents;
+  };
+  return /*#__PURE__*/_jsxs("div", _objectSpread(_objectSpread({}, getDropProps()), {}, {
+    ref: element,
+    className: rootClass,
+    dir: config.direction,
+    children: [/*#__PURE__*/_jsx(TreeContent, {
+      virtual: false,
+      jssStyle: jssStyle,
+      isControlled: isControlled,
+      id: id,
+      line: line,
+      data: data,
+      mode: mode,
+      contentClass: contentClass,
+      active: active,
+      fetching: fetching,
+      expanded: expanded,
+      keygen: keygen,
+      bindNode: bindNode,
+      bindContent: content,
+      childrenKey: childrenKey,
+      renderItem: renderItem,
+      iconClass: iconClass,
+      leafClass: leafClass,
+      expandIcons: expandIcons,
+      parentClickExpand: parentClickExpand,
+      doubleClickExpand: doubleClickExpand,
+      loader: loader,
+      inlineNode: inlineNode,
+      highlight: highlight,
+      setFetching: setFetching,
+      onChange: onChange,
+      onFetch: handleFetch,
+      onNodeClick: onNodeClick,
+      onDragOver: handleDragOver,
+      onToggle: handleToggle,
+      actionOnClick: actionOnClick
+    }), hasChildren && /*#__PURE__*/createElement(List, getChildrenListProps())]
+  }));
+};
+export default Node;

package/esm/tree/tree-virtual-node.d.ts

@@ -0,0 +1,5 @@
+import { TreeVirtualNodeProps } from './tree-node.type';
+import { KeygenResult } from '@sheinx/hooks';
+declare const VirtualNode: <DataItem, Value extends KeygenResult[]>(props: TreeVirtualNodeProps<DataItem, Value>) => import("react/jsx-runtime").JSX.Element;
+export default VirtualNode;
+//# sourceMappingURL=tree-virtual-node.d.ts.map

package/esm/tree/tree-virtual-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-virtual-node.d.ts","sourceRoot":"","sources":["tree-virtual-node.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,EAA4B,YAAY,EAAE,MAAM,eAAe,CAAC;AAKvE,QAAA,MAAM,WAAW,mIA4HhB,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/esm/tree/tree-virtual-node.js

@@ -0,0 +1,119 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { useTreeContext } from "./tree-context";
+import { useRef } from 'react';
+import classNames from 'classnames';
+import TreeVirtualContent from "./tree-content";
+import { useTreeVirtualNode, util } from '@sheinx/hooks';
+import { useConfig } from "../config";
+import { jsx as _jsx } from "react/jsx-runtime";
+var placeElement = null;
+var VirtualNode = function VirtualNode(props) {
+  var jssStyle = props.jssStyle,
+    id = props.id,
+    data = props.data,
+    level = props.level,
+    line = props.line,
+    isControlled = props.isControlled,
+    renderItem = props.renderItem,
+    parentClickExpand = props.parentClickExpand,
+    doubleClickExpand = props.doubleClickExpand,
+    iconClass = props.iconClass,
+    leafClass = props.leafClass,
+    nodeClass = props.nodeClass,
+    contentClass = props.contentClass,
+    expandIcons = props.expandIcons,
+    keygen = props.keygen,
+    mode = props.mode,
+    childrenKey = props.childrenKey,
+    inlineNode = props.inlineNode,
+    highlight = props.highlight,
+    loader = props.loader,
+    onChange = props.onChange,
+    onNodeClick = props.onNodeClick,
+    onToggle = props.onToggle,
+    actionOnClick = props.actionOnClick;
+  var config = useConfig();
+  var datum = useTreeContext();
+  var element = useRef(null);
+  var content = useRef(null);
+  var _useTreeVirtualNode = useTreeVirtualNode({
+      id: id,
+      data: data,
+      datum: datum,
+      bindNode: datum.bindVirtualNode,
+      loader: loader,
+      onToggle: onToggle,
+      childrenKey: childrenKey,
+      element: element,
+      content: content.current
+    }),
+    active = _useTreeVirtualNode.active,
+    isLeaf = _useTreeVirtualNode.isLeaf,
+    fetching = _useTreeVirtualNode.fetching,
+    setFetching = _useTreeVirtualNode.setFetching,
+    expanded = _useTreeVirtualNode.expanded,
+    setExpanded = _useTreeVirtualNode.setExpanded;
+  var children = data[childrenKey];
+  var hasChildren = children && children.length > 0;
+  var contentStyle = (jssStyle === null || jssStyle === void 0 ? void 0 : jssStyle.tree()) || {};
+  var rootClass = classNames(contentStyle.node, isLeaf() && (util.isString(leafClass) ? leafClass : util.isFunc(leafClass) && leafClass(data)), util.isString(nodeClass) && nodeClass, util.isFunc(nodeClass) && nodeClass(data), _defineProperty({}, contentStyle.leaf, !hasChildren));
+  if (placeElement) {
+    placeElement.className = contentStyle.placement;
+  }
+  var handleFetch = function handleFetch() {};
+  var handleToggle = function handleToggle() {
+    var nextExpanded = !expanded;
+    setExpanded(nextExpanded);
+    var status = datum.dataFlatStatusMap.get(id);
+    datum.dataFlatStatusMap.set(id, {
+      active: (status === null || status === void 0 ? void 0 : status.active) || false,
+      fetching: (status === null || status === void 0 ? void 0 : status.fetching) || false,
+      expanded: nextExpanded
+    });
+    if (onToggle) onToggle(id, nextExpanded);
+  };
+  return /*#__PURE__*/_jsx("div", {
+    ref: element,
+    className: rootClass,
+    dir: config.direction,
+    style: {
+      paddingLeft: level * 24
+    },
+    children: /*#__PURE__*/_jsx(TreeVirtualContent, {
+      virtual: true,
+      jssStyle: jssStyle,
+      isControlled: isControlled,
+      id: id,
+      level: level,
+      line: line,
+      data: data,
+      mode: mode,
+      contentClass: contentClass,
+      active: active,
+      fetching: fetching,
+      expanded: expanded,
+      keygen: keygen,
+      bindContent: content,
+      childrenKey: childrenKey,
+      renderItem: renderItem,
+      iconClass: iconClass,
+      leafClass: leafClass,
+      expandIcons: expandIcons,
+      parentClickExpand: parentClickExpand,
+      doubleClickExpand: doubleClickExpand,
+      loader: loader,
+      inlineNode: inlineNode,
+      highlight: highlight,
+      setFetching: setFetching,
+      onChange: onChange,
+      onFetch: handleFetch,
+      onNodeClick: onNodeClick,
+      onToggle: handleToggle,
+      actionOnClick: actionOnClick
+    })
+  });
+};
+export default VirtualNode;

package/esm/tree/tree-virtual.d.ts

@@ -0,0 +1,5 @@
+import { KeygenResult } from '@sheinx/hooks';
+import { VirtualTreeProps } from './tree.type';
+declare const TreeVirtual: <DataItem, Value extends KeygenResult[]>(props: VirtualTreeProps<DataItem, Value>) => import("react/jsx-runtime").JSX.Element;
+export default TreeVirtual;
+//# sourceMappingURL=tree-virtual.d.ts.map

package/esm/tree/tree-virtual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-virtual.d.ts","sourceRoot":"","sources":["tree-virtual.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAgB,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,QAAA,MAAM,WAAW,+HAwFhB,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/esm/tree/tree-virtual.js

@@ -0,0 +1,84 @@
+import { useTreeContext } from "./tree-context";
+import VirtualTreeNode from "./tree-virtual-node";
+import { VirtualScrollList } from "../virtual-scroll";
+import { jsx as _jsx } from "react/jsx-runtime";
+var TreeVirtual = function TreeVirtual(props) {
+  var jssStyle = props.jssStyle,
+    height = props.height,
+    _props$lineHeight = props.lineHeight,
+    lineHeight = _props$lineHeight === void 0 ? 36 : _props$lineHeight,
+    line = props.line,
+    mode = props.mode,
+    contentClass = props.contentClass,
+    expandIcons = props.expandIcons,
+    loader = props.loader,
+    inlineNode = props.inlineNode,
+    highlight = props.highlight,
+    parentClickExpand = props.parentClickExpand,
+    doubleClickExpand = props.doubleClickExpand,
+    expanded = props.expanded,
+    keygen = props.keygen,
+    defaultExpandAll = props.defaultExpandAll,
+    active = props.active,
+    isControlled = props.isControlled,
+    childrenClass = props.childrenClass,
+    childrenKey = props.childrenKey,
+    iconClass = props.iconClass,
+    leafClass = props.leafClass,
+    nodeClass = props.nodeClass,
+    onNodeClick = props.onNodeClick,
+    onToggle = props.onToggle,
+    onChange = props.onChange;
+  var datum = useTreeContext();
+  var renderItem = function renderItem(item, index) {
+    var id = item.id,
+      data = item.data,
+      level = item.level;
+    return /*#__PURE__*/_jsx(VirtualTreeNode, {
+      jssStyle: jssStyle,
+      id: id,
+      level: level,
+      data: data,
+      index: index,
+      line: line,
+      keygen: keygen,
+      defaultExpandAll: defaultExpandAll,
+      isControlled: isControlled,
+      mode: mode,
+      active: active,
+      childrenClass: childrenClass,
+      childrenKey: childrenKey,
+      renderItem: props.renderItem,
+      iconClass: iconClass,
+      leafClass: leafClass,
+      nodeClass: nodeClass,
+      contentClass: contentClass,
+      expandIcons: expandIcons,
+      loader: loader,
+      inlineNode: inlineNode,
+      highlight: highlight,
+      parentClickExpand: parentClickExpand,
+      doubleClickExpand: doubleClickExpand,
+      expanded: expanded,
+      onNodeClick: onNodeClick,
+      onToggle: onToggle,
+      onChange: onChange
+    }, id);
+  };
+  return /*#__PURE__*/_jsx(VirtualScrollList, {
+    data: datum.dataFlat,
+    height: height,
+    rowsInView: 10,
+    scrollerStyle: {
+      height: '100%',
+      width: '100%',
+      overflow: 'auto',
+      padding: '0 4px'
+    },
+    keepScrollHeight: true,
+    dynamicVirtual: true,
+    lineHeight: lineHeight,
+    renderItem: renderItem
+  });
+};
+export default TreeVirtual;

package/esm/tree/tree.d.ts

@@ -1,6 +1,5 @@
-/// <reference types="react" />
 import { KeygenResult } from '@sheinx/hooks';
 import { TreeProps } from './tree.type';
-declare const Tree: <DataItem, Value extends KeygenResult[]>(props: TreeProps<DataItem, Value>) => JSX.Element;
+declare const Tree: <DataItem, Value extends KeygenResult[]>(props: TreeProps<DataItem, Value>) => import("react/jsx-runtime").JSX.Element;
 export default Tree;
 //# sourceMappingURL=tree.d.ts.map

package/esm/tree/tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tree.d.ts","sourceRoot":"","sources":["tree.tsx"],"names":[],"mappings":";AAEA,OAAO,EAAE,YAAY,EAA4B,MAAM,eAAe,CAAC;AAEvE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAOxC,QAAA,MAAM,IAAI,4FA4PT,CAAC;AAEF,eAAe,IAAI,CAAC"}
+{"version":3,"file":"tree.d.ts","sourceRoot":"","sources":["tree.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAA4B,MAAM,eAAe,CAAC;AAEvE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAQxC,QAAA,MAAM,IAAI,wHAgTT,CAAC;AAEF,eAAe,IAAI,CAAC"}