@ctzhian/tiptap 0.4.0

package/dist/extension/node/TableOfContents/type.js

@@ -0,0 +1 @@
+export {};

package/dist/extension/node/TableOfContents/utils.d.ts

@@ -0,0 +1,6 @@
+import type { GetTableOfContentIndexFunction, GetTableOfContentLevelFunction, TableOfContentDataItem } from './type';
+export declare const getLastHeadingOnLevel: (headings: TableOfContentDataItem[], level: number) => TableOfContentDataItem | undefined;
+export declare const getHeadlineLevel: GetTableOfContentLevelFunction;
+export declare const getLinearIndexes: GetTableOfContentIndexFunction;
+export declare const getHierarchicalIndexes: GetTableOfContentIndexFunction;
+export declare function debounce(func: (...args: any[]) => void, wait: number): (...args: any[]) => void;

package/dist/extension/node/TableOfContents/utils.js

@@ -0,0 +1,70 @@
+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; }
+export var getLastHeadingOnLevel = function getLastHeadingOnLevel(headings, level) {
+  var heading = headings.filter(function (currentHeading) {
+    return currentHeading.level === level;
+  }).pop();
+  if (level === 0) {
+    return undefined;
+  }
+  if (!heading) {
+    heading = getLastHeadingOnLevel(headings, level - 1);
+  }
+  return heading;
+};
+export var getHeadlineLevel = function getHeadlineLevel(headline, previousItems) {
+  var level = 1;
+  var previousHeadline = previousItems.at(-1);
+  var highestHeadlineAbove = _toConsumableArray(previousItems).reverse().find(function (h) {
+    return h.originalLevel <= headline.node.attrs.level;
+  });
+  var highestLevelAbove = (highestHeadlineAbove === null || highestHeadlineAbove === void 0 ? void 0 : highestHeadlineAbove.level) || 1;
+  if (headline.node.attrs.level > ((previousHeadline === null || previousHeadline === void 0 ? void 0 : previousHeadline.originalLevel) || 1)) {
+    level = ((previousHeadline === null || previousHeadline === void 0 ? void 0 : previousHeadline.level) || 1) + 1;
+  } else if (headline.node.attrs.level < ((previousHeadline === null || previousHeadline === void 0 ? void 0 : previousHeadline.originalLevel) || 1)) {
+    level = highestLevelAbove;
+  } else {
+    level = (previousHeadline === null || previousHeadline === void 0 ? void 0 : previousHeadline.level) || 1;
+  }
+  return level;
+};
+export var getLinearIndexes = function getLinearIndexes(_headline, previousHeadlines) {
+  var previousHeadline = previousHeadlines.at(-1);
+  if (!previousHeadline) {
+    return 1;
+  }
+  return ((previousHeadline === null || previousHeadline === void 0 ? void 0 : previousHeadline.itemIndex) || 1) + 1;
+};
+export var getHierarchicalIndexes = function getHierarchicalIndexes(headline, previousHeadlines, currentLevel) {
+  var _previousHeadlinesOnL;
+  var level = currentLevel || headline.node.attrs.level || 1;
+  var itemIndex = 1;
+  var previousHeadlinesOnLevelOrBelow = previousHeadlines.filter(function (h) {
+    return h.level <= level;
+  });
+  if (((_previousHeadlinesOnL = previousHeadlinesOnLevelOrBelow.at(-1)) === null || _previousHeadlinesOnL === void 0 ? void 0 : _previousHeadlinesOnL.level) === level) {
+    var _previousHeadlinesOnL2;
+    itemIndex = (((_previousHeadlinesOnL2 = previousHeadlinesOnLevelOrBelow.at(-1)) === null || _previousHeadlinesOnL2 === void 0 ? void 0 : _previousHeadlinesOnL2.itemIndex) || 1) + 1;
+  } else {
+    itemIndex = 1;
+  }
+  return itemIndex;
+};
+export function debounce(func, wait) {
+  var timeout = null;
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(function () {
+      func.apply(void 0, args);
+    }, wait);
+  };
+}

package/dist/extension/node/UploadProgress.d.ts

