@prosekit/extensions 0.0.13 → 0.0.14

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

@@ -9,46 +9,89 @@ import { PluginKey } from '@prosekit/pm/state';
 import { Transaction } from '@prosekit/pm/state';
 import { UserProjectConfigExport } from 'vitest/dist/config.js';
 
-export declare function addAutocomplete(rule: AutocompleteRule): Extension;
+declare class AutocompleteRule {
+    readonly regex: RegExp;
+    readonly onMatch: MatchHandler;
+    readonly onLeave?: VoidFunction;
+    readonly canMatch: (options: {
+        state: EditorState;
+    }) => boolean;
+    constructor(options: {
+        regex: RegExp;
+        onEnter: MatchHandler;
+        onLeave?: VoidFunction;
+        canMatch?: (options: {
+            state: EditorState;
+        }) => boolean;
+    });
+}
+export { AutocompleteRule }
+export { AutocompleteRule as AutocompleteRule_alias_1 }
+
+declare interface CodeBlockAttrs {
+    language?: string;
+}
+export { CodeBlockAttrs }
+export { CodeBlockAttrs as CodeBlockAttrs_alias_1 }
+
+export declare function createAutocompletePlugin({ getRules, }: {
+    getRules: () => AutocompleteRule[];
+}): Plugin_2;
+
+export declare function createPredictionPlugin(options: SuggestionOptions): Plugin_2;
+
+export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
+
+export declare const default_alias_1: UserProjectConfigExport;
+
+export declare function defaultCanMatch({ state }: {
+    state: EditorState;
+}): boolean;
+
+export declare function defaultIsValid({ state }: {
+    state: EditorState;
+}): boolean;
+
+export declare function defineAutocomplete(rule: AutocompleteRule): Extension;
 
 /** @public */
