@domternal/core 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -4,8 +4,8 @@ var state = require('@domternal/pm/state');
 var view = require('@domternal/pm/view');
 var model = require('@domternal/pm/model');
 var keymap = require('@domternal/pm/keymap');
-var inputrules = require('@domternal/pm/inputrules');
 var commands = require('@domternal/pm/commands');
+var inputrules = require('@domternal/pm/inputrules');
 var transform = require('@domternal/pm/transform');
 var schemaList = require('@domternal/pm/schema-list');
 var dom = require('@floating-ui/dom');
@@ -109,6 +109,112 @@ var EventEmitter = class {
     return Array.from(this.callbacks.keys());
   }
 };
+var MAX_MATCH = 500;
+function run(view, from, to, text, rules, plugin) {
+  if (view.composing) return false;
+  const state = view.state;
+  const $from = state.doc.resolve(from);
+  const textBefore = $from.parent.textBetween(
+    Math.max(0, $from.parentOffset - MAX_MATCH),
+    $from.parentOffset,
+    null,
+    "\uFFFC"
+  ) + text;
+  for (const rawRule of rules) {
+    const rule = rawRule;
+    if (!rule.inCodeMark && $from.marks().some((m) => m.type.spec.code)) continue;
+    if ($from.parent.type.spec.code) {
+      if (!rule.inCode) continue;
+    } else if (rule.inCode === "only") {
+      continue;
+    }
+    const match = rule.match.exec(textBefore);
+    if (!match || match[0].length < text.length) continue;
+    const startPos = from - (match[0].length - text.length);
+    if (!rule.inCodeMark) {
+      const codeMarks = [];
+      state.doc.nodesBetween(startPos, $from.pos, (node) => {
+        if (node.isInline && node.marks.some((m) => m.type.spec.code)) codeMarks.push(true);
+      });
+      if (codeMarks.length > 0) continue;
+    }
+    const tr = rule.handler(state, match, startPos, to);
+    if (!tr) continue;
+    if (rule.undoable) {
+      tr.setMeta(plugin, { transform: tr, from, to, text });
+    }
+    view.dispatch(tr);
+    return true;
+  }
+  return false;
+}
+function undoInputRule(plugin, state$1, dispatch) {
+  const undoable = plugin.getState(state$1);
+  if (!undoable) return false;
+  if (dispatch) {
+    const tr = state$1.tr;
+    const toUndo = undoable.transform;
+    for (let j = toUndo.steps.length - 1; j >= 0; j--) {
+      const step = toUndo.steps[j];
+      const doc = toUndo.docs[j];
+      if (step && doc) tr.step(step.invert(doc));
+    }
+    if (undoable.text) {
+      const marks = tr.doc.resolve(undoable.from).marks();
+      tr.replaceWith(undoable.from, undoable.to, state$1.schema.text(undoable.text, marks));
+      const endPos = undoable.from + undoable.text.length;
+      if (endPos <= tr.doc.content.size) {
+        tr.setSelection(state.TextSelection.create(tr.doc, endPos));
+      }
+    } else {
+      tr.delete(undoable.from, undoable.to);
+    }
+    dispatch(tr);
+  }
+  return true;
+}
+function inputRulesPlugin({ rules }) {
+  const plugin = new state.Plugin({
+    state: {
+      init() {
+        return null;
+      },
+      apply(tr, prev) {
+        const stored = tr.getMeta(plugin);
+        if (stored) return stored;
+        if (tr.getMeta("appendedTransaction")) return prev;
+        return tr.selectionSet || tr.docChanged ? null : prev;
+      }
+    },
+    props: {
+      handleTextInput(view, from, to, text) {
+        return run(view, from, to, text, rules, plugin);
+      },
+      handleKeyDown(view, event) {
+        if (event.key === "Backspace" && !event.ctrlKey && !event.metaKey && !event.altKey) {
+          return undoInputRule(plugin, view.state, (tr) => {
+            view.dispatch(tr);
+          });
+        }
+        return false;
+      },
+      handleDOMEvents: {
+        compositionend: (view) => {
+          setTimeout(() => {
+            const { $cursor } = view.state.selection;
+            if ($cursor) {
+              run(view, $cursor.pos, $cursor.pos, "", rules, plugin);
+            }
+          });
+        }
+      }
+    },
+    // Tag so external undoInputRule can also find this plugin
+    isInputRules: true
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  });
+  return plugin;
+}
 
 // src/helpers/callOrReturn.ts
 function callOrReturn(value, context, ...args) {
@@ -486,14 +592,14 @@ var ExtensionManager = class {
    */
   buildPlugins() {
     const plugins = [];
+    const rules = this.collectInputRules();
+    if (rules.length > 0) {
+      plugins.push(inputRulesPlugin({ rules }));
+    }
     const shortcuts = this.collectKeyboardShortcuts();
     if (Object.keys(shortcuts).length > 0) {
       plugins.push(keymap.keymap(shortcuts));
     }
-    const rules = this.collectInputRules();
-    if (rules.length > 0) {
-      plugins.push(inputrules.inputRules({ rules }));
-    }
     for (const ext of this._extensions) {
       const addPlugins = ext.config.addProseMirrorPlugins;
       if (addPlugins) {
@@ -936,7 +1042,7 @@ function isDocumentEmpty(doc) {
   });
 }
 function markInputRule(options) {
-  const { find: find2, type, getAttributes } = options;
+  const { find: find2, type, getAttributes, undoable } = options;
   return new inputrules.InputRule(
     find2,
     (state, match, start, end) => {
@@ -953,7 +1059,8 @@ function markInputRule(options) {
       tr.addMark(start, start + textContent.length, type.create(attributes ?? void 0));
       tr.removeStoredMark(type);
       return tr;
-    }
+    },
+    undoable !== void 0 ? { undoable } : {}
   );
 }
 var markInputRulePatterns = {
@@ -978,6 +1085,69 @@ var markInputRulePatterns = {
    */
   highlight: /(?:==)([^=]+)(?:==)$/
 };
+function wrappingInputRule(options) {
+  const { find: find2, type, getAttributes = null, joinPredicate, undoable, guard } = options;
+  return new inputrules.InputRule(
+    find2,
+    (state, match, start, end) => {
+      if (guard && !guard(state)) return null;
+      const attrs = getAttributes instanceof Function ? getAttributes(match) : getAttributes;
+      const tr = state.tr.delete(start, end);
+      const $start = tr.doc.resolve(start);
+      const range = $start.blockRange();
+      const wrapping = range && transform.findWrapping(range, type, attrs);
+      if (!wrapping) return null;
+      tr.wrap(range, wrapping);
+      const before = tr.doc.resolve(start - 1).nodeBefore;
+      if (before?.type === type && transform.canJoin(tr.doc, start - 1) && (!joinPredicate || joinPredicate(match, before))) {
+        tr.join(start - 1);
+      }
+      return tr;
+    },
+    undoable !== void 0 ? { undoable } : {}
+  );
+}
+function notInsideList(state) {
+  const { $from } = state.selection;
+  for (let d = $from.depth; d > 0; d--) {
+    const name = $from.node(d).type.name;
+    if (name === "listItem" || name === "taskItem") return false;
+  }
+  return true;
+}
+function textblockTypeInputRule(options) {
+  const { find: find2, type, getAttributes = null, undoable } = options;
+  return new inputrules.InputRule(
+    find2,
+    (state, match, start, end) => {
+      const $start = state.doc.resolve(start);
+      const attrs = getAttributes instanceof Function ? getAttributes(match) : getAttributes;
+      if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), type)) return null;
+      return state.tr.delete(start, end).setBlockType(start, start, type, attrs);
+    },
+    undoable !== void 0 ? { undoable } : {}
+  );
+}
+function textInputRule(options) {
+  const { find: find2, replace, undoable } = options;
+  return new inputrules.InputRule(
+    find2,
+    (state, _match, start, end) => state.tr.replaceWith(start, end, state.schema.text(replace)),
+    undoable !== void 0 ? { undoable } : {}
+  );
+}
+function nodeInputRule(options) {
+  const { find: find2, type, getAttributes = null, undoable } = options;
+  return new inputrules.InputRule(
+    find2,
+    (state, match, start, end) => {
+      const attrs = getAttributes instanceof Function ? getAttributes(match, state) : getAttributes;
+      if (getAttributes instanceof Function && attrs === null) return null;
+      return state.tr.replaceWith(start, end, type.create(attrs));
+    },
+    undoable !== void 0 ? { undoable } : {}
+  );
+}
 
 // src/helpers/isValidUrl.ts
 function isValidUrl(url, options = {}) {
@@ -1821,8 +1991,8 @@ var wrapIn = (nodeName, attributes) => ({ state, tr, dispatch }) => {
   return true;
 };
 var toggleWrap = (nodeName, attributes) => (props) => {
-  const { state: state$1, tr, dispatch } = props;
-  const nodeType = state$1.schema.nodes[nodeName];
+  const { state, tr, dispatch } = props;
+  const nodeType = state.schema.nodes[nodeName];
   if (!nodeType) {
     return false;
   }
@@ -1866,8 +2036,18 @@ var toggleWrap = (nodeName, attributes) => (props) => {
   const allWrapped = contentBlocks.length > 0 ? contentBlocks.every(({ pos }) => isInsideWrap(pos)) : isInsideWrap(from);
   if (allWrapped) {
     const first = contentBlocks[0];
-    if (first) {
-      tr.setSelection(state.TextSelection.create(tr.doc, first.pos + 1));
+    const last = contentBlocks[contentBlocks.length - 1];
+    if (first && last) {
+      const $liftFrom = tr.doc.resolve(first.pos + 1);
+      const $liftTo = tr.doc.resolve(last.pos + 1);
+      const range = $liftFrom.blockRange($liftTo);
+      if (!range) return false;
+      const target = transform.liftTarget(range);
+      if (target === null) return false;
+      if (!dispatch) return true;
+      tr.lift(range, target).scrollIntoView();
+      dispatch(tr);
+      return true;
     }
     return lift()(props);
   }
@@ -1901,6 +2081,36 @@ var lift = () => ({ tr, dispatch }) => {
   dispatch(tr);
   return true;
 };
+function joinListBackwards(tr, listType) {
+  const { $from } = tr.selection;
+  for (let d = $from.depth; d >= 0; d--) {
+    if ($from.node(d).type === listType) {
+      const listPos = $from.before(d);
+      if (listPos > 0 && transform.canJoin(tr.doc, listPos)) {
+        const nodeBefore = tr.doc.resolve(listPos - 1).parent;
+        if (nodeBefore.type === listType) {
+          tr.join(listPos);
+        }
+      }
+      return;
+    }
+  }
+}
+function joinListForwards(tr, listType) {
+  const { $from } = tr.selection;
+  for (let d = $from.depth; d >= 0; d--) {
+    if ($from.node(d).type === listType) {
+      const after = $from.after(d);
+      if (after < tr.doc.content.size && transform.canJoin(tr.doc, after)) {
+        const nodeAfter = tr.doc.nodeAt(after);
+        if (nodeAfter?.type === listType) {
+          tr.join(after);
+        }
+      }
+      return;
+    }
+  }
+}
 var toggleList = (listNodeName, listItemNodeName, attributes) => ({ state: state$1, tr, dispatch }) => {
   const listType = state$1.schema.nodes[listNodeName];
   const listItemType = state$1.schema.nodes[listItemNodeName];
@@ -2056,11 +2266,56 @@ var toggleList = (listNodeName, listItemNodeName, attributes) => ({ state: state
     dispatch(tr);
     return true;
   }
-  const { $from: $wrapFrom, $to: $wrapTo } = tr.selection;
+  const blocksInList = contentBlocks.filter((b) => b.inSomeList);
+  if (blocksInList.length === 0) {
+    const { $from: $wf, $to: $wt } = tr.selection;
+    const wr = $wf.blockRange($wt);
+    if (!wr) return false;
+    if (!schemaList.wrapRangeInList(dispatch ? tr : null, wr, listType, attributes)) return false;
+    if (dispatch) {
+      joinListBackwards(tr, listType);
+      joinListForwards(tr, listType);
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  }
+  if (!dispatch) return true;
+  const seen = /* @__PURE__ */ new Set();
+  const listPositions = [];
+  for (const block of blocksInList) {
+    const $pos = tr.doc.resolve(block.pos);
+    for (let d = $pos.depth; d >= 0; d--) {
+      const groups = ($pos.node(d).type.spec.group ?? "").split(/\s+/);
+      if (groups.includes("list")) {
+        const lpos = $pos.before(d);
+        if (!seen.has(lpos)) {
+          seen.add(lpos);
+          listPositions.push(lpos);
+        }
+        break;
+      }
+    }
+  }
+  listPositions.sort((a, b) => b - a);
+  for (const pos of listPositions) {
+    const listNode = tr.doc.nodeAt(pos);
+    if (!listNode) continue;
+    const children = [];
+    listNode.forEach((item) => {
+      item.forEach((child) => children.push(child));
+    });
+    tr.replaceWith(pos, pos + listNode.nodeSize, children);
+  }
+  const mappedFrom = tr.mapping.map(from, -1);
+  const mappedTo = tr.mapping.map(to, 1);
+  const $wrapFrom = tr.doc.resolve(mappedFrom);
+  const $wrapTo = tr.doc.resolve(mappedTo);
   const wrapRange = $wrapFrom.blockRange($wrapTo);
   if (!wrapRange) return false;
-  if (!schemaList.wrapRangeInList(dispatch ? tr : null, wrapRange, listType, attributes)) return false;
-  if (dispatch) dispatch(tr.scrollIntoView());
+  schemaList.wrapRangeInList(tr, wrapRange, listType, attributes);
+  joinListBackwards(tr, listType);
+  joinListForwards(tr, listType);
+  dispatch(tr.scrollIntoView());
   return true;
 };
 
@@ -4409,7 +4664,32 @@ var Heading = Node.create({
     ];
   },
   addProseMirrorPlugins() {
+    const { options, editor } = this;
+    const codeToLevel = {};
+    for (const level of options.levels) {
+      codeToLevel[`Digit${String(level)}`] = level;
+    }
+    codeToLevel["Digit0"] = 0;
     return [
+      new state.Plugin({
+        key: new state.PluginKey("headingKeydownFix"),
+        props: {
+          handleDOMEvents: {
+            keydown(_view, event) {
+              if (!event.altKey || !(event.metaKey || event.ctrlKey)) return false;
+              const level = codeToLevel[event.code];
+              if (level === void 0) return false;
+              event.preventDefault();
+              if (level === 0) {
+                editor?.commands["setParagraph"]?.();
+              } else {
+                editor?.commands["toggleHeading"]?.({ level });
+              }
+              return true;
+            }
+          }
+        }
+      }),
       keymap.keymap({
         Backspace: ((state, dispatch) => {
           const { selection } = state;
@@ -4436,10 +4716,10 @@ var Heading = Node.create({
     }
     const maxLevel = Math.max(...options.levels);
     return [
-      inputrules.textblockTypeInputRule(
-        new RegExp(`^(#{1,${String(maxLevel)}})\\s$`),
-        nodeType,
-        (match) => {
+      textblockTypeInputRule({
+        find: new RegExp(`^(#{1,${String(maxLevel)}})\\s$`),
+        type: nodeType,
+        getAttributes: (match) => {
           const hashes = match[1];
           if (!hashes) {
             return null;
@@ -4450,10 +4730,12 @@ var Heading = Node.create({
           }
           return { level };
         }
-      )
+      })
     ];
   }
 });
+
+// src/nodes/Blockquote.ts
 var Blockquote = Node.create({
   name: "blockquote",
   group: "block",
@@ -4513,7 +4795,7 @@ var Blockquote = Node.create({
       return [];
     }
     return [
-      inputrules.wrappingInputRule(/^\s*>\s$/, nodeType)
+      wrappingInputRule({ find: /^\s*>\s$/, type: nodeType })
     ];
   }
 });
@@ -4643,14 +4925,14 @@ var CodeBlock = Node.create({
       return [];
     }
     return [
-      inputrules.textblockTypeInputRule(
-        /^```([a-z]*)?[\s\n]$/,
-        nodeType,
-        (match) => {
+      textblockTypeInputRule({
+        find: /^```([a-z]*)?[\s\n]$/,
+        type: nodeType,
+        getAttributes: (match) => {
           const language = match[1] ?? null;
           return { language };
         }
-      )
+      })
     ];
   }
 });
@@ -4834,14 +5116,16 @@ var BulletList = Node.create({
     }
     return [
       // - item
-      inputrules.wrappingInputRule(/^\s*[-]\s$/, nodeType),
+      wrappingInputRule({ find: /^\s*[-]\s$/, type: nodeType, guard: notInsideList }),
       // * item
-      inputrules.wrappingInputRule(/^\s*[*]\s$/, nodeType),
+      wrappingInputRule({ find: /^\s*[*]\s$/, type: nodeType, guard: notInsideList }),
       // + item
-      inputrules.wrappingInputRule(/^\s*[+]\s$/, nodeType)
+      wrappingInputRule({ find: /^\s*[+]\s$/, type: nodeType, guard: notInsideList })
     ];
   }
 });
+
+// src/nodes/OrderedList.ts
 var OrderedList = Node.create({
   name: "orderedList",
   group: "block list",
@@ -4917,14 +5201,15 @@ var OrderedList = Node.create({
     }
     return [
       // 1. item (any number followed by . )
-      inputrules.wrappingInputRule(
-        /^(\d+)\.\s$/,
-        nodeType,
-        (match) => {
+      wrappingInputRule({
+        find: /^(\d+)\.\s$/,
+        type: nodeType,
+        guard: notInsideList,
+        getAttributes: (match) => {
           const num = match[1];
           return { start: num ? parseInt(num, 10) : 1 };
         }
-      )
+      })
     ];
   }
 });
@@ -4999,13 +5284,12 @@ var HorizontalRule = Node.create({
             const $start = state$1.doc.resolve(start);
             const from = $start.before();
             const to = $start.after();
-            tr.replaceWith(from, to, nodeType.create());
-            if (from + 1 < tr.doc.content.size) {
-              const $after = tr.doc.resolve(from + 1);
-              const sel = state.TextSelection.findFrom($after, 1);
-              if (sel) {
-                tr.setSelection(sel);
-              }
+            const paragraph = state$1.schema.nodes["paragraph"]?.create();
+            const nodes = paragraph ? [nodeType.create(), paragraph] : [nodeType.create()];
+            tr.replaceWith(from, to, nodes);
+            const sel = state.TextSelection.findFrom(tr.doc.resolve(from + 1), 1);
+            if (sel) {
+              tr.setSelection(sel);
             }
           }
           return tr;
@@ -5047,6 +5331,20 @@ var HardBreak = Node.create({
       }
     };
   },
+  addToolbarItems() {
+    return [
+      {
+        type: "button",
+        name: "hardBreak",
+        command: "setHardBreak",
+        icon: "linkBreak",
+        label: "Hard Break",
+        shortcut: "Shift-Enter",
+        group: "insert",
+        priority: 50
+      }
+    ];
+  },
   addKeyboardShortcuts() {
     const { editor } = this;
     return {
@@ -5282,9 +5580,9 @@ var TaskList = Node.create({
     }
     return [
       // [ ] at start of line creates unchecked task
-      inputrules.wrappingInputRule(/^\s*\[\s?\]\s$/, nodeType),
+      wrappingInputRule({ find: /^\s*\[\s?\]\s$/, type: nodeType, guard: notInsideList }),
       // [x] or [X] at start of line creates checked task
-      inputrules.wrappingInputRule(/^\s*\[[xX]\]\s$/, nodeType)
+      wrappingInputRule({ find: /^\s*\[[xX]\]\s$/, type: nodeType, guard: notInsideList })
     ];
   }
 });
@@ -6582,40 +6880,39 @@ var Typography = Extension.create({
   },
   addInputRules() {
     const rules = [];
-    const textReplace = (find2, replacement) => new inputrules.InputRule(find2, (state, _match, start, end) => state.tr.replaceWith(start, end, state.schema.text(replacement)));
     if (this.options.emDash) {
-      rules.push(textReplace(/--$/, "\u2014"));
+      rules.push(textInputRule({ find: /--$/, replace: "\u2014" }));
     }
     if (this.options.ellipsis) {
-      rules.push(textReplace(/\.\.\.$/, "\u2026"));
+      rules.push(textInputRule({ find: /\.\.\.$/, replace: "\u2026" }));
     }
     if (this.options.arrows) {
-      rules.push(textReplace(/<-$/, "\u2190"));
-      rules.push(textReplace(/->$/, "\u2192"));
-      rules.push(textReplace(/=>$/, "\u21D2"));
+      rules.push(textInputRule({ find: /<-$/, replace: "\u2190" }));
+      rules.push(textInputRule({ find: /->$/, replace: "\u2192" }));
+      rules.push(textInputRule({ find: /=>$/, replace: "\u21D2" }));
     }
     if (this.options.fractions) {
-      rules.push(textReplace(/1\/2$/, "\xBD"));
-      rules.push(textReplace(/1\/4$/, "\xBC"));
-      rules.push(textReplace(/3\/4$/, "\xBE"));
-      rules.push(textReplace(/1\/3$/, "\u2153"));
-      rules.push(textReplace(/2\/3$/, "\u2154"));
+      rules.push(textInputRule({ find: /1\/2$/, replace: "\xBD" }));
+      rules.push(textInputRule({ find: /1\/4$/, replace: "\xBC" }));
+      rules.push(textInputRule({ find: /3\/4$/, replace: "\xBE" }));
+      rules.push(textInputRule({ find: /1\/3$/, replace: "\u2153" }));
+      rules.push(textInputRule({ find: /2\/3$/, replace: "\u2154" }));
     }
     if (this.options.symbols) {
-      rules.push(textReplace(/\(c\)$/i, "\xA9"));
-      rules.push(textReplace(/\(r\)$/i, "\xAE"));
-      rules.push(textReplace(/\(tm\)$/i, "\u2122"));
-      rules.push(textReplace(/\(sm\)$/i, "\u2120"));
+      rules.push(textInputRule({ find: /\(c\)$/i, replace: "\xA9" }));
+      rules.push(textInputRule({ find: /\(r\)$/i, replace: "\xAE" }));
+      rules.push(textInputRule({ find: /\(tm\)$/i, replace: "\u2122" }));
+      rules.push(textInputRule({ find: /\(sm\)$/i, replace: "\u2120" }));
     }
     if (this.options.math) {
-      rules.push(textReplace(/\+\/-$/, "\xB1"));
-      rules.push(textReplace(/!=$/, "\u2260"));
-      rules.push(textReplace(/<=$/, "\u2264"));
-      rules.push(textReplace(/>=$/, "\u2265"));
+      rules.push(textInputRule({ find: /\+\/-$/, replace: "\xB1" }));
+      rules.push(textInputRule({ find: /!=$/, replace: "\u2260" }));
+      rules.push(textInputRule({ find: /<=$/, replace: "\u2264" }));
+      rules.push(textInputRule({ find: />=$/, replace: "\u2265" }));
     }
     if (this.options.guillemets) {
-      rules.push(textReplace(/<<$/, "\xAB"));
-      rules.push(textReplace(/>>$/, "\xBB"));
+      rules.push(textInputRule({ find: /<<$/, replace: "\xAB" }));
+      rules.push(textInputRule({ find: />>$/, replace: "\xBB" }));
     }
     if (this.options.smartQuotes) {
       const { openDoubleQuote, closeDoubleQuote, openSingleQuote, closeSingleQuote } = this.options;
@@ -7852,11 +8149,13 @@ function linkPopoverPlugin({ editor, markType, protocols }) {
   applyBtn.type = "button";
   applyBtn.className = "dm-link-popover-btn dm-link-popover-apply";
   applyBtn.title = "Apply link";
+  applyBtn.setAttribute("aria-label", "Apply link");
   applyBtn.innerHTML = defaultIcons["check"] ?? "";
   const removeBtn = document.createElement("button");
   removeBtn.type = "button";
   removeBtn.className = "dm-link-popover-btn dm-link-popover-remove";
   removeBtn.title = "Remove link";
+  removeBtn.setAttribute("aria-label", "Remove link");
   removeBtn.innerHTML = defaultIcons["linkBreak"] ?? "";
   el.appendChild(input);
   el.appendChild(applyBtn);
@@ -8622,6 +8921,7 @@ exports.linkPastePlugin = linkPastePlugin;
 exports.linkPastePluginKey = linkPastePluginKey;
 exports.markInputRule = markInputRule;
 exports.markInputRulePatterns = markInputRulePatterns;
+exports.nodeInputRule = nodeInputRule;
 exports.placeholderPluginKey = placeholderPluginKey;
 exports.positionFloating = positionFloating;
 exports.positionFloatingOnce = positionFloatingOnce;
@@ -8632,6 +8932,8 @@ exports.selectionDecorationPluginKey = selectionDecorationPluginKey;
 exports.setBlockType = setBlockType;
 exports.setContent = setContent;
 exports.setMark = setMark;
+exports.textInputRule = textInputRule;
+exports.textblockTypeInputRule = textblockTypeInputRule;
 exports.toggleBlockType = toggleBlockType;
 exports.toggleList = toggleList;
 exports.toggleMark = toggleMark;
@@ -8641,5 +8943,6 @@ exports.unsetAllMarks = unsetAllMarks;
 exports.unsetMark = unsetMark;
 exports.updateAttributes = updateAttributes;
 exports.wrapIn = wrapIn;
+exports.wrappingInputRule = wrappingInputRule;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map