@seafile/sdoc-editor 3.0.113 → 3.0.115

package/dist/extension/plugins/toggle-header/plugin.js

@@ -0,0 +1,537 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _slate = require("@seafile/slate");
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _constants = require("../../constants");
+var _core = require("../../core");
+var _helper = require("./helper");
+var withToggleHeader = function withToggleHeader(editor) {
+  var insertBreak = editor.insertBreak,
+    normalizeNode = editor.normalizeNode,
+    insertSoftBreak = editor.insertSoftBreak,
+    deleteBackward = editor.deleteBackward,
+    insertFragment = editor.insertFragment,
+    onHotKeyDown = editor.onHotKeyDown;
+  var newEditor = editor;
+  var getToggleBodyChildren = function getToggleBodyChildren(toggleNode) {
+    var _toggleNode$children;
+    var contentNode = toggleNode === null || toggleNode === void 0 ? void 0 : (_toggleNode$children = toggleNode.children) === null || _toggleNode$children === void 0 ? void 0 : _toggleNode$children[1];
+    if ((contentNode === null || contentNode === void 0 ? void 0 : contentNode.type) === _constants.TOGGLE_CONTENT) {
+      return contentNode.children || [];
+    }
+    if (Array.isArray(toggleNode === null || toggleNode === void 0 ? void 0 : toggleNode.collapsed_body)) {
+      return toggleNode.collapsed_body;
+    }
+    return [];
+  };
+  newEditor.insertBreak = function () {
+    var _afterFragment$;
+    var selection = newEditor.selection;
+    if (!selection || !_slate.Range.isCollapsed(selection)) {
+      insertBreak();
+      return;
+    }
+    var selectedEntry = _slate.Editor.above(newEditor, {
+      at: selection,
+      match: function match(n) {
+        return n.type === _constants.TOGGLE_HEADER;
+      },
+      mode: 'lowest'
+    });
+    var selectedNode = selectedEntry ? selectedEntry[0] : null;
+    if (!selectedNode || (selectedNode === null || selectedNode === void 0 ? void 0 : selectedNode.type) !== _constants.TOGGLE_HEADER) {
+      insertBreak();
+      return;
+    }
+    var titleEntry = _slate.Editor.above(newEditor, {
+      at: selection,
+      match: function match(n) {
+        return _slate.Element.isElement(n) && _constants.TOGGLE_TITLE_TYPES.includes(n.type);
+      },
+      mode: 'lowest'
+    });
+    if (!titleEntry) {
+      insertBreak();
+      return;
+    }
+    var _titleEntry = (0, _slicedToArray2["default"])(titleEntry, 2),
+      titlePath = _titleEntry[1];
+    var toggleEntry = _slate.Editor.above(newEditor, {
+      at: titlePath,
+      match: function match(n) {
+        return n.type === _constants.TOGGLE_HEADER;
+      },
+      mode: 'lowest'
+    });
+    var _toggleEntry = (0, _slicedToArray2["default"])(toggleEntry, 2),
+      toggleNode = _toggleEntry[0],
+      togglePath = _toggleEntry[1];
+    var contentPath = [].concat((0, _toConsumableArray2["default"])(togglePath), [1]);
+    var bodyChildren = getToggleBodyChildren(toggleNode);
+    var cursorPoint = selection.anchor;
+    // when toggle header is collapsed
+    if (toggleNode.collapsed) {
+      var titleStartPoint = _slate.Editor.start(newEditor, titlePath);
+      var _titleEndPoint = _slate.Editor.end(newEditor, titlePath);
+      var isAtTitleStart = _slate.Point.equals(cursorPoint, titleStartPoint);
+      var _isAtTitleEnd = _slate.Editor.isEnd(newEditor, cursorPoint, titlePath);
+      _slate.Editor.withoutNormalizing(newEditor, function () {
+        var _titleNode, _titleNode$children;
+        if (isAtTitleStart) {
+          var _newParagraph = (0, _core.generateEmptyElement)(_constants.PARAGRAPH);
+          _slate.Transforms.insertNodes(newEditor, _newParagraph, {
+            at: togglePath
+          });
+          return;
+        }
+        var titleNode = [];
+        if (!_isAtTitleEnd) {
+          var _afterRange = {
+            anchor: cursorPoint,
+            focus: _titleEndPoint
+          };
+          var _afterFragment = _slate.Editor.fragment(newEditor, _afterRange);
+          titleNode = (0, _helper.findFirstTitleNode)(_afterFragment);
+          _slate.Transforms["delete"](newEditor, {
+            at: _afterRange
+          });
+        }
+        var newParagraph = (0, _core.generateEmptyElement)(_constants.PARAGRAPH);
+        newParagraph.children = (_titleNode = titleNode) !== null && _titleNode !== void 0 && (_titleNode$children = _titleNode.children) !== null && _titleNode$children !== void 0 && _titleNode$children.length ? titleNode.children : [(0, _core.generateDefaultText)('')];
+        var insertPath = _slate.Path.next(togglePath);
+        _slate.Transforms.insertNodes(newEditor, newParagraph, {
+          at: insertPath
+        });
+        _slate.Transforms.select(newEditor, _slate.Editor.start(newEditor, insertPath));
+      });
+      return;
+    }
+    var titleEndPoint = _slate.Editor.end(newEditor, titlePath);
+    var isAtTitleEnd = _slate.Editor.isEnd(newEditor, cursorPoint, titlePath);
+    var afterRange = {
+      anchor: cursorPoint,
+      focus: titleEndPoint
+    };
+    var afterFragment = isAtTitleEnd ? [] : _slate.Editor.fragment(newEditor, afterRange);
+    var afterChildren = ((_afterFragment$ = afterFragment[0]) === null || _afterFragment$ === void 0 ? void 0 : _afterFragment$.children) || [];
+
+    // when toggle header is listed all
+    _slate.Editor.withoutNormalizing(newEditor, function () {
+      var _toggleNode$children3, _toggleNode$children$2;
+      // The afterText is the text content after the cursor in the toggle header
+      var afterText = '';
+      if (!isAtTitleEnd) {
+        afterText = _slate.Editor.string(newEditor, {
+          anchor: cursorPoint,
+          focus: titleEndPoint
+        });
+        _slate.Transforms["delete"](newEditor, {
+          at: afterRange
+        });
+      }
+
+      // Keep collapsed toggle data model consistent before editing body.
+      if (toggleNode.collapsed) {
+        var _toggleNode$children2, _toggleNode$children$;
+        if (!((_toggleNode$children2 = toggleNode.children) !== null && _toggleNode$children2 !== void 0 && _toggleNode$children2[1]) || ((_toggleNode$children$ = toggleNode.children[1]) === null || _toggleNode$children$ === void 0 ? void 0 : _toggleNode$children$.type) !== _constants.TOGGLE_CONTENT) {
+          var content = (0, _core.generateEmptyElement)(_constants.TOGGLE_CONTENT);
+          content.children = bodyChildren.length > 0 ? bodyChildren : [(0, _core.generateEmptyElement)(_constants.PARAGRAPH)];
+          _slate.Transforms.insertNodes(newEditor, content, {
+            at: contentPath
+          });
+        }
+        _slate.Transforms.setNodes(newEditor, {
+          collapsed: false,
+          collapsed_body: null
+        }, {
+          at: togglePath
+        });
+      } else if (!((_toggleNode$children3 = toggleNode.children) !== null && _toggleNode$children3 !== void 0 && _toggleNode$children3[1]) || ((_toggleNode$children$2 = toggleNode.children[1]) === null || _toggleNode$children$2 === void 0 ? void 0 : _toggleNode$children$2.type) !== _constants.TOGGLE_CONTENT) {
+        var _content = (0, _core.generateEmptyElement)(_constants.TOGGLE_CONTENT);
+        _content.children = [(0, _core.generateEmptyElement)(_constants.PARAGRAPH)];
+        _slate.Transforms.insertNodes(newEditor, _content, {
+          at: contentPath
+        });
+      }
+
+      // Insert new paragraph node with afterText
+      var newParagraph = (0, _core.generateEmptyElement)(_constants.PARAGRAPH);
+      if (afterChildren.length > 0) {
+        newParagraph.children = [(0, _core.generateDefaultText)(afterText)];
+      }
+      var firstParagraphPath = [].concat((0, _toConsumableArray2["default"])(contentPath), [0]);
+      _slate.Transforms.insertNodes(newEditor, newParagraph, {
+        at: firstParagraphPath
+      });
+      _slate.Transforms.select(newEditor, _slate.Editor.start(newEditor, firstParagraphPath));
+    });
+  };
+  newEditor.insertSoftBreak = function () {
+    var selection = newEditor.selection;
+    if (!selection || !_slate.Range.isCollapsed(selection)) {
+      insertSoftBreak();
+      return;
+    }
+    var _Editor$node = _slate.Editor.node(newEditor, selection, {
+        depth: 1
+      }),
+      _Editor$node2 = (0, _slicedToArray2["default"])(_Editor$node, 1),
+      selectedNode = _Editor$node2[0];
+    if (selectedNode.type === _constants.TOGGLE_HEADER) {
+      newEditor.insertBreak();
+      return;
+    }
+    insertSoftBreak();
+  };
+  newEditor.deleteBackward = function (unit) {
+    var selection = newEditor.selection;
+    if (!selection || !_slate.Range.isCollapsed(selection)) {
+      deleteBackward(unit);
+      return;
+    }
+    var currentBlockEntry = _slate.Editor.above(newEditor, {
+      at: selection,
+      match: function match(n) {
+        return _slate.Element.isElement(n) && _slate.Editor.isBlock(newEditor, n);
+      },
+      mode: 'lowest'
+    });
+    if (!currentBlockEntry) {
+      deleteBackward(unit);
+      return;
+    }
+    var _currentBlockEntry = (0, _slicedToArray2["default"])(currentBlockEntry, 2),
+      currentBlockNode = _currentBlockEntry[0],
+      currentBlockPath = _currentBlockEntry[1];
+    var toggleContentEntry = _slate.Editor.above(newEditor, {
+      at: currentBlockPath,
+      match: function match(n) {
+        return _slate.Element.isElement(n) && n.type === _constants.TOGGLE_CONTENT;
+      },
+      mode: 'lowest'
+    });
+
+    // When cursor is in start point of the last toggle content
+    if (toggleContentEntry) {
+      var _toggleContentEntry = (0, _slicedToArray2["default"])(toggleContentEntry, 2),
+        toggleContentNode = _toggleContentEntry[0],
+        toggleContentPath = _toggleContentEntry[1];
+      var childCount = toggleContentNode.children.length;
+      var currentIndex = currentBlockPath[currentBlockPath.length - 1];
+      var isLastChild = currentIndex === childCount - 1;
+      var hasOtherChildren = childCount > 1;
+      var isAtLastChildStart = _slate.Editor.isStart(newEditor, selection.anchor, currentBlockPath);
+      if (isLastChild && isAtLastChildStart && hasOtherChildren && !_constants.TOGGLE_TITLE_TYPES.includes(currentBlockNode.type)) {
+        var parentToggleEntry = _slate.Editor.parent(newEditor, toggleContentPath);
+        var _parentToggleEntry = (0, _slicedToArray2["default"])(parentToggleEntry, 2),
+          parentToggleNode = _parentToggleEntry[0],
+          parentTogglePath = _parentToggleEntry[1];
+        if (parentToggleNode && parentToggleNode.type === _constants.TOGGLE_HEADER) {
+          var liftedNode = currentBlockNode;
+          var insertPath = _slate.Path.next(parentTogglePath);
+          _slate.Editor.withoutNormalizing(newEditor, function () {
+            _slate.Transforms.removeNodes(newEditor, {
+              at: currentBlockPath
+            });
+            (0, _helper.ensureToggleContentNotEmpty)(newEditor, toggleContentPath);
+            _slate.Transforms.insertNodes(newEditor, liftedNode, {
+              at: insertPath
+            });
+            _slate.Transforms.select(newEditor, _slate.Editor.start(newEditor, insertPath));
+          });
+          return;
+        }
+      }
+    }
+
+    // Other cases
+    var titleEntry = _slate.Editor.above(newEditor, {
+      at: selection,
+      match: function match(n) {
+        return _slate.Element.isElement(n) && _constants.TOGGLE_TITLE_TYPES.includes(n.type);
+      },
+      mode: 'lowest'
+    });
+    if (!titleEntry) {
+      deleteBackward(unit);
+      return;
+    }
+    var _titleEntry2 = (0, _slicedToArray2["default"])(titleEntry, 2),
+      titlePath = _titleEntry2[1];
+    if (titleEntry && titlePath) {
+      var _Editor$node3 = _slate.Editor.node(newEditor, titlePath),
+        _Editor$node4 = (0, _slicedToArray2["default"])(_Editor$node3, 1),
+        titleNode = _Editor$node4[0];
+      var isAtTitleStart = _slate.Editor.isStart(newEditor, selection.anchor, titlePath);
+      if (!isAtTitleStart) {
+        deleteBackward(unit);
+        return;
+      }
+      var toggleEntry = _slate.Editor.parent(newEditor, titlePath);
+      var _toggleEntry2 = (0, _slicedToArray2["default"])(toggleEntry, 2),
+        toggleNode = _toggleEntry2[0],
+        togglePath = _toggleEntry2[1];
+      var contentChildren = getToggleBodyChildren(toggleNode);
+      var normalHeaderTypeMap = {
+        toggle_header1: _constants.HEADER1,
+        toggle_header2: _constants.HEADER2,
+        toggle_header3: _constants.HEADER3
+      };
+      var normalHeaderType = normalHeaderTypeMap[titleNode.type];
+      var normalHeaderNode = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, titleNode), {}, {
+        type: normalHeaderType
+      });
+      var nodesToInsert = [normalHeaderNode];
+      if (contentChildren.length > 0) {
+        nodesToInsert.push.apply(nodesToInsert, (0, _toConsumableArray2["default"])(contentChildren));
+      }
+      _slate.Editor.withoutNormalizing(newEditor, function () {
+        _slate.Transforms.removeNodes(newEditor, {
+          at: togglePath
+        });
+        _slate.Transforms.insertNodes(newEditor, nodesToInsert, {
+          at: togglePath
+        });
+        _slate.Transforms.select(newEditor, _slate.Editor.start(newEditor, togglePath));
+      });
+      return;
+    }
+    return deleteBackward(unit);
+  };
+  newEditor.insertFragment = function (data) {
+    var _nextFragment$;
+    var selection = newEditor.selection;
+    if (!selection) return insertFragment(data);
+    var nextFragment = [];
+    data.forEach(function (node) {
+      if ((node === null || node === void 0 ? void 0 : node.type) === _constants.TOGGLE_HEADER) {
+        if ((0, _helper.isOnlyHasToggleContent)(node)) {
+          var childrenNodes = [];
+          node.children.forEach(function (child) {
+            if (child !== null && child !== void 0 && child.children) {
+              childrenNodes = childrenNodes.concat(child.children);
+            }
+          });
+          nextFragment.push.apply(nextFragment, (0, _toConsumableArray2["default"])(childrenNodes));
+        } else {
+          nextFragment.push(node);
+        }
+      } else {
+        nextFragment.push(node);
+      }
+    });
+    if (((_nextFragment$ = nextFragment[0]) === null || _nextFragment$ === void 0 ? void 0 : _nextFragment$.type) === _constants.TOGGLE_HEADER) {
+      var currentBlockEntry = _slate.Editor.above(newEditor, {
+        at: selection,
+        match: function match(n) {
+          return _slate.Element.isElement(n) && _slate.Editor.isBlock(newEditor, n);
+        },
+        mode: 'lowest'
+      });
+      if (!currentBlockEntry) {
+        insertFragment(nextFragment);
+        return;
+      }
+      var _currentBlockEntry2 = (0, _slicedToArray2["default"])(currentBlockEntry, 1),
+        currentBlockNode = _currentBlockEntry2[0];
+      var isBlockEmpty = _slate.Editor.isEmpty(newEditor, currentBlockNode);
+      _slate.Editor.withoutNormalizing(newEditor, function () {
+        if (!isBlockEmpty) {
+          _slate.Transforms.splitNodes(newEditor, {
+            at: selection,
+            match: function match(n) {
+              return _slate.Element.isElement(n) && _slate.Editor.isBlock(newEditor, n);
+            },
+            always: true
+          });
+        }
+        insertFragment(nextFragment);
+      });
+      return;
+    }
+    insertFragment(nextFragment);
+  };
+  newEditor.onHotKeyDown = function (event) {
+    var selection = newEditor.selection;
+    if (!selection) return false;
+    var _Editor$node5 = _slate.Editor.node(newEditor, selection, {
+        depth: 1
+      }),
+      _Editor$node6 = (0, _slicedToArray2["default"])(_Editor$node5, 1),
+      selectedNode = _Editor$node6[0];
+    if (selectedNode.type === _constants.TOGGLE_HEADER && (0, _isHotkey["default"])('tab', event)) {
+      event.preventDefault();
+      return true;
+    }
+    if (selectedNode.type === _constants.TOGGLE_HEADER && (0, _isHotkey["default"])('shift+tab', event)) {
+      event.preventDefault();
+      var _getCurrentNode = (0, _core.getCurrentNode)(editor),
+        _getCurrentNode2 = (0, _slicedToArray2["default"])(_getCurrentNode, 2),
+        currentPath = _getCurrentNode2[1];
+      var currentToggleContentEntry = (0, _core.getAboveNode)(editor, {
+        match: {
+          type: _constants.TOGGLE_CONTENT
+        }
+      });
+      // No operation in the first toggle-header1-3
+      if (!currentToggleContentEntry) {
+        return true;
+      }
+      var _currentToggleContent = (0, _slicedToArray2["default"])(currentToggleContentEntry, 2),
+        toggleContentNode = _currentToggleContent[0],
+        toggleContentPath = _currentToggleContent[1];
+      var _Editor$parent = _slate.Editor.parent(editor, toggleContentPath),
+        _Editor$parent2 = (0, _slicedToArray2["default"])(_Editor$parent, 2),
+        parentNode = _Editor$parent2[0],
+        parentPath = _Editor$parent2[1];
+
+      // Current direct child index in toggle content's children
+      var currentIndexInToggleContent = currentPath[toggleContentPath.length];
+      var movingChildren = toggleContentNode.children.slice(currentIndexInToggleContent);
+      var targetCursorPath = [];
+      var targetOffset = editor.selection.anchor.offset;
+      _slate.Editor.withoutNormalizing(editor, function () {
+        // Remove toggle content children node
+        for (var i = toggleContentNode.children.length - 1; i >= currentIndexInToggleContent; i--) {
+          _slate.Transforms.removeNodes(editor, {
+            at: toggleContentPath.concat(i)
+          });
+        }
+
+        // In the first toggle content
+        if (parentNode.type === _constants.TOGGLE_HEADER && parentPath.length === 1) {
+          var insertPath = _slate.Path.next(parentPath);
+          targetCursorPath = insertPath;
+          movingChildren.forEach(function (child) {
+            _slate.Transforms.insertNodes(editor, child, {
+              at: insertPath
+            });
+            insertPath = _slate.Path.next(insertPath);
+          });
+          (0, _helper.ensureToggleContentNotEmpty)(editor, toggleContentPath);
+          var targetPoint = (0, _helper.getFirstTextPoint)(editor, targetCursorPath, targetOffset);
+          _slate.Transforms.select(newEditor, targetPoint);
+          return true;
+        }
+
+        // In the multi layer toggle content
+        if (parentNode.type === _constants.TOGGLE_HEADER && parentPath.length > 1) {
+          var parentIndexInOuterToggleContent = parentPath[parentPath.length - 1];
+          var outerToggleContentPath = _slate.Path.parent(parentPath);
+          var _insertPath = outerToggleContentPath.concat(parentIndexInOuterToggleContent + 1);
+          targetCursorPath = _insertPath;
+          movingChildren.forEach(function (child) {
+            _slate.Transforms.insertNodes(editor, child, {
+              at: _insertPath
+            });
+            _insertPath = _slate.Path.next(_insertPath);
+          });
+          (0, _helper.ensureToggleContentNotEmpty)(editor, toggleContentPath);
+          var _targetPoint = (0, _helper.getFirstTextPoint)(editor, targetCursorPath, targetOffset);
+          _slate.Transforms.select(newEditor, _targetPoint);
+        }
+      });
+      return true;
+    }
+    return onHotKeyDown && onHotKeyDown(event);
+  };
+  newEditor.normalizeNode = function (_ref) {
+    var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+      node = _ref2[0],
+      path = _ref2[1];
+    if (node.type === _constants.TOGGLE_HEADER) {
+      var _node$children, _node$children2;
+      // code-block is the last node in the editor and needs to be followed by a p node
+      var isLast = (0, _core.isLastNode)(newEditor, node);
+      if (isLast) {
+        var paragraph = (0, _core.generateEmptyElement)(_constants.PARAGRAPH);
+        _slate.Transforms.insertNodes(newEditor, paragraph, {
+          at: [path[0] + 1]
+        });
+      }
+      var toggleHeaderType = _constants.TOGGLE_TITLE_TYPES.includes(node.children[0].type) && node.children[0].type;
+      var level = Math.min(6, Math.max(1, Number((0, _helper.getLevelFromType)(toggleHeaderType) || 1)));
+
+      // For toggle-header1-3 element
+      var titleType = (0, _helper.getTitleTypeByLevel)(level);
+      var titleNode = (_node$children = node.children) === null || _node$children === void 0 ? void 0 : _node$children[0];
+      if (!titleNode || !_constants.TOGGLE_TITLE_TYPES.includes(titleNode.type)) {
+        var title = (0, _core.generateEmptyElement)(titleType);
+        _slate.Transforms.insertNodes(newEditor, title, {
+          at: [].concat((0, _toConsumableArray2["default"])(path), [0])
+        });
+        return;
+      }
+      if (titleNode.type !== titleType) {
+        _slate.Transforms.setNodes(newEditor, {
+          type: titleType
+        }, {
+          at: [].concat((0, _toConsumableArray2["default"])(path), [0])
+        });
+        return;
+      }
+      // For toggle-content element
+      var contentNode = (_node$children2 = node.children) === null || _node$children2 === void 0 ? void 0 : _node$children2[1];
+      if (node.collapsed) {
+        if ((contentNode === null || contentNode === void 0 ? void 0 : contentNode.type) === _constants.TOGGLE_CONTENT) {
+          if (!Array.isArray(node.collapsed_body)) {
+            _slate.Transforms.setNodes(newEditor, {
+              collapsed_body: contentNode.children || []
+            }, {
+              at: path
+            });
+            return;
+          }
+          _slate.Transforms.removeNodes(newEditor, {
+            at: [].concat((0, _toConsumableArray2["default"])(path), [1])
+          });
+          return;
+        }
+        if (!Array.isArray(node.collapsed_body)) {
+          _slate.Transforms.setNodes(newEditor, {
+            collapsed_body: [(0, _core.generateEmptyElement)(_constants.PARAGRAPH)]
+          }, {
+            at: path
+          });
+          return;
+        }
+        return;
+      }
+      if (!contentNode || contentNode.type !== _constants.TOGGLE_CONTENT) {
+        var collapsedBody = Array.isArray(node.collapsed_body) ? node.collapsed_body : [];
+        var content = (0, _core.generateEmptyElement)(_constants.TOGGLE_CONTENT);
+        content.children = collapsedBody.length > 0 ? collapsedBody : [(0, _core.generateEmptyElement)(_constants.PARAGRAPH)];
+        _slate.Transforms.insertNodes(newEditor, content, {
+          at: [].concat((0, _toConsumableArray2["default"])(path), [1])
+        });
+        return;
+      }
+      if (node.collapsed_body) {
+        _slate.Transforms.setNodes(newEditor, {
+          collapsed_body: null
+        }, {
+          at: path
+        });
+        return;
+      }
+      if (!contentNode.children || contentNode.children.length === 0) {
+        var _paragraph = (0, _core.generateEmptyElement)(_constants.PARAGRAPH);
+        _slate.Transforms.insertNodes(newEditor, _paragraph, {
+          at: [].concat((0, _toConsumableArray2["default"])(path), [1, 0])
+        });
+        return;
+      }
+    }
+    return normalizeNode([node, path]);
+  };
+  return newEditor;
+};
+var _default = exports["default"] = withToggleHeader;