@@ -0,0 +1,21 @@
+import { Node } from '@tiptap/core';
+import { UploadProgressAttributes } from '../component/UploadProgress';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        uploadProgress: {
+            /**
+             * Insert upload progress indicator
+             */
+            setUploadProgress: (options: UploadProgressAttributes) => ReturnType;
+            /**
+             * Update upload progress
+             */
+            updateUploadProgress: (tempId: string, progress: number) => ReturnType;
+            /**
+             * Remove upload progress indicator
+             */
+            removeUploadProgress: (tempId: string) => ReturnType;
+        };
+    }
+}
+export declare const UploadProgressExtension: Node<any, any>;

package/dist/extension/node/UploadProgress.js

@@ -0,0 +1,135 @@
+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 { mergeAttributes, Node } from '@tiptap/core';
+import { ReactNodeViewRenderer } from '@tiptap/react';
+import UploadProgressView from "../component/UploadProgress";
+export var UploadProgressExtension = Node.create({
+  name: 'uploadProgress',
+  group: 'block',
+  atom: true,
+  selectable: false,
+  draggable: false,
+  addAttributes: function addAttributes() {
+    return {
+      fileName: {
+        default: '',
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('data-file-name');
+        },
+        renderHTML: function renderHTML(attributes) {
+          if (!attributes.fileName) {
+            return {};
+          }
+          return {
+            'data-file-name': attributes.fileName
+          };
+        }
+      },
+      fileType: {
+        default: 'other',
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('data-file-type');
+        },
+        renderHTML: function renderHTML(attributes) {
+          if (!attributes.fileType) {
+            return {};
+          }
+          return {
+            'data-file-type': attributes.fileType
+          };
+        }
+      },
+      progress: {
+        default: 0,
+        parseHTML: function parseHTML(element) {
+          return parseFloat(element.getAttribute('data-progress') || '0');
+        },
+        renderHTML: function renderHTML(attributes) {
+          return {
+            'data-progress': attributes.progress
+          };
+        }
+      },
+      tempId: {
+        default: '',
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('data-temp-id');
+        },
+        renderHTML: function renderHTML(attributes) {
+          if (!attributes.tempId) {
+            return {};
+          }
+          return {
+            'data-temp-id': attributes.tempId
+          };
+        }
+      }
+    };
+  },
+  parseHTML: function parseHTML() {
+    return [{
+      tag: 'div[data-type="upload-progress"]'
+    }];
+  },
+  renderHTML: function renderHTML(_ref) {
+    var HTMLAttributes = _ref.HTMLAttributes;
+    return ['div', mergeAttributes({
+      'data-type': 'upload-progress'
+    }, HTMLAttributes)];
+  },
+  addCommands: function addCommands() {
+    var _this = this;
+    return {
+      setUploadProgress: function setUploadProgress(options) {
+        return function (_ref2) {
+          var commands = _ref2.commands;
+          return commands.insertContent({
+            type: _this.name,
+            attrs: options
+          });
+        };
+      },
+      updateUploadProgress: function updateUploadProgress(tempId, progress) {
+        return function (_ref3) {
+          var tr = _ref3.tr,
+            state = _ref3.state;
+          var doc = state.doc;
+          var updated = false;
+          doc.descendants(function (node, pos) {
+            if (node.type.name === _this.name && node.attrs.tempId === tempId) {
+              tr.setNodeMarkup(pos, undefined, _objectSpread(_objectSpread({}, node.attrs), {}, {
+                progress: progress
+              }));
+              updated = true;
+              return false; // 停止遍历
+            }
+          });
+          return updated;
+        };
+      },
+      removeUploadProgress: function removeUploadProgress(tempId) {
+        return function (_ref4) {
+          var tr = _ref4.tr,
+            state = _ref4.state;
+          var doc = state.doc;
+          var removed = false;
+          doc.descendants(function (node, pos) {
+            if (node.type.name === _this.name && node.attrs.tempId === tempId) {
+              tr.delete(pos, pos + node.nodeSize);
+              removed = true;
+              return false; // 停止遍历
+            }
+          });
+          return removed;
+        };
+      }
+    };
+  },
+  addNodeView: function addNodeView() {
+    return ReactNodeViewRenderer(UploadProgressView);
+  }
+});

