@prosekit/extensions 0.4.3 → 0.4.5

package/dist/_tsup-dts-rollup.d.ts

@@ -29,7 +29,7 @@ import { ToggleCollapsedOptions } from 'prosemirror-flat-list';
 import { Transaction } from '@prosekit/pm/state';
 import { UnwrapListOptions } from 'prosemirror-flat-list';
 
-export declare function applyMarkRules(rules: MarkRule[], transactions: readonly Transaction[], oldState: EditorState, newState: EditorState): Transaction | null;
+export declare function applyMarkRules(rules: MarkRuleOptions[], transactions: readonly Transaction[], oldState: EditorState, newState: EditorState): Transaction | null;
 
 declare class AutocompleteRule {
     readonly regex: RegExp;
@@ -118,6 +118,11 @@ export declare function createAutocompletePlugin({ getRules, }: {
  */
 export declare function createLazyParser(highlighterOptions: HighlighterOptions): Parser;
 
+/**
+ * @internal
+ */
+export declare function createMarkInputRule({ regex, type, attrs, }: MarkInputRuleOptions): InputRule;
+
 export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
 
 export declare const default_alias_1: {
@@ -165,6 +170,8 @@ toggleBold: [];
 };
 }>;
 
+export declare function defineBoldInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
 export declare function defineBoldKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
 export declare function defineBoldSpec(): Extension<    {
@@ -283,6 +290,10 @@ toggleCode: [];
 };
 }>;
 
+export declare function defineCodeInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineCodeKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
 /**
  * @public
  */
@@ -385,9 +396,9 @@ toggleItalic: [];
 };
 }>;
 
