@tiptap/core 2.0.0-beta.19 → 2.0.0-beta.193

package/dist/tiptap-core.umd.js

@@ -1,2997 +0,0 @@
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('prosemirror-state'), require('prosemirror-view'), require('prosemirror-model'), require('prosemirror-keymap'), require('prosemirror-inputrules'), require('prosemirror-transform'), require('prosemirror-commands'), require('prosemirror-schema-list')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'prosemirror-state', 'prosemirror-view', 'prosemirror-model', 'prosemirror-keymap', 'prosemirror-inputrules', 'prosemirror-transform', 'prosemirror-commands', 'prosemirror-schema-list'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global['@tiptap/core'] = {}, global.prosemirrorState, global.prosemirrorView, global.prosemirrorModel, global.prosemirrorKeymap, global.prosemirrorInputrules, global.prosemirrorTransform, global.prosemirrorCommands, global.prosemirrorSchemaList));
-}(this, (function (exports, prosemirrorState, prosemirrorView, prosemirrorModel, prosemirrorKeymap, prosemirrorInputrules, prosemirrorTransform, prosemirrorCommands, prosemirrorSchemaList) { 'use strict';
-
-  function getNodeType(nameOrType, schema) {
-      if (typeof nameOrType === 'string') {
-          return schema.nodes[nameOrType];
-      }
-      return nameOrType;
-  }
-
-  function getNodeAttributes(state, typeOrName) {
-      const type = getNodeType(typeOrName, state.schema);
-      const { from, to } = state.selection;
-      let nodes = [];
-      state.doc.nodesBetween(from, to, node => {
-          nodes = [...nodes, node];
-      });
-      const node = nodes
-          .reverse()
-          .find(nodeItem => nodeItem.type.name === type.name);
-      if (node) {
-          return { ...node.attrs };
-      }
-      return {};
-  }
-
-  function getMarkType(nameOrType, schema) {
-      if (typeof nameOrType === 'string') {
-          return schema.marks[nameOrType];
-      }
-      return nameOrType;
-  }
-
-  function getMarkAttributes(state, typeOrName) {
-      const type = getMarkType(typeOrName, state.schema);
-      const { from, to, empty } = state.selection;
-      let marks = [];
-      if (empty) {
-          marks = state.selection.$head.marks();
-      }
-      else {
-          state.doc.nodesBetween(from, to, node => {
-              marks = [...marks, ...node.marks];
-          });
-      }
-      const mark = marks.find(markItem => markItem.type.name === type.name);
-      if (mark) {
-          return { ...mark.attrs };
-      }
-      return {};
-  }
-
-  /**
-   * Check if object1 includes object2
-   * @param object1 Object
-   * @param object2 Object
-   */
-  function objectIncludes(object1, object2) {
-      const keys = Object.keys(object2);
-      if (!keys.length) {
-          return true;
-      }
-      return !!keys
-          .filter(key => object2[key] === object1[key])
-          .length;
-  }
-
-  function isNodeActive(state, typeOrName, attributes = {}) {
-      const { from, to, empty } = state.selection;
-      const type = typeOrName
-          ? getNodeType(typeOrName, state.schema)
-          : null;
-      let nodeRanges = [];
-      state.doc.nodesBetween(from, to, (node, pos) => {
-          if (!node.isText) {
-              const relativeFrom = Math.max(from, pos);
-              const relativeTo = Math.min(to, pos + node.nodeSize);
-              nodeRanges = [...nodeRanges, {
-                      node,
-                      from: relativeFrom,
-                      to: relativeTo,
-                  }];
-          }
-      });
-      if (empty) {
-          return !!nodeRanges
-              .filter(nodeRange => {
-              if (!type) {
-                  return true;
-              }
-              return type.name === nodeRange.node.type.name;
-          })
-              .find(nodeRange => objectIncludes(nodeRange.node.attrs, attributes));
-      }
-      const selectionRange = to - from;
-      const range = nodeRanges
-          .filter(nodeRange => {
-          if (!type) {
-              return true;
-          }
-          return type.name === nodeRange.node.type.name;
-      })
-          .filter(nodeRange => objectIncludes(nodeRange.node.attrs, attributes))
-          .reduce((sum, nodeRange) => {
-          const size = nodeRange.to - nodeRange.from;
-          return sum + size;
-      }, 0);
-      return range >= selectionRange;
-  }
-
-  function isMarkActive(state, typeOrName, attributes = {}) {
-      const { from, to, empty } = state.selection;
-      const type = typeOrName
-          ? getMarkType(typeOrName, state.schema)
-          : null;
-      if (empty) {
-          return !!(state.storedMarks || state.selection.$from.marks())
-              .filter(mark => {
-              if (!type) {
-                  return true;
-              }
-              return type.name === mark.type.name;
-          })
-              .find(mark => objectIncludes(mark.attrs, attributes));
-      }
-      let selectionRange = 0;
-      let markRanges = [];
-      state.doc.nodesBetween(from, to, (node, pos) => {
-          if (node.isText) {
-              const relativeFrom = Math.max(from, pos);
-              const relativeTo = Math.min(to, pos + node.nodeSize);
-              const range = relativeTo - relativeFrom;
-              selectionRange += range;
-              markRanges = [...markRanges, ...node.marks.map(mark => ({
-                      mark,
-                      from: relativeFrom,
-                      to: relativeTo,
-                  }))];
-          }
-      });
-      if (selectionRange === 0) {
-          return false;
-      }
-      const range = markRanges
-          .filter(markRange => {
-          if (!type) {
-              return true;
-          }
-          return type.name === markRange.mark.type.name;
-      })
-          .filter(markRange => objectIncludes(markRange.mark.attrs, attributes))
-          .reduce((sum, markRange) => {
-          const size = markRange.to - markRange.from;
-          return sum + size;
-      }, 0);
-      return range >= selectionRange;
-  }
-
-  function getSchemaTypeNameByName(name, schema) {
-      if (schema.nodes[name]) {
-          return 'node';
-      }
-      if (schema.marks[name]) {
-          return 'mark';
-      }
-      return null;
-  }
-
-  function isActive(state, name, attributes = {}) {
-      if (!name) {
-          return isNodeActive(state, null, attributes) || isMarkActive(state, null, attributes);
-      }
-      const schemaType = getSchemaTypeNameByName(name, state.schema);
-      if (schemaType === 'node') {
-          return isNodeActive(state, name, attributes);
-      }
-      if (schemaType === 'mark') {
-          return isMarkActive(state, name, attributes);
-      }
-      return false;
-  }
-
-  function removeElement(element) {
-      if (element && element.parentNode) {
-          element.parentNode.removeChild(element);
-      }
-  }
-
-  function elementFromString(value) {
-      const htmlString = `<div>${value}</div>`;
-      const parser = new window.DOMParser();
-      const element = parser.parseFromString(htmlString, 'text/html').body;
-      return element;
-  }
-
-  function createNodeFromContent(content, schema, options) {
-      options = {
-          slice: true,
-          parseOptions: {},
-          ...options,
-      };
-      if (content && typeof content === 'object') {
-          try {
-              return schema.nodeFromJSON(content);
-          }
-          catch (error) {
-              console.warn('[tiptap warn]: Invalid content.', 'Passed value:', content, 'Error:', error);
-              return createNodeFromContent('', schema, options);
-          }
-      }
-      if (typeof content === 'string') {
-          const isHTML = content.trim().startsWith('<') && content.trim().endsWith('>');
-          if (isHTML || !options.slice) {
-              const parser = prosemirrorModel.DOMParser.fromSchema(schema);
-              return options.slice
-                  ? parser.parseSlice(elementFromString(content), options.parseOptions).content
-                  : parser.parse(elementFromString(content), options.parseOptions);
-          }
-          return content;
-      }
-      return createNodeFromContent('', schema, options);
-  }
-
-  function createDocument(content, schema, parseOptions = {}) {
-      return createNodeFromContent(content, schema, { slice: false, parseOptions });
-  }
-
-  function getHTMLFromFragment(doc, schema) {
-      const fragment = prosemirrorModel.DOMSerializer
-          .fromSchema(schema)
-          .serializeFragment(doc.content);
-      const temporaryDocument = document.implementation.createHTMLDocument();
-      const container = temporaryDocument.createElement('div');
-      container.appendChild(fragment);
-      return container.innerHTML;
-  }
-
-  function isNodeEmpty(node) {
-      var _a;
-      const defaultContent = (_a = node.type.createAndFill()) === null || _a === void 0 ? void 0 : _a.toJSON();
-      const content = node.toJSON();
-      return JSON.stringify(defaultContent) === JSON.stringify(content);
-  }
-
-  function createStyleTag(style) {
-      const styleNode = document.createElement('style');
-      styleNode.innerHTML = style;
-      document.getElementsByTagName('head')[0].appendChild(styleNode);
-      return styleNode;
-  }
-
-  class CommandManager {
-      constructor(editor, commands) {
-          this.editor = editor;
-          this.commands = commands;
-      }
-      createCommands() {
-          const { commands, editor } = this;
-          const { state, view } = editor;
-          const { tr } = state;
-          const props = this.buildProps(tr);
-          return Object.fromEntries(Object
-              .entries(commands)
-              .map(([name, command]) => {
-              const method = (...args) => {
-                  const callback = command(...args)(props);
-                  if (!tr.getMeta('preventDispatch')) {
-                      view.dispatch(tr);
-                  }
-                  return callback;
-              };
-              return [name, method];
-          }));
-      }
-      createChain(startTr, shouldDispatch = true) {
-          const { commands, editor } = this;
-          const { state, view } = editor;
-          const callbacks = [];
-          const hasStartTransaction = !!startTr;
-          const tr = startTr || state.tr;
-          const run = () => {
-              if (!hasStartTransaction && shouldDispatch && !tr.getMeta('preventDispatch')) {
-                  view.dispatch(tr);
-              }
-              return () => callbacks.every(callback => callback === true);
-          };
-          const chain = {
-              ...Object.fromEntries(Object.entries(commands).map(([name, command]) => {
-                  const chainedCommand = (...args) => {
-                      const props = this.buildProps(tr, shouldDispatch);
-                      const callback = command(...args)(props);
-                      callbacks.push(callback);
-                      return chain;
-                  };
-                  return [name, chainedCommand];
-              })),
-              run,
-          };
-          return chain;
-      }
-      createCan(startTr) {
-          const { commands, editor } = this;
-          const { state } = editor;
-          const dispatch = undefined;
-          const tr = startTr || state.tr;
-          const props = this.buildProps(tr, dispatch);
-          const formattedCommands = Object.fromEntries(Object
-              .entries(commands)
-              .map(([name, command]) => {
-              return [name, (...args) => command(...args)({ ...props, dispatch })];
-          }));
-          return {
-              ...formattedCommands,
-              chain: () => this.createChain(tr, dispatch),
-          };
-      }
-      buildProps(tr, shouldDispatch = true) {
-          const { editor, commands } = this;
-          const { state, view } = editor;
-          if (state.storedMarks) {
-              tr.setStoredMarks(state.storedMarks);
-          }
-          const props = {
-              tr,
-              editor,
-              view,
-              state: this.chainableState(tr, state),
-              dispatch: shouldDispatch
-                  ? () => undefined
-                  : undefined,
-              chain: () => this.createChain(tr),
-              can: () => this.createCan(tr),
-              get commands() {
-                  return Object.fromEntries(Object
-                      .entries(commands)
-                      .map(([name, command]) => {
-                      return [name, (...args) => command(...args)(props)];
-                  }));
-              },
-          };
-          return props;
-      }
-      chainableState(tr, state) {
-          let { selection } = tr;
-          let { doc } = tr;
-          let { storedMarks } = tr;
-          return {
-              ...state,
-              schema: state.schema,
-              plugins: state.plugins,
-              apply: state.apply.bind(state),
-              applyTransaction: state.applyTransaction.bind(state),
-              reconfigure: state.reconfigure.bind(state),
-              toJSON: state.toJSON.bind(state),
-              get storedMarks() {
-                  return storedMarks;
-              },
-              get selection() {
-                  return selection;
-              },
-              get doc() {
-                  return doc;
-              },
-              get tr() {
-                  selection = tr.selection;
-                  doc = tr.doc;
-                  storedMarks = tr.storedMarks;
-                  return tr;
-              },
-          };
-      }
-  }
-
-  function splitExtensions(extensions) {
-      const baseExtensions = extensions.filter(extension => extension.type === 'extension');
-      const nodeExtensions = extensions.filter(extension => extension.type === 'node');
-      const markExtensions = extensions.filter(extension => extension.type === 'mark');
-      return {
-          baseExtensions,
-          nodeExtensions,
-          markExtensions,
-      };
-  }
-
-  /**
-   * Get a list of all extension attributes defined in `addAttribute` and `addGlobalAttribute`.
-   * @param extensions List of extensions
-   */
-  function getAttributesFromExtensions(extensions) {
-      const extensionAttributes = [];
-      const { nodeExtensions, markExtensions } = splitExtensions(extensions);
-      const nodeAndMarkExtensions = [...nodeExtensions, ...markExtensions];
-      const defaultAttribute = {
-          default: null,
-          rendered: true,
-          renderHTML: null,
-          parseHTML: null,
-          keepOnSplit: true,
-      };
-      extensions.forEach(extension => {
-          const context = {
-              options: extension.options,
-          };
-          if (!extension.config.addGlobalAttributes) {
-              return;
-          }
-          const globalAttributes = extension.config.addGlobalAttributes.bind(context)();
-          globalAttributes.forEach(globalAttribute => {
-              globalAttribute.types.forEach(type => {
-                  Object
-                      .entries(globalAttribute.attributes)
-                      .forEach(([name, attribute]) => {
-                      extensionAttributes.push({
-                          type,
-                          name,
-                          attribute: {
-                              ...defaultAttribute,
-                              ...attribute,
-                          },
-                      });
-                  });
-              });
-          });
-      });
-      nodeAndMarkExtensions.forEach(extension => {
-          const context = {
-              options: extension.options,
-          };
-          if (!extension.config.addAttributes) {
-              return;
-          }
-          const attributes = extension.config.addAttributes.bind(context)();
-          Object
-              .entries(attributes)
-              .forEach(([name, attribute]) => {
-              extensionAttributes.push({
-                  type: extension.config.name,
-                  name,
-                  attribute: {
-                      ...defaultAttribute,
-                      ...attribute,
-                  },
-              });
-          });
-      });
-      return extensionAttributes;
-  }
-
-  function mergeAttributes(...objects) {
-      return objects
-          .filter(item => !!item)
-          .reduce((items, item) => {
-          const mergedAttributes = { ...items };
-          Object.entries(item).forEach(([key, value]) => {
-              const exists = mergedAttributes[key];
-              if (!exists) {
-                  mergedAttributes[key] = value;
-                  return;
-              }
-              if (key === 'class') {
-                  mergedAttributes[key] = [mergedAttributes[key], value].join(' ');
-              }
-              else if (key === 'style') {
-                  mergedAttributes[key] = [mergedAttributes[key], value].join('; ');
-              }
-              else {
-                  mergedAttributes[key] = value;
-              }
-          });
-          return mergedAttributes;
-      }, {});
-  }
-
-  function getRenderedAttributes(nodeOrMark, extensionAttributes) {
-      return extensionAttributes
-          .filter(item => item.attribute.rendered)
-          .map(item => {
-          if (!item.attribute.renderHTML) {
-              return {
-                  [item.name]: nodeOrMark.attrs[item.name],
-              };
-          }
-          return item.attribute.renderHTML(nodeOrMark.attrs) || {};
-      })
-          .reduce((attributes, attribute) => {
-          return mergeAttributes(attributes, attribute);
-      }, {});
-  }
-
-  function isEmptyObject(object = {}) {
-      return Object.keys(object).length === 0 && object.constructor === Object;
-  }
-
-  function fromString(value) {
-      if (typeof value !== 'string') {
-          return value;
-      }
-      if (value.match(/^\d*(\.\d+)?$/)) {
-          return Number(value);
-      }
-      if (value === 'true') {
-          return true;
-      }
-      if (value === 'false') {
-          return false;
-      }
-      return value;
-  }
-
-  /**
-   * This function merges extension attributes into parserule attributes (`attrs` or `getAttrs`).
-   * Cancels when `getAttrs` returned `false`.
-   * @param parseRule ProseMirror ParseRule
-   * @param extensionAttributes List of attributes to inject
-   */
-  function injectExtensionAttributesToParseRule(parseRule, extensionAttributes) {
-      if (parseRule.style) {
-          return parseRule;
-      }
-      return {
-          ...parseRule,
-          getAttrs: node => {
-              const oldAttributes = parseRule.getAttrs
-                  ? parseRule.getAttrs(node)
-                  : parseRule.attrs;
-              if (oldAttributes === false) {
-                  return false;
-              }
-              const newAttributes = extensionAttributes
-                  .filter(item => item.attribute.rendered)
-                  .reduce((items, item) => {
-                  const attributes = item.attribute.parseHTML
-                      ? item.attribute.parseHTML(node) || {}
-                      : {
-                          [item.name]: fromString(node.getAttribute(item.name)),
-                      };
-                  const filteredAttributes = Object.fromEntries(Object.entries(attributes)
-                      .filter(([, value]) => value !== undefined && value !== null));
-                  return {
-                      ...items,
-                      ...filteredAttributes,
-                  };
-              }, {});
-              return { ...oldAttributes, ...newAttributes };
-          },
-      };
-  }
-
-  /**
-   * Optionally calls `value` as a function.
-   * Otherwise it is returned directly.
-   * @param value Function or any value.
-   * @param context Optional context to bind to function.
-   * @param props Optional props to pass to function.
-   */
-  function callOrReturn(value, context = undefined, ...props) {
-      if (typeof value === 'function') {
-          if (context) {
-              return value.bind(context)(...props);
-          }
-          return value(...props);
-      }
-      return value;
-  }
-
-  function cleanUpSchemaItem(data) {
-      return Object.fromEntries(Object.entries(data).filter(([key, value]) => {
-          if (key === 'attrs' && isEmptyObject(value)) {
-              return false;
-          }
-          return value !== null && value !== undefined;
-      }));
-  }
-  function getSchema(extensions) {
-      var _a;
-      const allAttributes = getAttributesFromExtensions(extensions);
-      const { nodeExtensions, markExtensions } = splitExtensions(extensions);
-      const topNode = (_a = nodeExtensions.find(extension => extension.config.topNode)) === null || _a === void 0 ? void 0 : _a.config.name;
-      const nodeSchemaExtenders = [];
-      const markSchemaExtenders = [];
-      extensions.forEach(extension => {
-          if (typeof extension.config.extendNodeSchema === 'function') {
-              nodeSchemaExtenders.push(extension.config.extendNodeSchema);
-          }
-          if (typeof extension.config.extendMarkSchema === 'function') {
-              markSchemaExtenders.push(extension.config.extendMarkSchema);
-          }
-      });
-      const nodes = Object.fromEntries(nodeExtensions.map(extension => {
-          var _a;
-          const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.config.name);
-          const context = { options: extension.options };
-          const extraNodeFields = nodeSchemaExtenders.reduce((fields, nodeSchemaExtender) => {
-              const extraFields = callOrReturn(nodeSchemaExtender, context, extension);
-              return {
-                  ...fields,
-                  ...extraFields,
-              };
-          }, {});
-          const schema = cleanUpSchemaItem({
-              ...extraNodeFields,
-              content: callOrReturn(extension.config.content, context),
-              marks: callOrReturn(extension.config.marks, context),
-              group: callOrReturn(extension.config.group, context),
-              inline: callOrReturn(extension.config.inline, context),
-              atom: callOrReturn(extension.config.atom, context),
-              selectable: callOrReturn(extension.config.selectable, context),
-              draggable: callOrReturn(extension.config.draggable, context),
-              code: callOrReturn(extension.config.code, context),
-              defining: callOrReturn(extension.config.defining, context),
-              isolating: callOrReturn(extension.config.isolating, context),
-              attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
-                  var _a;
-                  return [extensionAttribute.name, { default: (_a = extensionAttribute === null || extensionAttribute === void 0 ? void 0 : extensionAttribute.attribute) === null || _a === void 0 ? void 0 : _a.default }];
-              })),
-          });
-          if (extension.config.parseHTML) {
-              schema.parseDOM = (_a = extension.config.parseHTML
-                  .bind(context)()) === null || _a === void 0 ? void 0 : _a.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
-          }
-          if (extension.config.renderHTML) {
-              schema.toDOM = node => {
-                  var _a;
-                  return (_a = extension.config.renderHTML) === null || _a === void 0 ? void 0 : _a.bind(context)({
-                      node,
-                      HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
-                  });
-              };
-          }
-          return [extension.config.name, schema];
-      }));
-      const marks = Object.fromEntries(markExtensions.map(extension => {
-          var _a;
-          const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.config.name);
-          const context = { options: extension.options };
-          const extraMarkFields = markSchemaExtenders.reduce((fields, markSchemaExtender) => {
-              const extraFields = callOrReturn(markSchemaExtender, context, extension);
-              return {
-                  ...fields,
-                  ...extraFields,
-              };
-          }, {});
-          const schema = cleanUpSchemaItem({
-              ...extraMarkFields,
-              inclusive: callOrReturn(extension.config.inclusive, context),
-              excludes: callOrReturn(extension.config.excludes, context),
-              group: callOrReturn(extension.config.group, context),
-              spanning: callOrReturn(extension.config.spanning, context),
-              attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
-                  var _a;
-                  return [extensionAttribute.name, { default: (_a = extensionAttribute === null || extensionAttribute === void 0 ? void 0 : extensionAttribute.attribute) === null || _a === void 0 ? void 0 : _a.default }];
-              })),
-          });
-          if (extension.config.parseHTML) {
-              schema.parseDOM = (_a = extension.config.parseHTML
-                  .bind(context)()) === null || _a === void 0 ? void 0 : _a.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
-          }
-          if (extension.config.renderHTML) {
-              schema.toDOM = mark => {
-                  var _a;
-                  return (_a = extension.config.renderHTML) === null || _a === void 0 ? void 0 : _a.bind(context)({
-                      mark,
-                      HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
-                  });
-              };
-          }
-          return [extension.config.name, schema];
-      }));
-      return new prosemirrorModel.Schema({
-          topNode,
-          nodes,
-          marks,
-      });
-  }
-
-  function getSchemaTypeByName(name, schema) {
-      if (schema.nodes[name]) {
-          return schema.nodes[name];
-      }
-      if (schema.marks[name]) {
-          return schema.marks[name];
-      }
-      return null;
-  }
-
-  class ExtensionManager {
-      constructor(extensions, editor) {
-          this.splittableMarks = [];
-          this.editor = editor;
-          this.extensions = this.sort(extensions);
-          this.schema = getSchema(this.extensions);
-          this.extensions.forEach(extension => {
-              var _a;
-              const context = {
-                  options: extension.options,
-                  editor: this.editor,
-                  type: getSchemaTypeByName(extension.config.name, this.schema),
-              };
-              if (extension.type === 'mark') {
-                  const keepOnSplit = (_a = callOrReturn(extension.config.keepOnSplit, context)) !== null && _a !== void 0 ? _a : true;
-                  if (keepOnSplit) {
-                      this.splittableMarks.push(extension.config.name);
-                  }
-              }
-              if (typeof extension.config.onCreate === 'function') {
-                  this.editor.on('create', extension.config.onCreate.bind(context));
-              }
-              if (typeof extension.config.onUpdate === 'function') {
-                  this.editor.on('update', extension.config.onUpdate.bind(context));
-              }
-              if (typeof extension.config.onSelectionUpdate === 'function') {
-                  this.editor.on('selectionUpdate', extension.config.onSelectionUpdate.bind(context));
-              }
-              if (typeof extension.config.onViewUpdate === 'function') {
-                  this.editor.on('viewUpdate', extension.config.onViewUpdate.bind(context));
-              }
-              if (typeof extension.config.onTransaction === 'function') {
-                  this.editor.on('transaction', extension.config.onTransaction.bind(context));
-              }
-              if (typeof extension.config.onFocus === 'function') {
-                  this.editor.on('focus', extension.config.onFocus.bind(context));
-              }
-              if (typeof extension.config.onBlur === 'function') {
-                  this.editor.on('blur', extension.config.onBlur.bind(context));
-              }
-              if (typeof extension.config.onDestroy === 'function') {
-                  this.editor.on('destroy', extension.config.onDestroy.bind(context));
-              }
-          });
-      }
-      sort(extensions) {
-          const defaultPriority = 100;
-          return extensions.sort((a, b) => {
-              if ((a.config.priority || defaultPriority) > (b.config.priority || defaultPriority)) {
-                  return -1;
-              }
-              if ((a.config.priority || defaultPriority) < (b.config.priority || defaultPriority)) {
-                  return 1;
-              }
-              return 0;
-          });
-      }
-      get commands() {
-          return this.extensions.reduce((commands, extension) => {
-              const context = {
-                  options: extension.options,
-                  editor: this.editor,
-                  type: getSchemaTypeByName(extension.config.name, this.schema),
-              };
-              if (!extension.config.addCommands) {
-                  return commands;
-              }
-              return {
-                  ...commands,
-                  ...extension.config.addCommands.bind(context)(),
-              };
-          }, {});
-      }
-      get plugins() {
-          return [...this.extensions]
-              .reverse()
-              .map(extension => {
-              const context = {
-                  options: extension.options,
-                  editor: this.editor,
-                  type: getSchemaTypeByName(extension.config.name, this.schema),
-              };
-              const plugins = [];
-              if (extension.config.addKeyboardShortcuts) {
-                  const keyMapPlugin = prosemirrorKeymap.keymap(extension.config.addKeyboardShortcuts.bind(context)());
-                  plugins.push(keyMapPlugin);
-              }
-              if (this.editor.options.enableInputRules && extension.config.addInputRules) {
-                  const inputRules = extension.config.addInputRules.bind(context)();
-                  const inputRulePlugins = inputRules.length
-                      ? [prosemirrorInputrules.inputRules({ rules: inputRules })]
-                      : [];
-                  plugins.push(...inputRulePlugins);
-              }
-              if (this.editor.options.enablePasteRules && extension.config.addPasteRules) {
-                  const pasteRulePlugins = extension.config.addPasteRules.bind(context)();
-                  plugins.push(...pasteRulePlugins);
-              }
-              if (extension.config.addProseMirrorPlugins) {
-                  const proseMirrorPlugins = extension.config.addProseMirrorPlugins.bind(context)();
-                  plugins.push(...proseMirrorPlugins);
-              }
-              return plugins;
-          })
-              .flat();
-      }
-      get attributes() {
-          return getAttributesFromExtensions(this.extensions);
-      }
-      get nodeViews() {
-          const { editor } = this;
-          const { nodeExtensions } = splitExtensions(this.extensions);
-          return Object.fromEntries(nodeExtensions
-              .filter(extension => !!extension.config.addNodeView)
-              .map(extension => {
-              var _a;
-              const extensionAttributes = this.attributes.filter(attribute => attribute.type === extension.config.name);
-              const context = {
-                  options: extension.options,
-                  editor,
-                  type: getNodeType(extension.config.name, this.schema),
-              };
-              const renderer = (_a = extension.config.addNodeView) === null || _a === void 0 ? void 0 : _a.call(context);
-              const nodeview = (node, view, getPos, decorations) => {
-                  const HTMLAttributes = getRenderedAttributes(node, extensionAttributes);
-                  return renderer({
-                      editor,
-                      node,
-                      getPos,
-                      decorations,
-                      HTMLAttributes,
-                      extension,
-                  });
-              };
-              return [extension.config.name, nodeview];
-          }));
-      }
-      get textSerializers() {
-          const { editor } = this;
-          const { nodeExtensions } = splitExtensions(this.extensions);
-          return Object.fromEntries(nodeExtensions
-              .filter(extension => !!extension.config.renderText)
-              .map(extension => {
-              const context = {
-                  options: extension.options,
-                  editor,
-                  type: getNodeType(extension.config.name, this.schema),
-              };
-              const textSerializer = (props) => { var _a; return (_a = extension.config.renderText) === null || _a === void 0 ? void 0 : _a.call(context, props); };
-              return [extension.config.name, textSerializer];
-          }));
-      }
-  }
-
-  class EventEmitter {
-      constructor() {
-          this.callbacks = {};
-      }
-      on(event, fn) {
-          if (!this.callbacks[event]) {
-              this.callbacks[event] = [];
-          }
-          this.callbacks[event].push(fn);
-          return this;
-      }
-      emit(event, ...args) {
-          const callbacks = this.callbacks[event];
-          if (callbacks) {
-              callbacks.forEach(callback => callback.apply(this, args));
-          }
-          return this;
-      }
-      off(event, fn) {
-          const callbacks = this.callbacks[event];
-          if (callbacks) {
-              if (fn) {
-                  this.callbacks[event] = callbacks.filter(callback => callback !== fn);
-              }
-              else {
-                  delete this.callbacks[event];
-              }
-          }
-          return this;
-      }
-      removeAllListeners() {
-          this.callbacks = {};
-      }
-  }
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-
-  function __classPrivateFieldGet(receiver, state, kind, f) {
-      if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-      if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-      return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-  }
-
-  // see: https://github.com/mesqueeb/is-what/blob/88d6e4ca92fb2baab6003c54e02eedf4e729e5ab/src/index.ts
-  function getType(payload) {
-      return Object.prototype.toString.call(payload).slice(8, -1);
-  }
-  function isPlainObject(payload) {
-      if (getType(payload) !== 'Object')
-          return false;
-      return payload.constructor === Object && Object.getPrototypeOf(payload) === Object.prototype;
-  }
-
-  function mergeDeep(target, source) {
-      const output = { ...target };
-      if (isPlainObject(target) && isPlainObject(source)) {
-          Object.keys(source).forEach(key => {
-              if (isPlainObject(source[key])) {
-                  if (!(key in target)) {
-                      Object.assign(output, { [key]: source[key] });
-                  }
-                  else {
-                      output[key] = mergeDeep(target[key], source[key]);
-                  }
-              }
-              else {
-                  Object.assign(output, { [key]: source[key] });
-              }
-          });
-      }
-      return output;
-  }
-
-  var _configure$2;
-  class Extension {
-      constructor(config) {
-          this.type = 'extension';
-          this.config = {
-              name: 'extension',
-              priority: 100,
-              defaultOptions: {},
-          };
-          _configure$2.set(this, (options) => {
-              this.options = mergeDeep(this.config.defaultOptions, options);
-              return this;
-          });
-          this.config = {
-              ...this.config,
-              ...config,
-          };
-          this.options = this.config.defaultOptions;
-      }
-      static create(config) {
-          return new Extension(config);
-      }
-      configure(options = {}) {
-          var _a;
-          return __classPrivateFieldGet((_a = Extension
-              .create(this.config)), _configure$2).call(_a, options);
-      }
-      extend(extendedConfig) {
-          return new Extension({
-              ...this.config,
-              ...extendedConfig,
-          });
-      }
-  }
-  _configure$2 = new WeakMap();
-
-  const textBetween = (editor, from, to, blockSeparator, leafText) => {
-      let text = '';
-      let separated = true;
-      editor.state.doc.nodesBetween(from, to, (node, pos) => {
-          var _a;
-          const textSerializer = editor.extensionManager.textSerializers[node.type.name];
-          if (textSerializer) {
-              text += textSerializer({ node });
-              separated = !blockSeparator;
-          }
-          else if (node.isText) {
-              text += (_a = node === null || node === void 0 ? void 0 : node.text) === null || _a === void 0 ? void 0 : _a.slice(Math.max(from, pos) - pos, to - pos);
-              separated = !blockSeparator;
-          }
-          else if (node.isLeaf && leafText) {
-              text += leafText;
-              separated = !blockSeparator;
-          }
-          else if (!separated && node.isBlock) {
-              text += blockSeparator;
-              separated = true;
-          }
-      }, 0);
-      return text;
-  };
-  const ClipboardTextSerializer = Extension.create({
-      name: 'editable',
-      addProseMirrorPlugins() {
-          return [
-              new prosemirrorState.Plugin({
-                  key: new prosemirrorState.PluginKey('clipboardTextSerializer'),
-                  props: {
-                      clipboardTextSerializer: () => {
-                          const { editor } = this;
-                          const { from, to } = editor.state.selection;
-                          return textBetween(editor, from, to, '\n');
-                      },
-                  },
-              }),
-          ];
-      },
-  });
-
-  const blur = () => ({ view }) => {
-      const element = view.dom;
-      element.blur();
-      return true;
-  };
-
-  var blur$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    blur: blur
-  });
-
-  const clearContent = (emitUpdate = false) => ({ commands }) => {
-      return commands.setContent('', emitUpdate);
-  };
-
-  var clearContent$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    clearContent: clearContent
-  });
-
-  const clearNodes = () => ({ state, tr, dispatch }) => {
-      const { selection } = tr;
-      const { ranges } = selection;
-      ranges.forEach(range => {
-          state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-              if (!node.type.isText) {
-                  const fromPos = tr.doc.resolve(tr.mapping.map(pos + 1));
-                  const toPos = tr.doc.resolve(tr.mapping.map(pos + node.nodeSize - 1));
-                  const nodeRange = fromPos.blockRange(toPos);
-                  if (nodeRange) {
-                      const targetLiftDepth = prosemirrorTransform.liftTarget(nodeRange);
-                      if (node.type.isTextblock && dispatch) {
-                          tr.setNodeMarkup(nodeRange.start, state.doc.type.contentMatch.defaultType);
-                      }
-                      if ((targetLiftDepth || targetLiftDepth === 0) && dispatch) {
-                          tr.lift(nodeRange, targetLiftDepth);
-                      }
-                  }
-              }
-          });
-      });
-      return true;
-  };
-
-  var clearNodes$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    clearNodes: clearNodes
-  });
-
-  const command = fn => props => {
-      return fn(props);
-  };
-
-  var command$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    command: command
-  });
-
-  const createParagraphNear = () => ({ state, dispatch }) => {
-      return prosemirrorCommands.createParagraphNear(state, dispatch);
-  };
-
-  var createParagraphNear$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    createParagraphNear: createParagraphNear
-  });
-
-  const deleteRange = range => ({ tr, dispatch }) => {
-      const { from, to } = range;
-      if (dispatch) {
-          tr.delete(from, to);
-      }
-      return true;
-  };
-
-  var deleteRange$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    deleteRange: deleteRange
-  });
-
-  const deleteSelection = () => ({ state, dispatch }) => {
-      return prosemirrorCommands.deleteSelection(state, dispatch);
-  };
-
-  var deleteSelection$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    deleteSelection: deleteSelection
-  });
-
-  const enter = () => ({ commands }) => {
-      return commands.keyboardShortcut('Enter');
-  };
-
-  var enter$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    enter: enter
-  });
-
-  const exitCode = () => ({ state, dispatch }) => {
-      return prosemirrorCommands.exitCode(state, dispatch);
-  };
-
-  var exitCode$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    exitCode: exitCode
-  });
-
-  function getMarkRange($pos, type) {
-      if (!$pos || !type) {
-          return;
-      }
-      const start = $pos.parent.childAfter($pos.parentOffset);
-      if (!start.node) {
-          return;
-      }
-      const link = start.node.marks.find(mark => mark.type === type);
-      if (!link) {
-          return;
-      }
-      let startIndex = $pos.index();
-      let startPos = $pos.start() + start.offset;
-      let endIndex = startIndex + 1;
-      let endPos = startPos + start.node.nodeSize;
-      while (startIndex > 0 && link.isInSet($pos.parent.child(startIndex - 1).marks)) {
-          startIndex -= 1;
-          startPos -= $pos.parent.child(startIndex).nodeSize;
-      }
-      while (endIndex < $pos.parent.childCount && link.isInSet($pos.parent.child(endIndex).marks)) {
-          endPos += $pos.parent.child(endIndex).nodeSize;
-          endIndex += 1;
-      }
-      return {
-          from: startPos,
-          to: endPos,
-      };
-  }
-
-  const extendMarkRange = typeOrName => ({ tr, state, dispatch }) => {
-      const type = getMarkType(typeOrName, state.schema);
-      const { doc, selection } = tr;
-      const { $from, empty } = selection;
-      if (empty && dispatch) {
-          const range = getMarkRange($from, type);
-          if (range) {
-              const newSelection = prosemirrorState.TextSelection.create(doc, range.from, range.to);
-              tr.setSelection(newSelection);
-          }
-      }
-      return true;
-  };
-
-  var extendMarkRange$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    extendMarkRange: extendMarkRange
-  });
-
-  const first = commands => props => {
-      const items = typeof commands === 'function'
-          ? commands(props)
-          : commands;
-      for (let i = 0; i < items.length; i += 1) {
-          if (items[i](props)) {
-              return true;
-          }
-      }
-      return false;
-  };
-
-  var first$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    first: first
-  });
-
-  function minMax(value = 0, min = 0, max = 0) {
-      return Math.min(Math.max(value, min), max);
-  }
-
-  function isClass(item) {
-      var _a;
-      if (((_a = item.constructor) === null || _a === void 0 ? void 0 : _a.toString().substring(0, 5)) !== 'class') {
-          return false;
-      }
-      return true;
-  }
-
-  function isObject(item) {
-      return (item
-          && typeof item === 'object'
-          && !Array.isArray(item)
-          && !isClass(item));
-  }
-
-  function isTextSelection(value) {
-      return isObject(value) && value instanceof prosemirrorState.TextSelection;
-  }
-
-  function resolveSelection(state, position = null) {
-      if (!position) {
-          return null;
-      }
-      if (position === 'start' || position === true) {
-          return {
-              from: 0,
-              to: 0,
-          };
-      }
-      if (position === 'end') {
-          const { size } = state.doc.content;
-          return {
-              from: size,
-              to: size,
-          };
-      }
-      return {
-          from: position,
-          to: position,
-      };
-  }
-  const focus = (position = null) => ({ editor, view, tr, dispatch, }) => {
-      if ((view.hasFocus() && position === null) || position === false) {
-          return true;
-      }
-      // we don’t try to resolve a NodeSelection or CellSelection
-      if (dispatch && position === null && !isTextSelection(editor.state.selection)) {
-          view.focus();
-          return true;
-      }
-      const { from, to } = resolveSelection(editor.state, position) || editor.state.selection;
-      const { doc, storedMarks } = tr;
-      const resolvedFrom = minMax(from, 0, doc.content.size);
-      const resolvedEnd = minMax(to, 0, doc.content.size);
-      const selection = prosemirrorState.TextSelection.create(doc, resolvedFrom, resolvedEnd);
-      const isSameSelection = editor.state.selection.eq(selection);
-      if (dispatch) {
-          tr.setSelection(selection);
-          // `tr.setSelection` resets the stored marks
-          // so we’ll restore them if the selection is the same as before
-          if (isSameSelection && storedMarks) {
-              tr.setStoredMarks(storedMarks);
-          }
-          view.focus();
-      }
-      return true;
-  };
-
-  var focus$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    focus: focus
-  });
-
-  // source: https://github.com/ProseMirror/prosemirror-state/blob/master/src/selection.js#L466
-  function selectionToInsertionEnd(tr, startLen, bias) {
-      const last = tr.steps.length - 1;
-      if (last < startLen) {
-          return;
-      }
-      const step = tr.steps[last];
-      if (!(step instanceof prosemirrorTransform.ReplaceStep || step instanceof prosemirrorTransform.ReplaceAroundStep)) {
-          return;
-      }
-      const map = tr.mapping.maps[last];
-      let end = 0;
-      map.forEach((_from, _to, _newFrom, newTo) => {
-          if (end === 0) {
-              end = newTo;
-          }
-      });
-      tr.setSelection(prosemirrorState.Selection.near(tr.doc.resolve(end), bias));
-  }
-
-  const insertContent = value => ({ tr, dispatch, editor }) => {
-      if (dispatch) {
-          const content = createNodeFromContent(value, editor.schema);
-          if (typeof content === 'string') {
-              tr.insertText(content);
-              return true;
-          }
-          if (!tr.selection.empty) {
-              tr.deleteSelection();
-          }
-          tr.insert(tr.selection.anchor, content);
-          selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
-      }
-      return true;
-  };
-
-  var insertContent$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    insertContent: insertContent
-  });
-
-  const insertHTML = value => ({ tr, state, dispatch }) => {
-      console.warn('[tiptap warn]: insertHTML() is deprecated. please use insertContent() instead.');
-      const { selection } = tr;
-      const element = elementFromString(value);
-      const slice = prosemirrorModel.DOMParser.fromSchema(state.schema).parseSlice(element);
-      if (dispatch) {
-          tr.insert(selection.anchor, slice.content);
-          selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
-      }
-      return true;
-  };
-
-  var insertHTML$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    insertHTML: insertHTML
-  });
-
-  const insertNode = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-      console.warn('[tiptap warn]: insertNode() is deprecated. please use insertContent() instead.');
-      const { selection } = tr;
-      const type = getNodeType(typeOrName, state.schema);
-      if (!type) {
-          return false;
-      }
-      const node = type.create(attributes);
-      if (dispatch) {
-          tr.insert(selection.anchor, node);
-      }
-      return true;
-  };
-
-  var insertNode$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    insertNode: insertNode
-  });
-
-  const insertText = value => ({ tr, dispatch }) => {
-      console.warn('[tiptap warn]: insertText() is deprecated. please use insertContent() instead.');
-      if (dispatch) {
-          tr.insertText(value);
-      }
-      return true;
-  };
-
-  var insertText$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    insertText: insertText
-  });
-
-  const joinBackward = () => ({ state, dispatch }) => {
-      return prosemirrorCommands.joinBackward(state, dispatch);
-  };
-
-  var joinBackward$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    joinBackward: joinBackward
-  });
-
-  const joinForward = () => ({ state, dispatch }) => {
-      return prosemirrorCommands.joinForward(state, dispatch);
-  };
-
-  var joinForward$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    joinForward: joinForward
-  });
-
-  const mac = typeof navigator !== 'undefined' ? /Mac/.test(navigator.platform) : false;
-  function normalizeKeyName(name) {
-      const parts = name.split(/-(?!$)/);
-      let result = parts[parts.length - 1];
-      if (result === 'Space') {
-          result = ' ';
-      }
-      let alt;
-      let ctrl;
-      let shift;
-      let meta;
-      for (let i = 0; i < parts.length - 1; i += 1) {
-          const mod = parts[i];
-          if (/^(cmd|meta|m)$/i.test(mod)) {
-              meta = true;
-          }
-          else if (/^a(lt)?$/i.test(mod)) {
-              alt = true;
-          }
-          else if (/^(c|ctrl|control)$/i.test(mod)) {
-              ctrl = true;
-          }
-          else if (/^s(hift)?$/i.test(mod)) {
-              shift = true;
-          }
-          else if (/^mod$/i.test(mod)) {
-              if (mac) {
-                  meta = true;
-              }
-              else {
-                  ctrl = true;
-              }
-          }
-          else {
-              throw new Error(`Unrecognized modifier name: ${mod}`);
-          }
-      }
-      if (alt) {
-          result = `Alt-${result}`;
-      }
-      if (ctrl) {
-          result = `Ctrl-${result}`;
-      }
-      if (meta) {
-          result = `Meta-${result}`;
-      }
-      if (shift) {
-          result = `Shift-${result}`;
-      }
-      return result;
-  }
-  const keyboardShortcut = name => ({ editor, view, tr, dispatch, }) => {
-      const keys = normalizeKeyName(name).split(/-(?!$)/);
-      const key = keys.find(item => !['Alt', 'Ctrl', 'Meta', 'Shift'].includes(item));
-      const event = new KeyboardEvent('keydown', {
-          key: key === 'Space'
-              ? ' '
-              : key,
-          altKey: keys.includes('Alt'),
-          ctrlKey: keys.includes('Ctrl'),
-          metaKey: keys.includes('Meta'),
-          shiftKey: keys.includes('Shift'),
-          bubbles: true,
-          cancelable: true,
-      });
-      const capturedTransaction = editor.captureTransaction(() => {
-          view.someProp('handleKeyDown', f => f(view, event));
-      });
-      capturedTransaction === null || capturedTransaction === void 0 ? void 0 : capturedTransaction.steps.forEach(step => {
-          const newStep = step.map(tr.mapping);
-          if (newStep && dispatch) {
-              tr.maybeStep(newStep);
-          }
-      });
-      return true;
-  };
-
-  var keyboardShortcut$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    keyboardShortcut: keyboardShortcut
-  });
-
-  const lift = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      const isActive = isNodeActive(state, type, attributes);
-      if (!isActive) {
-          return false;
-      }
-      return prosemirrorCommands.lift(state, dispatch);
-  };
-
-  var lift$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    lift: lift
-  });
-
-  const liftEmptyBlock = () => ({ state, dispatch }) => {
-      return prosemirrorCommands.liftEmptyBlock(state, dispatch);
-  };
-
-  var liftEmptyBlock$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    liftEmptyBlock: liftEmptyBlock
-  });
-
-  const liftListItem = typeOrName => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      return prosemirrorSchemaList.liftListItem(type)(state, dispatch);
-  };
-
-  var liftListItem$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    liftListItem: liftListItem
-  });
-
-  const newlineInCode = () => ({ state, dispatch }) => {
-      return prosemirrorCommands.newlineInCode(state, dispatch);
-  };
-
-  var newlineInCode$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    newlineInCode: newlineInCode
-  });
-
-  const replace = (typeOrName, attributes = {}) => ({ state, commands }) => {
-      const { from, to } = state.selection;
-      const range = { from, to };
-      return commands.replaceRange(range, typeOrName, attributes);
-  };
-
-  var replace$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    replace: replace
-  });
-
-  const replaceRange = (range, typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      const { from, to } = range;
-      const $from = tr.doc.resolve(from);
-      const index = $from.index();
-      if (!$from.parent.canReplaceWith(index, index, type)) {
-          return false;
-      }
-      if (dispatch) {
-          tr.replaceWith(from, to, type.create(attributes));
-      }
-      return true;
-  };
-
-  var replaceRange$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    replaceRange: replaceRange
-  });
-
-  /**
-   * Remove a property or an array of properties from an object
-   * @param obj Object
-   * @param key Key to remove
-   */
-  function deleteProps(obj, propOrProps) {
-      const props = typeof propOrProps === 'string'
-          ? [propOrProps]
-          : propOrProps;
-      return Object
-          .keys(obj)
-          .reduce((newObj, prop) => {
-          if (!props.includes(prop)) {
-              newObj[prop] = obj[prop];
-          }
-          return newObj;
-      }, {});
-  }
-
-  const resetNodeAttributes = (typeOrName, attributes) => ({ tr, state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      const { selection } = tr;
-      const { ranges } = selection;
-      ranges.forEach(range => {
-          state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-              if (node.type === type && dispatch) {
-                  tr.setNodeMarkup(pos, undefined, deleteProps(node.attrs, attributes));
-              }
-          });
-      });
-      return true;
-  };
-
-  var resetNodeAttributes$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    resetNodeAttributes: resetNodeAttributes
-  });
-
-  const scrollIntoView = () => ({ tr, dispatch }) => {
-      if (dispatch) {
-          tr.scrollIntoView();
-      }
-      return true;
-  };
-
-  var scrollIntoView$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    scrollIntoView: scrollIntoView
-  });
-
-  const selectAll = () => ({ state, dispatch }) => {
-      return prosemirrorCommands.selectAll(state, dispatch);
-  };
-
-  var selectAll$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    selectAll: selectAll
-  });
-
-  const selectNodeBackward = () => ({ state, dispatch }) => {
-      return prosemirrorCommands.selectNodeBackward(state, dispatch);
-  };
-
-  var selectNodeBackward$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    selectNodeBackward: selectNodeBackward
-  });
-
-  const selectNodeForward = () => ({ state, dispatch }) => {
-      return prosemirrorCommands.selectNodeForward(state, dispatch);
-  };
-
-  var selectNodeForward$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    selectNodeForward: selectNodeForward
-  });
-
-  const selectParentNode = () => ({ state, dispatch }) => {
-      return prosemirrorCommands.selectParentNode(state, dispatch);
-  };
-
-  var selectParentNode$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    selectParentNode: selectParentNode
-  });
-
-  const setContent = (content, emitUpdate = false, parseOptions = {}) => ({ tr, editor, dispatch }) => {
-      const { doc } = tr;
-      const document = createDocument(content, editor.schema, parseOptions);
-      const selection = prosemirrorState.TextSelection.create(doc, 0, doc.content.size);
-      if (dispatch) {
-          tr.setSelection(selection)
-              .replaceSelectionWith(document, false)
-              .setMeta('preventUpdate', !emitUpdate);
-      }
-      return true;
-  };
-
-  var setContent$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    setContent: setContent
-  });
-
-  const setMark = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-      const { selection } = tr;
-      const { empty, ranges } = selection;
-      const type = getMarkType(typeOrName, state.schema);
-      const oldAttributes = getMarkAttributes(state, type);
-      const newAttributes = {
-          ...oldAttributes,
-          ...attributes,
-      };
-      if (dispatch) {
-          if (empty) {
-              tr.addStoredMark(type.create(newAttributes));
-          }
-          else {
-              ranges.forEach(range => {
-                  tr.addMark(range.$from.pos, range.$to.pos, type.create(newAttributes));
-              });
-          }
-      }
-      return true;
-  };
-
-  var setMark$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    setMark: setMark
-  });
-
-  const setNode = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      return prosemirrorCommands.setBlockType(type, attributes)(state, dispatch);
-  };
-
-  var setNode$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    setNode: setNode
-  });
-
-  const sinkListItem = typeOrName => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      return prosemirrorSchemaList.sinkListItem(type)(state, dispatch);
-  };
-
-  var sinkListItem$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    sinkListItem: sinkListItem
-  });
-
-  function getSplittedAttributes(extensionAttributes, typeName, attributes) {
-      return Object.fromEntries(Object
-          .entries(attributes)
-          .filter(([name]) => {
-          const extensionAttribute = extensionAttributes.find(item => {
-              return item.type === typeName && item.name === name;
-          });
-          if (!extensionAttribute) {
-              return false;
-          }
-          return extensionAttribute.attribute.keepOnSplit;
-      }));
-  }
-
-  function defaultBlockAt(match) {
-      for (let i = 0; i < match.edgeCount; i + 1) {
-          const { type } = match.edge(i);
-          if (type.isTextblock && !type.hasRequiredAttrs()) {
-              return type;
-          }
-      }
-      return null;
-  }
-  function ensureMarks(state, splittableMarks) {
-      const marks = state.storedMarks
-          || (state.selection.$to.parentOffset && state.selection.$from.marks());
-      if (marks) {
-          const filteredMarks = marks.filter(mark => splittableMarks === null || splittableMarks === void 0 ? void 0 : splittableMarks.includes(mark.type.name));
-          state.tr.ensureMarks(filteredMarks);
-      }
-  }
-  const splitBlock = ({ keepMarks = true } = {}) => ({ tr, state, dispatch, editor, }) => {
-      const { selection, doc } = tr;
-      const { $from, $to } = selection;
-      const extensionAttributes = editor.extensionManager.attributes;
-      const newAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
-      if (selection instanceof prosemirrorState.NodeSelection && selection.node.isBlock) {
-          if (!$from.parentOffset || !prosemirrorTransform.canSplit(doc, $from.pos)) {
-              return false;
-          }
-          if (dispatch) {
-              if (keepMarks) {
-                  ensureMarks(state, editor.extensionManager.splittableMarks);
-              }
-              tr.split($from.pos).scrollIntoView();
-          }
-          return true;
-      }
-      if (!$from.parent.isBlock) {
-          return false;
-      }
-      if (dispatch) {
-          const atEnd = $to.parentOffset === $to.parent.content.size;
-          if (selection instanceof prosemirrorState.TextSelection) {
-              tr.deleteSelection();
-          }
-          const deflt = $from.depth === 0
-              ? undefined
-              : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));
-          let types = atEnd && deflt
-              ? [{
-                      type: deflt,
-                      attrs: newAttributes,
-                  }]
-              : undefined;
-          let can = prosemirrorTransform.canSplit(tr.doc, tr.mapping.map($from.pos), 1, types);
-          if (!types
-              && !can
-              && prosemirrorTransform.canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : undefined)) {
-              can = true;
-              types = deflt
-                  ? [{
-                          type: deflt,
-                          attrs: newAttributes,
-                      }]
-                  : undefined;
-          }
-          if (can) {
-              tr.split(tr.mapping.map($from.pos), 1, types);
-              if (!atEnd
-                  && !$from.parentOffset
-                  && $from.parent.type !== deflt
-                  && $from.node(-1).canReplace($from.index(-1), $from.indexAfter(-1), prosemirrorModel.Fragment.from(deflt === null || deflt === void 0 ? void 0 : deflt.create()))) {
-                  tr.setNodeMarkup(tr.mapping.map($from.before()), deflt || undefined);
-              }
-          }
-          if (keepMarks) {
-              ensureMarks(state, editor.extensionManager.splittableMarks);
-          }
-          tr.scrollIntoView();
-      }
-      return true;
-  };
-
-  var splitBlock$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    splitBlock: splitBlock
-  });
-
-  const splitListItem = typeOrName => ({ tr, state, dispatch, editor, }) => {
-      var _a;
-      const type = getNodeType(typeOrName, state.schema);
-      const { $from, $to } = state.selection;
-      // @ts-ignore
-      // eslint-disable-next-line
-      const node = state.selection.node;
-      if ((node && node.isBlock) || $from.depth < 2 || !$from.sameParent($to)) {
-          return false;
-      }
-      const grandParent = $from.node(-1);
-      if (grandParent.type !== type) {
-          return false;
-      }
-      const extensionAttributes = editor.extensionManager.attributes;
-      if ($from.parent.content.size === 0 && $from.node(-1).childCount === $from.indexAfter(-1)) {
-          // In an empty block. If this is a nested list, the wrapping
-          // list item should be split. Otherwise, bail out and let next
-          // command handle lifting.
-          if ($from.depth === 2
-              || $from.node(-3).type !== type
-              || $from.index(-2) !== $from.node(-2).childCount - 1) {
-              return false;
-          }
-          if (dispatch) {
-              let wrap = prosemirrorModel.Fragment.empty;
-              const keepItem = $from.index(-1) > 0;
-              // Build a fragment containing empty versions of the structure
-              // from the outer list item to the parent node of the cursor
-              for (let d = $from.depth - (keepItem ? 1 : 2); d >= $from.depth - 3; d -= 1) {
-                  wrap = prosemirrorModel.Fragment.from($from.node(d).copy(wrap));
-              }
-              // Add a second list item with an empty default start node
-              const newNextTypeAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
-              const nextType = ((_a = type.contentMatch.defaultType) === null || _a === void 0 ? void 0 : _a.createAndFill(newNextTypeAttributes)) || undefined;
-              wrap = wrap.append(prosemirrorModel.Fragment.from(type.createAndFill(null, nextType) || undefined));
-              tr
-                  .replace($from.before(keepItem ? undefined : -1), $from.after(-3), new prosemirrorModel.Slice(wrap, keepItem ? 3 : 2, 2))
-                  .setSelection(prosemirrorState.TextSelection.near(tr.doc.resolve($from.pos + (keepItem ? 3 : 2))))
-                  .scrollIntoView();
-          }
-          return true;
-      }
-      const nextType = $to.pos === $from.end()
-          ? grandParent.contentMatchAt(0).defaultType
-          : null;
-      const newTypeAttributes = getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs);
-      const newNextTypeAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
-      tr.delete($from.pos, $to.pos);
-      const types = nextType
-          ? [{ type, attrs: newTypeAttributes }, { type: nextType, attrs: newNextTypeAttributes }]
-          : [{ type, attrs: newTypeAttributes }];
-      if (!prosemirrorTransform.canSplit(tr.doc, $from.pos, 2)) {
-          return false;
-      }
-      if (dispatch) {
-          tr.split($from.pos, 2, types).scrollIntoView();
-      }
-      return true;
-  };
-
-  var splitListItem$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    splitListItem: splitListItem
-  });
-
-  function findParentNodeClosestToPos($pos, predicate) {
-      for (let i = $pos.depth; i > 0; i -= 1) {
-          const node = $pos.node(i);
-          if (predicate(node)) {
-              return {
-                  pos: i > 0 ? $pos.before(i) : 0,
-                  start: $pos.start(i),
-                  depth: i,
-                  node,
-              };
-          }
-      }
-  }
-
-  function findParentNode(predicate) {
-      return (selection) => findParentNodeClosestToPos(selection.$from, predicate);
-  }
-
-  function isList(name, extensions) {
-      const { nodeExtensions } = splitExtensions(extensions);
-      const extension = nodeExtensions.find(item => item.config.name === name);
-      if (!extension) {
-          return false;
-      }
-      const groups = callOrReturn(extension.config.group, { options: extension.options });
-      if (typeof groups !== 'string') {
-          return false;
-      }
-      return groups.split(' ').includes('list');
-  }
-
-  const toggleList = (listTypeOrName, itemTypeOrName) => ({ editor, tr, state, dispatch, chain, commands, can, }) => {
-      const { extensions } = editor.options;
-      const listType = getNodeType(listTypeOrName, state.schema);
-      const itemType = getNodeType(itemTypeOrName, state.schema);
-      const { selection } = state;
-      const { $from, $to } = selection;
-      const range = $from.blockRange($to);
-      if (!range) {
-          return false;
-      }
-      const parentList = findParentNode(node => isList(node.type.name, extensions))(selection);
-      if (range.depth >= 1 && parentList && range.depth - parentList.depth <= 1) {
-          // remove list
-          if (parentList.node.type === listType) {
-              return commands.liftListItem(itemType);
-          }
-          // change list type
-          if (isList(parentList.node.type.name, extensions)
-              && listType.validContent(parentList.node.content)
-              && dispatch) {
-              tr.setNodeMarkup(parentList.pos, listType);
-              return true;
-          }
-      }
-      const canWrapInList = can().wrapInList(listType);
-      // try to convert node to paragraph if needed
-      if (!canWrapInList) {
-          return chain()
-              .clearNodes()
-              .wrapInList(listType)
-              .run();
-      }
-      return commands.wrapInList(listType);
-  };
-
-  var toggleList$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    toggleList: toggleList
-  });
-
-  const toggleMark = (typeOrName, attributes = {}) => ({ state, commands }) => {
-      const type = getMarkType(typeOrName, state.schema);
-      const isActive = isMarkActive(state, type, attributes);
-      if (isActive) {
-          return commands.unsetMark(type);
-      }
-      return commands.setMark(type, attributes);
-  };
-
-  var toggleMark$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    toggleMark: toggleMark
-  });
-
-  const toggleNode = (typeOrName, toggleTypeOrName, attributes = {}) => ({ state, commands }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      const toggleType = getNodeType(toggleTypeOrName, state.schema);
-      const isActive = isNodeActive(state, type, attributes);
-      if (isActive) {
-          return commands.setNode(toggleType);
-      }
-      return commands.setNode(type, attributes);
-  };
-
-  var toggleNode$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    toggleNode: toggleNode
-  });
-
-  const toggleWrap = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      const isActive = isNodeActive(state, type, attributes);
-      if (isActive) {
-          return prosemirrorCommands.lift(state, dispatch);
-      }
-      return prosemirrorCommands.wrapIn(type, attributes)(state, dispatch);
-  };
-
-  var toggleWrap$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    toggleWrap: toggleWrap
-  });
-
-  const undoInputRule = () => ({ state, dispatch }) => {
-      return prosemirrorInputrules.undoInputRule(state, dispatch);
-  };
-
-  var undoInputRule$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    undoInputRule: undoInputRule
-  });
-
-  const unsetAllMarks = () => ({ tr, state, dispatch }) => {
-      const { selection } = tr;
-      const { empty, ranges } = selection;
-      if (empty) {
-          return true;
-      }
-      if (dispatch) {
-          Object
-              .entries(state.schema.marks)
-              .forEach(([, mark]) => {
-              ranges.forEach(range => {
-                  tr.removeMark(range.$from.pos, range.$to.pos, mark);
-              });
-          });
-      }
-      return true;
-  };
-
-  var unsetAllMarks$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    unsetAllMarks: unsetAllMarks
-  });
-
-  const unsetMark = typeOrName => ({ tr, state, dispatch }) => {
-      const { selection } = tr;
-      const type = getMarkType(typeOrName, state.schema);
-      const { $from, empty, ranges } = selection;
-      if (dispatch) {
-          if (empty) {
-              let { from, to } = selection;
-              const range = getMarkRange($from, type);
-              if (range) {
-                  from = range.from;
-                  to = range.to;
-              }
-              tr.removeMark(from, to, type);
-          }
-          else {
-              ranges.forEach(range => {
-                  tr.removeMark(range.$from.pos, range.$to.pos, type);
-              });
-          }
-          tr.removeStoredMark(type);
-      }
-      return true;
-  };
-
-  var unsetMark$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    unsetMark: unsetMark
-  });
-
-  const updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-      let nodeType = null;
-      let markType = null;
-      const schemaType = getSchemaTypeNameByName(typeof typeOrName === 'string'
-          ? typeOrName
-          : typeOrName.name, state.schema);
-      if (!schemaType) {
-          return false;
-      }
-      if (schemaType === 'node') {
-          nodeType = getNodeType(typeOrName, state.schema);
-      }
-      if (schemaType === 'mark') {
-          markType = getMarkType(typeOrName, state.schema);
-      }
-      if (dispatch) {
-          tr.selection.ranges.forEach(range => {
-              state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-                  if (nodeType && nodeType === node.type) {
-                      tr.setNodeMarkup(pos, undefined, {
-                          ...node.attrs,
-                          ...attributes,
-                      });
-                  }
-                  if (markType && node.marks.length) {
-                      node.marks.forEach(mark => {
-                          if (markType === mark.type) {
-                              tr.addMark(pos, pos + node.nodeSize, markType.create({
-                                  ...mark.attrs,
-                                  ...attributes,
-                              }));
-                          }
-                      });
-                  }
-              });
-          });
-      }
-      return true;
-  };
-
-  var updateAttributes$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    updateAttributes: updateAttributes
-  });
-
-  const updateNodeAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-      console.warn('[tiptap warn]: updateNodeAttributes() is deprecated. please use updateAttributes() instead.');
-      const type = getNodeType(typeOrName, state.schema);
-      const { selection } = tr;
-      const { ranges } = selection;
-      ranges.forEach(range => {
-          state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-              if (node.type === type && dispatch) {
-                  tr.setNodeMarkup(pos, undefined, {
-                      ...node.attrs,
-                      ...attributes,
-                  });
-              }
-          });
-      });
-      return true;
-  };
-
-  var updateNodeAttributes$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    updateNodeAttributes: updateNodeAttributes
-  });
-
-  const wrapIn = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      const isActive = isNodeActive(state, type, attributes);
-      if (isActive) {
-          return false;
-      }
-      return prosemirrorCommands.wrapIn(type, attributes)(state, dispatch);
-  };
-
-  var wrapIn$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    wrapIn: wrapIn
-  });
-
-  const wrapInList = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      return prosemirrorSchemaList.wrapInList(type, attributes)(state, dispatch);
-  };
-
-  var wrapInList$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    wrapInList: wrapInList
-  });
-
-  const Commands = Extension.create({
-      name: 'commands',
-      addCommands() {
-          return {
-              ...blur$1,
-              ...clearContent$1,
-              ...clearNodes$1,
-              ...command$1,
-              ...createParagraphNear$1,
-              ...deleteRange$1,
-              ...deleteSelection$1,
-              ...enter$1,
-              ...exitCode$1,
-              ...extendMarkRange$1,
-              ...first$1,
-              ...focus$1,
-              ...insertContent$1,
-              ...insertHTML$1,
-              ...insertNode$1,
-              ...insertText$1,
-              ...joinBackward$1,
-              ...joinForward$1,
-              ...keyboardShortcut$1,
-              ...lift$1,
-              ...liftEmptyBlock$1,
-              ...liftListItem$1,
-              ...newlineInCode$1,
-              ...replace$1,
-              ...replaceRange$1,
-              ...resetNodeAttributes$1,
-              ...scrollIntoView$1,
-              ...selectAll$1,
-              ...selectNodeBackward$1,
-              ...selectNodeForward$1,
-              ...selectParentNode$1,
-              ...setContent$1,
-              ...setMark$1,
-              ...setNode$1,
-              ...sinkListItem$1,
-              ...splitBlock$1,
-              ...splitListItem$1,
-              ...toggleList$1,
-              ...toggleMark$1,
-              ...toggleNode$1,
-              ...toggleWrap$1,
-              ...undoInputRule$1,
-              ...unsetAllMarks$1,
-              ...unsetMark$1,
-              ...updateAttributes$1,
-              ...updateNodeAttributes$1,
-              ...wrapIn$1,
-              ...wrapInList$1,
-          };
-      },
-  });
-
-  const Editable = Extension.create({
-      name: 'editable',
-      addProseMirrorPlugins() {
-          return [
-              new prosemirrorState.Plugin({
-                  key: new prosemirrorState.PluginKey('editable'),
-                  props: {
-                      editable: () => this.editor.options.editable,
-                  },
-              }),
-          ];
-      },
-  });
-
-  const FocusEvents = Extension.create({
-      name: 'focusEvents',
-      addProseMirrorPlugins() {
-          const { editor } = this;
-          return [
-              new prosemirrorState.Plugin({
-                  key: new prosemirrorState.PluginKey('focusEvents'),
-                  props: {
-                      attributes: {
-                          tabindex: '0',
-                      },
-                      handleDOMEvents: {
-                          focus: (view, event) => {
-                              editor.isFocused = true;
-                              const transaction = editor.state.tr
-                                  .setMeta('focus', { event })
-                                  .setMeta('addToHistory', false);
-                              view.dispatch(transaction);
-                              return false;
-                          },
-                          blur: (view, event) => {
-                              editor.isFocused = false;
-                              const transaction = editor.state.tr
-                                  .setMeta('blur', { event })
-                                  .setMeta('addToHistory', false);
-                              view.dispatch(transaction);
-                              return false;
-                          },
-                      },
-                  },
-              }),
-          ];
-      },
-  });
-
-  const Keymap = Extension.create({
-      name: 'keymap',
-      addKeyboardShortcuts() {
-          const handleBackspace = () => this.editor.commands.first(({ commands }) => [
-              () => commands.undoInputRule(),
-              () => commands.deleteSelection(),
-              () => commands.joinBackward(),
-              () => commands.selectNodeBackward(),
-          ]);
-          const handleDelete = () => this.editor.commands.first(({ commands }) => [
-              () => commands.deleteSelection(),
-              () => commands.joinForward(),
-              () => commands.selectNodeForward(),
-          ]);
-          return {
-              Enter: () => this.editor.commands.first(({ commands }) => [
-                  () => commands.newlineInCode(),
-                  () => commands.createParagraphNear(),
-                  () => commands.liftEmptyBlock(),
-                  () => commands.splitBlock(),
-              ]),
-              'Mod-Enter': () => this.editor.commands.exitCode(),
-              Backspace: () => handleBackspace(),
-              'Mod-Backspace': () => handleBackspace(),
-              Delete: () => handleDelete(),
-              'Mod-Delete': () => handleDelete(),
-              // we don’t need a custom `selectAll` for now
-              // 'Mod-a': () => this.editor.commands.selectAll(),
-          };
-      },
-  });
-
-  var extensions = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ClipboardTextSerializer: ClipboardTextSerializer,
-    Commands: Commands,
-    Editable: Editable,
-    FocusEvents: FocusEvents,
-    Keymap: Keymap
-  });
-
-  const style = `.ProseMirror {
-  position: relative;
-}
-
-.ProseMirror {
-  word-wrap: break-word;
-  white-space: pre-wrap;
-  -webkit-font-variant-ligatures: none;
-  font-variant-ligatures: none;
-}
-
-.ProseMirror [contenteditable="false"] {
-  white-space: normal;
-}
-
-.ProseMirror [contenteditable="false"] [contenteditable="true"] {
-  white-space: pre-wrap;
-}
-
-.ProseMirror pre {
-  white-space: pre-wrap;
-}
-
-.ProseMirror-gapcursor {
-  display: none;
-  pointer-events: none;
-  position: absolute;
-}
-
-.ProseMirror-gapcursor:after {
-  content: "";
-  display: block;
-  position: absolute;
-  top: -2px;
-  width: 20px;
-  border-top: 1px solid black;
-  animation: ProseMirror-cursor-blink 1.1s steps(2, start) infinite;
-}
-
-@keyframes ProseMirror-cursor-blink {
-  to {
-    visibility: hidden;
-  }
-}
-
-.ProseMirror-hideselection *::selection {
-  background: transparent;
-}
-
-.ProseMirror-hideselection *::-moz-selection {
-  background: transparent;
-}
-
-.ProseMirror-hideselection * {
-  caret-color: transparent;
-}
-
-.ProseMirror-focused .ProseMirror-gapcursor {
-  display: block;
-}`;
-
-  class Editor extends EventEmitter {
-      constructor(options = {}) {
-          super();
-          this.isFocused = false;
-          this.options = {
-              element: document.createElement('div'),
-              content: '',
-              injectCSS: true,
-              extensions: [],
-              autofocus: false,
-              editable: true,
-              editorProps: {},
-              parseOptions: {},
-              enableInputRules: true,
-              enablePasteRules: true,
-              onCreate: () => null,
-              onUpdate: () => null,
-              onSelectionUpdate: () => null,
-              onViewUpdate: () => null,
-              onTransaction: () => null,
-              onFocus: () => null,
-              onBlur: () => null,
-              onResize: () => null,
-              onDestroy: () => null,
-          };
-          this.isCapturingTransaction = false;
-          this.capturedTransaction = null;
-          this.setOptions(options);
-          this.createExtensionManager();
-          this.createCommandManager();
-          this.createSchema();
-          this.createView();
-          this.injectCSS();
-          this.on('create', this.options.onCreate);
-          this.on('update', this.options.onUpdate);
-          this.on('selectionUpdate', this.options.onSelectionUpdate);
-          this.on('viewUpdate', this.options.onViewUpdate);
-          this.on('transaction', this.options.onTransaction);
-          this.on('focus', this.options.onFocus);
-          this.on('blur', this.options.onBlur);
-          this.on('destroy', this.options.onDestroy);
-          window.setTimeout(() => {
-              this.commands.focus(this.options.autofocus);
-              this.emit('create', { editor: this });
-              if (window.ResizeObserver) {
-                  this.resizeObserver = new ResizeObserver(() => {
-                      this.emit('resize', { editor: this });
-                  });
-                  this.resizeObserver.observe(this.view.dom);
-              }
-          }, 0);
-      }
-      /**
-       * An object of all registered commands.
-       */
-      get commands() {
-          return this.commandManager.createCommands();
-      }
-      /**
-       * Create a command chain to call multiple commands at once.
-       */
-      chain() {
-          return this.commandManager.createChain();
-      }
-      /**
-       * Check if a command or a command chain can be executed. Without executing it.
-       */
-      can() {
-          return this.commandManager.createCan();
-      }
-      /**
-       * Inject CSS styles.
-       */
-      injectCSS() {
-          if (this.options.injectCSS && document) {
-              this.css = createStyleTag(style);
-          }
-      }
-      /**
-       * Update editor options.
-       *
-       * @param options A list of options
-       */
-      setOptions(options = {}) {
-          this.options = { ...this.options, ...options };
-      }
-      /**
-       * Update editable state of the editor.
-       */
-      setEditable(editable) {
-          this.setOptions({ editable });
-          if (this.view && this.state && !this.isDestroyed) {
-              this.view.updateState(this.state);
-          }
-      }
-      /**
-       * Returns whether the editor is editable.
-       */
-      get isEditable() {
-          return this.view && this.view.editable;
-      }
-      /**
-       * Returns the editor state.
-       */
-      get state() {
-          return this.view.state;
-      }
-      /**
-       * Register a ProseMirror plugin.
-       *
-       * @param plugin A ProseMirror plugin
-       * @param handlePlugins Control how to merge the plugin into the existing plugins.
-       */
-      registerPlugin(plugin, handlePlugins) {
-          const plugins = typeof handlePlugins === 'function'
-              ? handlePlugins(plugin, this.state.plugins)
-              : [...this.state.plugins, plugin];
-          const state = this.state.reconfigure({ plugins });
-          this.view.updateState(state);
-      }
-      /**
-       * Unregister a ProseMirror plugin.
-       *
-       * @param name The plugins name
-       */
-      unregisterPlugin(nameOrPluginKey) {
-          if (this.isDestroyed) {
-              return;
-          }
-          const name = typeof nameOrPluginKey === 'string'
-              ? `${nameOrPluginKey}$`
-              // @ts-ignore
-              : nameOrPluginKey.key;
-          const state = this.state.reconfigure({
-              // @ts-ignore
-              plugins: this.state.plugins.filter(plugin => !plugin.key.startsWith(name)),
-          });
-          this.view.updateState(state);
-      }
-      /**
-       * Creates an extension manager.
-       */
-      createExtensionManager() {
-          const coreExtensions = Object.entries(extensions).map(([, extension]) => extension);
-          const allExtensions = [...coreExtensions, ...this.options.extensions].filter(extension => {
-              return ['extension', 'node', 'mark'].includes(extension === null || extension === void 0 ? void 0 : extension.type);
-          });
-          this.extensionManager = new ExtensionManager(allExtensions, this);
-      }
-      /**
-       * Creates an command manager.
-       */
-      createCommandManager() {
-          this.commandManager = new CommandManager(this, this.extensionManager.commands);
-      }
-      /**
-       * Creates a ProseMirror schema.
-       */
-      createSchema() {
-          this.schema = this.extensionManager.schema;
-      }
-      /**
-       * Creates a ProseMirror view.
-       */
-      createView() {
-          this.view = new prosemirrorView.EditorView(this.options.element, {
-              ...this.options.editorProps,
-              dispatchTransaction: this.dispatchTransaction.bind(this),
-              state: prosemirrorState.EditorState.create({
-                  doc: createDocument(this.options.content, this.schema, this.options.parseOptions),
-              }),
-          });
-          // `editor.view` is not yet available at this time.
-          // Therefore we will add all plugins and node views directly afterwards.
-          const newState = this.state.reconfigure({
-              plugins: [
-                  new prosemirrorState.Plugin({
-                      view: () => ({
-                          update: () => this.emit('viewUpdate', {
-                              editor: this,
-                          }),
-                      }),
-                  }),
-                  ...this.extensionManager.plugins,
-              ],
-          });
-          this.view.updateState(newState);
-          this.createNodeViews();
-          // Let’s store the editor instance in the DOM element.
-          // So we’ll have access to it for tests.
-          const dom = this.view.dom;
-          dom.editor = this;
-      }
-      /**
-       * Creates all node views.
-       */
-      createNodeViews() {
-          this.view.setProps({
-              nodeViews: this.extensionManager.nodeViews,
-          });
-      }
-      captureTransaction(fn) {
-          this.isCapturingTransaction = true;
-          fn();
-          this.isCapturingTransaction = false;
-          const tr = this.capturedTransaction;
-          this.capturedTransaction = null;
-          return tr;
-      }
-      /**
-       * The callback over which to send transactions (state updates) produced by the view.
-       *
-       * @param transaction An editor state transaction
-       */
-      dispatchTransaction(transaction) {
-          if (transaction.docChanged && !this.isEditable) {
-              return;
-          }
-          if (this.isCapturingTransaction) {
-              if (!this.capturedTransaction) {
-                  this.capturedTransaction = transaction;
-                  return;
-              }
-              transaction.steps.forEach(step => { var _a; return (_a = this.capturedTransaction) === null || _a === void 0 ? void 0 : _a.step(step); });
-              return;
-          }
-          const state = this.state.apply(transaction);
-          const selectionHasChanged = !this.state.selection.eq(state.selection);
-          this.view.updateState(state);
-          this.emit('transaction', {
-              editor: this,
-              transaction,
-          });
-          if (selectionHasChanged) {
-              this.emit('selectionUpdate', {
-                  editor: this,
-              });
-          }
-          const focus = transaction.getMeta('focus');
-          const blur = transaction.getMeta('blur');
-          if (focus) {
-              this.emit('focus', {
-                  editor: this,
-                  event: focus.event,
-              });
-          }
-          if (blur) {
-              this.emit('blur', {
-                  editor: this,
-                  event: blur.event,
-              });
-          }
-          if (!transaction.docChanged || transaction.getMeta('preventUpdate')) {
-              return;
-          }
-          this.emit('update', {
-              editor: this,
-              transaction,
-          });
-      }
-      /**
-       * Get attributes of the currently selected node.
-       *
-       * @param name Name of the node
-       */
-      getNodeAttributes(name) {
-          return getNodeAttributes(this.state, name);
-      }
-      /**
-       * Get attributes of the currently selected mark.
-       *
-       * @param name Name of the mark
-       */
-      getMarkAttributes(name) {
-          return getMarkAttributes(this.state, name);
-      }
-      isActive(nameOrAttributes, attributesOrUndefined) {
-          const name = typeof nameOrAttributes === 'string'
-              ? nameOrAttributes
-              : null;
-          const attributes = typeof nameOrAttributes === 'string'
-              ? attributesOrUndefined
-              : nameOrAttributes;
-          return isActive(this.state, name, attributes);
-      }
-      /**
-       * Get the document as JSON.
-       */
-      getJSON() {
-          return this.state.doc.toJSON();
-      }
-      /**
-       * Get the document as HTML.
-       */
-      getHTML() {
-          return getHTMLFromFragment(this.state.doc, this.schema);
-      }
-      /**
-       * Check if there is no content.
-       */
-      get isEmpty() {
-          return isNodeEmpty(this.state.doc);
-      }
-      /**
-       * Get the number of characters for the current document.
-       */
-      getCharacterCount() {
-          return this.state.doc.content.size - 2;
-      }
-      /**
-       * Destroy the editor.
-       */
-      destroy() {
-          var _a;
-          (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.unobserve(this.view.dom);
-          this.emit('destroy');
-          if (this.view) {
-              this.view.destroy();
-          }
-          this.removeAllListeners();
-          removeElement(this.css);
-      }
-      /**
-       * Check if the editor is already destroyed.
-       */
-      get isDestroyed() {
-          var _a;
-          // @ts-ignore
-          return !((_a = this.view) === null || _a === void 0 ? void 0 : _a.docView);
-      }
-  }
-
-  var _configure$1;
-  class Node {
-      constructor(config) {
-          this.type = 'node';
-          this.config = {
-              name: 'node',
-              priority: 100,
-              defaultOptions: {},
-          };
-          _configure$1.set(this, (options) => {
-              this.options = mergeDeep(this.config.defaultOptions, options);
-              return this;
-          });
-          this.config = {
-              ...this.config,
-              ...config,
-          };
-          this.options = this.config.defaultOptions;
-      }
-      static create(config) {
-          return new Node(config);
-      }
-      configure(options = {}) {
-          var _a;
-          return __classPrivateFieldGet((_a = Node
-              .create(this.config)), _configure$1).call(_a, options);
-      }
-      extend(extendedConfig) {
-          return new Node({
-              ...this.config,
-              ...extendedConfig,
-          });
-      }
-  }
-  _configure$1 = new WeakMap();
-
-  var _configure;
-  class Mark {
-      constructor(config) {
-          this.type = 'mark';
-          this.config = {
-              name: 'mark',
-              priority: 100,
-              defaultOptions: {},
-          };
-          _configure.set(this, (options) => {
-              this.options = mergeDeep(this.config.defaultOptions, options);
-              return this;
-          });
-          this.config = {
-              ...this.config,
-              ...config,
-          };
-          this.options = this.config.defaultOptions;
-      }
-      static create(config) {
-          return new Mark(config);
-      }
-      configure(options = {}) {
-          var _a;
-          return __classPrivateFieldGet((_a = Mark
-              .create(this.config)), _configure).call(_a, options);
-      }
-      extend(extendedConfig) {
-          return new Mark({
-              ...this.config,
-              ...extendedConfig,
-          });
-      }
-  }
-  _configure = new WeakMap();
-
-  class NodeView {
-      constructor(component, props, options) {
-          this.isDragging = false;
-          this.options = {
-              stopEvent: null,
-              update: null,
-          };
-          this.component = component;
-          this.options = { ...this.options, ...options };
-          this.editor = props.editor;
-          this.extension = props.extension;
-          this.node = props.node;
-          this.decorations = props.decorations;
-          this.getPos = props.getPos;
-          this.mount();
-      }
-      mount() {
-          // eslint-disable-next-line
-          return;
-      }
-      get dom() {
-          return null;
-      }
-      get contentDOM() {
-          return null;
-      }
-      onDragStart(event) {
-          var _a, _b;
-          if (!this.dom) {
-              return;
-          }
-          const { view } = this.editor;
-          const target = event.target;
-          if ((_a = this.contentDOM) === null || _a === void 0 ? void 0 : _a.contains(target)) {
-              return;
-          }
-          // sometimes `event.target` is not the `dom` element
-          (_b = event.dataTransfer) === null || _b === void 0 ? void 0 : _b.setDragImage(this.dom, 0, 0);
-          const selection = prosemirrorState.NodeSelection.create(view.state.doc, this.getPos());
-          const transaction = view.state.tr.setSelection(selection);
-          view.dispatch(transaction);
-      }
-      stopEvent(event) {
-          var _a;
-          if (!this.dom) {
-              return false;
-          }
-          if (typeof this.options.stopEvent === 'function') {
-              return this.options.stopEvent(event);
-          }
-          const target = event.target;
-          const isInElement = this.dom.contains(target) && !((_a = this.contentDOM) === null || _a === void 0 ? void 0 : _a.contains(target));
-          // any event from child nodes should be handled by ProseMirror
-          if (!isInElement) {
-              return false;
-          }
-          const isInput = ['INPUT', 'BUTTON', 'SELECT', 'TEXTAREA'].includes(target.tagName)
-              || target.isContentEditable;
-          // any input event within node views should be ignored by ProseMirror
-          if (isInput) {
-              return true;
-          }
-          const { isEditable } = this.editor;
-          const { isDragging } = this;
-          const isDraggable = !!this.node.type.spec.draggable;
-          const isSelectable = prosemirrorState.NodeSelection.isSelectable(this.node);
-          const isCopyEvent = event.type === 'copy';
-          const isPasteEvent = event.type === 'paste';
-          const isCutEvent = event.type === 'cut';
-          const isClickEvent = event.type === 'mousedown';
-          const isDragEvent = event.type.startsWith('drag') || event.type === 'drop';
-          // ProseMirror tries to drag selectable nodes
-          // even if `draggable` is set to `false`
-          // this fix prevents that
-          if (!isDraggable && isSelectable && isDragEvent) {
-              event.preventDefault();
-          }
-          if (isDraggable && isDragEvent && !isDragging) {
-              event.preventDefault();
-              return false;
-          }
-          // we have to store that dragging started
-          if (isDraggable && isEditable && !isDragging && isClickEvent) {
-              const dragHandle = target.closest('[data-drag-handle]');
-              const isValidDragHandle = dragHandle
-                  && (this.dom === dragHandle || (this.dom.contains(dragHandle)));
-              if (isValidDragHandle) {
-                  this.isDragging = true;
-                  document.addEventListener('dragend', () => {
-                      this.isDragging = false;
-                  }, { once: true });
-                  document.addEventListener('mouseup', () => {
-                      this.isDragging = false;
-                  }, { once: true });
-              }
-          }
-          // these events are handled by prosemirror
-          if (isDragging
-              || isCopyEvent
-              || isPasteEvent
-              || isCutEvent
-              || (isClickEvent && isSelectable)) {
-              return false;
-          }
-          return true;
-      }
-      ignoreMutation(mutation) {
-          if (mutation.type === 'selection') {
-              if (this.node.isLeaf) {
-                  return true;
-              }
-              return false;
-          }
-          if (!this.contentDOM) {
-              return true;
-          }
-          const contentDOMHasChanged = !this.contentDOM.contains(mutation.target)
-              || this.contentDOM === mutation.target;
-          return contentDOMHasChanged;
-      }
-      updateAttributes(attributes) {
-          if (!this.editor.view.editable) {
-              return;
-          }
-          const { state } = this.editor.view;
-          const pos = this.getPos();
-          const transaction = state.tr.setNodeMarkup(pos, undefined, {
-              ...this.node.attrs,
-              ...attributes,
-          });
-          this.editor.view.dispatch(transaction);
-      }
-  }
-
-  function nodeInputRule (regexp, type, getAttributes) {
-      return new prosemirrorInputrules.InputRule(regexp, (state, match, start, end) => {
-          const attributes = getAttributes instanceof Function
-              ? getAttributes(match)
-              : getAttributes;
-          const { tr } = state;
-          if (match[0]) {
-              tr.replaceWith(start - 1, end, type.create(attributes));
-          }
-          return tr;
-      });
-  }
-
-  function getMarksBetween(from, to, state) {
-      let marks = [];
-      state.doc.nodesBetween(from, to, (node, pos) => {
-          marks = [...marks, ...node.marks.map(mark => ({
-                  from: pos,
-                  to: pos + node.nodeSize,
-                  mark,
-              }))];
-      });
-      return marks;
-  }
-
-  function markInputRule (regexp, markType, getAttributes) {
-      return new prosemirrorInputrules.InputRule(regexp, (state, match, start, end) => {
-          const attributes = getAttributes instanceof Function
-              ? getAttributes(match)
-              : getAttributes;
-          const { tr } = state;
-          const captureGroup = match[match.length - 1];
-          const fullMatch = match[0];
-          let markEnd = end;
-          if (captureGroup) {
-              const startSpaces = fullMatch.search(/\S/);
-              const textStart = start + fullMatch.indexOf(captureGroup);
-              const textEnd = textStart + captureGroup.length;
-              const excludedMarks = getMarksBetween(start, end, state)
-                  .filter(item => {
-                  // TODO: PR to add excluded to MarkType
-                  // @ts-ignore
-                  const { excluded } = item.mark.type;
-                  return excluded.find((type) => type.name === markType.name);
-              })
-                  .filter(item => item.to > textStart);
-              if (excludedMarks.length) {
-                  return null;
-              }
-              if (textEnd < end) {
-                  tr.delete(textEnd, end);
-              }
-              if (textStart > start) {
-                  tr.delete(start + startSpaces, textStart);
-              }
-              markEnd = start + startSpaces + captureGroup.length;
-              tr.addMark(start + startSpaces, markEnd, markType.create(attributes));
-              tr.removeStoredMark(markType);
-          }
-          return tr;
-      });
-  }
-
-  function markPasteRule (regexp, type, getAttrs) {
-      const handler = (fragment, parent) => {
-          const nodes = [];
-          fragment.forEach(child => {
-              if (child.isText && child.text) {
-                  const { text } = child;
-                  let pos = 0;
-                  let match;
-                  // eslint-disable-next-line
-                  while ((match = regexp.exec(text)) !== null) {
-                      const outerMatch = Math.max(match.length - 2, 0);
-                      const innerMatch = Math.max(match.length - 1, 0);
-                      if (parent === null || parent === void 0 ? void 0 : parent.type.allowsMarkType(type)) {
-                          const start = match.index;
-                          const matchStart = start + match[0].indexOf(match[outerMatch]);
-                          const matchEnd = matchStart + match[outerMatch].length;
-                          const textStart = matchStart + match[outerMatch].lastIndexOf(match[innerMatch]);
-                          const textEnd = textStart + match[innerMatch].length;
-                          const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
-                          // adding text before markdown to nodes
-                          if (matchStart > 0) {
-                              nodes.push(child.cut(pos, matchStart));
-                          }
-                          // adding the markdown part to nodes
-                          nodes.push(child
-                              .cut(textStart, textEnd)
-                              .mark(type.create(attrs).addToSet(child.marks)));
-                          pos = matchEnd;
-                      }
-                  }
-                  // adding rest of text to nodes
-                  if (pos < text.length) {
-                      nodes.push(child.cut(pos));
-                  }
-              }
-              else {
-                  nodes.push(child.copy(handler(child.content, child)));
-              }
-          });
-          return prosemirrorModel.Fragment.fromArray(nodes);
-      };
-      return new prosemirrorState.Plugin({
-          key: new prosemirrorState.PluginKey('markPasteRule'),
-          props: {
-              transformPasted: slice => {
-                  return new prosemirrorModel.Slice(handler(slice.content), slice.openStart, slice.openEnd);
-              },
-          },
-      });
-  }
-
-  function generateHTML(doc, extensions) {
-      const schema = getSchema(extensions);
-      const contentNode = prosemirrorModel.Node.fromJSON(schema, doc);
-      return getHTMLFromFragment(contentNode, schema);
-  }
-
-  function isNodeSelection(value) {
-      return isObject(value) && value instanceof prosemirrorState.NodeSelection;
-  }
-
-  exports.Editor = Editor;
-  exports.Extension = Extension;
-  exports.Mark = Mark;
-  exports.Node = Node;
-  exports.NodeView = NodeView;
-  exports.callOrReturn = callOrReturn;
-  exports.extensions = extensions;
-  exports.findParentNodeClosestToPos = findParentNodeClosestToPos;
-  exports.generateHTML = generateHTML;
-  exports.getHTMLFromFragment = getHTMLFromFragment;
-  exports.getMarkAttributes = getMarkAttributes;
-  exports.getSchema = getSchema;
-  exports.isActive = isActive;
-  exports.isMarkActive = isMarkActive;
-  exports.isNodeActive = isNodeActive;
-  exports.isNodeEmpty = isNodeEmpty;
-  exports.isNodeSelection = isNodeSelection;
-  exports.isTextSelection = isTextSelection;
-  exports.markInputRule = markInputRule;
-  exports.markPasteRule = markPasteRule;
-  exports.mergeAttributes = mergeAttributes;
-  exports.nodeInputRule = nodeInputRule;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
-
-})));
-//# sourceMappingURL=tiptap-core.umd.js.map