@ctzhian/tiptap 1.5.2 → 1.5.4

package/dist/extension/component/Video/Readonly.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import { VideoAttributes } from ".";
+interface ReadonlyVideoProps {
+    attrs: VideoAttributes;
+    onError?: (error: Error) => void;
+}
+declare const ReadonlyVideo: ({ attrs, onError }: ReadonlyVideoProps) => React.JSX.Element;
+export default ReadonlyVideo;

package/dist/extension/component/Video/Readonly.js

@@ -0,0 +1,40 @@
+import { Box } from "@mui/material";
+import { NodeViewWrapper } from "@tiptap/react";
+import React from "react";
+var ReadonlyVideo = function ReadonlyVideo(_ref) {
+  var attrs = _ref.attrs,
+    _onError = _ref.onError;
+  return /*#__PURE__*/React.createElement(NodeViewWrapper, {
+    className: "video-wrapper",
+    "data-drag-handle": true
+  }, /*#__PURE__*/React.createElement(Box, {
+    sx: {
+      position: 'relative',
+      display: 'inline-block',
+      border: '1px solid',
+      borderColor: 'divider',
+      borderRadius: 'var(--mui-shape-borderRadius)',
+      p: '0.25rem',
+      '&:hover .video-controls': {
+        opacity: 1
+      }
+    }
+  }, /*#__PURE__*/React.createElement("video", {
+    src: attrs.src,
+    poster: attrs.poster || undefined,
+    controls: attrs.controls,
+    autoPlay: attrs.autoplay,
+    loop: attrs.loop,
+    muted: attrs.muted,
+    width: attrs.width,
+    style: {
+      maxWidth: '100%',
+      height: 'auto',
+      display: 'block'
+    },
+    onError: function onError(e) {
+      _onError === null || _onError === void 0 || _onError(e);
+    }
+  })));
+};
+export default ReadonlyVideo;

package/dist/extension/component/Video/index.d.ts

@@ -0,0 +1,14 @@
+import { EditorFnProps } from "../../../type";
+import { NodeViewProps } from '@tiptap/react';
+import React from "react";
+export interface VideoAttributes {
+    src: string;
+    width: number;
+    controls: boolean;
+    autoplay: boolean;
+    loop: boolean;
+    muted: boolean;
+    poster: string | null;
+}
+declare const VideoViewWrapper: React.FC<NodeViewProps & EditorFnProps>;
+export default VideoViewWrapper;

package/dist/extension/component/Video/index.js

