@seafile/sea-email-editor 0.0.1

package/dist/extension/plugins/formula/menu/formula-modal.js

@@ -0,0 +1,98 @@
+"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 _reactstrap = require("reactstrap");
+var _constants = require("@/constants");
+var _core = require("../../../core");
+var _components = require("../../../../components");
+var _helper = require("../helper");
+var _jsxRuntime = require("react/jsx-runtime");
+const FormulaModal = _ref => {
+  let {
+    editor,
+    formula,
+    onCloseModal
+  } = _ref;
+  const oldFormulaRef = (0, _react.useRef)(formula);
+  const [newFormula, setNewFormula] = (0, _react.useState)(formula);
+  const [modifyPath, setModifyPath] = (0, _react.useState)(null);
+  const [isDisabled, setIsDisabled] = (0, _react.useState)(true);
+  const formulaPreviewRef = (0, _react.useRef)(null);
+
+  // record current selection position
+  (0, _react.useEffect)(() => {
+    const node = (0, _core.getAboveBlockNode)(editor);
+    if (node) {
+      setModifyPath(node[1]);
+      return;
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  (0, _react.useEffect)(() => {
+    if (formulaPreviewRef.current) {
+      formulaPreviewRef.current.innerHTML = '';
+      const dom = window.MathJax.tex2svg(newFormula);
+      formulaPreviewRef.current.appendChild(dom);
+    }
+  });
+  const onFormulaChange = (0, _react.useCallback)(event => {
+    setIsDisabled(false);
+    setNewFormula(event.target.value);
+  }, []);
+  const handleUpdateFormula = (0, _react.useCallback)(() => {
+    const data = {
+      formula: newFormula,
+      at: modifyPath
+    };
+    if (oldFormulaRef.current) {
+      (0, _helper.updateFormula)(editor, data);
+    } else {
+      (0, _helper.insertFormula)(editor, data);
+    }
+    onCloseModal();
+  }, [editor, modifyPath, newFormula, onCloseModal]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactstrap.Modal, {
+    isOpen: true,
+    toggle: onCloseModal,
+    autoFocus: false,
+    wrapClassName: "formula-dialog-wrapper",
+    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_components.ModalHeader, {
+      toggle: onCloseModal,
+      children: (0, _constants.gettext)('Insert_formula')
+    }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactstrap.ModalBody, {
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+        className: "form-group",
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("label", {
+          className: "form-check-label",
+          children: (0, _constants.gettext)('Formula')
+        }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactstrap.Input, {
+          type: "textarea",
+          className: "form-control",
+          value: newFormula,
+          autoFocus: true,
+          onChange: onFormulaChange
+        })]
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+        ref: formulaPreviewRef,
+        className: "formula-preview"
+      })]
+    }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactstrap.ModalFooter, {
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_reactstrap.Button, {
+        color: "secondary",
+        onClick: onCloseModal,
+        children: (0, _constants.gettext)('Cancel')
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactstrap.Button, {
+        color: "primary",
+        disabled: isDisabled,
+        onClick: handleUpdateFormula,
+        children: (0, _constants.gettext)('Insert_formula')
+      })]
+    })]
+  });
+};
+var _default = exports.default = FormulaModal;

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

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _eventTypes = require("../../../../constants/event-types");
+var _menusConfig = require("../../../constants/menus-config");
+var _elementTypes = require("../../../constants/element-types");
+var _eventBus = _interopRequireDefault(require("../../../../utils/event-bus"));
+var _dropdownMenuItem = _interopRequireDefault(require("../../../commons/dropdown-menu-item"));
+var _jsxRuntime = require("react/jsx-runtime");
+const menuConfig = _menusConfig.MENUS_CONFIG_MAP[_elementTypes.FORMULA];
+const FormulaMenu = _ref => {
+  let {
+    readonly,
+    toggle
+  } = _ref;
+  const OpenFormulaModal = () => {
+    toggle && toggle();
+    const eventBus = _eventBus.default.getInstance();
+    eventBus.dispatch(_eventTypes.INTERNAL_EVENTS.INSERT_ELEMENT, {
+      type: _elementTypes.FORMULA
+    });
+  };
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_dropdownMenuItem.default, {
+    disabled: readonly,
+    menuConfig: menuConfig,
+    className: "pr-2",
+    onClick: OpenFormulaModal
+  });
+};
+var _default = exports.default = FormulaMenu;

