@harbour-enterprises/superdoc 0.8.10 → 0.8.12

package/dist/superdoc.umd.js

@@ -727,7 +727,7 @@
       globalVersion++;
       return;
     }
-    const run = (dep) => {
+    const run2 = (dep) => {
       if (dep) {
         {
           dep.trigger();
@@ -736,7 +736,7 @@
     };
     startBatch();
     if (type2 === "clear") {
-      depsMap.forEach(run);
+      depsMap.forEach(run2);
     } else {
       const targetIsArray = isArray$4(target);
       const isArrayIndex = targetIsArray && isIntegerKey(key);
@@ -744,38 +744,38 @@
         const newLength = Number(newValue);
         depsMap.forEach((dep, key2) => {
           if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol$2(key2) && key2 >= newLength) {
-            run(dep);
+            run2(dep);
           }
         });
       } else {
         if (key !== void 0 || depsMap.has(void 0)) {
-          run(depsMap.get(key));
+          run2(depsMap.get(key));
         }
         if (isArrayIndex) {
-          run(depsMap.get(ARRAY_ITERATE_KEY));
+          run2(depsMap.get(ARRAY_ITERATE_KEY));
         }
         switch (type2) {
           case "add":
             if (!targetIsArray) {
-              run(depsMap.get(ITERATE_KEY));
+              run2(depsMap.get(ITERATE_KEY));
               if (isMap(target)) {
-                run(depsMap.get(MAP_KEY_ITERATE_KEY));
+                run2(depsMap.get(MAP_KEY_ITERATE_KEY));
               }
             } else if (isArrayIndex) {
-              run(depsMap.get("length"));
+              run2(depsMap.get("length"));
             }
             break;
           case "delete":
             if (!targetIsArray) {
-              run(depsMap.get(ITERATE_KEY));
+              run2(depsMap.get(ITERATE_KEY));
               if (isMap(target)) {
-                run(depsMap.get(MAP_KEY_ITERATE_KEY));
+                run2(depsMap.get(MAP_KEY_ITERATE_KEY));
               }
             }
             break;
           case "set":
             if (isMap(target)) {
-              run(depsMap.get(ITERATE_KEY));
+              run2(depsMap.get(ITERATE_KEY));
             }
             break;
         }
@@ -26498,7 +26498,7 @@
   };
   function hasTextNode(elements) {
     const runs = elements.filter((el) => el.name === "w:r");
-    const runsHaveText = runs.some((run) => run.elements.some((el) => el.name === "w:t"));
+    const runsHaveText = runs.some((run2) => run2.elements.some((el) => el.name === "w:t"));
     return runsHaveText;
   }
   const handleTrackChangeNode = (params2) => {
@@ -27397,8 +27397,8 @@
     };
   };
   const parseAnnotationMarks = (content = {}) => {
-    const run = content.elements?.find((el) => el.name === "w:r");
-    const rPr = run?.elements?.find((el) => el.name === "w:rPr");
+    const run2 = content.elements?.find((el) => el.name === "w:r");
+    const rPr = run2?.elements?.find((el) => el.name === "w:rPr");
     if (!rPr) return {};
     const unknownMarks = [];
     const marks = parseMarks(rPr, unknownMarks) || [];
@@ -28001,7 +28001,7 @@
         return;
       }
     }
