@seafile/sea-email-editor 0.0.1

package/dist/extension/plugins/list/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _elementTypes = require("../../constants/element-types");
+var _menu = _interopRequireDefault(require("./menu"));
+var _plugin = _interopRequireDefault(require("./plugin"));
+var _renderElem = require("./render-elem");
+const ListPlugin = {
+  type: _elementTypes.LIST_ITEM,
+  nodeType: 'element',
+  editorMenus: [_menu.default],
+  editorPlugin: _plugin.default,
+  renderElements: [_renderElem.renderList, _renderElem.renderListItem, _renderElem.renderListLic]
+};
+var _default = exports.default = ListPlugin;

package/dist/extension/plugins/list/menu/index.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _components = require("../../../../components");
+var _helpers = require("../helpers");
+var _constants = require("../../../constants");
+var _transforms = require("../transforms");
+var _core = require("../../../core");
+var _elementTypes = require("../../../constants/element-types");
+var _jsxRuntime = require("react/jsx-runtime");
+const ListMenu = _ref => {
+  let {
+    editor,
+    readonly,
+    type,
+    className
+  } = _ref;
+  const isActive = (0, _helpers.getActiveListType)(editor, type) === type;
+
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  const menuConfig = (0, _react.useMemo)(() => _constants.MENUS_CONFIG_MAP[type], []);
+  const onClick = (0, _react.useCallback)(e => {
+    e.preventDefault();
+    (0, _transforms.transformsToList)(editor, type);
+    (0, _core.focusEditor)(editor);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isActive]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_components.ToolbarItem, {
+    isActive: isActive,
+    disabled: (0, _helpers.isMenuDisabled)(editor, readonly),
+    className: className,
+    onClick: onClick,
+    ...menuConfig
+  });
+};
+var _default = exports.default = ListMenu;

package/dist/extension/plugins/list/plugin/index.js

@@ -0,0 +1,80 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _helpers = require("../helpers");
+var _onTabHandle = require("./on-tab-handle");
+var _insertBreakList = require("./insert-break-list");
+var _insertFragmentList = require("./insert-fragment-list");
+var _normalizeList = require("./normalize-list");
+var _constant = require("../constant");
+var _shortcut = require("./shortcut");
+var _queries = require("../queries");
+var _core = require("../../../core");
+var _transforms = require("../transforms");
+var _elementTypes = require("../../../constants/element-types");
+const withList = editor => {
+  const {
+    insertBreak,
+    onHotKeyDown,
+    deleteBackward,
+    insertText
+  } = editor;
+  const newEditor = editor;
+  newEditor.insertBreak = () => {
+    if ((0, _insertBreakList.insertBreakList)(editor)) return;
+    insertBreak();
+    return;
+  };
+  newEditor.deleteBackward = unit => {
+    const {
+      selection
+    } = newEditor;
+    if (selection === null) {
+      deleteBackward(unit);
+      return;
+    }
+    const res = (0, _queries.getListItemEntry)(editor, {});
+    if (res && (0, _core.isSelectionAtBlockStart)(editor, {
+      match: node => node.type === _elementTypes.LIST_ITEM
+    })) {
+      const {
+        list,
+        listItem
+      } = res;
+      if ((0, _core.isFirstNode)(list[0], listItem[0]) && !(0, _queries.isListNested)(editor, list[1])) {
+        (0, _transforms.unwrapList)(editor);
+        return;
+      }
+    }
+    // nothing todo
+    deleteBackward(unit);
+  };
+  newEditor.insertText = text => {
+    const isPreventInsert = (0, _shortcut.handleShortcut)(newEditor, text);
+    if (isPreventInsert) return;
+    return insertText(text);
+  };
+  newEditor.onHotKeyDown = event => {
+    const activeListType = (0, _helpers.getActiveListType)(editor);
+    const isListActive = _constant.LIST_TYPES.includes(activeListType);
+    if (isListActive) {
+      if ((0, _isHotkey.default)(['tab', 'shift+tab'], event)) {
+        if ((0, _onTabHandle.handleTab)(newEditor, event)) return true;
+      }
+      if ((0, _isHotkey.default)('shift+enter', event)) {
+        event.preventDefault();
+        return true;
+      }
+    }
+    return onHotKeyDown && onHotKeyDown(event);
+  };
+  newEditor.insertFragment = (0, _insertFragmentList.insertFragmentList)(newEditor);
+  newEditor.normalizeNode = (0, _normalizeList.normalizeList)(newEditor);
+  return newEditor;
+};
+var _default = exports.default = withList;

