@harbour-enterprises/superdoc 0.8.10 → 0.8.12

package/dist/super-editor/chunks/{editor-nlt5JeOJ.js → editor-aREw3zbp.js}

@@ -12,9 +12,9 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
 var _events, _Attribute_static, getGlobalAttributes_fn, getNodeAndMarksAttributes_fn, _Schema_static, createNodesSchema_fn, createMarksSchema_fn, _ExtensionService_instances, setupExtensions_fn, attachEditorEvents_fn, _commandService, _css, _Editor_instances, init_fn, initRichText_fn, onFocus_fn, checkHeadless_fn, insertNewFileData_fn, registerPluginByNameIfNotExists_fn, createExtensionService_fn, createCommandService_fn, createConverter_fn, initMedia_fn, createSchema_fn, generatePmData_fn, createView_fn, onCollaborationReady_fn, initComments_fn, initPagination_fn, dispatchTransaction_fn, prepareDocumentForImport_fn, prepareDocumentForExport_fn, endCollaboration_fn, _FieldAnnotationView_instances, createAnnotation_fn;
 import * as Y from "yjs";
 import { UndoManager, Item as Item$1, ContentType, Text as Text$1, XmlElement } from "yjs";
-import { P as PluginKey, a as Plugin, M as Mapping, N as NodeSelection, S as Selection, T as TextSelection, b as Slice, D as DOMSerializer, F as Fragment, c as DOMParser$1, d as Mark$1, e as dropPoint, A as AllSelection, p as process$1, f as Schema$1, g as canSplit, l as liftTarget, h as canJoin, j as joinPoint, r as replaceStep$1, R as ReplaceAroundStep, o as objectIncludes, i as ReplaceStep, k as NodeRange, m as findWrapping, n as TrackDeleteMarkName, q as TrackInsertMarkName, v as v4, s as generateDocxRandomId, t as generateRandom32BitHex, u as TrackFormatMarkName, w as comments_module_events, x as AddMarkStep, y as RemoveMarkStep, z as twipsToLines, B as pixelsToTwips, C as SuperConverter, E as EditorState, G as toKebabCase, H as kebabCase, I as SelectionRange, J as Transform } from "./converter-B5SRaBp5.js";
+import { P as PluginKey, a as Plugin, M as Mapping, N as NodeSelection, S as Selection, T as TextSelection, b as Slice, D as DOMSerializer, F as Fragment, c as DOMParser$1, d as Mark$1, e as dropPoint, A as AllSelection, p as process$1, f as Schema$1, i as isRegExp, g as canSplit, l as liftTarget, h as canJoin, j as joinPoint, r as replaceStep$1, R as ReplaceAroundStep, o as objectIncludes, k as ReplaceStep, m as NodeRange, n as findWrapping, q as TrackDeleteMarkName, s as TrackInsertMarkName, v as v4, t as generateDocxRandomId, u as generateRandom32BitHex, w as TrackFormatMarkName, x as comments_module_events, y as AddMarkStep, z as RemoveMarkStep, B as twipsToLines, C as pixelsToTwips, E as SuperConverter, G as EditorState, H as toKebabCase, I as kebabCase, J as SelectionRange, K as Transform } from "./converter-vMwuPcFT.js";
 import { ref, computed, createElementBlock, openBlock, withModifiers, Fragment as Fragment$1, renderList, normalizeClass, createCommentVNode, toDisplayString, createElementVNode, createApp } from "vue";