-    static updateDocumentVersion(docx = this.convertedXml, version2 = "0.8.10") {
+    static updateDocumentVersion(docx = this.convertedXml, version2 = "0.8.12") {
       const customLocation = "docProps/custom.xml";
       if (!docx[customLocation]) {
         docx[customLocation] = generateCustomXml();
@@ -28274,7 +28274,7 @@
   function generateCustomXml() {
     return DEFAULT_CUSTOM_XML;
   }
-  function generateSuperdocVersion(pid = 2, version2 = "0.8.10") {
+  function generateSuperdocVersion(pid = 2, version2 = "0.8.12") {
     return {
       type: "element",
       name: "property",
@@ -38735,6 +38735,357 @@
   function getSchemaTypeByName(name, schema) {
     return schema.nodes[name] || schema.marks[name] || null;
   }
+  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 enabled;
+  }
+  function chainableEditorState(transaction, state2) {
+    let { selection, doc: doc2, storedMarks } = transaction;
+    return {
+      ...state2,
+      apply: state2.apply.bind(state2),
+      applyTransaction: state2.applyTransaction.bind(state2),
+      plugins: state2.plugins,
+      schema: state2.schema,
+      reconfigure: state2.reconfigure.bind(state2),
+      toJSON: state2.toJSON.bind(state2),
+      get storedMarks() {
+        return storedMarks;
+      },
+      get selection() {
+        return selection;
+      },
+      get doc() {
+        return doc2;
+      },
+      get tr() {
+        selection = transaction.selection;
+        doc2 = transaction.doc;
+        storedMarks = transaction.storedMarks;
+        return transaction;
+      }
+    };
+  }
+  class CommandService {
+    constructor(props) {
+      __publicField$1(this, "editor");
+      __publicField$1(this, "rawCommands");
+      this.editor = props.editor;
+      this.rawCommands = this.editor.extensionService.commands;
+    }
+    /**
+     * Static method for creating a service.
+     * @param args Arguments for the constructor.
+     */
+    static create(...args) {
+      return new CommandService(...args);
+    }
+    /**
+     * Get editor state.
+     */
+    get state() {
+      return this.editor.state;
+    }
+    /**
+     * Get all commands with wrapped command method.
+     */
+    get commands() {
+      const { editor, state: state2 } = this;
+      const { view } = editor;
+      const { tr } = state2;
+      const props = this.createProps(tr);
+      const entries = Object.entries(this.rawCommands).map(([name, command2]) => {
+        const method = (...args) => {
+          const fn2 = command2(...args)(props);
+          if (!tr.getMeta("preventDispatch")) {
+            view.dispatch(tr);
+          }
+          return fn2;
+        };
+        return [name, method];
+      });
+      return Object.fromEntries(entries);
+    }
+    /**
+     * Create a chain of commands to call multiple commands at once.
+     */
+    get chain() {
+      return () => this.createChain();
+    }
+    /**
+     * Check if a command or a chain of commands can be executed. Without executing it.
+     */
+    get can() {
+      return () => this.createCan();
+    }
+    /**
+     * Creates a chain of commands.
+     * @param startTr Start transaction.
+     * @param shouldDispatch Should dispatch or not.
+     */
+    createChain(startTr, shouldDispatch = true) {
+      const { editor, state: state2, rawCommands } = this;
+      const { view } = editor;
+      const callbacks2 = [];
+      const hasStartTr = !!startTr;
+      const tr = startTr || state2.tr;
+      const run2 = () => {
+        if (!hasStartTr && shouldDispatch && !tr.getMeta("preventDispatch")) {
+          view.dispatch(tr);
+        }
+        return callbacks2.every((cb) => cb === true);
+      };
+      const entries = Object.entries(rawCommands).map(([name, command2]) => {
+        const chainedCommand = (...args) => {
+          const props = this.createProps(tr, shouldDispatch);
+          const callback = command2(...args)(props);
+          callbacks2.push(callback);
+          return chain;
+        };
+        return [name, chainedCommand];
+      });
+      const chain = {
+        ...Object.fromEntries(entries),
+        run: run2
+      };
+      return chain;
+    }
+    /**
+     * Creates a can check for commands.
+     * @param startTr Start transaction.
+     */
+    createCan(startTr) {
+      const { rawCommands, state: state2 } = this;
+      const dispatch = false;
+      const tr = startTr || state2.tr;
+      const props = this.createProps(tr, dispatch);
+      const commands2 = Object.fromEntries(
+        Object.entries(rawCommands).map(([name, command2]) => {
+          return [name, (...args) => command2(...args)({ ...props, dispatch: void 0 })];
+        })
+      );
+      return {
+        ...commands2,
+        chain: () => this.createChain(tr, dispatch)
+      };
+    }
+    /**
+     * Creates default props for the command method.
+     * @param {*} tr Transaction.
+     * @param {*} shouldDispatch Check if should dispatch.
+     * @returns Object with props.
+     */
+    createProps(tr, shouldDispatch = true) {
+      const { editor, state: state2, rawCommands } = this;
+      const { view } = editor;
+      const props = {
+        tr,
+        editor,
+        view,
+        state: chainableEditorState(tr, state2),
+        dispatch: shouldDispatch ? () => void 0 : void 0,
+        chain: () => this.createChain(tr, shouldDispatch),
+        can: () => this.createCan(tr),
+        get commands() {
+          return Object.fromEntries(
+            Object.entries(rawCommands).map(([name, command2]) => {
+              return [name, (...args) => command2(...args)(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,
+      (node2, pos, parent, index2) => {
+        const chunk = node2.type.spec.toText?.({
+          node: node2,
+          pos,
+          parent,
+          index: index2
+        }) || node2.textContent || "%leaf%";
+        textBefore += node2.isAtom && !node2.isText ? chunk : chunk.slice(0, Math.max(0, sliceEndPos - pos));
+      }
+    );
+    return textBefore;
+  };
+  class InputRule {
+    constructor(config) {
+      __publicField$1(this, "match");
+      __publicField$1(this, "handler");
+      this.match = config.match;
+      this.handler = config.handler;
+    }
+  }
+  const inputRuleMatcherHandler = (text, match2) => {
+    if (isRegExp(match2)) {
+      return match2.exec(text);
+    }
+    const inputRuleMatch = match2(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: plugin2
+    } = 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 match2 = inputRuleMatcherHandler(textBefore, rule.match);
+      if (!match2) {
+        return;
+      }
+      const tr = view.state.tr;
+      const state2 = chainableEditorState(tr, view.state);
+      const range2 = {
+        from: from2 - (match2[0].length - text.length),
+        to
+      };
+      const { commands: commands2, chain, can } = new CommandService({
+        editor,
+        state: state2
+      });
+      const handler = rule.handler({
+        state: state2,
+        range: range2,
+        match: match2,
+        commands: commands2,
+        chain,
+        can
+      });
+      if (handler === null || !tr.steps.length) {
+        return;
+      }
+      tr.setMeta(plugin2, {
+        transform: tr,
+        from: from2,
+        to,
+        text
+      });
+      view.dispatch(tr);
+      matched = true;
+    });
+    return matched;
+  };
+  const inputRulesPlugin = ({ editor, rules }) => {
+    const plugin2 = new Plugin({
+      key: new PluginKey("inputRulesPlugin"),
+      state: {
+        init() {
+          return null;
+        },
+        apply(tr, prev, state2) {
+          const stored = tr.getMeta(plugin2);
+          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), state2.schema);
+              }
+              const { from: from2 } = simulatedInputMeta;
+              const to = from2 + text.length;
+              run({
+                editor,
+                from: from2,
+                to,
+                text,
+                rules,
+                plugin: plugin2
+              });
+            });
+          }
+          return tr.selectionSet || tr.docChanged ? null : prev;
+        }
+      },
+      props: {
+        handleTextInput(view, from2, to, text) {
+          return run({
+            editor,
+            from: from2,
+            to,
+            text,
+            rules,
+            plugin: plugin2
+          });
+        },
+        // 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: plugin2
+            });
+          }
+          return false;
+        }
+      },
+      isInputRules: true
+    });
+    return plugin2;
+  };
   const _ExtensionService = class _ExtensionService2 {
     constructor(extensions, userExtensions, editor) {
       __privateAdd$1(this, _ExtensionService_instances);
@@ -38819,6 +39170,7 @@
     get plugins() {
       const editor = this.editor;
       const extensions = _ExtensionService2.sortByPriority([...this.extensions].reverse());
+      const inputRules = [];
       const allPlugins = extensions.map((extension) => {
         const context = {
           name: extension.name,
@@ -38837,6 +39189,10 @@
           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();
@@ -38844,7 +39200,13 @@
         }
         return plugins;
       }).flat();
-      return [...allPlugins];
+      return [
+        inputRulesPlugin({
+          editor,
+          rules: inputRules
+        }),
+        ...allPlugins
+      ];
     }
     /**
      * Get all node views from the extensions.
@@ -38926,164 +39288,6 @@
     if (onDestroy2) this.editor.on("destroy", onDestroy2);
   };
   let ExtensionService = _ExtensionService;
-  function chainableEditorState(transaction, state2) {
-    let { selection, doc: doc2, storedMarks } = transaction;
-    return {
-      ...state2,
-      apply: state2.apply.bind(state2),
-      applyTransaction: state2.applyTransaction.bind(state2),
-      plugins: state2.plugins,
-      schema: state2.schema,
-      reconfigure: state2.reconfigure.bind(state2),
-      toJSON: state2.toJSON.bind(state2),
-      get storedMarks() {
-        return storedMarks;
-      },
-      get selection() {
-        return selection;
-      },
-      get doc() {
-        return doc2;
-      },
-      get tr() {
-        selection = transaction.selection;
-        doc2 = transaction.doc;
-        storedMarks = transaction.storedMarks;
-        return transaction;
-      }
-    };
-  }
-  class CommandService {
-    constructor(props) {
-      __publicField$1(this, "editor");
-      __publicField$1(this, "rawCommands");
-      this.editor = props.editor;
-      this.rawCommands = this.editor.extensionService.commands;
-    }
-    /**
-     * Static method for creating a service.
-     * @param args Arguments for the constructor.
-     */
-    static create(...args) {
-      return new CommandService(...args);
-    }
-    /**
-     * Get editor state.
-     */
-    get state() {
-      return this.editor.state;
-    }
-    /**
-     * Get all commands with wrapped command method.
-     */
-    get commands() {
-      const { editor, state: state2 } = this;
-      const { view } = editor;
-      const { tr } = state2;
-      const props = this.createProps(tr);
-      const entries = Object.entries(this.rawCommands).map(([name, command2]) => {
-        const method = (...args) => {
-          const fn2 = command2(...args)(props);
-          if (!tr.getMeta("preventDispatch")) {
-            view.dispatch(tr);
-          }
-          return fn2;
-        };
-        return [name, method];
-      });
-      return Object.fromEntries(entries);
-    }
-    /**
-     * Create a chain of commands to call multiple commands at once.
-     */
-    get chain() {
-      return () => this.createChain();
-    }
-    /**
-     * Check if a command or a chain of commands can be executed. Without executing it.
-     */
-    get can() {
-      return () => this.createCan();
-    }
-    /**
-     * Creates a chain of commands.
-     * @param startTr Start transaction.
-     * @param shouldDispatch Should dispatch or not.
-     */
-    createChain(startTr, shouldDispatch = true) {
-      const { editor, state: state2, rawCommands } = this;
-      const { view } = editor;
-      const callbacks2 = [];
-      const hasStartTr = !!startTr;
-      const tr = startTr || state2.tr;
-      const run = () => {
-        if (!hasStartTr && shouldDispatch && !tr.getMeta("preventDispatch")) {
-          view.dispatch(tr);
-        }
-        return callbacks2.every((cb) => cb === true);
-      };
-      const entries = Object.entries(rawCommands).map(([name, command2]) => {
-        const chainedCommand = (...args) => {
-          const props = this.createProps(tr, shouldDispatch);
-          const callback = command2(...args)(props);
-          callbacks2.push(callback);
-          return chain;
-        };
-        return [name, chainedCommand];
-      });
-      const chain = {
-        ...Object.fromEntries(entries),
-        run
-      };
-      return chain;
-    }
-    /**
-     * Creates a can check for commands.
-     * @param startTr Start transaction.
-     */
-    createCan(startTr) {
-      const { rawCommands, state: state2 } = this;
-      const dispatch = false;
-      const tr = startTr || state2.tr;
-      const props = this.createProps(tr, dispatch);
-      const commands2 = Object.fromEntries(
-        Object.entries(rawCommands).map(([name, command2]) => {
-          return [name, (...args) => command2(...args)({ ...props, dispatch: void 0 })];
-        })
-      );
-      return {
-        ...commands2,
-        chain: () => this.createChain(tr, dispatch)
-      };
-    }
-    /**
-     * Creates default props for the command method.
-     * @param {*} tr Transaction.
-     * @param {*} shouldDispatch Check if should dispatch.
-     * @returns Object with props.
-     */
-    createProps(tr, shouldDispatch = true) {
-      const { editor, state: state2, rawCommands } = this;
-      const { view } = editor;
-      const props = {
-        tr,
-        editor,
-        view,
-        state: chainableEditorState(tr, state2),
-        dispatch: shouldDispatch ? () => void 0 : void 0,
-        chain: () => this.createChain(tr, shouldDispatch),
-        can: () => this.createCan(tr),
-        get commands() {
-          return Object.fromEntries(
-            Object.entries(rawCommands).map(([name, command2]) => {
-              return [name, (...args) => command2(...args)(props)];
-            })
-          );
-        }
-      };
-      return props;
-    }
-  }
   const first = (commands2) => (props) => {
     const items = typeof commands2 === "function" ? commands2(props) : commands2;
     for (let i2 = 0; i2 < items.length; i2 += 1) {
@@ -40120,6 +40324,30 @@
     }
     return true;
   };
+  const undoInputRule = () => ({ state: state2, dispatch }) => {
+    const plugins = state2.plugins;
+    for (let i2 = 0; i2 < plugins.length; i2 += 1) {
+      const plugin2 = plugins[i2];
+      let undoable;
+      if (plugin2.spec.isInputRules && (undoable = plugin2.getState(state2))) {
+        if (dispatch) {
+          const tr = state2.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, state2.schema.text(undoable.text, marks));
+          } else {
+            tr.delete(undoable.from, undoable.to);
+          }
+        }
+        return true;
+      }
+    }
+    return false;
+  };
   function wrapInList$1(listType, attrs = null) {
     return function(state2, dispatch) {
       let { $from, $to } = state2.selection;
@@ -40449,6 +40677,7 @@
     toggleList,
     toggleMark,
     toggleNode,
+    undoInputRule,
     unsetAllMarks,
     unsetMark,
     updateAttributes,
@@ -40478,6 +40707,7 @@
         () => commands2.splitBlock()
       ]);
       const handleBackspace = () => this.editor.commands.first(({ commands: commands2, tr }) => [
+        () => commands2.undoInputRule(),
         () => {
           tr.setMeta("inputType", "deleteContentBackward");
           return false;
@@ -41093,199 +41323,6 @@
     });
     return DecorationSet.create(state2.doc, decorations);
   };