package/dist/extension/plugins/formula/plugin.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _constants = require("../../constants");
+const withFormula = editor => {
+  const {
+    isVoid
+  } = editor;
+  const newEditor = editor;
+  newEditor.isVoid = element => {
+    const {
+      type
+    } = element;
+    if (type === _constants.ElementTypes.FORMULA) return true;
+    return isVoid(element);
+  };
+  return newEditor;
+};
+var _default = exports.default = withFormula;

package/dist/extension/plugins/formula/render-elem.js

@@ -0,0 +1,64 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _slateReact = require("slate-react");
+var _classnames = _interopRequireDefault(require("classnames"));
+var _eventTypes = require("../../../constants/event-types");
+var _eventBus = _interopRequireDefault(require("../../../utils/event-bus"));
+var _constants = require("../../constants");
+require("./formula.css");
+var _jsxRuntime = require("react/jsx-runtime");
+const Formula = _ref => {
+  let {
+    attributes,
+    element,
+    children
+  } = _ref;
+  const isSelected = (0, _slateReact.useSelected)();
+  const formulaContainerRef = (0, _react.useRef)(null);
+  (0, _react.useEffect)(() => {
+    const {
+      formula = ''
+    } = element.data || {};
+    if (!formula) return;
+    if (formulaContainerRef.current && window.MathJax) {
+      formulaContainerRef.current.innerHTML = '';
+      const dom = window.MathJax.tex2svg(formula);
+      formulaContainerRef.current.appendChild(dom);
+    }
+  }, [element]);
+  const toggleFormulaEditor = (0, _react.useCallback)(() => {
+    const eventBus = _eventBus.default.getInstance();
+    eventBus.dispatch(_eventTypes.INTERNAL_EVENTS.ON_OPEN_FORMULA_DIALOG, element);
+  }, [element]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)("span", {
+    onDoubleClick: toggleFormulaEditor,
+    className: (0, _classnames.default)('sea-email-formula-block', {
+      'sea-email-selected-formula': isSelected
+    }),
+    ...attributes,
+    style: {
+      ...((element === null || element === void 0 ? void 0 : element.style) || {}),
+      ...(_constants.ELEMENT_DEFAULT_STYLE[element.type] || {})
+    },
+    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+      contentEditable: false,
+      ref: formulaContainerRef
+    }), /*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+      contentEditable: false,
+      children: children
+    })]
+  });
+};
+const renderFormula = props => {
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(Formula, {
+    ...props
+  });
+};
+var _default = exports.default = renderFormula;

package/dist/extension/plugins/header/helper.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setHeaderType = exports.isMenuDisabled = exports.getHeaderType = void 0;
+var _slate = require("slate");
+var _queries = require("../../core/queries");
+var _constants = require("../../constants");
+var _core = require("../../core");
+const isMenuDisabled = function (editor) {
+  let readonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (readonly) return true;
+  if (!editor.selection) return true;
+  const [match] = _slate.Editor.nodes(editor, {
+    match(node, path) {
+      let type = (0, _queries.getNodeType)(node);
+      if (!type && (0, _queries.isTextNode)(node) && node.id) {
+        const parentNode = (0, _queries.getParentNode)(node, node.id);
+        type = (0, _queries.getNodeType)(parentNode);
+      }
+      if (type === _constants.ElementTypes.PARAGRAPH) return true;
+      if (type && type.startsWith(_constants.ElementTypes.HEADER)) return true;
+      return false;
+    },
+    universal: true,
+    mode: 'highest'
+  });
+  return !match;
+};
+exports.isMenuDisabled = isMenuDisabled;
+const getHeaderType = editor => {
+  const [match] = _slate.Editor.nodes(editor, {
+    match: node => {
+      if (_slate.Element.isElement(node) && _slate.Editor.isBlock(editor, node)) {
+        const type = (0, _queries.getNodeType)(node);
+        if (type && type.startsWith(_constants.ElementTypes.HEADER)) return true;
+      }
+      return false;
+    },
+    universal: true
+  });
+  if (!match) return;
+  const [matchedNode] = match;
+  return (0, _queries.getNodeType)(matchedNode);
+};
+exports.getHeaderType = getHeaderType;
+const setHeaderType = (editor, type) => {
+  if (!type) return;
+  _slate.Transforms.setNodes(editor, {
+    type
+  });
+  (0, _core.focusEditor)(editor);
+};
+exports.setHeaderType = setHeaderType;

package/dist/extension/plugins/header/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 _constants = require("../../constants");
+var _renderElem = require("./render-elem");
+var _plugin = _interopRequireDefault(require("./plugin"));
+var _menu = _interopRequireDefault(require("./menu"));
+const HeaderPlugin = {
+  type: _constants.ElementTypes.HEADER,
+  nodeType: 'element',
+  editorMenus: [_menu.default],
+  editorPlugin: _plugin.default,
+  renderElements: [_renderElem.renderHeader]
+};
+var _default = exports.default = HeaderPlugin;

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

@@ -0,0 +1,72 @@
+"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 _constants = require("@/constants");
+var _helper = require("../helper");
+var _keyboard = require("../../../constants/keyboard");
+var _constants2 = require("../../../constants");
+var _components = require("../../../../components");
+var _jsxRuntime = require("react/jsx-runtime");
+const HeaderMenu = _ref => {
+  let {
+    editor,
+    readonly
+  } = _ref;
+  const [isShowHeaderPopover, setIsShowHeaderPopover] = (0, _react.useState)(false);
+  const headerRef = (0, _react.useRef)();
+  const options = (0, _react.useMemo)(() => {
+    const isMac = window.navigator.userAgent.indexOf('Macintosh') !== -1;
+    return [_constants2.ElementTypes.PARAGRAPH, ..._constants2.HEADERS].map(type => {
+      return {
+        value: type,
+        label: (0, _constants.gettext)(_constants2.HEADER_TITLE_MAP[type !== null && type !== void 0 ? type : _constants2.ElementTypes.PARAGRAPH]),
+        tooltip: isMac ? _keyboard.MAC_HOTKEYS_TIP_HEADER[type] : _keyboard.WIN_HOTKEYS_EVENT_HEADER[type]
+      };
+    });
+  }, []);
+  const currentHeaderType = (0, _helper.getHeaderType)(editor);
+  const isDisabled = (0, _helper.isMenuDisabled)(editor, readonly);
+  const onHideHeaderMenu = (0, _react.useCallback)(e => {
+    setIsShowHeaderPopover(false);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  const onToggleClick = event => {
+    event.stopPropagation();
+    event.preventDefault();
+    event.nativeEvent.stopImmediatePropagation();
+    setIsShowHeaderPopover(!isShowHeaderPopover);
+  };
+  const onChange = (0, _react.useCallback)(type => {
+    (0, _helper.setHeaderType)(editor, type);
+    setIsShowHeaderPopover(false);
+  }, [editor]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_jsxRuntime.Fragment, {
+    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_components.SelectorDisplay, {
+      icon: isShowHeaderPopover ? 'arrow-up' : 'arrow-down',
+      onClick: onToggleClick,
+      disabled: isDisabled,
+      iconPlacement: "right",
+      innerRef: headerRef,
+      border: false,
+      height: 24,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+        className: "active",
+        children: (0, _constants.gettext)(_constants2.HEADER_TITLE_MAP[currentHeaderType !== null && currentHeaderType !== void 0 ? currentHeaderType : _constants2.ElementTypes.PARAGRAPH])
+      })
+    }), isShowHeaderPopover && /*#__PURE__*/(0, _jsxRuntime.jsx)(_components.OptionsEditor, {
+      target: headerRef,
+      isMultiple: false,
+      isSearchEnabled: false,
+      options: options,
+      value: currentHeaderType,
+      onChange: onChange,
+      onToggle: onHideHeaderMenu
+    })]
+  });
+};
+var _default = exports.default = HeaderMenu;

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

