@harbour-enterprises/superdoc 0.8.10 → 0.8.11

package/dist/chunks/{super-editor.es-CnpejCPC.js → super-editor.es-DIeHC3Si.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.11") {
     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.11") {
   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;
@@ -34803,6 +35033,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
       editorProps: {},
       parseOptions: {},
       coreExtensionOptions: {},
+      enableInputRules: true,
       isCommentsEnabled: false,
       isNewFile: false,
       scale: 1,
@@ -35241,7 +35472,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.11");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -36586,6 +36817,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 +36866,8 @@ const BulletList = Node2.create({
     return {
       itemTypeName: "listItem",
       htmlAttributes: {},
-      keepMarks: true
+      keepMarks: true,
+      keepAttributes: false
     };
   },
   parseDOM() {
@@ -36634,8 +36905,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 +37138,7 @@ function buildFirstListItemAttrs({ state: state2, listItems }) {
     listNumberingType
   };
 }
+const inputRegex = /^(\d+)\.\s$/;
 const OrderedList = Node2.create({
   name: "orderedList",
   group: "block list",
@@ -36857,6 +37150,7 @@ const OrderedList = Node2.create({
       itemTypeName: "listItem",
       htmlAttributes: {},
       keepMarks: true,
+      keepAttributes: false,
       listStyleTypes: ["decimal", "lowerAlpha", "lowerRoman"]
     };
   },
@@ -37014,6 +37308,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 +59103,4 @@ export {
   helpers as m,
   index as n
 };
-//# sourceMappingURL=super-editor.es-CnpejCPC.js.map
+//# sourceMappingURL=super-editor.es-DIeHC3Si.js.map