@harbour-enterprises/superdoc 0.8.10 → 0.8.12

package/dist/chunks/{super-editor.es-CnpejCPC.js → super-editor.es-D8IC7SPE.js}

@@ -19161,7 +19161,7 @@ const isPropertiesElement = (element) => {
 };
 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) => {
@@ -20060,8 +20060,8 @@ const handleAnnotationNode = (params2) => {
   };
 };
 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) || [];
@@ -20664,7 +20664,7 @@ const _SuperConverter = class _SuperConverter2 {
       return;
     }
   }
-  static updateDocumentVersion(docx = this.convertedXml, version = "0.8.10") {
+  static updateDocumentVersion(docx = this.convertedXml, version = "0.8.12") {
     const customLocation = "docProps/custom.xml";
     if (!docx[customLocation]) {
       docx[customLocation] = generateCustomXml();
@@ -20937,7 +20937,7 @@ function storeSuperdocVersion(docx) {
 function generateCustomXml() {
   return DEFAULT_CUSTOM_XML;
 }
-function generateSuperdocVersion(pid = 2, version = "0.8.10") {
+function generateSuperdocVersion(pid = 2, version = "0.8.12") {
   return {
     type: "element",
     name: "property",
@@ -31398,6 +31398,357 @@ let Schema2 = _Schema;
 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, 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: 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 match = inputRuleMatcherHandler(textBefore, rule.match);
+    if (!match) {
+      return;
+    }
+    const tr = view.state.tr;
+    const state2 = chainableEditorState(tr, view.state);
+    const range2 = {
+      from: from2 - (match[0].length - text.length),
+      to
+    };
+    const { commands: commands2, chain, can } = new CommandService({
+      editor,
+      state: state2
+    });
+    const handler = rule.handler({
+      state: state2,
+      range: range2,
+      match,
+      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);
@@ -31482,6 +31833,7 @@ const _ExtensionService = class _ExtensionService2 {
   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,
@@ -31500,6 +31852,10 @@ const _ExtensionService = class _ExtensionService2 {
         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();
@@ -31507,7 +31863,13 @@ const _ExtensionService = class _ExtensionService2 {
       }
       return plugins;
     }).flat();
-    return [...allPlugins];
+    return [
+      inputRulesPlugin({
+        editor,
+        rules: inputRules
+      }),
+      ...allPlugins
+    ];
   }
   /**
    * Get all node views from the extensions.
@@ -31589,164 +31951,6 @@ attachEditorEvents_fn = function(extension) {
   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 i = 0; i < items.length; i += 1) {
@@ -32783,6 +32987,30 @@ const insertContentAt = (position, value, options2) => ({ tr, dispatch, editor }
   }
   return true;
 };
+const undoInputRule = () => ({ state: state2, dispatch }) => {
+  const plugins = state2.plugins;
+  for (let i = 0; i < plugins.length; i += 1) {
+    const plugin2 = plugins[i];
+    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;
@@ -33112,6 +33340,7 @@ const commands = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProp
   toggleList,
   toggleMark,
   toggleNode,
+  undoInputRule,
   unsetAllMarks,
   unsetMark,
   updateAttributes,
@@ -33141,6 +33370,7 @@ const Keymap = Extension.create({
       () => commands2.splitBlock()
     ]);
     const handleBackspace = () => this.editor.commands.first(({ commands: commands2, tr }) => [
+      () => commands2.undoInputRule(),
       () => {
         tr.setMeta("inputType", "deleteContentBackward");
         return false;
@@ -33756,199 +33986,6 @@ const getTrackChangesDecorations = (state2, onlyOriginalShown, onlyModifiedShown
   });
   return DecorationSet.create(state2.doc, decorations);
 };
-const replaceStep = ({ state: state2, tr, step, newTr, map: map22, 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(map22);
-  map22.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 = map22.maps.length - 1;
-    map22.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;
-    map22.appendMapping(deletionMap);
-  }
-  newTr.setMeta(TrackChangesBasePluginKey, meta);
-};
-const markWrapping = () => {
-};
-const replaceAroundStep = () => {
-};
-const addMarkStep = ({ state: state2, tr, step, newTr, map: map22, 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();
-    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: map22, 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(),
-          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);
@@ -34355,7 +34392,7 @@ const CommentsPlugin = Extension.create({
           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;
@@ -34389,10 +34426,14 @@ const CommentsPlugin = Extension.create({
                 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,
@@ -34460,9 +34501,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 found2 = false;
@@ -34499,13 +34544,30 @@ const getActiveCommentId = (doc2, selection) => {
   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 {
@@ -34645,6 +34707,202 @@ function findNode$1(node2, predicate) {
   });
   return found2;
 }
+const replaceStep = ({ state: state2, tr, step, newTr, map: map22, 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(map22);
+  map22.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 = map22.maps.length - 1;
+    map22.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;
+    map22.appendMapping(deletionMap);
+  }
+  newTr.setMeta(TrackChangesBasePluginKey, meta);
+  newTr.setMeta(CommentsPluginKey, { type: "force" });
+};
+const markWrapping = () => {
+};
+const replaceAroundStep = () => {
+};
+const addMarkStep = ({ state: state2, tr, step, newTr, map: map22, 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();
+    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: map22, 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(),
+          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"];
@@ -34803,6 +35061,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
       editorProps: {},
       parseOptions: {},
       coreExtensionOptions: {},
+      enableInputRules: true,
       isCommentsEnabled: false,
       isNewFile: false,
       scale: 1,
@@ -35241,7 +35500,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
    * @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");
@@ -36586,6 +36845,45 @@ const RunItem = Node2.create({
     };
   }
 });
+function wrappingInputRule(config) {
+  return new InputRule({
+    match: config.match,
+    handler: ({
+      state: state2,
+      range: range2,
+      match,
+      chain
+    }) => {
+      const attributes = callOrGet(config.getAttributes, null, match) || {};
+      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(match, before))) {
+        tr.join(range2.from - 1);
+      }
+    }
+  });
+}
+const inputRegex$1 = /^\s*([-+*])\s$/;
 const BulletList = Node2.create({
   name: "bulletList",
   group: "block list",
@@ -36596,7 +36894,8 @@ const BulletList = Node2.create({
     return {
       itemTypeName: "listItem",
       htmlAttributes: {},
-      keepMarks: true
+      keepMarks: true,
+      keepAttributes: false
     };
   },
   parseDOM() {
@@ -36634,8 +36933,29 @@ const BulletList = Node2.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(options2 = {}) {
   return new Plugin({
@@ -36846,6 +37166,7 @@ function buildFirstListItemAttrs({ state: state2, listItems }) {
     listNumberingType
   };
 }
+const inputRegex = /^(\d+)\.\s$/;
 const OrderedList = Node2.create({
   name: "orderedList",
   group: "block list",
@@ -36857,6 +37178,7 @@ const OrderedList = Node2.create({
       itemTypeName: "listItem",
       htmlAttributes: {},
       keepMarks: true,
+      keepAttributes: false,
       listStyleTypes: ["decimal", "lowerAlpha", "lowerRoman"]
     };
   },
@@ -37014,6 +37336,28 @@ const OrderedList = Node2.create({
   },
   addPmPlugins() {
     return [orderedListMarker(), orderedListSync()];
+  },
+  addInputRules() {
+    let inputRule = wrappingInputRule({
+      match: inputRegex,
+      type: this.type,
+      getAttributes: (match) => ({ start: +match[1] }),
+      joinPredicate: (match, node2) => node2.childCount + node2.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, node2) => node2.childCount + node2.attrs.start === +match[1],
+        editor: this.editor
+      });
+    }
+    return [
+      inputRule
+    ];
   }
 });
 function randomId() {
@@ -58787,4 +59131,4 @@ export {
   helpers as m,
   index as n
 };
-//# sourceMappingURL=super-editor.es-CnpejCPC.js.map
+//# sourceMappingURL=super-editor.es-D8IC7SPE.js.map