@@ -0,0 +1,155 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _core = require("../../core");
+var _helper = require("./helper");
+var _keyboard = require("../../constants/keyboard");
+var _common = require("../../../utils/common");
+var _constants = require("../../constants");
+var _elementTypes = require("../../constants/element-types");
+const isSelectionAtLineEnd = (editor, path) => {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const isAtLineEnd = _slate.Editor.isEnd(editor, selection.anchor, path) || _slate.Editor.isEnd(editor, selection.focus, path);
+  return isAtLineEnd;
+};
+const isSelectionAtLineStart = (editor, path) => {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const isAtLineEnd = _slate.Editor.isStart(editor, selection.anchor, path) || _slate.Editor.isStart(editor, selection.focus, path);
+  return isAtLineEnd;
+};
+const withHeader = editor => {
+  const {
+    insertBreak,
+    insertFragment,
+    insertText,
+    deleteBackward,
+    onHotKeyDown
+  } = editor;
+  const newEditor = editor;
+
+  // Rewrite insertBreak - insert paragraph when carriage return at the end of header
+  newEditor.insertBreak = () => {
+    const [match] = _slate.Editor.nodes(newEditor, {
+      match: n => {
+        if (!_slate.Element.isElement(n)) return false;
+        if (n.type.startsWith(_constants.ElementTypes.HEADER)) return true;
+        return false;
+      },
+      // Matches nodes whose node.type starts with header
+      universal: true
+    });
+    if (!match) {
+      insertBreak();
+      return;
+    }
+    const isAtLineEnd = isSelectionAtLineEnd(editor, match[1]);
+    // If an empty p is inserted at the end of the line, otherwise wrap normally
+    if (isAtLineEnd) {
+      const p = (0, _core.generateEmptyElement)(_constants.ElementTypes.PARAGRAPH);
+      _slate.Transforms.insertNodes(newEditor, p, {
+        mode: 'highest'
+      });
+    } else {
+      insertBreak();
+    }
+  };
+  newEditor.deleteBackward = unit => {
+    const {
+      selection
+    } = editor;
+    if (!selection) return deleteBackward(unit);
+    const [headerEntry] = _slate.Editor.nodes(newEditor, {
+      match: n => {
+        if (!_slate.Element.isElement(n)) return false;
+        if (n.type && n.type.startsWith(_constants.ElementTypes.HEADER)) return true;
+        return false;
+      },
+      // Matches nodes whose node.type starts with header
+      universal: true
+    });
+    if (!headerEntry) {
+      deleteBackward(unit);
+      return false;
+    }
+    const isAtLineStart = isSelectionAtLineStart(editor, headerEntry[1]);
+    if (isAtLineStart) {
+      (0, _helper.setHeaderType)(editor, _constants.ElementTypes.PARAGRAPH);
+      return true;
+    }
+    return deleteBackward(unit);
+  };
+  newEditor.insertFragment = fragment => {
+    const headerEntry = (0, _core.getSelectedNodeEntryByTypes)(editor, _constants.HEADERS);
+    if (!headerEntry) return insertFragment(fragment);
+    const firstChild = fragment[0];
+    if (fragment.length === 1) {
+      // is single list item
+      if (_constants.LIST_TYPE_ARRAY.includes(firstChild.type)) {
+        if (firstChild.children.length === 1) {
+          const text = _slate.Node.string(fragment[0]);
+          insertText(text);
+          return;
+        }
+
+        // insert list at current path
+        if ((0, _core.isSelectionAtBlockStart)(editor)) {
+          _slate.Transforms.insertNodes(newEditor, fragment);
+          return;
+        }
+        const nextPath = _slate.Path.next(headerEntry[1]);
+        _slate.Transforms.insertNodes(newEditor, fragment, {
+          at: nextPath
+        });
+        return;
+      }
+      if (firstChild.type === _elementTypes.TABLE) {
+        const nextPath = _slate.Path.next(headerEntry[1]);
+        _slate.Transforms.insertNodes(newEditor, fragment, {
+          at: nextPath
+        });
+        return;
+      }
+    }
+    return insertFragment(fragment);
+  };
+  newEditor.onHotKeyDown = event => {
+    const HOT_KEYS = (0, _common.isMac)() ? _keyboard.MAC_HOTKEYS_EVENT_HEADER : _keyboard.WIN_HOTKEYS_EVENT_HEADER;
+    const hotEntries = Object.entries(HOT_KEYS);
+    let isHeaderEvent = false;
+    let headerType = '';
+    for (const element of hotEntries) {
+      const [key, value] = element;
+      isHeaderEvent = (0, _isHotkey.default)(value, event);
+      if (isHeaderEvent) {
+        headerType = key;
+        break;
+      }
+    }
+    if (!isHeaderEvent) {
+      return onHotKeyDown && onHotKeyDown(event);
+    }
+    event.preventDefault();
+    if ((0, _helper.isMenuDisabled)(newEditor)) return true;
+    const currentHeaderType = (0, _helper.getHeaderType)(editor);
+    if (currentHeaderType === headerType) {
+      (0, _helper.setHeaderType)(newEditor, _constants.ElementTypes.PARAGRAPH);
+    } else {
+      (0, _helper.setHeaderType)(newEditor, headerType);
+    }
+    return true;
+  };
+  return newEditor;
+};
+var _default = exports.default = withHeader;