@@ -0,0 +1,166 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { DeleteLineIcon } from "../../../component/Icons";
+import { Box, IconButton, Tooltip } from "@mui/material";
+import { NodeViewWrapper } from '@tiptap/react';
+import React, { useEffect, useRef, useState } from "react";
+import InsertVideo from "./Insert";
+import ReadonlyVideo from "./Readonly";
+var VideoViewWrapper = function VideoViewWrapper(_ref) {
+  var editor = _ref.editor,
+    node = _ref.node,
+    updateAttributes = _ref.updateAttributes,
+    deleteNode = _ref.deleteNode,
+    selected = _ref.selected,
+    onUpload = _ref.onUpload,
+    _onError = _ref.onError;
+  var attrs = node.attrs;
+  var videoRef = useRef(null);
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    isDragging = _useState2[0],
+    setIsDragging = _useState2[1];
+  var _useState3 = useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    isHovering = _useState4[0],
+    setIsHovering = _useState4[1];
+  var _useState5 = useState(0),
+    _useState6 = _slicedToArray(_useState5, 2),
+    dragStartX = _useState6[0],
+    setDragStartX = _useState6[1];
+  var _useState7 = useState(0),
+    _useState8 = _slicedToArray(_useState7, 2),
+    dragStartWidth = _useState8[0],
+    setDragStartWidth = _useState8[1];
+  var handleMouseDown = function handleMouseDown(e) {
+    e.preventDefault();
+    setIsDragging(true);
+    setDragStartX(e.clientX);
+    setDragStartWidth(attrs.width);
+  };
+  var handleMouseMove = function handleMouseMove(e) {
+    if (!isDragging) return;
+    var deltaX = e.clientX - dragStartX;
+    var newWidth = Math.max(200, Math.min(1920, dragStartWidth + deltaX));
+    updateAttributes({
+      width: newWidth
+    });
+  };
+  var handleMouseUp = function handleMouseUp() {
+    setIsDragging(false);
+  };
+  useEffect(function () {
+    if (isDragging) {
+      document.addEventListener('mousemove', handleMouseMove);
+      document.addEventListener('mouseup', handleMouseUp);
+      return function () {
+        document.removeEventListener('mousemove', handleMouseMove);
+        document.removeEventListener('mouseup', handleMouseUp);
+      };
+    }
+  }, [isDragging]);
+  if (!attrs.src && !editor.isEditable) {
+    return null;
+  }
+  if (!editor.isEditable) {
+    return /*#__PURE__*/React.createElement(ReadonlyVideo, {
+      attrs: attrs,
+      onError: _onError
+    });
+  }
+  if (!attrs.src) {
+    return /*#__PURE__*/React.createElement(InsertVideo, {
+      selected: selected,
+      attrs: attrs,
+      updateAttributes: updateAttributes,
+      onUpload: onUpload,
+      onError: _onError
+    });
+  }
+  return /*#__PURE__*/React.createElement(NodeViewWrapper, {
+    className: "video-wrapper ".concat(selected ? 'ProseMirror-selectednode' : ''),
+    "data-drag-handle": true
+  }, /*#__PURE__*/React.createElement(Box, {
+    sx: {
+      position: 'relative',
+      display: 'inline-block',
+      border: '1px solid',
+      borderColor: 'divider',
+      borderRadius: 'var(--mui-shape-borderRadius)',
+      p: '0.25rem',
+      bgcolor: 'background.paper',
+      '&:hover .video-controls': {
+        opacity: 1
+      }
+    },
+    onMouseEnter: function onMouseEnter() {
+      return setIsHovering(true);
+    },
+    onMouseLeave: function onMouseLeave() {
+      return setIsHovering(false);
+    }
+  }, /*#__PURE__*/React.createElement("video", {
+    ref: videoRef,
+    src: attrs.src,
+    width: attrs.width,
+    poster: attrs.poster || undefined,
+    controls: attrs.controls,
+    autoPlay: attrs.autoplay,
+    loop: attrs.loop,
+    muted: attrs.muted,
+    style: {
+      maxWidth: '100%',
+      height: 'auto',
+      display: 'block'
+    },
+    onError: function onError(e) {
+      _onError === null || _onError === void 0 || _onError(e);
+    }
+  }), (isHovering || isDragging) && /*#__PURE__*/React.createElement(Box, {
+    onMouseDown: handleMouseDown,
+    sx: {
+      position: 'absolute',
+      right: -2,
+      top: '50%',
+      transform: 'translateY(-50%)',
+      width: 4,
+      height: 50,
+      bgcolor: isDragging ? 'primary.main' : 'text.primary',
+      cursor: 'ew-resize',
+      borderRadius: 2,
+      '&:hover': {
+        bgcolor: 'primary.main'
+      },
+      transition: 'background-color 0.2s ease',
+      zIndex: 10
+    }
+  }), isHovering && /*#__PURE__*/React.createElement(Box, {
+    className: "video-controls",
+    sx: {
+      position: 'absolute',
+      top: '0.5rem',
+      right: '0.5rem',
+      display: 'flex',
+      gap: '0.25rem'
+    }
+  }, /*#__PURE__*/React.createElement(Tooltip, {
+    arrow: true,
+    title: "\u5220\u9664\u89C6\u9891"
+  }, /*#__PURE__*/React.createElement(IconButton, {
+    size: "small",
+    onClick: deleteNode,
+    sx: {
+      color: 'text.primary',
+      bgcolor: 'background.paper'
+    }
+  }, /*#__PURE__*/React.createElement(DeleteLineIcon, {
+    sx: {
+      fontSize: 18
+    }
+  }))))));
+};
+export default VideoViewWrapper;