-  const replaceStep = ({ state: state2, tr, step, newTr, map: map2, doc: doc2, user, date, originalStep, originalStepIndex }) => {
-    const deletionMarkSchema = state2.schema.marks[TrackDeleteMarkName];
-    const deletionMark = findMark(state2, 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 = state2.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: state2, tr, step, newTr, map: map2, doc: doc2, user, date }) => {
-    const meta = {};
-    doc2.nodesBetween(step.from, step.to, (node2, pos) => {
-      if (!node2.isInline) {
-        return;
-      }
-      if (node2.marks.find((mark) => mark.type.name === TrackDeleteMarkName)) {
-        return false;
-      }
-      const existingChangeMark = node2.marks.find((mark) => [TrackDeleteMarkName, TrackFormatMarkName].includes(mark.type.name));
-      const wid = existingChangeMark ? existingChangeMark.attrs.id : v4$1();
-      newTr.addMark(Math.max(step.from, pos), Math.min(step.to, pos + node2.nodeSize), step.mark);
-      const allowedMarks = ["bold", "italic", "strike", "underline", "textStyle"];
-      if (allowedMarks.includes(step.mark.type.name) && !node2.marks.find((mark) => mark.type === step.mark.type)) {
-        const formatChangeMark = node2.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 = node2.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 = state2.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 + node2.nodeSize), formatChangeMark);
-        }
-      }
-    });
-  };
-  const removeMarkStep = ({ state: state2, tr, step, newTr, map: map2, doc: doc2, user, date }) => {
-    const meta = {};
-    doc2.nodesBetween(step.from, step.to, (node2, pos) => {
-      if (!node2.isInline) {
-        return true;
-      }
-      if (node2.marks.find((mark) => mark.type.name === TrackDeleteMarkName)) {
-        return false;
-      }
-      newTr.removeMark(Math.max(step.from, pos), Math.min(step.to, pos + node2.nodeSize), step.mark);
-      const allowedMarks = ["bold", "italic", "strike", "underline", "textStyle"];
-      if (allowedMarks.includes(step.mark.type.name) && node2.marks.find((mark) => mark.type === step.mark.type)) {
-        const formatChangeMark = node2.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 = state2.schema.marks[TrackFormatMarkName].create({
-            id: v4$1(),
-            author: user.name,
-            authorEmail: user.email,
-            date,
-            before,
-            after
-          });
-          newTr.addMark(
-            Math.max(step.from, pos),
-            Math.min(step.to, pos + node2.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 + node2.nodeSize), formatChangeMark);
-        }
-      }
-    });
-  };
   const CommentMarkName = "commentMark";
   const removeCommentsById = ({ commentId, state: state2, tr, dispatch }) => {
     const positions = getCommentPositionsById(commentId, state2.doc);
@@ -41692,7 +41729,7 @@
             update(view, prevState) {
               const { state: state2 } = view;
               const { doc: doc2, tr } = state2;
-              if (prevDoc && prevDoc.eq(doc2)) shouldUpdate = true;
+              if (prevDoc && !prevDoc.eq(doc2)) shouldUpdate = true;
               if (!shouldUpdate) return;
               prevDoc = doc2;
               shouldUpdate = false;
@@ -41726,10 +41763,14 @@
                   if (hasActive && activeThreadId !== threadId) return;
                   decorations.push(deco);
                 });