package/dist/extension/plugins/toggle-header/render-elem.css

@@ -0,0 +1,45 @@
+.sdoc-toggle-header-container {
+  padding: 5px 0;
+}
+
+.sdoc-toggle-header-row {
+  display: flex;
+  align-items: center;
+  padding-bottom: 5px;
+}
+
+.sdoc-toggle-header-row .sdoc-toggle-header-prefix {
+  display: inline-block;
+  height: 20px;
+  line-height: 20px;
+  text-align: center;
+  margin-right: 5px;
+  cursor: pointer;
+}
+
+.sdoc-toggle-header-prefix:has(.sdoc-big-caret-up) {
+  transform: rotate(90deg);
+}
+
+.sdoc-toggle-header-title-wrap {
+  flex: 1;
+  min-width: 0;
+}
+
+.sdoc-toggle-header-content-wrap {
+  margin-left: 20px;
+}
+
+.sdoc-toggle-header-content-wrap .sdoc-toggle-header-title,
+.sdoc-toggle-header-title-wrap .sdoc-toggle-header-title {
+  margin: 0;
+}
+
+.sdoc-toggle-header-content .sdoc-header-1,
+.sdoc-toggle-header-content .sdoc-header-2,
+.sdoc-toggle-header-content .sdoc-header-3,
+.sdoc-toggle-header-content .sdoc-header-4,
+.sdoc-toggle-header-content .sdoc-header-5,
+.sdoc-toggle-header-content .sdoc-header-6 {
+  margin: 5px 0 !important;
+}