package/dist/extension/extension/SlashCommands.d.ts

@@ -0,0 +1,3 @@
+import { Extension } from '@tiptap/core';
+export declare const SlashCommands: Extension<any, any>;
+export default SlashCommands;

package/dist/extension/extension/SlashCommands.js

@@ -0,0 +1,25 @@
+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 { Extension } from '@tiptap/core';
+import Suggestion from '@tiptap/suggestion';
+import { slashSuggestion } from "../suggestion/slash";
+export var SlashCommands = Extension.create({
+  name: 'slashCommands',
+  addOptions: function addOptions() {
+    return {
+      suggestion: _objectSpread({
+        char: '/'
+      }, slashSuggestion())
+    };
+  },
+  addProseMirrorPlugins: function addProseMirrorPlugins() {
+    return [Suggestion(_objectSpread({
+      editor: this.editor
+    }, this.options.suggestion))];
+  }
+});
+export default SlashCommands;

package/dist/extension/extension/StructuredDiff.d.ts

@@ -0,0 +1,18 @@
+import { Editor, Extension } from '@tiptap/core';
+import { PluginKey } from '@tiptap/pm/state';
+declare const diffPluginKey: PluginKey<any>;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        structuredDiff: {
+            showStructuredDiff: (oldHtml: string, newHtml: string) => ReturnType;
+            hideStructuredDiff: () => ReturnType;
+        };
+    }
+}
+export declare const StructuredDiffExtension: Extension<any, any>;
+export { diffPluginKey };
+export declare function getDiffState(editor: Editor): {
+    isActive: any;
+    diffs: any;
+    diffCount: any;
+} | null;

package/dist/extension/extension/StructuredDiff.js

@@ -0,0 +1,131 @@
+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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+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 { Extension } from '@tiptap/core';
+import { Plugin, PluginKey } from '@tiptap/pm/state';
+import { createDecorationsFromDiffs, createEmptyDecorationSet } from "../../util/decorations";
+import { compareDocuments } from "../../util/structuredDiff";
+var diffPluginKey = new PluginKey('structuredDiff');
+var DiffPluginState = /*#__PURE__*/function () {
+  function DiffPluginState(decorations) {
+    var diffs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var isActive = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    _classCallCheck(this, DiffPluginState);
+    _defineProperty(this, "decorations", void 0);
+    _defineProperty(this, "diffs", void 0);
+    _defineProperty(this, "isActive", void 0);
+    this.decorations = decorations;
+    this.diffs = diffs;
+    this.isActive = isActive;
+  }
+  _createClass(DiffPluginState, [{
+    key: "apply",
+    value: function apply(tr, value, oldState, newState) {
+      if (tr.docChanged && value.isActive) {
+        var mappedDecorations = value.decorations.map(tr.mapping, tr.doc);
+        return new DiffPluginState(mappedDecorations, value.diffs, value.isActive);
+      }
+      var diffMeta = tr.getMeta(diffPluginKey);
+      if (diffMeta) {
+        switch (diffMeta.type) {
+          case 'showDiff':
+            return new DiffPluginState(diffMeta.decorations, diffMeta.diffs, true);
+          case 'hideDiff':
+            return new DiffPluginState(createEmptyDecorationSet(newState.doc), [], false);
+          default:
+            return value;
+        }
+      }
+      return value;
+    }
+  }], [{
+    key: "init",
+    value: function init(config, state) {
+      return new DiffPluginState(createEmptyDecorationSet(state.doc), [], false);
+    }
+  }]);
+  return DiffPluginState;
+}();
+export var StructuredDiffExtension = Extension.create({
+  name: 'structuredDiff',
+  addProseMirrorPlugins: function addProseMirrorPlugins() {
+    return [new Plugin({
+      key: diffPluginKey,
+      state: {
+        init: DiffPluginState.init,
+        apply: DiffPluginState.prototype.apply
+      },
+      props: {
+        decorations: function decorations(state) {
+          var pluginState = diffPluginKey.getState(state);
+          return pluginState ? pluginState.decorations : null;
+        }
+      }
+    })];
+  },
+  addCommands: function addCommands() {
+    return {
+      showStructuredDiff: function showStructuredDiff(oldHtml, newHtml) {
+        return function (_ref) {
+          var tr = _ref.tr,
+            state = _ref.state,
+            dispatch = _ref.dispatch,
+            editor = _ref.editor;
+          try {
+            var extensions = editor.extensionManager.extensions;
+            var comparison = compareDocuments(oldHtml, newHtml, extensions);
+            if (!comparison.hasChanges) {
+              return false;
+            }
+            var decorations = createDecorationsFromDiffs(comparison.diffs, state.doc);
+            var newTr = tr.setMeta(diffPluginKey, {
+              type: 'showDiff',
+              decorations: decorations,
+              diffs: comparison.diffs
+            });
+            if (dispatch) {
+              dispatch(newTr);
+            }
+            return true;
+          } catch (error) {
+            console.error('显示结构化diff时出错:', error);
+            return false;
+          }
+        };
+      },
+      hideStructuredDiff: function hideStructuredDiff() {
+        return function (_ref2) {
+          var tr = _ref2.tr,
+            state = _ref2.state,
+            dispatch = _ref2.dispatch;
+          try {
+            var newTr = tr.setMeta(diffPluginKey, {
+              type: 'hideDiff'
+            });
+            if (dispatch) dispatch(newTr);
+            return true;
+          } catch (error) {
+            console.error('隐藏结构化diff时出错:', error);
+            return false;
+          }
+        };
+      }
+    };
+  }
+});
+export { diffPluginKey };
+export function getDiffState(editor) {
+  if (!editor || !editor.state) {
+    return null;
+  }
+  var pluginState = diffPluginKey.getState(editor.state);
+  return pluginState ? {
+    isActive: pluginState.isActive,
+    diffs: pluginState.diffs,
+    diffCount: pluginState.diffs.length
+  } : null;
+}