-                const trackedChangeNode = getTrackedChangeNode(node2);
-                if (trackedChangeNode) {
+                const trackedChangeMark = findTrackedMark({
+                  doc: doc2,
+                  from: pos,
+                  to: pos + node2.nodeSize
+                });
+                if (trackedChangeMark) {
                   const currentBounds = view.coordsAtPos(pos);
-                  const { id } = trackedChangeNode.attrs;
+                  const { id } = trackedChangeMark.mark.attrs;
                   updatePosition({
                     allCommentPositions,
                     threadId: id,
@@ -41797,9 +41838,13 @@
     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 found2 = false;
@@ -41836,13 +41881,30 @@
     const closestCommentMark = closestMarks.find((mark) => mark.type.name === CommentMarkName);
     return closestCommentMark?.attrs?.commentId || closestCommentMark?.attrs?.importedId;
   };
-  const getTrackedChangeNode = (node2) => {
-    if (!node2) return;
-    const nodeMarks = node2.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, (node2, pos) => {
+      if (!node2 || node2?.nodeSize === void 0) {
+        return;
+      }
+      const mark = node2.marks.find((mark2) => TRACK_CHANGE_MARKS.includes(mark2.type.name));
+      if (mark && !markFound) {
+        markFound = {
+          from: pos,
+          to: pos + node2.nodeSize,
+          mark
+        };
+      }
+    });
+    return markFound;
   };
   const handleTrackedChangeTransaction = (trackedChangeMeta, trackedChanges, newEditorState, editor) => {
     const {
@@ -41982,6 +42044,202 @@
     });
     return found2;
   }
+  const replaceStep = ({ state: state2, tr, step, newTr, map: map2, doc: doc2, user, date, originalStep, originalStepIndex }) => {
+    const deletionMarkSchema = state2.schema.marks[TrackDeleteMarkName];
+    const deletionMark = findMark(state2, 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 = state2.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: state2, tr, step, newTr, map: map2, doc: doc2, user, date }) => {
+    const meta = {};
+    doc2.nodesBetween(step.from, step.to, (node2, pos) => {
+      if (!node2.isInline) {
+        return;
+      }
+      if (node2.marks.find((mark) => mark.type.name === TrackDeleteMarkName)) {
+        return false;
+      }
+      const existingChangeMark = node2.marks.find((mark) => [TrackDeleteMarkName, TrackFormatMarkName].includes(mark.type.name));
+      const wid = existingChangeMark ? existingChangeMark.attrs.id : v4$1();
+      newTr.addMark(Math.max(step.from, pos), Math.min(step.to, pos + node2.nodeSize), step.mark);
+      const allowedMarks = ["bold", "italic", "strike", "underline", "textStyle"];
+      if (allowedMarks.includes(step.mark.type.name) && !node2.marks.find((mark) => mark.type === step.mark.type)) {
+        const formatChangeMark = node2.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 = node2.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 = state2.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 + node2.nodeSize), formatChangeMark);
+        }
+      }
+    });
+  };
+  const removeMarkStep = ({ state: state2, tr, step, newTr, map: map2, doc: doc2, user, date }) => {
+    const meta = {};
+    doc2.nodesBetween(step.from, step.to, (node2, pos) => {
+      if (!node2.isInline) {
+        return true;
+      }
+      if (node2.marks.find((mark) => mark.type.name === TrackDeleteMarkName)) {
+        return false;
+      }
+      newTr.removeMark(Math.max(step.from, pos), Math.min(step.to, pos + node2.nodeSize), step.mark);
+      const allowedMarks = ["bold", "italic", "strike", "underline", "textStyle"];
+      if (allowedMarks.includes(step.mark.type.name) && node2.marks.find((mark) => mark.type === step.mark.type)) {
+        const formatChangeMark = node2.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 = state2.schema.marks[TrackFormatMarkName].create({
+            id: v4$1(),
+            author: user.name,
+            authorEmail: user.email,
+            date,
+            before,
+            after
+          });
+          newTr.addMark(
+            Math.max(step.from, pos),
+            Math.min(step.to, pos + node2.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 + node2.nodeSize), formatChangeMark);
+        }
+      }
+    });
+  };
   const trackedTransaction = ({ tr, state: state2, user }) => {
     const onlyInputTypeMeta = ["inputType", "uiEvent", "paste", "pointer"];
     const notAllowedMeta = ["historyUndo", "historyRedo", "acceptReject"];
@@ -42140,6 +42398,7 @@
         editorProps: {},
         parseOptions: {},
         coreExtensionOptions: {},
+        enableInputRules: true,
         isCommentsEnabled: false,
         isNewFile: false,
         scale: 1,
@@ -42578,7 +42837,7 @@
      * @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");
@@ -43923,6 +44182,45 @@
       };
     }
   });