package/dist/extension/plugins/list/plugin/insert-break-list.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertBreakList = void 0;
+var _core = require("../../../core");
+var _queries = require("../queries");
+var _transforms = require("../transforms");
+const insertBreakList = editor => {
+  if (!editor.selection) return;
+
+  // moved | inserted
+  let moved = false;
+  const res = (0, _queries.getListItemEntry)(editor, {});
+  // If selection is in a li, and li content is empty
+  if (res) {
+    if ((0, _core.isBlockAboveEmpty)(editor)) {
+      moved = (0, _transforms.movedListItemUp)(editor, res);
+      if (moved) return true;
+    }
+  }
+  if (!moved) {
+    const inserted = (0, _transforms.insertListItem)(editor);
+    if (inserted) return true;
+  }
+  return;
+};
+exports.insertBreakList = insertBreakList;

package/dist/extension/plugins/list/plugin/insert-fragment-list.js

@@ -0,0 +1,179 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertFragmentList = exports.getTextAndListItemNodes = void 0;
+var _slate = require("slate");
+var _slugid = _interopRequireDefault(require("slugid"));
+var _core = require("../../../core");
+var _constant = require("../constant");
+var _elementTypes = require("../../../constants/element-types");
+const isListRoot = node => {
+  return _slate.Element.isElement(node) && _constant.LIST_TYPES.includes(node.type);
+};
+const getFirstAncestorOfType = (root, entry, _ref) => {
+  let {
+    type
+  } = _ref;
+  let ancestor = _slate.Path.parent(entry[1]);
+  while ((0, _core.getNode)(root, ancestor).type !== type) {
+    ancestor = _slate.Path.parent(ancestor);
+  }
+  return [(0, _core.getNode)(root, ancestor), ancestor];
+};
+const findListItemsWithContent = first => {
+  let prev = null;
+  let node = first;
+  while (isListRoot(node) || node.type === _elementTypes.LIST_ITEM && node.children[0].type !== _elementTypes.PARAGRAPH) {
+    prev = node;
+    [node] = node.children;
+  }
+  return prev ? prev.children : [node];
+};
+const trimList = listRoot => {
+  if (!isListRoot(listRoot)) {
+    return [listRoot];
+  }
+  const _texts = _slate.Node.texts(listRoot);
+  const textEntries = Array.from(_texts);
+  const commonAncestorEntry = textEntries.reduce((commonAncestor, textEntry) => {
+    return _slate.Path.isAncestor(commonAncestor[1], textEntry[1]) ? commonAncestor : (0, _core.getCommonNode)(listRoot, textEntry[1], commonAncestor[1]);
+  }, getFirstAncestorOfType(listRoot, textEntries[0], {
+    type: _elementTypes.LIST_ITEM
+  }));
+
+  // is ul/ol: return children
+  // is not ul/ol
+  const [first, ...rest] = isListRoot(commonAncestorEntry[0]) ? commonAncestorEntry[0].children : [commonAncestorEntry[0]];
+  return [...findListItemsWithContent(first), ...rest];
+};
+const wrapNodeIntoListItem = node => {
+  if (node.type === _elementTypes.LIST_ITEM) return node;
+  const children = (0, _core.getInlineNodes)(node);
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.LIST_ITEM,
+    children: [{
+      id: _slugid.default.nice(),
+      type: _elementTypes.PARAGRAPH,
+      children
+    }]
+  };
+};
+const isSingleLic = fragment => {
+  const isFragmentOnlyListRoot = fragment.length === 1 && isListRoot(fragment[0]);
+  return isFragmentOnlyListRoot && [...(0, _core.getNodes)({
+    children: fragment
+  })].filter(entry => _slate.Element.isElement(entry[0])).filter(_ref2 => {
+    let [node] = _ref2;
+    return node.type === _elementTypes.PARAGRAPH;
+  }).length === 1;
+};
+const getTextAndListItemNodes = (editor, fragment, liEntry, licEntry) => {
+  const [, liPath] = liEntry;
+  const [licNode, licPath] = licEntry;
+  const isEmptyNode = !_slate.Node.string(licNode);
+  // format copied fragment
+  // first: lic, path: [...liPath, 0, 0]
+  // rest: children, path: [...liPath, 1, 0]
+  const [first, ...rest] = fragment.flatMap(trimList).map(wrapNodeIntoListItem);
+  let textNode = null;
+  let listItemNodes = [];
+  if (isListRoot(fragment[0])) {
+    if (isSingleLic(fragment)) {
+      textNode = first;
+      listItemNodes = rest;
+    } else if (isEmptyNode) {
+      const li = (0, _core.getNode)(editor, liPath);
+      const [, ...currentSubLists] = li.children; // old
+
+      const [newLic, ...newSubLists] = first.children; // copied
+      // insert copied contents
+      _slate.Transforms.insertNodes(editor, newLic, {
+        at: _slate.Path.next(licPath),
+        select: true
+      });
+      _slate.Transforms.removeNodes(editor, {
+        at: licPath
+      });
+      if (newSubLists.length) {
+        if (currentSubLists.length) {
+          const path = [...liPath, 1, 0];
+          _slate.Transforms.insertNodes(editor, newSubLists[0].children, {
+            at: path,
+            select: true
+          });
+        } else {
+          _slate.Transforms.insertNodes(editor, newSubLists, {
+            at: _slate.Path.next(licPath),
+            select: true
+          });
+        }
+      }
+      textNode = (0, _core.generateDefaultText)();
+      listItemNodes = rest;
+    } else {
+      textNode = (0, _core.generateDefaultText)();
+      listItemNodes = [first, ...rest];
+    }
+  } else {
+    textNode = first;
+    listItemNodes = rest;
+    return {
+      textNode,
+      listItemNodes
+    };
+  }
+  return {
+    textNode,
+    listItemNodes
+  };
+};
+exports.getTextAndListItemNodes = getTextAndListItemNodes;
+const insertFragmentList = editor => {
+  return fragment => {
+    _slate.Editor.withoutNormalizing(editor, () => {
+      let liEntry = (0, _core.findNode)(editor, {
+        match: {
+          type: _elementTypes.LIST_ITEM
+        },
+        mode: 'lowest'
+      });
+      if (!liEntry) {
+        const nodes = isListRoot(fragment) ? [(0, _core.generateDefaultText)(), ...fragment] : fragment;
+        return (0, _slate.insertFragment)(editor, nodes);
+      }
+      (0, _slate.insertFragment)(editor, [(0, _core.generateDefaultText)()]); // need ' '
+
+      liEntry = (0, _core.findNode)(editor, {
+        match: {
+          type: _elementTypes.LIST_ITEM
+        },
+        mode: 'lowest'
+      });
+      const licEntry = (0, _core.findNode)(editor, {
+        match: {
+          type: _elementTypes.PARAGRAPH
+        },
+        mode: 'lowest'
+      });
+      if (!licEntry) {
+        const nodes = isListRoot(fragment) ? [(0, _core.generateDefaultText)(), ...fragment] : fragment;
+        return (0, _slate.insertFragment)(editor, nodes);
+      }
+      const {
+        textNode,
+        listItemNodes
+      } = getTextAndListItemNodes(editor, fragment, liEntry, licEntry);
+      (0, _slate.insertFragment)(editor, [textNode]);
+      const [, liPath] = liEntry;
+      return _slate.Transforms.insertNodes(editor, listItemNodes, {
+        at: _slate.Path.next(liPath),
+        select: true
+      });
+    });
+  };
+};
+exports.insertFragmentList = insertFragmentList;