package/dist/extension/plugins/header/render-elem.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderHeader = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _core = require("../../core");
+var _constants = require("../../constants");
+var _jsxRuntime = require("react/jsx-runtime");
+const renderHeader = (props, editor) => {
+  const {
+    element,
+    attributes,
+    children
+  } = props;
+  const HeaderTagName = `h${getHeaderTagName(element)}`;
+  function getHeaderTagName(element) {
+    const currentNodeType = (0, _core.getNodeType)(element);
+    if (currentNodeType.indexOf(_constants.ElementTypes.HEADER) > -1) {
+      return currentNodeType.split(_constants.ElementTypes.HEADER)[1];
+    }
+    return '1';
+  }
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(HeaderTagName, {
+    "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) || {}),
+      textAlign: element.align
+    },
+    children: children
+  });
+};
+exports.renderHeader = renderHeader;

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

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _plugin = _interopRequireDefault(require("./plugin"));
+const HtmlPlugin = {
+  type: 'html',
+  editorPlugin: _plugin.default
+};
+var _default = exports.default = HtmlPlugin;

package/dist/extension/plugins/html/plugin.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _isUrl = _interopRequireDefault(require("is-url"));
+var _slugid = _interopRequireDefault(require("slugid"));
+var _slateConvert = require("../../../slate-convert");
+var _elementTypes = require("../../constants/element-types");
+var _helpers = require("../code-block/helpers");
+const withHtml = editor => {
+  const {
+    insertData
+  } = editor;
+  const newEditor = editor;
+  newEditor.insertData = data => {
+    // If the text is a link and is not within the code_block block, it is processed as link
+    const text = data.getData('text/plain') || '';
+    if (text.trim() && (0, _isUrl.default)(text.trim()) && !(0, _helpers.isInCodeBlock)(newEditor)) {
+      insertData(data);
+      return;
+    }
+
+    // If the copied content contains files, proceed as shown in the image
+    if (data.types.includes('Files')) {
+      insertData(data);
+      return;
+    }
+
+    // If code_block is selected, the copied content will be processed according to code_block
+    if (!data.types.includes('text/code-block') && (0, _helpers.isInCodeBlock)(newEditor)) {
+      const plaintext = data.getData('text/plain') || '';
+      if (plaintext) {
+        let fragmentData = [];
+        plaintext.split('\n').forEach(item => {
+          const codeLine = {
+            id: _slugid.default.nice(),
+            type: _elementTypes.CODE_LINE,
+            children: [{
+              text: item,
+              id: _slugid.default.nice()
+            }]
+          };
+          fragmentData.push(codeLine);
+        });
+        newEditor.insertFragment(fragmentData);
+      }
+      return;
+    }
+
+    // If it is in slate format, it will be processed in slate format.
+    if (newEditor.insertFragmentData(data)) {
+      return;
+    }
+
+    // If it is in html format, it will be processed in html format.
+    const htmlContent = data.getData('text/html') || '';
+    if (htmlContent) {
+      const content = (0, _slateConvert.deserializeHtml)(htmlContent);
+      editor.insertFragment(content);
+      return;
+    }
+    insertData(data);
+  };
+  return newEditor;
+};
+var _default = exports.default = withHtml;