+  function wrappingInputRule(config) {
+    return new InputRule({
+      match: config.match,
+      handler: ({
+        state: state2,
+        range: range2,
+        match: match2,
+        chain
+      }) => {
+        const attributes = callOrGet(config.getAttributes, null, match2) || {};
+        const tr = state2.tr.delete(range2.from, range2.to);
+        const $start = tr.doc.resolve(range2.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 } = state2;
+          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(range2.from - 1).nodeBefore;
+        if (before && before.type === config.type && canJoin(tr.doc, range2.from - 1) && (!config.joinPredicate || config.joinPredicate(match2, before))) {
+          tr.join(range2.from - 1);
+        }
+      }
+    });
+  }
+  const inputRegex$1 = /^\s*([-+*])\s$/;
   const BulletList = Node$1.create({
     name: "bulletList",
     group: "block list",
@@ -43933,7 +44231,8 @@
       return {
         itemTypeName: "listItem",
         htmlAttributes: {},
-        keepMarks: true
+        keepMarks: true,
+        keepAttributes: false
       };
     },
     parseDOM() {
@@ -43971,8 +44270,29 @@
           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(options2 = {}) {
     return new Plugin({
@@ -44183,6 +44503,7 @@
       listNumberingType
     };
   }
+  const inputRegex = /^(\d+)\.\s$/;
   const OrderedList = Node$1.create({
     name: "orderedList",
     group: "block list",
@@ -44194,6 +44515,7 @@
         itemTypeName: "listItem",
         htmlAttributes: {},
         keepMarks: true,
+        keepAttributes: false,
         listStyleTypes: ["decimal", "lowerAlpha", "lowerRoman"]
       };
     },
@@ -44351,6 +44673,28 @@
     },
     addPmPlugins() {
       return [orderedListMarker(), orderedListSync()];
+    },
+    addInputRules() {
+      let inputRule = wrappingInputRule({
+        match: inputRegex,
+        type: this.type,
+        getAttributes: (match2) => ({ start: +match2[1] }),
+        joinPredicate: (match2, node2) => node2.childCount + node2.attrs.start === +match2[1]
+      });
+      if (this.options.keepMarks || this.options.keepAttributes) {
+        inputRule = wrappingInputRule({
+          match: inputRegex,
+          type: this.type,
+          keepMarks: this.options.keepMarks,
+          keepAttributes: this.options.keepAttributes,
+          getAttributes: (match2) => ({ start: +match2[1], ...this.editor.getAttributes("textStyle") }),
+          joinPredicate: (match2, node2) => node2.childCount + node2.attrs.start === +match2[1],
+          editor: this.editor
+        });
+      }
+      return [
+        inputRule
+      ];
     }
   });
   function randomId() {
@@ -110962,7 +111306,7 @@ ${style2}
       this.config.colors = shuffleArray(this.config.colors);
       this.userColorMap = /* @__PURE__ */ new Map();
       this.colorIndex = 0;
-      this.version = "0.8.10";
+      this.version = "0.8.12";
       console.debug("🦋 [superdoc] Using SuperDoc version:", this.version);
       this.superdocId = config.superdocId || v4();
       this.colors = this.config.colors;