package/dist/extension/extension/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SlashCommands';
+export * from './StructuredDiff';

package/dist/extension/extension/index.js

@@ -0,0 +1,2 @@
+export * from "./SlashCommands";
+export * from "./StructuredDiff";

package/dist/extension/index.d.ts

@@ -0,0 +1,2 @@
+import { GetExtensionsProps } from '../type';
+export declare const getExtensions: ({ limit, exclude, extensions: extensionsProps, youtube, editable, mentionItems, onMentionFilter, onUpload, onError, onTocUpdate, }: GetExtensionsProps) => any;

package/dist/extension/index.js

@@ -0,0 +1,146 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import Highlight from '@tiptap/extension-highlight';
+import InvisibleCharacters from '@tiptap/extension-invisible-characters';
+import Subscript from '@tiptap/extension-subscript';
+import Superscript from '@tiptap/extension-superscript';
+import TextAlign from '@tiptap/extension-text-align';
+import { TextStyleKit } from '@tiptap/extension-text-style';
+import { CharacterCount, Placeholder } from '@tiptap/extensions';
+import StarterKit from '@tiptap/starter-kit';
+import { PLACEHOLDER } from "../contants/placeholder";
+import { SlashCommands, StructuredDiffExtension } from "./extension";
+import { CodeExtension } from "./mark/Code";
+import { AlertExtension, AudioExtension, BlockAttachmentExtension, BlockLinkExtension, CodeBlockLowlightExtension, CustomBlockMathExtension, CustomInlineMathExtension, DetailsContentExtension, DetailsExtension, DetailsSummaryExtension, EmojiExtension, FileHandlerExtension, IframeExtension, ImageExtension, Indent, InlineAttachmentExtension, InlineLinkExtension, ListExtension, MentionExtension, TableExtension, TableOfContents, UploadProgressExtension, VerticalAlign, VideoExtension, YoutubeExtension } from "./node";
+export var getExtensions = function getExtensions(_ref) {
+  var limit = _ref.limit,
+    exclude = _ref.exclude,
+    extensionsProps = _ref.extensions,
+    youtube = _ref.youtube,
+    editable = _ref.editable,
+    mentionItems = _ref.mentionItems,
+    onMentionFilter = _ref.onMentionFilter,
+    onUpload = _ref.onUpload,
+    onError = _ref.onError,
+    onTocUpdate = _ref.onTocUpdate;
+  var defaultExtensions = [StarterKit.configure({
+    link: false,
+    code: false,
+    codeBlock: false,
+    listItem: false,
+    orderedList: false,
+    bulletList: false,
+    listKeymap: false,
+    undoRedo: exclude !== null && exclude !== void 0 && exclude.includes('undoRedo') ? false : undefined,
+    dropcursor: {
+      color: 'var(--mui-palette-primary-main)',
+      width: 2
+    }
+  }), ListExtension, TextAlign.configure({
+    types: ['heading', 'paragraph']
+  }), VerticalAlign.configure({
+    types: ['textStyle'],
+    defaultAlignment: null
+  }), CodeBlockLowlightExtension, CharacterCount.configure({
+    limit: limit !== null && limit !== void 0 ? limit : null
+  }), Subscript, Superscript, TextStyleKit, Indent.configure({
+    types: [
+    // 常见块级与项目中定义的节点
+    'paragraph', 'heading', 'blockquote', 'alert', 'codeBlock', 'horizontalRule', 'orderedList', 'bulletList', 'taskList', 'taskItem', 'listItem', 'details', 'detailsContent', 'detailsSummary', 'table', 'image', 'video', 'audio', 'iframe', 'blockAttachment', 'inlineAttachment', 'blockLink',
+    // 公式
+    'blockMath', 'inlineMath'
+    // 扩展里还有：youtube 等，如需也可开启
+    ],
+    maxLevel: 8,
+    indentPx: 32
+  }), CodeExtension, AlertExtension, Highlight.configure({
+    multicolor: true
+  }), Placeholder.configure({
+    emptyNodeClass: 'custom-placeholder-node',
+    showOnlyWhenEditable: true,
+    placeholder: function placeholder(_ref2) {
+      var node = _ref2.node,
+        pos = _ref2.pos;
+      var type = node.type,
+        attrs = node.attrs;
+      if (pos === 0) {
+        return PLACEHOLDER.default;
+      }
+      if (type.name === 'heading') {
+        return PLACEHOLDER.heading[attrs.level];
+      }
+      if (PLACEHOLDER[type.name]) {
+        return PLACEHOLDER[type.name];
+      }
+      return '';
+    }
+  }), InlineLinkExtension, BlockLinkExtension, DetailsExtension, DetailsContentExtension, DetailsSummaryExtension].concat(_toConsumableArray(TableExtension({
+    editable: editable
+  })), [TableOfContents({
+    onTocUpdate: onTocUpdate
+  }), CustomInlineMathExtension({
+    onError: onError
+  }), CustomBlockMathExtension({
+    onError: onError
+  }), IframeExtension({
+    onError: onError
+  }), VideoExtension({
+    onUpload: onUpload,
+    onError: onError
+  }), AudioExtension({
+    onUpload: onUpload,
+    onError: onError
+  }), ImageExtension({
+    onUpload: onUpload,
+    onError: onError
+  }), InlineAttachmentExtension({
+    onUpload: onUpload,
+    onError: onError
+  }), BlockAttachmentExtension({
+    onUpload: onUpload,
+    onError: onError
+  })]);
+  if (!(exclude !== null && exclude !== void 0 && exclude.includes('emoji'))) {
+    var Emoji = EmojiExtension;
+    defaultExtensions.push(Emoji);
+  }
+  if (!(exclude !== null && exclude !== void 0 && exclude.includes('mention')) && (mentionItems && mentionItems.length > 0 || onMentionFilter)) {
+    var Mention = MentionExtension({
+      mentionItems: mentionItems,
+      onMentionFilter: onMentionFilter
+    });
+    defaultExtensions.push(Mention);
+  }
+  if (!(exclude !== null && exclude !== void 0 && exclude.includes('youtube'))) {
+    var Youtube = YoutubeExtension(youtube);
+    defaultExtensions.push(Youtube);
+  }
+  if (editable) {
+    if (!(exclude !== null && exclude !== void 0 && exclude.includes('fileHandler'))) {
+      var FileHandler = FileHandlerExtension({
+        onUpload: onUpload
+      });
+      defaultExtensions.push(FileHandler);
+      var UploadProgress = UploadProgressExtension;
+      defaultExtensions.push(UploadProgress);
+    }
+    if (!(exclude !== null && exclude !== void 0 && exclude.includes('slashCommands'))) {
+      defaultExtensions.push(SlashCommands);
+    }
+    if (!(exclude !== null && exclude !== void 0 && exclude.includes('invisibleCharacters'))) {
+      defaultExtensions.push(InvisibleCharacters);
+    }
+  } else {
+    if (!(exclude !== null && exclude !== void 0 && exclude.includes('structuredDiff'))) {
+      defaultExtensions.push(StructuredDiffExtension);
+    }
+  }
+  if (extensionsProps && extensionsProps.length > 0) {
+    defaultExtensions.push.apply(defaultExtensions, _toConsumableArray(extensionsProps));
+  }
+  return defaultExtensions;
+};