package/dist/extension/plugins/list/plugin/normalize-list.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeList = void 0;
+var _slate = require("slate");
+var _transforms = require("../transforms");
+var _elementTypes = require("../../../constants/element-types");
+var _core = require("../../../core");
+var _constant = require("../constant");
+const normalizeList = editor => {
+  const {
+    normalizeNode
+  } = editor;
+  return _ref => {
+    let [node, path] = _ref;
+    if (!_slate.Element.isElement(node)) {
+      return normalizeNode([node, path]);
+    }
+
+    // root
+    if (_constant.LIST_TYPES.includes(node.type)) {
+      const children = (0, _core.getChildren)([node, path]);
+      const nonLiChild = children.find(_ref2 => {
+        let [child] = _ref2;
+        return child.type !== _elementTypes.LIST_ITEM;
+      });
+      if (nonLiChild) {
+        const listItem = (0, _core.generateElement)(_elementTypes.LIST_ITEM, {
+          childrenOrText: []
+        });
+        _slate.Transforms.wrapNodes(editor, listItem, {
+          at: nonLiChild[1]
+        });
+        return;
+      }
+    }
+    if ((0, _core.match)(node, [], {
+      type: _constant.LIST_TYPES
+    })) {
+      if (!node.children.length || !node.children.find(item => item.type === _elementTypes.LIST_ITEM)) {
+        _slate.Transforms.removeNodes(editor, {
+          at: path
+        });
+        return;
+      }
+      const nextPath = _slate.Path.next(path);
+      const nextNode = (0, _core.getNode)(editor, nextPath);
+      if ((nextNode === null || nextNode === void 0 ? void 0 : nextNode.type) === node.type) {
+        (0, _transforms.moveListItemsToList)(editor, {
+          fromList: [nextNode, nextPath],
+          toList: [node, path],
+          deleteFromList: true
+        });
+      }
+      const prevPath = (0, _core.getPreviousPath)(path);
+      const prevNode = (0, _core.getNode)(editor, prevPath);
+      if ((prevNode === null || prevNode === void 0 ? void 0 : prevNode.type) === node.type) {
+        editor.normalizeNode([prevNode, prevPath]);
+        return;
+      }
+      if ((0, _transforms.normalizeNestedList)(editor, {
+        nestedListItem: [node, path]
+      })) {
+        return;
+      }
+    }
+    if (node.type === _elementTypes.LIST_ITEM) {
+      if ((0, _transforms.normalizeListItem)(editor, {
+        listItem: [node, path]
+      })) {
+        return;
+      }
+    }
+    normalizeNode([node, path]);
+  };
+};
+exports.normalizeList = normalizeList;

