@harbour-enterprises/superdoc 0.8.10 → 0.8.11

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.11") {
       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.11") {
     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;
@@ -42140,6 +42370,7 @@
         editorProps: {},
         parseOptions: {},
         coreExtensionOptions: {},
+        enableInputRules: true,
         isCommentsEnabled: false,
         isNewFile: false,
         scale: 1,
@@ -42578,7 +42809,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.11");
       if (!this.options.ydoc) return;
       const metaMap = this.options.ydoc.getMap("meta");
       let docVersion = metaMap.get("version");
@@ -43923,6 +44154,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 +44203,8 @@
       return {
         itemTypeName: "listItem",
         htmlAttributes: {},
-        keepMarks: true
+        keepMarks: true,
+        keepAttributes: false
       };
     },
     parseDOM() {
@@ -43971,8 +44242,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 +44475,7 @@
       listNumberingType
     };
   }
+  const inputRegex = /^(\d+)\.\s$/;
   const OrderedList = Node$1.create({
     name: "orderedList",
     group: "block list",
@@ -44194,6 +44487,7 @@
         itemTypeName: "listItem",
         htmlAttributes: {},
         keepMarks: true,
+        keepAttributes: false,
         listStyleTypes: ["decimal", "lowerAlpha", "lowerRoman"]
       };
     },
@@ -44351,6 +44645,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 +111278,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.11";
       console.debug("🦋 [superdoc] Using SuperDoc version:", this.version);
       this.superdocId = config.superdocId || v4();
       this.colors = this.config.colors;