-import { D as DocxZipper } from "./docx-zipper-fdMcchlI.js";
+import { D as DocxZipper } from "./docx-zipper-CNguQWs9.js";
 function getMarksFromSelection(state) {
   const { from: from2, to, empty: empty2 } = state.selection;
   const marks = [];
@@ -7961,206 +7961,15 @@ let Schema = _Schema;
 function getSchemaTypeByName(name, schema) {
   return schema.nodes[name] || schema.marks[name] || null;
 }
-const _ExtensionService = class _ExtensionService {
-  constructor(extensions, userExtensions, editor) {
-    __privateAdd(this, _ExtensionService_instances);
-    __publicField(this, "editor");
-    __publicField(this, "schema");
-    __publicField(this, "extensions");
-    __publicField(this, "externalExtensions", []);
-    __publicField(this, "splittableMarks", []);
-    this.editor = editor;
-    this.externalExtensions = userExtensions || [];
-    this.extensions = _ExtensionService.getResolvedExtensions([...extensions, ...this.externalExtensions]);
-    this.schema = Schema.createSchemaByExtensions(this.extensions, editor);
-    __privateMethod(this, _ExtensionService_instances, setupExtensions_fn).call(this);
-  }
-  /**
-   * Static method for creating ExtensionService.
-   * @param args Arguments for the constructor.
-   */
-  static create(...args) {
-    return new _ExtensionService(...args);
-  }
-  /**
-   * Get an array of resolved extensions (e.g. sorted by priority).
-   * @param extensions Array of extensions.
-   * @returns Array of resolved extensions.
-   */
-  static getResolvedExtensions(extensions) {
-    const resolvedExtensions = _ExtensionService.sortByPriority(extensions);
-    return resolvedExtensions;
-  }
-  /**
-   * Sort extensions by priority.
-   * @param extensions Array of extensions.
-   * @returns Array of sorted extensions by priority.
-   */
-  static sortByPriority(extensions) {
-    const defaultValue = 100;
-    return extensions.sort((a, b) => {
-      const priorityA = getExtensionConfigField(a, "priority") || defaultValue;
-      const priorityB = getExtensionConfigField(b, "priority") || defaultValue;
-      if (priorityA > priorityB) return -1;
-      if (priorityA < priorityB) return 1;
-      return 0;
-    });
-  }
-  /**
-   * Get all attributes defined in the extensions.
-   * @returns Array of attributes.
-   */
-  get attributes() {
-    return Attribute.getAttributesFromExtensions(this.extensions);
-  }
-  /**
-   * Get all commands defined in the extensions.
-   * @returns Object with commands (key - command name, value - function).
-   */
-  get commands() {
-    let commandsObject = {};
-    for (const extension of this.extensions) {
-      const context = {
-        name: extension.name,
-        options: extension.options,
-        storage: extension.storage,
-        editor: this.editor,
-        type: getSchemaTypeByName(extension.name, this.schema)
-      };
-      const addCommands = getExtensionConfigField(extension, "addCommands", context);
-      if (addCommands) {
-        commandsObject = {
-          ...commandsObject,
-          ...addCommands()
-        };
-      }
-    }
-    return commandsObject;
-  }
-  /**
-   * Get all PM plugins defined in the extensions.
-   * And also keyboard shortcuts.
-   * @returns Array of PM plugins.
-   */
-  get plugins() {
-    const editor = this.editor;
-    const extensions = _ExtensionService.sortByPriority([...this.extensions].reverse());
-    const allPlugins = extensions.map((extension) => {
-      const context = {
-        name: extension.name,
-        options: extension.options,
-        storage: extension.storage,
-        editor,
-        type: getSchemaTypeByName(extension.name, this.schema)
-      };
-      const plugins = [];
-      const addShortcuts = getExtensionConfigField(extension, "addShortcuts", context);
-      let bindingsObject = {};
-      if (addShortcuts) {
-        const entries = Object.entries(addShortcuts()).map(([shortcut, method]) => {
-          return [shortcut, (...args) => method({ editor, keymapArgs: args })];
-        });
-        bindingsObject = { ...Object.fromEntries(entries) };
-      }
-      plugins.push(keymap(bindingsObject));
-      const addPmPlugins = getExtensionConfigField(extension, "addPmPlugins", context);
-      if (addPmPlugins) {
-        const pmPlugins = addPmPlugins();
-        plugins.push(...pmPlugins);
-      }
-      return plugins;
-    }).flat();
-    return [...allPlugins];
-  }
-  /**
-   * Get all node views from the extensions.
-   * @returns An object with all node views.
-   */
-  get nodeViews() {
-    const { editor } = this;
-    const nodeExtensions = this.extensions.filter((e) => e.type === "node");
-    const entries = nodeExtensions.filter((extension) => !!getExtensionConfigField(extension, "addNodeView")).map((extension) => {
-      const extensionAttrs = this.attributes.filter((a) => a.type === extension.name);
-      const context = {
-        name: extension.name,
-        options: extension.options,
-        storage: extension.storage,
-        editor,
-        type: getNodeType(extension.name, this.schema)
-      };
-      const addNodeView = getExtensionConfigField(extension, "addNodeView", context);
-      if (!addNodeView) return [];
-      const nodeview = (node, _view, getPos, decorations) => {
-        const htmlAttributes = Attribute.getAttributesToRender(node, extensionAttrs);
-        return addNodeView()({
-          editor,
-          node,
-          getPos,
-          decorations,
-          htmlAttributes,
-          extension
-        });
-      };
-      return [extension.name, nodeview];
+function isExtensionRulesEnabled(extension, enabled) {
+  if (Array.isArray(enabled)) {
+    return enabled.some((enabledExtension) => {
+      const name = typeof enabledExtension === "string" ? enabledExtension : enabledExtension.name;
+      return name === extension.name;
     });
-    return Object.fromEntries(entries);
-  }
-};
-_ExtensionService_instances = new WeakSet();
-/**
- * Install all extensions.
- * Create extension storage in the editor, attach editor events.
- */
-setupExtensions_fn = function() {
-  for (const extension of this.extensions) {
-    this.editor.extensionStorage[extension.name] = extension.storage;
-    const context = {
-      name: extension.name,
-      options: extension.options,
-      storage: extension.storage,
-      editor: this.editor,
-      type: getSchemaTypeByName(extension.name, this.schema)
-    };
-    if (extension.type === "mark") {
-      const keepOnSplit = callOrGet(getExtensionConfigField(extension, "keepOnSplit", context)) ?? true;
-      if (keepOnSplit) {
-        this.splittableMarks.push(extension.name);
-      }
-    }
-    __privateMethod(this, _ExtensionService_instances, attachEditorEvents_fn).call(this, extension);
   }
-};
-/**
- * Attach editor events to extension
- * if callbacks are defined in the extension config.
- * @param extension Extension.
- */
-attachEditorEvents_fn = function(extension) {
-  const context = {
-    name: extension.name,
-    options: extension.options,
-    storage: extension.storage,
-    editor: this.editor,
-    type: getSchemaTypeByName(extension.name, this.schema)
-  };
-  const onBeforeCreate = getExtensionConfigField(extension, "onBeforeCreate", context);
-  const onCreate2 = getExtensionConfigField(extension, "onCreate", context);
-  const onUpdate = getExtensionConfigField(extension, "onUpdate", context);
-  const onSelectionUpdate = getExtensionConfigField(extension, "onSelectionUpdate", context);
-  const onTransaction = getExtensionConfigField(extension, "onTransaction", context);
-  const onFocus = getExtensionConfigField(extension, "onFocus", context);
-  const onBlur = getExtensionConfigField(extension, "onBlur", context);
-  const onDestroy2 = getExtensionConfigField(extension, "onDestroy", context);
-  if (onBeforeCreate) this.editor.on("beforeCreate", onBeforeCreate);
-  if (onCreate2) this.editor.on("create", onCreate2);
-  if (onUpdate) this.editor.on("update", onUpdate);
-  if (onSelectionUpdate) this.editor.on("selectionUpdate", onSelectionUpdate);
-  if (onTransaction) this.editor.on("transaction", onTransaction);
-  if (onFocus) this.editor.on("focus", onFocus);
-  if (onBlur) this.editor.on("blur", onBlur);
-  if (onDestroy2) this.editor.on("destroy", onDestroy2);
-};
-let ExtensionService = _ExtensionService;
+  return enabled;
+}
 function chainableEditorState(transaction, state) {
   let { selection, doc: doc2, storedMarks } = transaction;
   return {
@@ -8251,7 +8060,7 @@ class CommandService {
     const callbacks = [];
     const hasStartTr = !!startTr;
     const tr = startTr || state.tr;
-    const run = () => {
+    const run2 = () => {
       if (!hasStartTr && shouldDispatch && !tr.getMeta("preventDispatch")) {
         view.dispatch(tr);
       }
@@ -8268,7 +8077,7 @@ class CommandService {
     });
     const chain = {
       ...Object.fromEntries(entries),
-      run
+      run: run2
     };
     return chain;
   }
@@ -8316,9 +8125,404 @@ class CommandService {
         );
       }
     };
-    return props;
+    return props;
+  }
+}
+function getHTMLFromFragment(fragment, schema) {
+  const documentFragment = DOMSerializer.fromSchema(schema).serializeFragment(fragment);
+  const temporaryDocument = document.implementation.createHTMLDocument();
+  const container = temporaryDocument.createElement("div");
+  container.appendChild(documentFragment);
+  return container.innerHTML;
+}
+const getTextContentFromNodes = ($from, maxMatch = 500) => {
+  let textBefore = "";
+  const sliceEndPos = $from.parentOffset;
+  $from.parent.nodesBetween(
+    Math.max(0, sliceEndPos - maxMatch),
+    sliceEndPos,
+    (node, pos, parent, index2) => {
+      const chunk = node.type.spec.toText?.({
+        node,
+        pos,
+        parent,
+        index: index2
+      }) || node.textContent || "%leaf%";
+      textBefore += node.isAtom && !node.isText ? chunk : chunk.slice(0, Math.max(0, sliceEndPos - pos));
+    }
+  );
+  return textBefore;
+};
+class InputRule {
+  constructor(config) {
+    __publicField(this, "match");
+    __publicField(this, "handler");
+    this.match = config.match;
+    this.handler = config.handler;
+  }
+}
+const inputRuleMatcherHandler = (text, match) => {
+  if (isRegExp(match)) {
+    return match.exec(text);
+  }
+  const inputRuleMatch = match(text);
+  if (!inputRuleMatch) {
+    return null;
+  }
+  const result = [inputRuleMatch.text];
+  result.index = inputRuleMatch.index;
+  result.input = text;
+  result.data = inputRuleMatch.data;
+  if (inputRuleMatch.replaceWith) {
+    if (!inputRuleMatch.text.includes(inputRuleMatch.replaceWith)) {
+      console.warn(
+        '[super-editor warn]: "inputRuleMatch.replaceWith" must be part of "inputRuleMatch.text".'
+      );
+    }
+    result.push(inputRuleMatch.replaceWith);
+  }
+  return result;
+};
+const run = (config) => {
+  const {
+    editor,
+    from: from2,
+    to,
+    text,
+    rules,
+    plugin
+  } = config;
+  const { view } = editor;
+  if (view.composing) {
+    return false;
+  }
+  const $from = view.state.doc.resolve(from2);
+  if ($from.parent.type.spec.code || !!($from.nodeBefore || $from.nodeAfter)?.marks.find((mark) => mark.type.spec.code)) {
+    return false;
+  }
+  let matched = false;
+  const textBefore = getTextContentFromNodes($from) + text;
+  rules.forEach((rule) => {
+    if (matched) {
+      return;
+    }
+    const match = inputRuleMatcherHandler(textBefore, rule.match);
+    if (!match) {
+      return;
+    }
+    const tr = view.state.tr;
+    const state = chainableEditorState(tr, view.state);
+    const range = {
+      from: from2 - (match[0].length - text.length),
+      to
+    };
+    const { commands: commands2, chain, can } = new CommandService({
+      editor,
+      state
+    });
+    const handler = rule.handler({
+      state,
+      range,
+      match,
+      commands: commands2,
+      chain,
+      can
+    });
+    if (handler === null || !tr.steps.length) {
+      return;
+    }
+    tr.setMeta(plugin, {
+      transform: tr,
+      from: from2,
+      to,
+      text
+    });
+    view.dispatch(tr);
+    matched = true;
+  });
+  return matched;
+};
+const inputRulesPlugin = ({ editor, rules }) => {
+  const plugin = new Plugin({
+    key: new PluginKey("inputRulesPlugin"),
+    state: {
+      init() {
+        return null;
+      },
+      apply(tr, prev, state) {
+        const stored = tr.getMeta(plugin);
+        if (stored) {
+          return stored;
+        }
+        const simulatedInputMeta = tr.getMeta("applyInputRules");
+        const isSimulatedInput = !!simulatedInputMeta;
+        if (isSimulatedInput) {
+          setTimeout(() => {
+            let { text } = simulatedInputMeta;
+            if (typeof text !== "string") {
+              text = getHTMLFromFragment(Fragment.from(text), state.schema);
+            }
+            const { from: from2 } = simulatedInputMeta;
+            const to = from2 + text.length;
+            run({
+              editor,
+              from: from2,
+              to,
+              text,
+              rules,
+              plugin
+            });
+          });
+        }
+        return tr.selectionSet || tr.docChanged ? null : prev;
+      }
+    },
+    props: {
+      handleTextInput(view, from2, to, text) {
+        return run({
+          editor,
+          from: from2,
+          to,
+          text,
+          rules,
+          plugin
+        });
+      },
+      // add support for input rules to trigger on enter
+      // this is useful for example for code blocks
+      handleKeyDown(view, event) {
+        if (event.key !== "Enter") {
+          return false;
+        }
+        const { $cursor } = view.state.selection;
+        if ($cursor) {
+          return run({
+            editor,
+            from: $cursor.pos,
+            to: $cursor.pos,
+            text: "\n",
+            rules,
+            plugin
+          });
+        }
+        return false;
+      }
+    },
+    isInputRules: true
+  });
+  return plugin;
+};
+const _ExtensionService = class _ExtensionService {
+  constructor(extensions, userExtensions, editor) {
+    __privateAdd(this, _ExtensionService_instances);
+    __publicField(this, "editor");
+    __publicField(this, "schema");
+    __publicField(this, "extensions");
+    __publicField(this, "externalExtensions", []);
+    __publicField(this, "splittableMarks", []);
+    this.editor = editor;
+    this.externalExtensions = userExtensions || [];
+    this.extensions = _ExtensionService.getResolvedExtensions([...extensions, ...this.externalExtensions]);
+    this.schema = Schema.createSchemaByExtensions(this.extensions, editor);
+    __privateMethod(this, _ExtensionService_instances, setupExtensions_fn).call(this);
+  }
+  /**
+   * Static method for creating ExtensionService.
+   * @param args Arguments for the constructor.
+   */
+  static create(...args) {
+    return new _ExtensionService(...args);
+  }
+  /**
+   * Get an array of resolved extensions (e.g. sorted by priority).
+   * @param extensions Array of extensions.
+   * @returns Array of resolved extensions.
+   */
+  static getResolvedExtensions(extensions) {
+    const resolvedExtensions = _ExtensionService.sortByPriority(extensions);
+    return resolvedExtensions;
+  }
+  /**
+   * Sort extensions by priority.
+   * @param extensions Array of extensions.
+   * @returns Array of sorted extensions by priority.
+   */
+  static sortByPriority(extensions) {
+    const defaultValue = 100;
+    return extensions.sort((a, b) => {
+      const priorityA = getExtensionConfigField(a, "priority") || defaultValue;
+      const priorityB = getExtensionConfigField(b, "priority") || defaultValue;
+      if (priorityA > priorityB) return -1;
+      if (priorityA < priorityB) return 1;
+      return 0;
+    });
+  }
+  /**
+   * Get all attributes defined in the extensions.
+   * @returns Array of attributes.
+   */
+  get attributes() {
+    return Attribute.getAttributesFromExtensions(this.extensions);
+  }
+  /**
+   * Get all commands defined in the extensions.
+   * @returns Object with commands (key - command name, value - function).
+   */
+  get commands() {
+    let commandsObject = {};
+    for (const extension of this.extensions) {
+      const context = {
+        name: extension.name,
+        options: extension.options,
+        storage: extension.storage,
+        editor: this.editor,
+        type: getSchemaTypeByName(extension.name, this.schema)
+      };
+      const addCommands = getExtensionConfigField(extension, "addCommands", context);
+      if (addCommands) {
+        commandsObject = {
+          ...commandsObject,
+          ...addCommands()
+        };
+      }
+    }
+    return commandsObject;
+  }
+  /**
+   * Get all PM plugins defined in the extensions.
+   * And also keyboard shortcuts.
+   * @returns Array of PM plugins.
+   */
+  get plugins() {
+    const editor = this.editor;
+    const extensions = _ExtensionService.sortByPriority([...this.extensions].reverse());
+    const inputRules = [];
+    const allPlugins = extensions.map((extension) => {
+      const context = {
+        name: extension.name,
+        options: extension.options,
+        storage: extension.storage,
+        editor,
+        type: getSchemaTypeByName(extension.name, this.schema)
+      };
+      const plugins = [];
+      const addShortcuts = getExtensionConfigField(extension, "addShortcuts", context);
+      let bindingsObject = {};
+      if (addShortcuts) {
+        const entries = Object.entries(addShortcuts()).map(([shortcut, method]) => {
+          return [shortcut, (...args) => method({ editor, keymapArgs: args })];
+        });
+        bindingsObject = { ...Object.fromEntries(entries) };
+      }
+      plugins.push(keymap(bindingsObject));
+      const addInputRules = getExtensionConfigField(extension, "addInputRules", context);
+      if (isExtensionRulesEnabled(extension, editor.options.enableInputRules) && addInputRules) {
+        inputRules.push(...addInputRules());
+      }
+      const addPmPlugins = getExtensionConfigField(extension, "addPmPlugins", context);
+      if (addPmPlugins) {
+        const pmPlugins = addPmPlugins();
+        plugins.push(...pmPlugins);
+      }
+      return plugins;
+    }).flat();
+    return [
+      inputRulesPlugin({
+        editor,
+        rules: inputRules
+      }),
+      ...allPlugins
+    ];
+  }
+  /**
+   * Get all node views from the extensions.
+   * @returns An object with all node views.
+   */
+  get nodeViews() {
+    const { editor } = this;
+    const nodeExtensions = this.extensions.filter((e) => e.type === "node");
+    const entries = nodeExtensions.filter((extension) => !!getExtensionConfigField(extension, "addNodeView")).map((extension) => {
+      const extensionAttrs = this.attributes.filter((a) => a.type === extension.name);
+      const context = {
+        name: extension.name,
+        options: extension.options,
+        storage: extension.storage,
+        editor,
+        type: getNodeType(extension.name, this.schema)
+      };
+      const addNodeView = getExtensionConfigField(extension, "addNodeView", context);
+      if (!addNodeView) return [];
+      const nodeview = (node, _view, getPos, decorations) => {
+        const htmlAttributes = Attribute.getAttributesToRender(node, extensionAttrs);
+        return addNodeView()({
+          editor,
+          node,
+          getPos,
+          decorations,
+          htmlAttributes,
+          extension
+        });
+      };
+      return [extension.name, nodeview];
+    });
+    return Object.fromEntries(entries);
+  }
+};
+_ExtensionService_instances = new WeakSet();
+/**
+ * Install all extensions.
+ * Create extension storage in the editor, attach editor events.
+ */
+setupExtensions_fn = function() {
+  for (const extension of this.extensions) {
+    this.editor.extensionStorage[extension.name] = extension.storage;
+    const context = {
+      name: extension.name,
+      options: extension.options,
+      storage: extension.storage,
+      editor: this.editor,
+      type: getSchemaTypeByName(extension.name, this.schema)
+    };
+    if (extension.type === "mark") {
+      const keepOnSplit = callOrGet(getExtensionConfigField(extension, "keepOnSplit", context)) ?? true;
+      if (keepOnSplit) {
+        this.splittableMarks.push(extension.name);
+      }
+    }
+    __privateMethod(this, _ExtensionService_instances, attachEditorEvents_fn).call(this, extension);
   }
-}
+};
+/**
+ * Attach editor events to extension
+ * if callbacks are defined in the extension config.
+ * @param extension Extension.
+ */
+attachEditorEvents_fn = function(extension) {
+  const context = {
+    name: extension.name,
+    options: extension.options,
+    storage: extension.storage,
+    editor: this.editor,
+    type: getSchemaTypeByName(extension.name, this.schema)
+  };
+  const onBeforeCreate = getExtensionConfigField(extension, "onBeforeCreate", context);
+  const onCreate2 = getExtensionConfigField(extension, "onCreate", context);
+  const onUpdate = getExtensionConfigField(extension, "onUpdate", context);
+  const onSelectionUpdate = getExtensionConfigField(extension, "onSelectionUpdate", context);
+  const onTransaction = getExtensionConfigField(extension, "onTransaction", context);
+  const onFocus = getExtensionConfigField(extension, "onFocus", context);
+  const onBlur = getExtensionConfigField(extension, "onBlur", context);
+  const onDestroy2 = getExtensionConfigField(extension, "onDestroy", context);
+  if (onBeforeCreate) this.editor.on("beforeCreate", onBeforeCreate);
+  if (onCreate2) this.editor.on("create", onCreate2);
+  if (onUpdate) this.editor.on("update", onUpdate);
+  if (onSelectionUpdate) this.editor.on("selectionUpdate", onSelectionUpdate);
+  if (onTransaction) this.editor.on("transaction", onTransaction);
+  if (onFocus) this.editor.on("focus", onFocus);
+  if (onBlur) this.editor.on("blur", onBlur);
+  if (onDestroy2) this.editor.on("destroy", onDestroy2);
+};
+let ExtensionService = _ExtensionService;
 const first = (commands2) => (props) => {
   const items = typeof commands2 === "function" ? commands2(props) : commands2;
   for (let i = 0; i < items.length; i += 1) {
@@ -9355,6 +9559,30 @@ const insertContentAt = (position, value, options) => ({ tr, dispatch, editor })
   }
   return true;
 };
+const undoInputRule = () => ({ state, dispatch }) => {
+  const plugins = state.plugins;
+  for (let i = 0; i < plugins.length; i += 1) {
+    const plugin = plugins[i];
+    let undoable;
+    if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
+      if (dispatch) {
+        const tr = state.tr;
+        const toUndo = undoable.transform;
+        for (let j = toUndo.steps.length - 1; j >= 0; j -= 1) {
+          tr.step(toUndo.steps[j].invert(toUndo.docs[j]));
+        }
+        if (undoable.text) {
+          const marks = tr.doc.resolve(undoable.from).marks();
+          tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks));
+        } else {
+          tr.delete(undoable.from, undoable.to);
+        }
+      }
+      return true;
+    }
+  }
+  return false;
+};
 function wrapInList$1(listType, attrs = null) {
   return function(state, dispatch) {
     let { $from, $to } = state.selection;
@@ -9684,6 +9912,7 @@ const commands = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProp
   toggleList,
   toggleMark,
   toggleNode,
+  undoInputRule,
   unsetAllMarks,
   unsetMark,
   updateAttributes,
@@ -9713,6 +9942,7 @@ const Keymap = Extension.create({
       () => commands2.splitBlock()
     ]);
     const handleBackspace = () => this.editor.commands.first(({ commands: commands2, tr }) => [
+      () => commands2.undoInputRule(),
       () => {
         tr.setMeta("inputType", "deleteContentBackward");
         return false;
@@ -10318,208 +10548,15 @@ const getTrackChangesDecorations = (state, onlyOriginalShown, onlyModifiedShown)
           class: "track-format-dec normal"
         });
         decorations.push(decoration);
-      } else {
-        const decoration = Decoration.inline(from2, to, {
-          class: "track-format-dec highlighted"
-        });
-        decorations.push(decoration);
-      }
-    }
-  });
-  return DecorationSet.create(state.doc, decorations);
-};
-const replaceStep = ({ state, tr, step, newTr, map: map2, doc: doc2, user, date, originalStep, originalStepIndex }) => {
-  const deletionMarkSchema = state.schema.marks[TrackDeleteMarkName];
-  const deletionMark = findMark(state, deletionMarkSchema, false);
-  const positionTo = deletionMark ? deletionMark.to : step.to;
-  const newStep = new ReplaceStep(
-    positionTo,
-    // We insert all the same steps, but with "from"/"to" both set to "to" in order not to delete content. Mapped as needed.
-    positionTo,
-    step.slice,
-    step.structure
-  );
-  const invertStep = originalStep.invert(tr.docs[originalStepIndex]).map(map2);
-  map2.appendMap(invertStep.getMap());
-  const meta = {};
-  if (newStep) {
-    const trTemp = state.apply(newTr).tr;
-    if (trTemp.maybeStep(newStep).failed) {
-      return;
-    }
-    const mappedNewStepTo = newStep.getMap().map(newStep.to);
-    const insertedMark = markInsertion({
-      tr: trTemp,
-      from: newStep.from,
-      to: mappedNewStepTo,
-      user,
-      date
-    });
-    const condensedStep = new ReplaceStep(newStep.from, newStep.to, trTemp.doc.slice(newStep.from, mappedNewStepTo));
-    newTr.step(condensedStep);
-    const mirrorIndex = map2.maps.length - 1;
-    map2.appendMap(condensedStep.getMap(), mirrorIndex);
-    if (newStep.from !== mappedNewStepTo) {
-      meta.insertedMark = insertedMark;
-      meta.step = condensedStep;
-    }
-    if (!newTr.selection.eq(trTemp.selection)) {
-      newTr.setSelection(trTemp.selection);
-    }
-  }
-  if (step.from !== step.to) {
-    const { deletionMark: deletionMark2, deletionMap, nodes: deletionNodes } = markDeletion({
-      tr: newTr,
-      from: step.from,
-      to: step.to,
-      user,
-      date
-    });
-    meta.deletionNodes = deletionNodes;
-    meta.deletionMark = deletionMark2;
-    map2.appendMapping(deletionMap);
-  }
-  newTr.setMeta(TrackChangesBasePluginKey, meta);
-};
-const markWrapping = () => {
-};
-const replaceAroundStep = () => {
-};
-const addMarkStep = ({ state, tr, step, newTr, map: map2, doc: doc2, user, date }) => {
-  const meta = {};
-  doc2.nodesBetween(step.from, step.to, (node, pos) => {
-    if (!node.isInline) {
-      return;
-    }
-    if (node.marks.find((mark) => mark.type.name === TrackDeleteMarkName)) {
-      return false;
-    }
-    const existingChangeMark = node.marks.find((mark) => [TrackDeleteMarkName, TrackFormatMarkName].includes(mark.type.name));
-    const wid = existingChangeMark ? existingChangeMark.attrs.id : v4();
-    newTr.addMark(Math.max(step.from, pos), Math.min(step.to, pos + node.nodeSize), step.mark);
-    const allowedMarks = ["bold", "italic", "strike", "underline", "textStyle"];
-    if (allowedMarks.includes(step.mark.type.name) && !node.marks.find((mark) => mark.type === step.mark.type)) {
-      const formatChangeMark = node.marks.find((mark) => mark.type.name === TrackFormatMarkName);
-      let after = [];
-      let before = [];
-      if (formatChangeMark) {
-        let foundBefore = formatChangeMark.attrs.before.find((mark) => {
-          if (mark.type === "textStyle") {
-            return mark.type === step.mark.type.name && objectIncludes(mark.attrs, step.mark.attrs);
-          }
-          return mark.type === step.mark.type.name;
-        });
-        if (foundBefore) {
-          before = [...formatChangeMark.attrs.before.filter((mark) => mark.type !== step.mark.type.name)];
-          after = [...formatChangeMark.attrs.after];
-        } else {
-          before = [...formatChangeMark.attrs.before];
-          after = [
-            ...formatChangeMark.attrs.after,
-            {
-              type: step.mark.type.name,
-              attrs: { ...step.mark.attrs }
-            }
-          ];
-        }
-      } else {
-        before = node.marks.map((mark) => ({
-          type: mark.type.name,
-          attrs: { ...mark.attrs }
-        }));
-        after = [
-          {
-            type: step.mark.type.name,
-            attrs: { ...step.mark.attrs }
-          }
-        ];
-      }
-      if (after.length || before.length) {
-        const newFormatMark = state.schema.marks[TrackFormatMarkName].create({
-          id: wid,
-          author: user.name,
-          authorEmail: user.email,
-          date,
-          before,
-          after
-        });
-        newTr.addMark(
-          step.from,
-          // Math.max(step.from, pos)
-          step.to,
-          // Math.min(step.to, pos + node.nodeSize),
-          newFormatMark
-        );
-        meta.formatMark = newFormatMark;
-        meta.step = step;
-        newTr.setMeta(TrackChangesBasePluginKey, meta);
-      } else if (formatChangeMark) {
-        newTr.removeMark(Math.max(step.from, pos), Math.min(step.to, pos + node.nodeSize), formatChangeMark);
-      }
-    }
-  });
-};
-const removeMarkStep = ({ state, tr, step, newTr, map: map2, doc: doc2, user, date }) => {
-  const meta = {};
-  doc2.nodesBetween(step.from, step.to, (node, pos) => {
-    if (!node.isInline) {
-      return true;
-    }
-    if (node.marks.find((mark) => mark.type.name === TrackDeleteMarkName)) {
-      return false;
-    }
-    newTr.removeMark(Math.max(step.from, pos), Math.min(step.to, pos + node.nodeSize), step.mark);
-    const allowedMarks = ["bold", "italic", "strike", "underline", "textStyle"];
-    if (allowedMarks.includes(step.mark.type.name) && node.marks.find((mark) => mark.type === step.mark.type)) {
-      const formatChangeMark = node.marks.find((mark) => mark.type.name === TrackFormatMarkName);
-      let after = [];
-      let before = [];
-      if (formatChangeMark) {
-        let foundAfter = formatChangeMark.attrs.after.find((mark) => mark.type === step.mark.type.name);
-        if (foundAfter) {
-          after = [...formatChangeMark.attrs.after.filter((mark) => mark.type !== step.mark.type.name)];
-          before = [...formatChangeMark.attrs.before];
-        } else {
-          after = [...formatChangeMark.attrs.after];
-          before = [
-            ...formatChangeMark.attrs.before,
-            {
-              type: step.mark.type.name,
-              attrs: { ...step.mark.attrs }
-            }
-          ];
-        }
-      } else {
-        after = [];
-        before = [
-          {
-            type: step.mark.type.name,
-            attrs: { ...step.mark.attrs }
-          }
-        ];
-      }
-      if (after.length || before.length) {
-        const newFormatMark = state.schema.marks[TrackFormatMarkName].create({
-          id: v4(),
-          author: user.name,
-          authorEmail: user.email,
-          date,
-          before,
-          after
+      } else {
+        const decoration = Decoration.inline(from2, to, {
+          class: "track-format-dec highlighted"
         });
-        newTr.addMark(
-          Math.max(step.from, pos),
-          Math.min(step.to, pos + node.nodeSize),
-          newFormatMark
-        );
-        meta.formatMark = newFormatMark;
-        meta.step = step;
-        newTr.setMeta(TrackChangesBasePluginKey, meta);
-      } else if (formatChangeMark) {
-        newTr.removeMark(Math.max(step.from, pos), Math.min(step.to, pos + node.nodeSize), formatChangeMark);
+        decorations.push(decoration);
       }
     }
   });
+  return DecorationSet.create(state.doc, decorations);
 };
 const CommentMarkName = "commentMark";
 const removeCommentsById = ({ commentId, state, tr, dispatch }) => {
@@ -10927,7 +10964,7 @@ const CommentsPlugin = Extension.create({
           update(view, prevState) {
             const { state } = view;
             const { doc: doc2, tr } = state;
-            if (prevDoc && prevDoc.eq(doc2)) shouldUpdate = true;
+            if (prevDoc && !prevDoc.eq(doc2)) shouldUpdate = true;
             if (!shouldUpdate) return;
             prevDoc = doc2;
             shouldUpdate = false;
@@ -10961,10 +10998,14 @@ const CommentsPlugin = Extension.create({
                 if (hasActive && activeThreadId !== threadId) return;
                 decorations.push(deco);
               });
-              const trackedChangeNode = getTrackedChangeNode(node);
-              if (trackedChangeNode) {
+              const trackedChangeMark = findTrackedMark({
+                doc: doc2,
+                from: pos,
+                to: pos + node.nodeSize
+              });
+              if (trackedChangeMark) {
                 const currentBounds = view.coordsAtPos(pos);
-                const { id } = trackedChangeNode.attrs;
+                const { id } = trackedChangeMark.mark.attrs;
                 updatePosition({
                   allCommentPositions,
                   threadId: id,
@@ -11032,9 +11073,13 @@ const getActiveCommentId = (doc2, selection) => {
   if ($from.pos !== $to.pos) return;
   const nodeAtPos = doc2.nodeAt($from.pos);
   if (!nodeAtPos) return;
-  const trackedChangeNode = getTrackedChangeNode(nodeAtPos);
-  if (trackedChangeNode) {
-    return trackedChangeNode.attrs.id;
+  const trackedChangeMark = findTrackedMark({
+    doc: doc2,
+    from: $from.pos,
+    to: $to.pos
+  });
+  if (trackedChangeMark) {
+    return trackedChangeMark.mark.attrs.id;
   }
   const overlaps = [];
   let found = false;
@@ -11071,13 +11116,30 @@ const getActiveCommentId = (doc2, selection) => {
   const closestCommentMark = closestMarks.find((mark) => mark.type.name === CommentMarkName);
   return closestCommentMark?.attrs?.commentId || closestCommentMark?.attrs?.importedId;
 };
-const getTrackedChangeNode = (node) => {
-  if (!node) return;
-  const nodeMarks = node.marks;
-  const trackedInsertMark = nodeMarks?.find((mark) => mark.type.name === TrackInsertMarkName);
-  const trackedDeleteMark = nodeMarks?.find((mark) => mark.type.name === TrackDeleteMarkName);
-  const trackedFormatMark = nodeMarks?.find((mark) => mark.type.name === TrackFormatMarkName);
-  return trackedInsertMark || trackedDeleteMark || trackedFormatMark;
+const findTrackedMark = ({
+  doc: doc2,
+  from: from2,
+  to,
+  offset: offset2 = 1
+  // To get non-inclusive marks. 
+}) => {
+  const startPos = Math.max(from2 - offset2, 0);
+  const endPos = Math.min(to + offset2, doc2.content.size);
+  let markFound;
+  doc2.nodesBetween(startPos, endPos, (node, pos) => {
+    if (!node || node?.nodeSize === void 0) {
+      return;
+    }
+    const mark = node.marks.find((mark2) => TRACK_CHANGE_MARKS.includes(mark2.type.name));
+    if (mark && !markFound) {
+      markFound = {
+        from: pos,
+        to: pos + node.nodeSize,
+        mark
+      };
+    }
+  });
+  return markFound;
 };
 const handleTrackedChangeTransaction = (trackedChangeMeta, trackedChanges, newEditorState, editor) => {
   const {
@@ -11217,6 +11279,202 @@ function findNode$1(node, predicate) {
   });
   return found;
 }
+const replaceStep = ({ state, tr, step, newTr, map: map2, doc: doc2, user, date, originalStep, originalStepIndex }) => {
+  const deletionMarkSchema = state.schema.marks[TrackDeleteMarkName];
+  const deletionMark = findMark(state, deletionMarkSchema, false);
+  const positionTo = deletionMark ? deletionMark.to : step.to;
+  const newStep = new ReplaceStep(
+    positionTo,
+    // We insert all the same steps, but with "from"/"to" both set to "to" in order not to delete content. Mapped as needed.
+    positionTo,
+    step.slice,
+    step.structure
+  );
+  const invertStep = originalStep.invert(tr.docs[originalStepIndex]).map(map2);
+  map2.appendMap(invertStep.getMap());
+  const meta = {};
+  if (newStep) {
+    const trTemp = state.apply(newTr).tr;
+    if (trTemp.maybeStep(newStep).failed) {
+      return;
+    }
+    const mappedNewStepTo = newStep.getMap().map(newStep.to);
+    const insertedMark = markInsertion({
+      tr: trTemp,
+      from: newStep.from,
+      to: mappedNewStepTo,
+      user,
+      date
+    });
+    const condensedStep = new ReplaceStep(newStep.from, newStep.to, trTemp.doc.slice(newStep.from, mappedNewStepTo));
+    newTr.step(condensedStep);
+    const mirrorIndex = map2.maps.length - 1;
+    map2.appendMap(condensedStep.getMap(), mirrorIndex);
+    if (newStep.from !== mappedNewStepTo) {
+      meta.insertedMark = insertedMark;
+      meta.step = condensedStep;
+    }
+    if (!newTr.selection.eq(trTemp.selection)) {
+      newTr.setSelection(trTemp.selection);
+    }
+  }
+  if (step.from !== step.to) {
+    const { deletionMark: deletionMark2, deletionMap, nodes: deletionNodes } = markDeletion({
+      tr: newTr,
+      from: step.from,
+      to: step.to,
+      user,
+      date
+    });
+    meta.deletionNodes = deletionNodes;
+    meta.deletionMark = deletionMark2;
+    map2.appendMapping(deletionMap);
+  }
+  newTr.setMeta(TrackChangesBasePluginKey, meta);
+  newTr.setMeta(CommentsPluginKey, { type: "force" });
+};
+const markWrapping = () => {
+};
+const replaceAroundStep = () => {
+};
+const addMarkStep = ({ state, tr, step, newTr, map: map2, doc: doc2, user, date }) => {
+  const meta = {};
+  doc2.nodesBetween(step.from, step.to, (node, pos) => {
+    if (!node.isInline) {
+      return;
+    }
+    if (node.marks.find((mark) => mark.type.name === TrackDeleteMarkName)) {
+      return false;
+    }
+    const existingChangeMark = node.marks.find((mark) => [TrackDeleteMarkName, TrackFormatMarkName].includes(mark.type.name));
+    const wid = existingChangeMark ? existingChangeMark.attrs.id : v4();
+    newTr.addMark(Math.max(step.from, pos), Math.min(step.to, pos + node.nodeSize), step.mark);
+    const allowedMarks = ["bold", "italic", "strike", "underline", "textStyle"];
+    if (allowedMarks.includes(step.mark.type.name) && !node.marks.find((mark) => mark.type === step.mark.type)) {
+      const formatChangeMark = node.marks.find((mark) => mark.type.name === TrackFormatMarkName);
+      let after = [];
+      let before = [];
+      if (formatChangeMark) {
+        let foundBefore = formatChangeMark.attrs.before.find((mark) => {
+          if (mark.type === "textStyle") {
+            return mark.type === step.mark.type.name && objectIncludes(mark.attrs, step.mark.attrs);
+          }
+          return mark.type === step.mark.type.name;
+        });
+        if (foundBefore) {
+          before = [...formatChangeMark.attrs.before.filter((mark) => mark.type !== step.mark.type.name)];
+          after = [...formatChangeMark.attrs.after];
+        } else {
+          before = [...formatChangeMark.attrs.before];
+          after = [
+            ...formatChangeMark.attrs.after,
+            {
+              type: step.mark.type.name,
+              attrs: { ...step.mark.attrs }
+            }
+          ];
+        }
+      } else {
+        before = node.marks.map((mark) => ({
+          type: mark.type.name,
+          attrs: { ...mark.attrs }
+        }));
+        after = [
+          {
+            type: step.mark.type.name,
+            attrs: { ...step.mark.attrs }
+          }
+        ];
+      }
+      if (after.length || before.length) {
+        const newFormatMark = state.schema.marks[TrackFormatMarkName].create({
+          id: wid,
+          author: user.name,
+          authorEmail: user.email,
+          date,
+          before,
+          after
+        });
+        newTr.addMark(
+          step.from,
+          // Math.max(step.from, pos)
+          step.to,
+          // Math.min(step.to, pos + node.nodeSize),
+          newFormatMark
+        );
+        meta.formatMark = newFormatMark;
+        meta.step = step;
+        newTr.setMeta(TrackChangesBasePluginKey, meta);
+        newTr.setMeta(CommentsPluginKey, { type: "force" });
+      } else if (formatChangeMark) {
+        newTr.removeMark(Math.max(step.from, pos), Math.min(step.to, pos + node.nodeSize), formatChangeMark);
+      }
+    }
+  });
+};
+const removeMarkStep = ({ state, tr, step, newTr, map: map2, doc: doc2, user, date }) => {
+  const meta = {};
+  doc2.nodesBetween(step.from, step.to, (node, pos) => {
+    if (!node.isInline) {
+      return true;
+    }
+    if (node.marks.find((mark) => mark.type.name === TrackDeleteMarkName)) {
+      return false;
+    }
+    newTr.removeMark(Math.max(step.from, pos), Math.min(step.to, pos + node.nodeSize), step.mark);
+    const allowedMarks = ["bold", "italic", "strike", "underline", "textStyle"];
+    if (allowedMarks.includes(step.mark.type.name) && node.marks.find((mark) => mark.type === step.mark.type)) {
+      const formatChangeMark = node.marks.find((mark) => mark.type.name === TrackFormatMarkName);
+      let after = [];
+      let before = [];
+      if (formatChangeMark) {
+        let foundAfter = formatChangeMark.attrs.after.find((mark) => mark.type === step.mark.type.name);
+        if (foundAfter) {
+          after = [...formatChangeMark.attrs.after.filter((mark) => mark.type !== step.mark.type.name)];
+          before = [...formatChangeMark.attrs.before];
+        } else {
+          after = [...formatChangeMark.attrs.after];
+          before = [
+            ...formatChangeMark.attrs.before,
+            {
+              type: step.mark.type.name,
+              attrs: { ...step.mark.attrs }
+            }
+          ];
+        }
+      } else {
+        after = [];
+        before = [
+          {
+            type: step.mark.type.name,
+            attrs: { ...step.mark.attrs }
+          }
+        ];
+      }
+      if (after.length || before.length) {
+        const newFormatMark = state.schema.marks[TrackFormatMarkName].create({
+          id: v4(),
+          author: user.name,
+          authorEmail: user.email,
+          date,
+          before,
+          after
+        });
+        newTr.addMark(
+          Math.max(step.from, pos),
+          Math.min(step.to, pos + node.nodeSize),
+          newFormatMark
+        );
+        meta.formatMark = newFormatMark;
+        meta.step = step;
+        newTr.setMeta(TrackChangesBasePluginKey, meta);
+        newTr.setMeta(CommentsPluginKey, { type: "force" });
+      } else if (formatChangeMark) {
+        newTr.removeMark(Math.max(step.from, pos), Math.min(step.to, pos + node.nodeSize), formatChangeMark);
+      }
+    }
+  });
+};
 const trackedTransaction = ({ tr, state, user }) => {
   const onlyInputTypeMeta = ["inputType", "uiEvent", "paste", "pointer"];
   const notAllowedMeta = ["historyUndo", "historyRedo", "acceptReject"];
@@ -11375,6 +11633,7 @@ const _Editor = class _Editor extends EventEmitter {
       editorProps: {},
       parseOptions: {},
       coreExtensionOptions: {},
+      enableInputRules: true,
       isCommentsEnabled: false,
       isNewFile: false,
       scale: 1,
@@ -11813,7 +12072,7 @@ const _Editor = class _Editor extends EventEmitter {
    * @returns {Y.Doc | undefined} Updated Y.Doc if any, otherwise undefined
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "0.8.10");
+    console.debug("[checkVersionMigrations] Current editor version", "0.8.12");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -13206,6 +13465,45 @@ const RunItem = Node.create({
     };
   }
 });
+function wrappingInputRule(config) {
+  return new InputRule({
+    match: config.match,
+    handler: ({
+      state,
+      range,
+      match,
+      chain
+    }) => {
+      const attributes = callOrGet(config.getAttributes, null, match) || {};
+      const tr = state.tr.delete(range.from, range.to);
+      const $start = tr.doc.resolve(range.from);
+      const blockRange = $start.blockRange();
+      const wrapping = blockRange && findWrapping(blockRange, config.type, attributes);
+      if (!wrapping) {
+        return null;
+      }
+      tr.wrap(blockRange, wrapping);
+      if (config.keepMarks && config.editor) {
+        const { selection, storedMarks } = state;
+        const { splittableMarks } = config.editor.extensionService;
+        const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
+        if (marks) {
+          const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
+          tr.ensureMarks(filteredMarks);
+        }
+      }
+      if (config.keepAttributes) {
+        const nodeType = config.type.name === "bulletList" || config.type.name === "orderedList" ? "listItem" : config.type.name;
+        chain().updateAttributes(nodeType, attributes).run();
+      }
+      const before = tr.doc.resolve(range.from - 1).nodeBefore;
+      if (before && before.type === config.type && canJoin(tr.doc, range.from - 1) && (!config.joinPredicate || config.joinPredicate(match, before))) {
+        tr.join(range.from - 1);
+      }
+    }
+  });
+}
+const inputRegex$1 = /^\s*([-+*])\s$/;
 const BulletList = Node.create({
   name: "bulletList",
   group: "block list",
@@ -13216,7 +13514,8 @@ const BulletList = Node.create({
     return {
       itemTypeName: "listItem",
       htmlAttributes: {},
-      keepMarks: true
+      keepMarks: true,
+      keepAttributes: false
     };
   },
   parseDOM() {
@@ -13254,8 +13553,29 @@ const BulletList = Node.create({
         return this.editor.commands.toggleBulletList();
       }
     };
-  }
+  },
   // Input rules.
+  addInputRules() {
+    let inputRule = wrappingInputRule({
+      match: inputRegex$1,
+      type: this.type
+    });
+    if (this.options.keepMarks || this.options.keepAttributes) {
+      inputRule = wrappingInputRule({
+        match: inputRegex$1,
+        type: this.type,
+        keepMarks: this.options.keepMarks,
+        keepAttributes: this.options.keepAttributes,
+        getAttributes: () => {
+          return this.editor.getAttributes("textStyle");
+        },
+        editor: this.editor
+      });
+    }
+    return [
+      inputRule
+    ];
+  }
 });
 function orderedListSync(options = {}) {
   return new Plugin({
@@ -13466,6 +13786,7 @@ function buildFirstListItemAttrs({ state, listItems }) {
     listNumberingType
   };
 }
+const inputRegex = /^(\d+)\.\s$/;
 const OrderedList = Node.create({
   name: "orderedList",
   group: "block list",
@@ -13477,6 +13798,7 @@ const OrderedList = Node.create({
       itemTypeName: "listItem",
       htmlAttributes: {},
       keepMarks: true,
+      keepAttributes: false,
       listStyleTypes: ["decimal", "lowerAlpha", "lowerRoman"]
     };
   },
@@ -13634,6 +13956,28 @@ const OrderedList = Node.create({
   },
   addPmPlugins() {
     return [orderedListMarker(), orderedListSync()];
+  },
+  addInputRules() {
+    let inputRule = wrappingInputRule({
+      match: inputRegex,
+      type: this.type,
+      getAttributes: (match) => ({ start: +match[1] }),
+      joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1]
+    });
+    if (this.options.keepMarks || this.options.keepAttributes) {
+      inputRule = wrappingInputRule({
+        match: inputRegex,
+        type: this.type,
+        keepMarks: this.options.keepMarks,
+        keepAttributes: this.options.keepAttributes,
+        getAttributes: (match) => ({ start: +match[1], ...this.editor.getAttributes("textStyle") }),
+        joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1],
+        editor: this.editor
+      });
+    }
+    return [
+      inputRule
+    ];
   }
 });
 function randomId() {
@@ -22752,4 +23096,4 @@ export {
   redoDepth as r,
   undoDepth as u
 };
-//# sourceMappingURL=editor-nlt5JeOJ.js.map
+//# sourceMappingURL=editor-aREw3zbp.js.map