-export declare function addBlockquote(): Extension<    {
+export declare function defineBlockquote(): Extension<    {
 NODES: "blockquote";
 }>;
 
-export declare function addBlockquoteSpec(): Extension<    {
+export declare function defineBlockquoteSpec(): Extension<    {
 NODES: "blockquote";
 }>;
 
 /** @public */
-export declare function addBold(): Extension<    {
+export declare function defineBold(): Extension<    {
 MARKS: "bold";
 COMMAND_ARGS: {
 toggleBold: [];
 };
 }>;
 
-export declare function addBoldCommands(): Extension<    {
+export declare function defineBoldCommands(): Extension<    {
 COMMAND_ARGS: {
 toggleBold: [];
 };
 }>;
 
-export declare function addBoldKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export declare function defineBoldKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
-export declare function addBoldSpec(): Extension<    {
+export declare function defineBoldSpec(): Extension<    {
 MARKS: "bold";
 }>;
 
 /**
  * @public
  */
-export declare function addCode(): Extension<    {
+export declare function defineCode(): Extension<    {
 MARKS: "code";
 }>;
 
 /** @public */
-export declare function addCodeBlock(options?: {
+export declare function defineCodeBlock(options?: {
     hljs?: HLJSApi;
 }): Extension<    {
 NODES: "codeBlock";
@@ -57,62 +100,62 @@ setCodeBlockLanguage: [language: string];
 };
 }>;
 
-export declare function addCodeBlockCommands(): Extension<    {
+export declare function defineCodeBlockCommands(): Extension<    {
 COMMAND_ARGS: {
 setCodeBlockLanguage: [language: string];
 };
 }>;
 
-export declare function addCodeBlockHighlight(options: {
+export declare function defineCodeBlockHighlight(options: {
     hljs?: HLJSApi;
 }): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
-export declare function addCodeBlockInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export declare function defineCodeBlockInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
-export declare function addCodeBlockSpec(): Extension<    {
+export declare function defineCodeBlockSpec(): Extension<    {
 NODES: "codeBlock";
 }>;
 
 /**
  * @public
  */
-export declare function addCodeSpec(): Extension<    {
+export declare function defineCodeSpec(): Extension<    {
 MARKS: "code";
 }>;
 
 /** @public */
-export declare function addHeading(): Extension<    {
+export declare function defineHeading(): Extension<    {
 NODES: "heading";
 COMMAND_ARGS: {
 toggleHeading: [attrs?: HeadingAttrs | undefined];
 };
 }>;
 
-export declare function addHeadingCommands(): Extension<    {
+export declare function defineHeadingCommands(): Extension<    {
 COMMAND_ARGS: {
 toggleHeading: [attrs?: HeadingAttrs | undefined];
 };
 }>;
 
-export declare function addHeadingInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export declare function defineHeadingInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
-export declare function addHeadingKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export declare function defineHeadingKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
-export declare function addHeadingSpec(): Extension<    {
+export declare function defineHeadingSpec(): Extension<    {
 NODES: "heading";
 }>;
 
 /** @public */
-export declare function addImage(): Extension<    {
+export declare function defineImage(): Extension<    {
 NODES: "image";
 }>;
 
-export declare function addImageSpec(): Extension<    {
+export declare function defineImageSpec(): Extension<    {
 NODES: "image";
 }>;
 
 /** @public */
-export declare function addItalic(): Extension<    {
+export declare function defineItalic(): Extension<    {
 MARKS: "italic";
 COMMAND_ARGS: {
 toggleItalic: [];
@@ -120,7 +163,7 @@ toggleItalic: [];
 }>;
 
 /** @public */
-export declare function addItalic_alias_1(): Extension<    {
+export declare function defineItalic_alias_1(): Extension<    {
 MARKS: "link";
 COMMAND_ARGS: {
 addLink: [attrs: LinkAttrs];
@@ -128,55 +171,55 @@ toggleLink: [attrs: LinkAttrs];
 };
 }>;
 
-export declare function addItalicCommands(): Extension<    {
+export declare function defineItalicCommands(): Extension<    {
 COMMAND_ARGS: {
 toggleItalic: [];
 };
 }>;
 
-export declare function addItalicKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export declare function defineItalicKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
-export declare function addItalicSpec(): Extension<    {
+export declare function defineItalicSpec(): Extension<    {
 MARKS: "italic";
 }>;
 
-export declare function addLinkCommands(): Extension<    {
+export declare function defineLinkCommands(): Extension<    {
 COMMAND_ARGS: {
 addLink: [attrs: LinkAttrs];
 toggleLink: [attrs: LinkAttrs];
 };
 }>;
 
-export declare function addLinkSpec(): Extension<    {
+export declare function defineLinkSpec(): Extension<    {
 MARKS: "link";
 }>;
 
 /** @public */
-export declare function addList(): Extension<    {
+export declare function defineList(): Extension<    {
 NODES: "list";
 }>;
 
-export declare function addListInputRules(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export declare function defineListInputRules(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
-export declare function addListKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export declare function defineListKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
-export declare function addListPlugins(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export declare function defineListPlugins(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
-export declare function addListSpec(): Extension<    {
+export declare function defineListSpec(): Extension<    {
 NODES: "list";
 }>;
 
 /**
  * @public
  */
-export declare function addMention(): Extension<    {
+export declare function defineMention(): Extension<    {
 NODES: "mention";
 }>;
 
 /**
  * @public
  */
-export declare function addMentionSpec(): Extension<    {
+export declare function defineMentionSpec(): Extension<    {
 NODES: "mention";
 }>;
 
@@ -184,52 +227,9 @@ NODES: "mention";
  * Add a placeholder text to the editor when the current block or document is
  * empty.
  */
-export declare function addPlaceholder(options: PlaceholderOptions): Extension<ExtensionTyping<string, string, CommandArgs>>;
-
-export declare function addSuggestion(options: SuggestionOptions): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export declare function definePlaceholder(options: PlaceholderOptions): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
-declare class AutocompleteRule {
-    readonly regex: RegExp;
-    readonly onMatch: MatchHandler;
-    readonly onLeave?: VoidFunction;
-    readonly canMatch: (options: {
-        state: EditorState;
-    }) => boolean;
-    constructor(options: {
-        regex: RegExp;
-        onEnter: MatchHandler;
-        onLeave?: VoidFunction;
-        canMatch?: (options: {
-            state: EditorState;
-        }) => boolean;
-    });
-}
-export { AutocompleteRule }
-export { AutocompleteRule as AutocompleteRule_alias_1 }
-
-declare interface CodeBlockAttrs {
-    language?: string;
-}
-export { CodeBlockAttrs }
-export { CodeBlockAttrs as CodeBlockAttrs_alias_1 }
-
-export declare function createAutocompletePlugin({ getRules, }: {
-    getRules: () => AutocompleteRule[];
-}): Plugin_2;
-
-export declare function createPredictionPlugin(options: SuggestionOptions): Plugin_2;
-
-export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
-
-export declare const default_alias_1: UserProjectConfigExport;
-
-export declare function defaultCanMatch({ state }: {
-    state: EditorState;
-}): boolean;
-
-export declare function defaultIsValid({ state }: {
-    state: EditorState;
-}): boolean;
+export declare function defineSuggestion(options: SuggestionOptions): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
 export declare function getPluginState(state: EditorState): PredictionPluginState | undefined;
 
@@ -296,7 +296,7 @@ export declare interface PlaceholderOptions {
 
 export declare const pluginKey: PluginKey<PredictionPluginState>;
 
-export declare type PredictionPluginState = {
+export declare interface PredictionPluginState {
     active: boolean;
     ignore: number | null;
     matching: {
@@ -305,7 +305,7 @@ export declare type PredictionPluginState = {
         to: number;
         match: RegExpExecArray;
     } | null;
-};
+}
 
 declare interface PredictionRule {
     match: RegExp;

package/dist/list/style.css

@@ -1,4 +1,4 @@
-/* ../../node_modules/.pnpm/prosemirror-flat-list@0.4.2/node_modules/prosemirror-flat-list/dist/style.css */
+/* ../../node_modules/.pnpm/prosemirror-flat-list@0.4.3/node_modules/prosemirror-flat-list/dist/style.css */
 .prosemirror-flat-list {
   padding: 0;
   margin-top: 0;

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

@@ -1,3 +1,3 @@
-export { addAutocomplete } from './_tsup-dts-rollup';
+export { defineAutocomplete } from './_tsup-dts-rollup';
 export { AutocompleteRule } from './_tsup-dts-rollup';
 export { MatchHandler } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-autocomplete.js

@@ -163,7 +163,7 @@ var AutocompleteRule = class {
 };
 
 // src/autocomplete/index.ts
-function addAutocomplete(rule) {
+function defineAutocomplete(rule) {
   return autocompleteFacet.extension([rule]);
 }
 var autocompleteFacet = Facet.define({
@@ -186,5 +186,5 @@ var autocompleteFacet = Facet.define({
 });
 export {
   AutocompleteRule,
-  addAutocomplete
+  defineAutocomplete
 };

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

@@ -1,2 +1,2 @@
-export { addBlockquoteSpec } from './_tsup-dts-rollup';
-export { addBlockquote } from './_tsup-dts-rollup';
+export { defineBlockquoteSpec } from './_tsup-dts-rollup';
+export { defineBlockquote } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-blockquote.js

@@ -1,7 +1,7 @@
 // src/blockquote/index.ts
-import { addNodeSpec, defineExtension } from "@prosekit/core";
-function addBlockquoteSpec() {
-  return addNodeSpec({
+import { defineNodeSpec, union } from "@prosekit/core";
+function defineBlockquoteSpec() {
+  return defineNodeSpec({
     name: "blockquote",
     content: "block+",
     group: "block",
@@ -12,10 +12,10 @@ function addBlockquoteSpec() {
     }
   });
 }
-function addBlockquote() {
-  return defineExtension([addBlockquoteSpec()]);
+function defineBlockquote() {
+  return union([defineBlockquoteSpec()]);
 }
 export {
-  addBlockquote,
-  addBlockquoteSpec
+  defineBlockquote,
+  defineBlockquoteSpec
 };

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

@@ -1,4 +1,4 @@
-export { addBoldSpec } from './_tsup-dts-rollup';
-export { addBoldCommands } from './_tsup-dts-rollup';
-export { addBoldKeymap } from './_tsup-dts-rollup';
-export { addBold } from './_tsup-dts-rollup';
+export { defineBoldSpec } from './_tsup-dts-rollup';
+export { defineBoldCommands } from './_tsup-dts-rollup';
+export { defineBoldKeymap } from './_tsup-dts-rollup';
+export { defineBold } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-bold.js

@@ -1,13 +1,13 @@
 // src/bold/index.ts
 import {
-  addCommands,
-  addKeymap,
-  addMarkSpec,
-  defineExtension,
+  defineCommands,
+  defineKeymap,
+  defineMarkSpec,
+  union,
   toggleMark
 } from "@prosekit/core";
-function addBoldSpec() {
-  return addMarkSpec({
+function defineBoldSpec() {
+  return defineMarkSpec({
     name: "bold",
     parseDOM: [
       { tag: "strong" },
@@ -33,22 +33,22 @@ function addBoldSpec() {
     }
   });
 }
-function addBoldCommands() {
-  return addCommands({
+function defineBoldCommands() {
+  return defineCommands({
     toggleBold: () => toggleMark({ type: "bold" })
   });
 }
-function addBoldKeymap() {
-  return addKeymap({
+function defineBoldKeymap() {
+  return defineKeymap({
     "Mod-b": toggleMark({ type: "bold" })
   });
 }
-function addBold() {
-  return defineExtension([addBoldSpec(), addBoldCommands(), addBoldKeymap()]);
+function defineBold() {
+  return union([defineBoldSpec(), defineBoldCommands(), defineBoldKeymap()]);
 }
 export {
-  addBold,
-  addBoldCommands,
-  addBoldKeymap,
-  addBoldSpec
+  defineBold,
+  defineBoldCommands,
+  defineBoldKeymap,
+  defineBoldSpec
 };

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

@@ -1,5 +1,5 @@
-export { addCodeBlockSpec } from './_tsup-dts-rollup';
-export { addCodeBlockInputRule } from './_tsup-dts-rollup';
-export { addCodeBlockCommands } from './_tsup-dts-rollup';
-export { addCodeBlock } from './_tsup-dts-rollup';
+export { defineCodeBlockSpec } from './_tsup-dts-rollup';
+export { defineCodeBlockInputRule } from './_tsup-dts-rollup';
+export { defineCodeBlockCommands } from './_tsup-dts-rollup';
+export { defineCodeBlock } from './_tsup-dts-rollup';
 export { CodeBlockAttrs_alias_1 as CodeBlockAttrs } from './_tsup-dts-rollup';

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

@@ -1,19 +1,19 @@
 // src/code-block/index.ts
 import {
-  addCommands,
-  addInputRule,
-  addNodeSpec,
-  defineExtension,
+  defineCommands,
+  defineInputRule,
+  defineNodeSpec,
+  union,
   getNodeType
 } from "@prosekit/core";
 import { textblockTypeInputRule } from "@prosekit/pm/inputrules";
 
 // src/code-block/code-block-highlight.ts
-import { addPlugin } from "@prosekit/core";
+import { definePlugin } from "@prosekit/core";
 import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
 import { DecorationSet } from "@prosekit/pm/view";
 import { getHighlightDecorations } from "prosemirror-highlightjs";
-function addCodeBlockHighlight(options) {
+function defineCodeBlockHighlight(options) {
   const hljs = options.hljs;
   const plugin = new ProseMirrorPlugin({
     key,
@@ -41,7 +41,7 @@ function addCodeBlockHighlight(options) {
       }
     }
   });
-  return addPlugin(plugin);
+  return definePlugin(plugin);
 }
 var key = new PluginKey("prosekit-code-block-highlight");
 var blockTypes = ["codeBlock"];
@@ -50,8 +50,8 @@ function languageExtractor(node) {
 }
 
 // src/code-block/index.ts
-function addCodeBlockSpec() {
-  return addNodeSpec({
+function defineCodeBlockSpec() {
+  return defineNodeSpec({
     name: "codeBlock",
     content: "text*",
     group: "block",
@@ -78,8 +78,8 @@ function addCodeBlockSpec() {
     }
   });
 }
-function addCodeBlockInputRule() {
-  return addInputRule(({ schema }) => {
+function defineCodeBlockInputRule() {
+  return defineInputRule(({ schema }) => {
     const nodeType = getNodeType(schema, "codeBlock");
     const getAttrs = (match) => {
       return { language: match[1] || "" };
@@ -88,8 +88,8 @@ function addCodeBlockInputRule() {
     return [inputRule];
   });
 }
-function addCodeBlockCommands() {
-  return addCommands({
+function defineCodeBlockCommands() {
+  return defineCommands({
     setCodeBlockLanguage: (language) => (state, dispatch) => {
       const pos = state.selection.$from.before();
       const codeBlock = state.doc.nodeAt(pos);
@@ -103,17 +103,17 @@ function addCodeBlockCommands() {
     }
   });
 }
-function addCodeBlock(options) {
-  return defineExtension([
-    addCodeBlockSpec(),
-    addCodeBlockInputRule(),
-    addCodeBlockHighlight({ hljs: options == null ? void 0 : options.hljs }),
-    addCodeBlockCommands()
+function defineCodeBlock(options) {
+  return union([
+    defineCodeBlockSpec(),
+    defineCodeBlockInputRule(),
+    defineCodeBlockHighlight({ hljs: options == null ? void 0 : options.hljs }),
+    defineCodeBlockCommands()
   ]);
 }
 export {
-  addCodeBlock,
-  addCodeBlockCommands,
-  addCodeBlockInputRule,
-  addCodeBlockSpec
+  defineCodeBlock,
+  defineCodeBlockCommands,
+  defineCodeBlockInputRule,
+  defineCodeBlockSpec
 };

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

@@ -1,2 +1,2 @@
-export { addCodeSpec } from './_tsup-dts-rollup';
-export { addCode } from './_tsup-dts-rollup';
+export { defineCodeSpec } from './_tsup-dts-rollup';
+export { defineCode } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-code.js

@@ -1,7 +1,7 @@
 // src/code/index.ts
-import { addMarkSpec, defineExtension } from "@prosekit/core";
-function addCodeSpec() {
-  return addMarkSpec({
+import { defineMarkSpec, union } from "@prosekit/core";
+function defineCodeSpec() {
+  return defineMarkSpec({
     name: "code",
     parseDOM: [{ tag: "code" }],
     toDOM() {
@@ -9,10 +9,10 @@ function addCodeSpec() {
     }
   });
 }
-function addCode() {
-  return defineExtension([addCodeSpec()]);
+function defineCode() {
+  return union([defineCodeSpec()]);
 }
 export {
-  addCode,
-  addCodeSpec
+  defineCode,
+  defineCodeSpec
 };

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

@@ -1,6 +1,6 @@
-export { addHeadingSpec } from './_tsup-dts-rollup';
-export { addHeadingKeymap } from './_tsup-dts-rollup';
-export { addHeadingInputRule } from './_tsup-dts-rollup';
-export { addHeadingCommands } from './_tsup-dts-rollup';
-export { addHeading } from './_tsup-dts-rollup';
+export { defineHeadingSpec } from './_tsup-dts-rollup';
+export { defineHeadingKeymap } from './_tsup-dts-rollup';
+export { defineHeadingInputRule } from './_tsup-dts-rollup';
+export { defineHeadingCommands } from './_tsup-dts-rollup';
+export { defineHeading } from './_tsup-dts-rollup';
 export { HeadingAttrs } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-heading.js

@@ -1,16 +1,16 @@
 // src/heading/index.ts
 import {
-  addCommands,
-  addInputRule,
-  addKeymap,
-  addNodeSpec,
-  defineExtension,
+  defineCommands,
+  defineInputRule,
+  defineKeymap,
+  defineNodeSpec,
+  union,
   getNodeType,
   toggleNode
 } from "@prosekit/core";
 import { textblockTypeInputRule } from "@prosekit/pm/inputrules";
-function addHeadingSpec() {
-  return addNodeSpec({
+function defineHeadingSpec() {
+  return defineNodeSpec({
     name: "heading",
     attrs: { level: { default: 1 } },
     content: "inline*",
@@ -29,8 +29,8 @@ function addHeadingSpec() {
     }
   });
 }
-function addHeadingKeymap() {
-  return addKeymap({
+function defineHeadingKeymap() {
+  return defineKeymap({
     "mod-1": toggleNode({ type: "heading", attrs: { level: 1 } }),
     "mod-2": toggleNode({ type: "heading", attrs: { level: 2 } }),
     "mod-3": toggleNode({ type: "heading", attrs: { level: 3 } }),
@@ -39,8 +39,8 @@ function addHeadingKeymap() {
     "mod-6": toggleNode({ type: "heading", attrs: { level: 6 } })
   });
 }
-function addHeadingInputRule() {
-  return addInputRule(({ schema }) => {
+function defineHeadingInputRule() {
+  return defineInputRule(({ schema }) => {
     const nodeSpec = getNodeType(schema, "heading");
     const inputRule = textblockTypeInputRule(
       /^(#{1,6})\s/,
@@ -54,25 +54,25 @@ function addHeadingInputRule() {
     return [inputRule];
   });
 }
-function addHeadingCommands() {
-  return addCommands({
+function defineHeadingCommands() {
+  return defineCommands({
     toggleHeading: (attrs) => {
       return toggleNode({ type: "heading", attrs });
     }
   });
 }
-function addHeading() {
-  return defineExtension([
-    addHeadingSpec(),
-    addHeadingInputRule(),
-    addHeadingKeymap(),
-    addHeadingCommands()
+function defineHeading() {
+  return union([
+    defineHeadingSpec(),
+    defineHeadingInputRule(),
+    defineHeadingKeymap(),
+    defineHeadingCommands()
   ]);
 }
 export {
-  addHeading,
-  addHeadingCommands,
-  addHeadingInputRule,
-  addHeadingKeymap,
-  addHeadingSpec
+  defineHeading,
+  defineHeadingCommands,
+  defineHeadingInputRule,
+  defineHeadingKeymap,
+  defineHeadingSpec
 };

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

@@ -1,3 +1,3 @@
-export { addImageSpec } from './_tsup-dts-rollup';
-export { addImage } from './_tsup-dts-rollup';
+export { defineImageSpec } from './_tsup-dts-rollup';
+export { defineImage } from './_tsup-dts-rollup';
 export { ImageAttrs } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-image.js

@@ -1,7 +1,7 @@
 // src/image/index.ts
-import { addNodeSpec, defineExtension } from "@prosekit/core";
-function addImageSpec() {
-  return addNodeSpec({
+import { defineNodeSpec, union } from "@prosekit/core";
+function defineImageSpec() {
+  return defineNodeSpec({
     name: "image",
     attrs: {
       src: { default: null }
@@ -26,10 +26,10 @@ function addImageSpec() {
     }
   });
 }
-function addImage() {
-  return defineExtension([addImageSpec()]);
+function defineImage() {
+  return union([defineImageSpec()]);
 }
 export {
-  addImage,
-  addImageSpec
+  defineImage,
+  defineImageSpec
 };

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

@@ -1,4 +1,4 @@
-export { addItalicSpec } from './_tsup-dts-rollup';
-export { addItalicCommands } from './_tsup-dts-rollup';
-export { addItalicKeymap } from './_tsup-dts-rollup';
-export { addItalic } from './_tsup-dts-rollup';
+export { defineItalicSpec } from './_tsup-dts-rollup';
+export { defineItalicCommands } from './_tsup-dts-rollup';
+export { defineItalicKeymap } from './_tsup-dts-rollup';
+export { defineItalic } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-italic.js

@@ -1,13 +1,13 @@
 // src/italic/index.ts
 import {
-  addCommands,
-  addKeymap,
-  addMarkSpec,
-  defineExtension,
+  defineCommands,
+  defineKeymap,
+  defineMarkSpec,
+  union,
   toggleMark
 } from "@prosekit/core";
-function addItalicSpec() {
-  return addMarkSpec({
+function defineItalicSpec() {
+  return defineMarkSpec({
     name: "italic",
     parseDOM: [
       { tag: "i" },
@@ -23,26 +23,26 @@ function addItalicSpec() {
     }
   });
 }
-function addItalicCommands() {
-  return addCommands({
+function defineItalicCommands() {
+  return defineCommands({
     toggleItalic: () => toggleMark({ type: "italic" })
   });
 }
-function addItalicKeymap() {
-  return addKeymap({
+function defineItalicKeymap() {
+  return defineKeymap({
     "Mod-i": toggleMark({ type: "italic" })
   });
 }
-function addItalic() {
-  return defineExtension([
-    addItalicSpec(),
-    addItalicCommands(),
-    addItalicKeymap()
+function defineItalic() {
+  return union([
+    defineItalicSpec(),
+    defineItalicCommands(),
+    defineItalicKeymap()
   ]);
 }
 export {
-  addItalic,
-  addItalicCommands,
-  addItalicKeymap,
-  addItalicSpec
+  defineItalic,
+  defineItalicCommands,
+  defineItalicKeymap,
+  defineItalicSpec
 };

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

@@ -1,4 +1,4 @@
-export { addLinkSpec } from './_tsup-dts-rollup';
-export { addLinkCommands } from './_tsup-dts-rollup';
-export { addItalic_alias_1 as addItalic } from './_tsup-dts-rollup';
+export { defineLinkSpec } from './_tsup-dts-rollup';
+export { defineLinkCommands } from './_tsup-dts-rollup';
+export { defineItalic_alias_1 as defineItalic } from './_tsup-dts-rollup';
 export { LinkAttrs } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-link.js

@@ -1,13 +1,13 @@
 // src/link/index.ts
 import {
-  addCommands,
+  defineCommands,
   addMark,
-  addMarkSpec,
-  defineExtension,
+  defineMarkSpec,
+  union,
   toggleMark
 } from "@prosekit/core";
-function addLinkSpec() {
-  return addMarkSpec({
+function defineLinkSpec() {
+  return defineMarkSpec({
     name: "link",
     parseDOM: [
       {
@@ -28,17 +28,17 @@ function addLinkSpec() {
     }
   });
 }
-function addLinkCommands() {
-  return addCommands({
+function defineLinkCommands() {
+  return defineCommands({
     addLink: (attrs) => addMark({ type: "link", attrs }),
     toggleLink: (attrs) => toggleMark({ type: "link", attrs })
   });
 }
-function addItalic() {
-  return defineExtension([addLinkSpec(), addLinkCommands()]);
+function defineItalic() {
+  return union([defineLinkSpec(), defineLinkCommands()]);
 }
 export {
-  addItalic,
-  addLinkCommands,
-  addLinkSpec
+  defineItalic,
+  defineLinkCommands,
+  defineLinkSpec
 };

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

@@ -1,5 +1,5 @@
-export { addListSpec } from './_tsup-dts-rollup';
-export { addListPlugins } from './_tsup-dts-rollup';
-export { addListKeymap } from './_tsup-dts-rollup';
-export { addListInputRules } from './_tsup-dts-rollup';
-export { addList } from './_tsup-dts-rollup';
+export { defineListSpec } from './_tsup-dts-rollup';
+export { defineListPlugins } from './_tsup-dts-rollup';
+export { defineListKeymap } from './_tsup-dts-rollup';
+export { defineListInputRules } from './_tsup-dts-rollup';
+export { defineList } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-list.js

@@ -1,10 +1,10 @@
 // src/list/index.ts
 import {
-  addInputRule,
-  addKeymap,
-  addNodeSpec,
-  addPlugin,
-  defineExtension
+  defineInputRule,
+  defineKeymap,
+  defineNodeSpec,
+  definePlugin,
+  union
 } from "@prosekit/core";
 import {
   createListPlugins,
@@ -12,30 +12,30 @@ import {
   listInputRules,
   listKeymap
 } from "prosemirror-flat-list";
-function addListSpec() {
-  return addNodeSpec({ ...createListSpec(), name: "list" });
+function defineListSpec() {
+  return defineNodeSpec({ ...createListSpec(), name: "list" });
 }
-function addListPlugins() {
-  return addPlugin(({ schema }) => createListPlugins({ schema }));
+function defineListPlugins() {
+  return definePlugin(({ schema }) => createListPlugins({ schema }));
 }
-function addListKeymap() {
-  return addKeymap(listKeymap);
+function defineListKeymap() {
+  return defineKeymap(listKeymap);
 }
-function addListInputRules() {
-  return addInputRule(() => listInputRules);
+function defineListInputRules() {
+  return defineInputRule(() => listInputRules);
 }
-function addList() {
-  return defineExtension([
-    addListSpec(),
-    addListPlugins(),
-    addListKeymap(),
-    addListInputRules()
+function defineList() {
+  return union([
+    defineListSpec(),
+    defineListPlugins(),
+    defineListKeymap(),
+    defineListInputRules()
   ]);
 }
 export {
-  addList,
-  addListInputRules,
-  addListKeymap,
-  addListPlugins,
-  addListSpec
+  defineList,
+  defineListInputRules,
+  defineListKeymap,
+  defineListPlugins,
+  defineListSpec
 };

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

@@ -1,3 +1,3 @@
-export { addMentionSpec } from './_tsup-dts-rollup';
-export { addMention } from './_tsup-dts-rollup';
+export { defineMentionSpec } from './_tsup-dts-rollup';
+export { defineMention } from './_tsup-dts-rollup';
 export { MentionAttrs } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-mention.js

@@ -1,7 +1,7 @@
 // src/mention/index.ts
-import { addNodeSpec, defineExtension } from "@prosekit/core";
-function addMentionSpec() {
-  return addNodeSpec({
+import { defineNodeSpec, union } from "@prosekit/core";
+function defineMentionSpec() {
+  return defineNodeSpec({
     name: "mention",
     atom: true,
     group: "inline",
@@ -34,10 +34,10 @@ function addMentionSpec() {
     }
   });
 }
-function addMention() {
-  return defineExtension([addMentionSpec()]);
+function defineMention() {
+  return union([defineMentionSpec()]);
 }
 export {
-  addMention,
-  addMentionSpec
+  defineMention,
+  defineMentionSpec
 };

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

@@ -1,2 +1,2 @@
-export { addPlaceholder } from './_tsup-dts-rollup';
+export { definePlaceholder } from './_tsup-dts-rollup';
 export { PlaceholderOptions } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-placeholder.js

@@ -1,10 +1,10 @@
 // src/placeholder/index.ts
-import { addPlugin } from "@prosekit/core";
+import { definePlugin } from "@prosekit/core";
 import "@prosekit/pm/model";
 import { Plugin, PluginKey } from "@prosekit/pm/state";
 import { Decoration, DecorationSet } from "@prosekit/pm/view";
-function addPlaceholder(options) {
-  return addPlugin(createPlaceholderPlugin(options));
+function definePlaceholder(options) {
+  return definePlugin(createPlaceholderPlugin(options));
 }
 function createPlaceholderPlugin(options) {
   return new Plugin({
@@ -44,5 +44,5 @@ function createPlaceholderDecoration(state, placeholderText) {
   });
 }
 export {
-  addPlaceholder
+  definePlaceholder
 };

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

@@ -1,3 +1,3 @@
-export { addSuggestion } from './_tsup-dts-rollup';
+export { defineSuggestion } from './_tsup-dts-rollup';
 export { PredictionRule } from './_tsup-dts-rollup';
 export { SuggestionOptions } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-suggestion.js

@@ -1,5 +1,5 @@
 // src/suggestion/index.ts
-import { addPlugin } from "@prosekit/core";
+import { definePlugin } from "@prosekit/core";
 
 // src/suggestion/plugin.ts
 import { ProseKitError } from "@prosekit/core";
@@ -131,7 +131,7 @@ function calcPluginState(state, rules) {
   for (const rule of rules) {
     const match = textBefore.match(rule.match);
     const matchAfter2 = rule.matchAfter ? textAfter.match(rule.matchAfter) : null;
-    if (match && match.index != null) {
+    if ((match == null ? void 0 : match.index) != null) {
       const from = $anchor.pos - textBefore.length + match.index;
       const to = $anchor.pos + (matchAfter2 ? matchAfter2[0].length : 0);
       return {
@@ -152,10 +152,10 @@ function calcPluginState(state, rules) {
 var MAX_MATCH = 200;
 
 // src/suggestion/index.ts
-function addSuggestion(options) {
+function defineSuggestion(options) {
   const plugin = createPredictionPlugin(options);
-  return addPlugin(plugin);
+  return definePlugin(plugin);
 }
 export {
-  addSuggestion
+  defineSuggestion
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/extensions",
   "type": "module",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -106,10 +106,10 @@
     "dist"
   ],
   "dependencies": {
-    "@prosekit/core": "^0.0.11",
+    "@prosekit/core": "^0.0.12",
     "@prosekit/pm": "^0.0.6",
     "highlight.js": "^11.9.0",
-    "prosemirror-flat-list": "^0.4.2",
+    "prosemirror-flat-list": "^0.4.3",
     "prosemirror-highlightjs": "^0.9.1"
   },
   "devDependencies": {