package/dist/extension/node/VerticalAlign.d.ts

@@ -0,0 +1,49 @@
+import { Extension } from '@tiptap/core';
+export interface VerticalAlignOptions {
+    /**
+     * The types where the vertical align attribute can be applied.
+     * @default ['textStyle']
+     * @example ['textStyle']
+     */
+    types: string[];
+    /**
+     * The alignments which are allowed.
+     * @default ['top', 'middle', 'bottom']
+     */
+    alignments: string[];
+    /**
+     * The default alignment.
+     * @default null
+     */
+    defaultAlignment: string | null;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        verticalAlign: {
+            /**
+             * Set the vertical align attribute
+             * @param alignment The alignment
+             * @example editor.commands.setVerticalAlign('top')
+             */
+            setVerticalAlign: (alignment: string) => ReturnType;
+            /**
+             * Unset the vertical align attribute
+             * @example editor.commands.unsetVerticalAlign()
+             */
+            unsetVerticalAlign: () => ReturnType;
+            /**
+             * Toggle the vertical align attribute
+             * @param alignment The alignment
+             * @example editor.commands.toggleVerticalAlign('middle')
+             */
+            toggleVerticalAlign: (alignment: string) => ReturnType;
+        };
+    }
+}
+declare module '@tiptap/extension-text-style' {
+    interface TextStyleAttributes {
+        verticalAlign?: string | null;
+    }
+}
+export declare const VerticalAlign: Extension<VerticalAlignOptions, any>;
+export default VerticalAlign;

package/dist/extension/node/VerticalAlign.js

@@ -0,0 +1,88 @@
+import { Extension } from '@tiptap/core';
+export var VerticalAlign = Extension.create({
+  name: 'verticalAlign',
+  addOptions: function addOptions() {
+    return {
+      types: ['textStyle'],
+      alignments: ['top', 'middle', 'bottom'],
+      defaultAlignment: null
+    };
+  },
+  addGlobalAttributes: function addGlobalAttributes() {
+    var _this = this;
+    return [{
+      types: this.options.types,
+      attributes: {
+        verticalAlign: {
+          default: this.options.defaultAlignment,
+          parseHTML: function parseHTML(element) {
+            var alignment = element.style.verticalAlign;
+            return _this.options.alignments.includes(alignment) ? alignment : _this.options.defaultAlignment;
+          },
+          renderHTML: function renderHTML(attributes) {
+            if (!attributes.verticalAlign) {
+              return {};
+            }
+            return {
+              style: "vertical-align: ".concat(attributes.verticalAlign)
+            };
+          }
+        }
+      }
+    }];
+  },
+  addCommands: function addCommands() {
+    var _this2 = this;
+    return {
+      setVerticalAlign: function setVerticalAlign(alignment) {
+        return function (_ref) {
+          var commands = _ref.commands;
+          if (!_this2.options.alignments.includes(alignment)) {
+            return false;
+          }
+          return commands.toggleTextStyle({
+            verticalAlign: alignment
+          });
+        };
+      },
+      unsetVerticalAlign: function unsetVerticalAlign() {
+        return function (_ref2) {
+          var commands = _ref2.commands;
+          return commands.toggleTextStyle({
+            verticalAlign: null
+          });
+        };
+      },
+      toggleVerticalAlign: function toggleVerticalAlign(alignment) {
+        return function (_ref3) {
+          var editor = _ref3.editor,
+            commands = _ref3.commands;
+          if (!_this2.options.alignments.includes(alignment)) {
+            return false;
+          }
+          if (editor.isActive('textStyle', {
+            verticalAlign: alignment
+          })) {
+            return commands.unsetVerticalAlign();
+          }
+          return commands.setVerticalAlign(alignment);
+        };
+      }
+    };
+  },
+  addKeyboardShortcuts: function addKeyboardShortcuts() {
+    var _this3 = this;
+    return {
+      'Mod-Alt-t': function ModAltT() {
+        return _this3.editor.commands.setVerticalAlign('top');
+      },
+      'Mod-Alt-m': function ModAltM() {
+        return _this3.editor.commands.setVerticalAlign('middle');
+      },
+      'Mod-Alt-b': function ModAltB() {
+        return _this3.editor.commands.setVerticalAlign('bottom');
+      }
+    };
+  }
+});
+export default VerticalAlign;