-export declare function defineItalicKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export declare function defineItalicInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
-export declare function defineItalicKeymap_alias_1(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export declare function defineItalicKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
 export declare function defineItalicSpec(): Extension<    {
 MARKS: "italic";
@@ -481,11 +492,21 @@ export declare function defineListSpec(): Extension<{
     NODES: "list";
 }>;
 
+/**
+ * Defines an input rule for automatically adding inline marks when a given
+ * pattern is typed.
+ *
+ * @public
+ */
+export declare function defineMarkInputRule(options: MarkInputRuleOptions): Extension;
+
 /**
  * A mark rule is something that can automatically apply marks to text if it
  * matches a certain pattern, and remove them if it doesn't match anymore.
  */
-export declare function defineMarkRule(options: MarkRuleOptions): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineMarkRule(options: MarkRuleOptions): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineMarkRule }
+export { defineMarkRule as defineMarkRule_alias_1 }
 
 /**
  * @public
@@ -537,6 +558,8 @@ toggleStrike: [];
 };
 }>;
 
+export declare function defineStrikeInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
 export declare function defineStrikeKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
 export declare function defineStrikeSpec(): Extension<    {
@@ -626,8 +649,9 @@ export declare function defineTextBlockEnterRule({ regex, type, attrs, stop, }:
  */
 export declare function defineTextBlockInputRule({ regex, type, attrs, }: {
     /**
-     * The regular expression to match against. You'll usually want to start it
-     * with `^` to that it is only matched at the start of a textblock.
+     * The regular expression to match against, which should end with `$`. It
+     * usually also starts with `^` to that it is only matched at the start of a
+     * textblock.
      */
     regex: RegExp;
     /**
@@ -684,8 +708,9 @@ export declare function defineVirtualSelection(): Extension;
  */
 export declare function defineWrappingInputRule({ regex, type, attrs, join, }: {
     /**
-     * The regular expression to match against. You'll usually want to start it
-     * with `^` to that it is only matched at the start of a textblock.
+     * The regular expression to match against, which should end with `$`. It
+     * usually also starts with `^` to that it is only matched at the start of a
+     * textblock.
      */
     regex: RegExp;
     /**
@@ -837,13 +862,25 @@ export declare interface LinkAttrs {
 export { ListDOMSerializer }
 
 /**
- * @internal
+ * Options for {@link defineMarkInputRule}.
+ *
+ * @public
  */
-export declare class MarkRule {
-    readonly regex: RegExp;
-    readonly type: string | MarkType;
-    readonly getAttrs: (match: RegExpMatchArray) => Attrs | null;
-    constructor({ regex, type, attrs }: MarkRuleOptions);
+export declare interface MarkInputRuleOptions {
+    /**
+     * The regular expression to match against, which should end with `$` and has
+     * exactly one capture group. All other matched text outside the capture group
+     * will be deleted.
+     */
+    regex: RegExp;
+    /**
+     * The type of mark to set.
+     */
+    type: string | MarkType;
+    /**
+     * Attributes to set on the mark.
+     */
+    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
 }
 
 /**

package/dist/chunk-CJ3SOSL6.js

@@ -0,0 +1,100 @@
+// src/input-rule/index.ts
+import {
+  Facet,
+  getMarkType,
+  getNodeType,
+  isMarkAbsent,
+  maybeRun,
+  pluginFacet
+} from "@prosekit/core";
+import {
+  InputRule,
+  inputRules,
+  textblockTypeInputRule,
+  wrappingInputRule
+} from "@prosekit/pm/inputrules";
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+function defineInputRule(rule) {
+  return inputRuleFacet.extension([() => rule]);
+}
+function createMarkInputRule({
+  regex,
+  type,
+  attrs = null
+}) {
+  const rule = new InputRule(regex, (state, match, start, end) => {
+    var _a;
+    const { tr, schema } = state;
+    const [fullText, markText] = match;
+    if (!markText) {
+      return null;
+    }
+    const markStart = start + fullText.indexOf(markText);
+    const markEnd = markStart + markText.length;
+    if (!(start <= markStart && markStart < markEnd && markEnd <= end)) {
+      return null;
+    }
+    const markType = getMarkType(schema, type);
+    const mark = markType.create(maybeRun(attrs, match));
+    if (!isMarkAbsent(tr.doc, markStart, markEnd, markType, attrs)) {
+      return null;
+    }
+    const initialStoredMarks = (_a = tr.storedMarks) != null ? _a : [];
+    tr.addMark(markStart, markEnd, mark);
+    if (markEnd < end) {
+      tr.delete(markEnd, end);
+    }
+    if (start < markStart) {
+      tr.delete(start, markStart);
+    }
+    tr.setStoredMarks(initialStoredMarks);
+    return tr;
+  });
+  return rule;
+}
+function defineMarkInputRule(options) {
+  return defineInputRule(createMarkInputRule(options));
+}
+function defineTextBlockInputRule({
+  regex,
+  type,
+  attrs
+}) {
+  return inputRuleFacet.extension([
+    ({ schema }) => {
+      const nodeType = getNodeType(schema, type);
+      return textblockTypeInputRule(regex, nodeType, attrs);
+    }
+  ]);
+}
+function defineWrappingInputRule({
+  regex,
+  type,
+  attrs,
+  join
+}) {
+  return inputRuleFacet.extension([
+    ({ schema }) => {
+      const nodeType = getNodeType(schema, type);
+      return wrappingInputRule(regex, nodeType, attrs, join);
+    }
+  ]);
+}
+var inputRuleFacet = Facet.define({
+  convert: (inputs) => {
+    return (context) => {
+      const rules = inputs.flatMap((callback) => callback(context));
+      return [inputRules({ rules })];
+    };
+  },
+  next: pluginFacet
+});
+
+export {
+  defineInputRule,
+  createMarkInputRule,
+  defineMarkInputRule,
+  defineTextBlockInputRule,
+  defineWrappingInputRule
+};

package/dist/{chunk-TXF4SPMB.js → chunk-FG6YUKCN.js}

@@ -1,9 +1,13 @@
-// src/mark-rule/index.ts
+// src/mark-rule/extension.ts
 import { Facet, pluginFacet } from "@prosekit/core";
 import { ProseMirrorPlugin } from "@prosekit/pm/state";
 
 // src/mark-rule/apply.ts
-import { OBJECT_REPLACEMENT_CHARACTER, getMarkType } from "@prosekit/core";
+import {
+  OBJECT_REPLACEMENT_CHARACTER,
+  getMarkType,
+  maybeRun
+} from "@prosekit/core";
 import "@prosekit/pm/model";
 import "@prosekit/pm/state";
 
@@ -62,7 +66,7 @@ function getMapRange(transactions, oldState, newState) {
       hi = map.map(hi);
       map.forEach((_oldStart, _oldEnd, newStart, newEnd) => {
         lo = Math.min(lo, hi, newStart);
-        hi = Math.max(hi, hi, newEnd);
+        hi = Math.max(lo, hi, newEnd);
       });
     }
   }
@@ -78,7 +82,7 @@ function getCheckRanges(transactions, oldState, newState) {
 // src/mark-rule/apply.ts
 function getExpectedMarkings(rules, doc, from, to) {
   const text = doc.textBetween(from, to, OBJECT_REPLACEMENT_CHARACTER);
-  const result = [];
+  const ranges = [];
   for (const rule of rules) {
     rule.regex.lastIndex = 0;
     const matches = text.matchAll(rule.regex);
@@ -87,9 +91,18 @@ function getExpectedMarkings(rules, doc, from, to) {
       const index = match.index;
       if (index == null)
         continue;
-      const attrs = rule.getAttrs(match);
+      const attrs = maybeRun(rule.attrs, match);
       const mark = markType.create(attrs);
-      result.push([mark, from + index, from + index + match[0].length]);
+      ranges.push([from + index, from + index + match[0].length, mark]);
+    }
+  }
+  ranges.sort((a, b) => a[0] - b[0] || b[1] - a[1]);
+  const result = [];
+  let freeIndex = 0;
+  for (const range of ranges) {
+    if (range[0] >= freeIndex) {
+      result.push(range);
+      freeIndex = range[1];
     }
   }
   return result;
@@ -105,17 +118,17 @@ function getReceivedMarkings(rules, doc, from, to) {
     for (const markType of markTypes) {
       const mark = node.marks.find((mark2) => mark2.type === markType);
       if (mark) {
-        result.push([mark, pos, pos + node.nodeSize]);
+        result.push([pos, pos + node.nodeSize, mark]);
       }
     }
   });
   return result;
 }
-function markingEquals(a, b) {
-  return a[1] === b[1] && a[2] === b[2] && a[0].eq(b[0]);
+function markRangeEquals(a, b) {
+  return a[0] === b[0] && a[1] === b[1] && a[2].eq(b[2]);
 }
-function markingDiffs(a, b) {
-  return a.filter((x) => !b.some((y) => markingEquals(x, y)));
+function markRangeDiffs(a, b) {
+  return a.filter((x) => !b.some((y) => markRangeEquals(x, y)));
 }
 function applyMarkRules(rules, transactions, oldState, newState) {
   if (transactions.length === 0 || transactions.every((tr2) => !tr2.docChanged)) {
@@ -127,35 +140,25 @@ function applyMarkRules(rules, transactions, oldState, newState) {
   for (const [from, to] of ranges) {
     const expected = getExpectedMarkings(rules, newState.doc, from, to);
     const received = getReceivedMarkings(rules, newState.doc, from, to);
-    toRemove.push(...markingDiffs(received, expected));
-    toCreate.push(...markingDiffs(expected, received));
+    toRemove.push(...markRangeDiffs(received, expected));
+    toCreate.push(...markRangeDiffs(expected, received));
   }
   if (toCreate.length === 0 && toRemove.length === 0) {
     return null;
   }
   const tr = newState.tr;
-  for (const [mark, from, to] of toRemove) {
+  for (const [from, to, mark] of toRemove) {
     tr.removeMark(from, to, mark);
   }
-  for (const [mark, from, to] of toCreate) {
+  for (const [from, to, mark] of toCreate) {
     tr.addMark(from, to, mark);
   }
   return tr;
 }
 
-// src/mark-rule/rule.ts
-import "@prosekit/pm/model";
-var MarkRule = class {
-  constructor({ regex, type, attrs = null }) {
-    this.regex = regex;
-    this.type = type;
-    this.getAttrs = typeof attrs === "function" ? attrs : () => attrs;
-  }
-};
-
-// src/mark-rule/index.ts
+// src/mark-rule/extension.ts
 function defineMarkRule(options) {
-  return markRuleFacet.extension([new MarkRule(options)]);
+  return markRuleFacet.extension([options]);
 }
 var markRuleFacet = Facet.define({
   converter: () => {

package/dist/{chunk-ASTUC4KT.js → chunk-HLBUHIMJ.js}

@@ -4,6 +4,7 @@ import {
   OBJECT_REPLACEMENT_CHARACTER,
   getNodeType,
   isTextSelection,
+  maybeRun,
   pluginFacet
 } from "@prosekit/core";
 import { keydownHandler } from "@prosekit/pm/keymap";
@@ -32,7 +33,7 @@ function defineTextBlockEnterRule({
       if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType)) {
         return null;
       }
-      const nodeAttrs = attrs && typeof attrs === "function" ? attrs(match) : attrs;
+      const nodeAttrs = maybeRun(attrs, match);
       return state.tr.delete(from, to).setBlockType(from, from, nodeType, nodeAttrs);
     },
     stop

package/dist/prosekit-extensions-blockquote.js

@@ -1,6 +1,6 @@
 import {
   defineWrappingInputRule
-} from "./chunk-DYFRBXUX.js";
+} from "./chunk-CJ3SOSL6.js";
 
 // src/blockquote/index.ts
 import { defineNodeSpec, union } from "@prosekit/core";

package/dist/prosekit-extensions-bold.d.ts

@@ -1,4 +1,5 @@
 export { defineBoldSpec } from './_tsup-dts-rollup';
 export { defineBoldCommands } from './_tsup-dts-rollup';
 export { defineBoldKeymap } from './_tsup-dts-rollup';
+export { defineBoldInputRule } from './_tsup-dts-rollup';
 export { defineBold } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-bold.js

@@ -1,10 +1,15 @@
+import {
+  defineMarkInputRule
+} from "./chunk-CJ3SOSL6.js";
+
 // src/bold/index.ts
 import {
+  canUseRegexLookbehind,
   defineCommands,
   defineKeymap,
   defineMarkSpec,
-  union,
-  toggleMark
+  toggleMark,
+  union
 } from "@prosekit/core";
 function defineBoldSpec() {
   return defineMarkSpec({
@@ -43,12 +48,24 @@ function defineBoldKeymap() {
     "Mod-b": toggleMark({ type: "bold" })
   });
 }
+function defineBoldInputRule() {
+  return defineMarkInputRule({
+    regex: canUseRegexLookbehind() ? /(?<=\s|^)\*\*([^\s*]|[^\s*][^*]*[^\s*])\*\*$/ : /\*\*([^\s*]|[^\s*][^*]*[^\s*])\*\*$/,
+    type: "bold"
+  });
+}
 function defineBold() {
-  return union([defineBoldSpec(), defineBoldCommands(), defineBoldKeymap()]);
+  return union([
+    defineBoldSpec(),
+    defineBoldCommands(),
+    defineBoldKeymap(),
+    defineBoldInputRule()
+  ]);
 }
 export {
   defineBold,
   defineBoldCommands,
+  defineBoldInputRule,
   defineBoldKeymap,
   defineBoldSpec
 };

package/dist/prosekit-extensions-code-block.js

@@ -1,9 +1,9 @@
 import {
   defineTextBlockEnterRule
-} from "./chunk-ASTUC4KT.js";
+} from "./chunk-HLBUHIMJ.js";
 import {
   defineTextBlockInputRule
-} from "./chunk-DYFRBXUX.js";
+} from "./chunk-CJ3SOSL6.js";
 
 // src/code-block/code-block.ts
 import { union } from "@prosekit/core";

package/dist/prosekit-extensions-code.d.ts

@@ -1,4 +1,5 @@
 export { defineCodeSpec } from './_tsup-dts-rollup';
 export { defineCodeCommands } from './_tsup-dts-rollup';
-export { defineItalicKeymap } from './_tsup-dts-rollup';
+export { defineCodeKeymap } from './_tsup-dts-rollup';
+export { defineCodeInputRule } from './_tsup-dts-rollup';
 export { defineCode } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-code.js

@@ -1,5 +1,10 @@
+import {
+  defineMarkInputRule
+} from "./chunk-CJ3SOSL6.js";
+
 // src/code/index.ts
 import {
+  canUseRegexLookbehind,
   defineCommands,
   defineKeymap,
   defineMarkSpec,
@@ -20,17 +25,29 @@ function defineCodeCommands() {
     toggleCode: () => toggleMark({ type: "code" })
   });
 }
-function defineItalicKeymap() {
+function defineCodeKeymap() {
   return defineKeymap({
     "Mod-e": toggleMark({ type: "code" })
   });
 }
+function defineCodeInputRule() {
+  return defineMarkInputRule({
+    regex: canUseRegexLookbehind() ? /(?<=\s|^)`([^\s`]|[^\s`][^`]*[^\s`])`$/ : /`([^\s`]|[^\s`][^`]*[^\s`])`$/,
+    type: "code"
+  });
+}
 function defineCode() {
-  return union([defineCodeSpec(), defineCodeCommands(), defineItalicKeymap()]);
+  return union([
+    defineCodeSpec(),
+    defineCodeCommands(),
+    defineCodeKeymap(),
+    defineCodeInputRule()
+  ]);
 }
 export {
   defineCode,
   defineCodeCommands,
-  defineCodeSpec,
-  defineItalicKeymap
+  defineCodeInputRule,
+  defineCodeKeymap,
+  defineCodeSpec
 };

package/dist/prosekit-extensions-enter-rule.js

@@ -1,7 +1,7 @@
 import {
   defineEnterRule,
   defineTextBlockEnterRule
-} from "./chunk-ASTUC4KT.js";
+} from "./chunk-HLBUHIMJ.js";
 export {
   defineEnterRule,
   defineTextBlockEnterRule

package/dist/prosekit-extensions-heading.js

@@ -1,6 +1,6 @@
 import {
   defineTextBlockInputRule
-} from "./chunk-DYFRBXUX.js";
+} from "./chunk-CJ3SOSL6.js";
 
 // src/heading/index.ts
 import {

package/dist/prosekit-extensions-input-rule.d.ts

@@ -1,3 +1,6 @@
 export { defineInputRule } from './_tsup-dts-rollup';
+export { createMarkInputRule } from './_tsup-dts-rollup';
+export { defineMarkInputRule } from './_tsup-dts-rollup';
 export { defineTextBlockInputRule } from './_tsup-dts-rollup';
 export { defineWrappingInputRule } from './_tsup-dts-rollup';
+export { MarkInputRuleOptions } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-input-rule.js

@@ -1,10 +1,14 @@
 import {
+  createMarkInputRule,
   defineInputRule,
+  defineMarkInputRule,
   defineTextBlockInputRule,
   defineWrappingInputRule
-} from "./chunk-DYFRBXUX.js";
+} from "./chunk-CJ3SOSL6.js";
 export {
+  createMarkInputRule,
   defineInputRule,
+  defineMarkInputRule,
   defineTextBlockInputRule,
   defineWrappingInputRule
 };

package/dist/prosekit-extensions-italic.d.ts

@@ -1,4 +1,5 @@
 export { defineItalicSpec } from './_tsup-dts-rollup';
 export { defineItalicCommands } from './_tsup-dts-rollup';
-export { defineItalicKeymap_alias_1 as defineItalicKeymap } from './_tsup-dts-rollup';
+export { defineItalicKeymap } from './_tsup-dts-rollup';
+export { defineItalicInputRule } from './_tsup-dts-rollup';
 export { defineItalic } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-italic.js

@@ -1,10 +1,15 @@
+import {
+  defineMarkInputRule
+} from "./chunk-CJ3SOSL6.js";
+
 // src/italic/index.ts
 import {
+  canUseRegexLookbehind,
   defineCommands,
   defineKeymap,
   defineMarkSpec,
-  union,
-  toggleMark
+  toggleMark,
+  union
 } from "@prosekit/core";
 function defineItalicSpec() {
   return defineMarkSpec({
@@ -33,16 +38,24 @@ function defineItalicKeymap() {
     "Mod-i": toggleMark({ type: "italic" })
   });
 }
+function defineItalicInputRule() {
+  return defineMarkInputRule({
+    regex: canUseRegexLookbehind() ? /(?<=\s|^)\*([^\s*]|[^\s*][^*]*[^\s*])\*$/ : /\*([^\s*]|[^\s*][^*]*[^\s*])\*$/,
+    type: "italic"
+  });
+}
 function defineItalic() {
   return union([
     defineItalicSpec(),
     defineItalicCommands(),
-    defineItalicKeymap()
+    defineItalicKeymap(),
+    defineItalicInputRule()
   ]);
 }
 export {
   defineItalic,
   defineItalicCommands,
+  defineItalicInputRule,
   defineItalicKeymap,
   defineItalicSpec
 };

package/dist/prosekit-extensions-link.js

@@ -1,12 +1,12 @@
 import {
   defineMarkRule
-} from "./chunk-TXF4SPMB.js";
+} from "./chunk-FG6YUKCN.js";
 import {
   defineEnterRule
-} from "./chunk-ASTUC4KT.js";
+} from "./chunk-HLBUHIMJ.js";
 import {
   defineInputRule
-} from "./chunk-DYFRBXUX.js";
+} from "./chunk-CJ3SOSL6.js";
 
 // src/link/index.ts
 import {

package/dist/prosekit-extensions-list.js

@@ -1,6 +1,6 @@
 import {
   defineInputRule
-} from "./chunk-DYFRBXUX.js";
+} from "./chunk-CJ3SOSL6.js";
 
 // src/list/index.ts
 import {

package/dist/prosekit-extensions-mark-rule.d.ts

@@ -1,2 +1,2 @@
-export { defineMarkRule } from './_tsup-dts-rollup';
+export { defineMarkRule_alias_1 as defineMarkRule } from './_tsup-dts-rollup';
 export { MarkRuleOptions } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-mark-rule.js

@@ -1,6 +1,6 @@
 import {
   defineMarkRule
-} from "./chunk-TXF4SPMB.js";
+} from "./chunk-FG6YUKCN.js";
 export {
   defineMarkRule
 };

package/dist/prosekit-extensions-strike.d.ts

@@ -1,4 +1,5 @@
 export { defineStrikeSpec } from './_tsup-dts-rollup';
 export { defineStrikeCommands } from './_tsup-dts-rollup';
 export { defineStrikeKeymap } from './_tsup-dts-rollup';
+export { defineStrikeInputRule } from './_tsup-dts-rollup';
 export { defineStrike } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-strike.js

@@ -1,10 +1,15 @@
+import {
+  defineMarkInputRule
+} from "./chunk-CJ3SOSL6.js";
+
 // src/strike/index.ts
 import {
   defineCommands,
   defineKeymap,
   defineMarkSpec,
   union,
-  toggleMark
+  toggleMark,
+  canUseRegexLookbehind
 } from "@prosekit/core";
 function defineStrikeSpec() {
   return defineMarkSpec({
@@ -32,16 +37,24 @@ function defineStrikeKeymap() {
     "Mod-shift-x": toggleMark({ type: "strike" })
   });
 }
+function defineStrikeInputRule() {
+  return defineMarkInputRule({
+    regex: canUseRegexLookbehind() ? /(?<=\s|^)~~([^\s~]|[^\s~][^~]*[^\s~])~~$/ : /~~([^\s~]|[^\s~][^~]*[^\s~])~~$/,
+    type: "strike"
+  });
+}
 function defineStrike() {
   return union([
     defineStrikeSpec(),
     defineStrikeCommands(),
-    defineStrikeKeymap()
+    defineStrikeKeymap(),
+    defineStrikeInputRule()
   ]);
 }
 export {
   defineStrike,
   defineStrikeCommands,
+  defineStrikeInputRule,
   defineStrikeKeymap,
   defineStrikeSpec
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/extensions",
   "type": "module",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -152,7 +152,7 @@
     "dist"
   ],
   "dependencies": {
-    "@prosekit/core": "^0.4.0",
+    "@prosekit/core": "^0.4.2",
     "@prosekit/pm": "^0.1.2",
     "prosemirror-dropcursor": "^1.8.1",
     "prosemirror-flat-list": "^0.5.0",

package/dist/chunk-DYFRBXUX.js

@@ -1,56 +0,0 @@
-// src/input-rule/index.ts
-import {
-  Facet,
-  getNodeType,
-  pluginFacet
-} from "@prosekit/core";
-import {
-  inputRules,
-  textblockTypeInputRule,
-  wrappingInputRule
-} from "@prosekit/pm/inputrules";
-import "@prosekit/pm/model";
-import "@prosekit/pm/state";
-function defineInputRule(rule) {
-  return inputRuleFacet.extension([() => rule]);
-}
-function defineTextBlockInputRule({
-  regex,
-  type,
-  attrs
-}) {
-  return inputRuleFacet.extension([
-    ({ schema }) => {
-      const nodeType = getNodeType(schema, type);
-      return textblockTypeInputRule(regex, nodeType, attrs);
-    }
-  ]);
-}
-function defineWrappingInputRule({
-  regex,
-  type,
-  attrs,
-  join
-}) {
-  return inputRuleFacet.extension([
-    ({ schema }) => {
-      const nodeType = getNodeType(schema, type);
-      return wrappingInputRule(regex, nodeType, attrs, join);
-    }
-  ]);
-}
-var inputRuleFacet = Facet.define({
-  convert: (inputs) => {
-    return (context) => {
-      const rules = inputs.flatMap((callback) => callback(context));
-      return [inputRules({ rules })];
-    };
-  },
-  next: pluginFacet
-});
-
-export {
-  defineInputRule,
-  defineTextBlockInputRule,
-  defineWrappingInputRule
-};