package/dist/extension/plugins/list/plugin/on-tab-handle.js

@@ -0,0 +1,63 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleTab = void 0;
+var _slate = require("slate");
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _core = require("../../../core");
+var _elementTypes = require("../../../constants/element-types");
+var _transforms = require("../transforms");
+const handleTab = (editor, event) => {
+  const {
+    selection,
+    hasMovedSelection
+  } = editor;
+  if (!selection) return;
+  if (hasMovedSelection) event.stopPropagation();
+  const selectedList = (0, _core.findNode)(editor, {
+    type: [_elementTypes.LIST_ITEM]
+  });
+  if (!selectedList) return;
+  let workRange = editor.selection;
+  if (!_slate.Range.isCollapsed(selection)) {
+    let {
+      anchor,
+      focus
+    } = selection;
+    if (_slate.Range.isBackward(selection)) {
+      ({
+        anchor,
+        focus
+      } = {
+        anchor: {
+          ...selection.focus
+        },
+        focus: {
+          ...selection.anchor
+        }
+      });
+    }
+    const unHungRange = _slate.Editor.unhangRange(editor, {
+      anchor,
+      focus
+    });
+    if (unHungRange) {
+      workRange = unHungRange;
+      _slate.Transforms.select(editor, unHungRange);
+    }
+  }
+  const isIncrease = (0, _isHotkey.default)('shift+tab', event) ? false : true;
+  if (workRange && selectedList) {
+    event.preventDefault();
+    (0, _transforms.moveListItems)(editor, {
+      at: workRange,
+      increase: isIncrease,
+      enableResetOnShiftTab: true
+    });
+    return true;
+  }
+};
+exports.handleTab = handleTab;

package/dist/extension/plugins/list/plugin/shortcut.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleShortcut = void 0;
+var _slate = require("slate");
+var _helpers = require("../helpers");
+var _elementTypes = require("../../../constants/element-types");
+var _core = require("../../../core");
+/**
+ * @param {Editor} editor
+ * @param {String} text
+ * @returns {Boolean} isPreventInsert
+ */
+const handleShortcut = (editor, text) => {
+  if (text !== ' ') return false;
+  const {
+    selection
+  } = editor;
+  if (!_slate.Range.isCollapsed(selection)) return false;
+  let [aboveNode, aboveNodePath] = _slate.Editor.above(editor);
+  if (aboveNode.type !== _elementTypes.PARAGRAPH) return false;
+  // Match ordered list shortcut
+  const regOrderListShortcut = /^\s*[1]+\.\s*$/;
+  const regUnorderedListShortcut = /^\s*\*+\s*$/;
+  const {
+    beforeText,
+    range
+  } = (0, _helpers.getBeforeText)(editor);
+  const matchOrderListResult = beforeText.match(regOrderListShortcut);
+  const matchUnorderedListResult = beforeText.match(regUnorderedListShortcut);
+  const matchedOrderListText = matchOrderListResult && matchOrderListResult[0];
+  const matchedUnorderedListText = matchUnorderedListResult && matchUnorderedListResult[0];
+  if (matchUnorderedListResult) {
+    // Unordered list shortcut
+    if (matchedUnorderedListText !== '*') return false;
+    if (matchUnorderedListResult.index !== 0) return false;
+    // Delete shortcut key text
+    _slate.Transforms.delete(editor, {
+      at: range
+    });
+    (0, _helpers.setListType)(editor, _elementTypes.UNORDERED_LIST);
+    (0, _core.focusEditor)(editor);
+    return true;
+  } else if (matchOrderListResult) {
+    // Ordered list shortcut
+    // If the match fails or the match is not at the beginning of the line, it is not a shortcut
+    if (matchOrderListResult.index !== 0) return false;
+    if (matchedOrderListText !== '1.') return false;
+    const previousNodePath = (0, _core.getPreviousPath)(aboveNodePath);
+    let previousNodeEntry = null;
+    if (previousNodePath) {
+      previousNodeEntry = _slate.Editor.node(editor, previousNodePath);
+    }
+    // If the previous node is not an ordered list and is start with `1.`,transforms to ordered list
+    if (!previousNodePath || previousNodeEntry[0].type !== _elementTypes.ORDERED_LIST) {
+      // Delete shortcut key text
+      _slate.Transforms.delete(editor, {
+        at: range
+      });
+      (0, _helpers.setListType)(editor, _elementTypes.ORDERED_LIST);
+      (0, _core.focusEditor)(editor);
+      return true;
+    }
+  }
+  return false;
+};
+exports.handleShortcut = handleShortcut;