package/dist/extension/node/Video.d.ts

@@ -0,0 +1,23 @@
+import { Node } from '@tiptap/core';
+import { EditorFnProps } from "../../type";
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        video: {
+            /**
+             * Insert a video
+             */
+            setVideo: (options: {
+                src: string;
+                width?: number;
+                controls?: boolean;
+                autoplay?: boolean;
+                loop?: boolean;
+                muted?: boolean;
+                poster?: string;
+            }) => ReturnType;
+        };
+    }
+}
+export type VideoExtensionProps = EditorFnProps;
+export declare const VideoExtension: (props: VideoExtensionProps) => Node<any, any>;
+export default VideoExtension;

package/dist/extension/node/Video.js

@@ -0,0 +1,195 @@
+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 { mergeAttributes, Node } from '@tiptap/core';
+import { ReactNodeViewRenderer } from '@tiptap/react';
+import VideoViewWrapper from "../component/Video";
+export var VideoExtension = function VideoExtension(props) {
+  return Node.create({
+    name: 'video',
+    group: 'block',
+    atom: true,
+    selectable: true,
+    draggable: true,
+    addKeyboardShortcuts: function addKeyboardShortcuts() {
+      var _this = this;
+      return {
+        'Mod-3': function Mod3() {
+          return _this.editor.commands.setVideo({
+            src: '',
+            width: 760,
+            controls: true,
+            autoplay: false
+          });
+        }
+      };
+    },
+    addAttributes: function addAttributes() {
+      return {
+        class: {
+          default: 'video-wrapper'
+        },
+        src: {
+          default: null,
+          parseHTML: function parseHTML(element) {
+            return element.getAttribute('src');
+          },
+          renderHTML: function renderHTML(attributes) {
+            if (!attributes.src) return {};
+            return {
+              src: attributes.src
+            };
+          }
+        },
+        controls: {
+          default: true,
+          parseHTML: function parseHTML(element) {
+            return element.hasAttribute('controls');
+          },
+          renderHTML: function renderHTML(attributes) {
+            if (!attributes.controls) return {};
+            return {
+              controls: 'true'
+            };
+          }
+        },
+        autoplay: {
+          default: false,
+          parseHTML: function parseHTML(element) {
+            return element.hasAttribute('autoplay');
+          },
+          renderHTML: function renderHTML(attributes) {
+            if (!attributes.autoplay) return {};
+            return {
+              autoplay: 'true'
+            };
+          }
+        },
+        loop: {
+          default: false,
+          parseHTML: function parseHTML(element) {
+            return element.hasAttribute('loop');
+          },
+          renderHTML: function renderHTML(attributes) {
+            if (!attributes.loop) return {};
+            return {
+              loop: 'true'
+            };
+          }
+        },
+        muted: {
+          default: false,
+          parseHTML: function parseHTML(element) {
+            return element.hasAttribute('muted');
+          },
+          renderHTML: function renderHTML(attributes) {
+            if (!attributes.muted) return {};
+            return {
+              muted: 'true'
+            };
+          }
+        },
+        poster: {
+          default: null,
+          parseHTML: function parseHTML(element) {
+            return element.getAttribute('poster');
+          },
+          renderHTML: function renderHTML(attributes) {
+            if (!attributes.poster) return {};
+            return {
+              poster: attributes.poster
+            };
+          }
+        },
+        width: {
+          default: 760,
+          parseHTML: function parseHTML(element) {
+            var width = element.getAttribute('width');
+            return width ? parseInt(width, 10) : 760;
+          },
+          renderHTML: function renderHTML(attributes) {
+            return {
+              width: attributes.width
+            };
+          }
+        }
+      };
+    },
+    parseHTML: function parseHTML() {
+      return [{
+        tag: 'video',
+        getAttrs: function getAttrs(dom) {
+          if (!(dom instanceof HTMLElement)) return false;
+          var src = dom.getAttribute('src');
+          if (!src) return false;
+          return {
+            src: src,
+            controls: dom.hasAttribute('controls'),
+            autoplay: dom.hasAttribute('autoplay'),
+            loop: dom.hasAttribute('loop'),
+            muted: dom.hasAttribute('muted'),
+            poster: dom.getAttribute('poster'),
+            width: dom.getAttribute('width') ? parseInt(dom.getAttribute('width'), 10) : 760
+          };
+        }
+      }];
+    },
+    renderHTML: function renderHTML(_ref) {
+      var HTMLAttributes = _ref.HTMLAttributes;
+      return ['video', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
+    },
+    addCommands: function addCommands() {
+      var _this2 = this;
+      return {
+        setVideo: function setVideo(options) {
+          return function (_ref2) {
+            var commands = _ref2.commands;
+            return commands.insertContent({
+              type: _this2.name,
+              attrs: {
+                src: options.src,
+                width: options.width || 760,
+                controls: options.controls !== false,
+                autoplay: options.autoplay || false,
+                loop: options.loop || false,
+                muted: options.muted || false,
+                poster: options.poster || null
+              }
+            });
+          };
+        }
+      };
+    },
+    addInputRules: function addInputRules() {
+      var _this3 = this;
+      return [
+      // Auto-embed video URLs
+      {
+        find: /^https?:\/\/.*\.(mp4|webm|ogg|mov|m4v|avi|wmv|flv|mkv|mpg|mpeg|m4p|m4v|m4b|m4r|m4a)$/,
+        handler: function handler(_ref3) {
+          var state = _ref3.state,
+            range = _ref3.range,
+            match = _ref3.match;
+          var from = range.from,
+            to = range.to;
+          var videoUrl = match[0];
+          state.tr.replaceWith(from, to, _this3.type.create({
+            src: videoUrl
+          }));
+        }
+      }];
+    },
+    addNodeView: function addNodeView() {
+      return ReactNodeViewRenderer(function (renderProps) {
+        return VideoViewWrapper(_objectSpread(_objectSpread({}, renderProps), {}, {
+          onUpload: props.onUpload,
+          onError: props.onError
+        }));
+      });
+    }
+  });
+};
+export default VideoExtension;

package/dist/extension/node/Youtube.d.ts

@@ -0,0 +1,3 @@
+import { YoutubeOptions } from "@tiptap/extension-youtube";
+export declare const YoutubeExtension: (youtube?: Partial<YoutubeOptions>) => import("@tiptap/core").Node<YoutubeOptions, any>;
+export default YoutubeExtension;

package/dist/extension/node/Youtube.js

@@ -0,0 +1,14 @@
+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 Youtube from "@tiptap/extension-youtube";
+export var YoutubeExtension = function YoutubeExtension(youtube) {
+  return Youtube.configure(_objectSpread({
+    ccLanguage: 'zh-CN',
+    nocookie: true
+  }, youtube));
+};
+export default YoutubeExtension;

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

@@ -0,0 +1,17 @@
+export * from './Attachment';
+export * from './Audio';
+export * from './CodeBlockLowlight';
+export * from './Details';
+export * from './Emoji';
+export * from './FileHandler';
+export * from './Image';
+export * from './Link';
+export * from './ListKit';
+export * from './Mathematics';
+export * from './Mention';
+export * from './Table';
+export * from './TableOfContents';
+export * from './UploadProgress';
+export * from './VerticalAlign';
+export * from './Video';
+export * from './Youtube';

package/dist/extension/node/index.js

@@ -0,0 +1,17 @@
+export * from "./Attachment";
+export * from "./Audio";
+export * from "./CodeBlockLowlight";
+export * from "./Details";
+export * from "./Emoji";
+export * from "./FileHandler";
+export * from "./Image";
+export * from "./Link";
+export * from "./ListKit";
+export * from "./Mathematics";
+export * from "./Mention";
+export * from "./Table";
+export * from "./TableOfContents";
+export * from "./UploadProgress";
+export * from "./VerticalAlign";
+export * from "./Video";
+export * from "./Youtube";

package/dist/extension/suggestion/emoji.d.ts

@@ -0,0 +1,3 @@
+import { EmojiOptions } from '@tiptap/extension-emoji';
+export declare const emojiSuggestion: EmojiOptions["suggestion"];
+export default emojiSuggestion;