package/dist/extension/mark/Code.d.ts

@@ -0,0 +1,2 @@
+export declare const CodeExtension: import("@tiptap/core").Mark<import("@tiptap/extension-code").CodeOptions, any>;
+export default CodeExtension;

package/dist/extension/mark/Code.js

@@ -0,0 +1,9 @@
+import Code from '@tiptap/extension-code';
+
+// 允许与 textStyle 等标记共存，以便字号/颜色等样式可应用到 code 文本
+export var CodeExtension = Code.extend({
+  // 默认 `@tiptap/extension-code` 的 excludes 为 '_'（排除所有其他 mark）
+  // 这里清空以允许共存，从而让 textStyle 的 fontSize 生效
+  excludes: ''
+});
+export default CodeExtension;

package/dist/extension/mark/Link.js

@@ -0,0 +1,58 @@
+// import { Link } from "@tiptap/extension-link";
+
+// const customLink = Link.extend({
+//   addAttributes() {
+//     return {
+//       ...(this.parent as any)?.(),
+//       type: {
+//         default: 'link',
+//         parseHTML: (element: HTMLElement) => {
+//           return element.getAttribute('data-type') || 'link'
+//         },
+//         renderHTML: (attributes: any) => {
+//           return {
+//             'data-type': attributes.type,
+//           }
+//         }
+//       },
+//       title: {
+//         default: '',
+//         parseHTML: (element: HTMLElement) => {
+//           return element.getAttribute('data-title') || ''
+//         },
+//         renderHTML: (attributes: any) => {
+//           return {
+//             'data-title': attributes.title,
+//           }
+//         }
+//       },
+//     }
+//   },
+//   addKeyboardShortcuts() {
+//     return {
+//       'Mod-k': () => {
+//         return this.editor.commands.setLink({ href: '' })
+//       }
+//     }
+//   },
+//   // addMarkView() {
+//   //   return ReactMarkViewRenderer(LinkViewWrapper, {
+//   //     as: 'a',
+//   //   })
+//   // }
+// })
+
+// export const LinkExtension = customLink.configure({
+//   autolink: true,
+//   openOnClick: true,
+//   enableClickSelection: true,
+//   linkOnPaste: true,
+//   protocols: ['http', 'https', 'mailto', 'tel'],
+//   defaultProtocol: 'http',
+//   HTMLAttributes: {
+//     rel: null,
+//     target: '_blank',
+//   },
+// })
+
+// export default LinkExtension

package/dist/extension/mark/index.js

@@ -0,0 +1 @@
+// export * from './Link';