package/dist/extension/plugins/list/queries/index.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isListNested = exports.hasListChild = exports.getListItemEntry = void 0;
+var _slate = require("slate");
+var _elementTypes = require("../../../constants/element-types");
+var _constant = require("../constant");
+const getListItemEntry = function (editor) {
+  let {
+    at = editor.selection
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let _at = null;
+  if (_slate.Range.isRange(at) && !_slate.Range.isCollapsed(at)) {
+    _at = at.focus.path;
+  } else if (_slate.Range.isRange(at)) {
+    _at = at.anchor.path;
+  } else {
+    _at = at;
+  }
+  if (_at) {
+    const node = _slate.Node.get(editor, _at);
+    if (node) {
+      const listItem = _slate.Editor.above(editor, {
+        at: _at,
+        match: n => _slate.Element.isElement(n) && n.type === _elementTypes.LIST_ITEM
+      });
+      if (listItem) {
+        const list = _slate.Editor.parent(editor, listItem[1]);
+        return {
+          list,
+          listItem
+        };
+      }
+    }
+  }
+  return null;
+};
+exports.getListItemEntry = getListItemEntry;
+const hasListChild = node => {
+  return node.children.some(n => {
+    return _slate.Element.isElement(n) && _constant.LIST_TYPES.includes(n.type);
+  });
+};
+exports.hasListChild = hasListChild;
+const isListNested = (editor, listPath) => {
+  var _Editor$parent;
+  const listParentNode = (_Editor$parent = _slate.Editor.parent(editor, listPath)) === null || _Editor$parent === void 0 ? void 0 : _Editor$parent[0];
+  return (listParentNode === null || listParentNode === void 0 ? void 0 : listParentNode.type) === _elementTypes.LIST_ITEM;
+};
+exports.isListNested = isListNested;

package/dist/extension/plugins/list/render-elem/index.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderListLic = exports.renderListItem = exports.renderList = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _elementTypes = require("../../../constants/element-types");
+var _constants = require("../../../constants");
+var _jsxRuntime = require("react/jsx-runtime");
+const renderList = (props, editor) => {
+  const {
+    attributes,
+    children,
+    element: node
+  } = props;
+  const Tag = node.type === _elementTypes.ORDERED_LIST ? 'ol' : 'ul';
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(Tag, {
+    "data-id": node.id,
+    "data-root": "true",
+    ...attributes,
+    className: node.className,
+    style: {
+      ...(_constants.ELEMENT_DEFAULT_STYLE[node.type] || {}),
+      ...((node === null || node === void 0 ? void 0 : node.style) || {})
+    },
+    children: children
+  });
+};
+exports.renderList = renderList;
+const renderListItem = (props, editor) => {
+  const {
+    attributes,
+    children,
+    element
+  } = props;
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)("li", {
+    "data-id": element.id,
+    "data-root": "true",
+    ...attributes,
+    className: element.className,
+    style: {
+      ...(_constants.ELEMENT_DEFAULT_STYLE[element.type] || {}),
+      ...((element === null || element === void 0 ? void 0 : element.style) || {})
+    },
+    children: children
+  });
+};
+exports.renderListItem = renderListItem;
+const renderListLic = (props, editor) => {
+  const {
+    attributes,
+    children,
+    element
+  } = props;
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+    "data-id": element.id,
+    ...attributes,
+    className: element.className,
+    style: {
+      ...(_constants.ELEMENT_DEFAULT_STYLE[element.type] || {}),
+      ...((element === null || element === void 0 ? void 0 : element.style) || {})
+    },
+    children: children
+  });
+};
+exports.renderListLic = renderListLic;