@prosekit/core 0.7.4 → 0.7.6

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

@@ -148,6 +148,27 @@ declare type AttrSpec<AttrType = any> = {
 export { AttrSpec }
 export { AttrSpec as AttrSpec_alias_1 }
 
+/**
+ * @internal
+ */
+declare type BaseCommandsExtension = Extension<{
+    Commands: {
+        insertText: [options: InsertTextOptions];
+        insertNode: [options: InsertNodeOptions];
+        removeNode: [options: RemoveNodeOptions];
+        wrap: [options: WrapOptions];
+        setBlockType: [options: SetBlockTypeOptions];
+        setNodeAttrs: [options: SetNodeAttrsOptions];
+        selectAll: [];
+        addMark: [options: AddMarkOptions];
+        removeMark: [options: RemoveMarkOptions];
+        unsetBlockType: [options?: UnsetBlockTypeOptions];
+        unsetMark: [options?: UnsetMarkOptions];
+    };
+}>;
+export { BaseCommandsExtension }
+export { BaseCommandsExtension as BaseCommandsExtension_alias_1 }
+
 /**
  * @internal
  */
@@ -171,6 +192,13 @@ export declare abstract class BaseExtension<T extends ExtensionTyping = Extensio
     get schema(): Schema | null;
 }
 
+/**
+ * @internal
+ */
+declare type BaseKeymapExtension = PlainExtension;
+export { BaseKeymapExtension }
+export { BaseKeymapExtension as BaseKeymapExtension_alias_1 }
+
 /**
  * Some basic props for custom node views.
  *
@@ -272,6 +300,13 @@ declare interface CommandTyping {
 export { CommandTyping }
 export { CommandTyping as CommandTyping_alias_1 }
 
+/**
+ * @internal
+ */
+declare function containsInlineNode(doc: ProseMirrorNode, from: number, to: number): boolean;
+export { containsInlineNode }
+export { containsInlineNode as containsInlineNode_alias_1 }
+
 /**
  * @public
  */
@@ -341,27 +376,7 @@ export { DefaultStateOptions as DefaultStateOptions_alias_1 }
  *
  * @public
  */
-declare function defineBaseCommands(): Extension<{
-    Commands: {
-        insertText: [{
-            text: string;
-            from?: number;
-            to?: number;
-        }];
-        insertNode: [options: InsertNodeOptions];
-        removeNode: [options: RemoveNodeOptions];
-        wrap: [WrapOptions];
-        setBlockType: [options: SetBlockTypeOptions];
-        setNodeAttrs: [options: SetNodeAttrsOptions];
-        selectAll: [];
-        addMark: [options: AddMarkOptions];
-        removeMark: [options: RemoveMarkOptions];
-        unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
-        unsetMark: [options?: UnsetMarkOptions | undefined];
-    };
-    Nodes: never;
-    Marks: never;
-}>;
+declare function defineBaseCommands(): BaseCommandsExtension;
 export { defineBaseCommands }
 export { defineBaseCommands as defineBaseCommands_alias_1 }
 
@@ -377,7 +392,7 @@ declare function defineBaseKeymap(options?: {
      * @default Priority.low
      */
     priority?: Priority;
-}): Extension<ExtensionTyping<any, any, any>>;
+}): BaseKeymapExtension;
 export { defineBaseKeymap }
 export { defineBaseKeymap as defineBaseKeymap_alias_1 }
 
@@ -403,26 +418,18 @@ declare function defineCommands<T extends Record<string, CommandCreator> = Recor
     Commands: {
         [K in keyof T]: Parameters<T[K]>;
     };
-    Nodes: never;
-    Marks: never;
 }>;
 export { defineCommands }
 export { defineCommands as defineCommands_alias_1 }
 
-declare function defineDefaultState({ defaultDoc, defaultHTML, defaultSelection, }: DefaultStateOptions): Extension;
+declare function defineDefaultState({ defaultDoc, defaultHTML, defaultSelection, }: DefaultStateOptions): PlainExtension;
 export { defineDefaultState }
 export { defineDefaultState as defineDefaultState_alias_1 }
 
 /**
  * @public
  */
-declare function defineDoc(): Extension<    {
-Nodes: {
-doc: Attrs_2;
-};
-Marks: never;
-Commands: never;
-}>;
+declare function defineDoc(): DocExtension;
 export { defineDoc }
 export { defineDoc as defineDoc_alias_1 }
 
@@ -431,7 +438,7 @@ export { defineDoc as defineDoc_alias_1 }
  *
  * @public
  */
-declare function defineDocChangeHandler(handler: DocChangeHandler): Extension<ExtensionTyping<any, any, any>>;
+declare function defineDocChangeHandler(handler: DocChangeHandler): PlainExtension;
 export { defineDocChangeHandler }
 export { defineDocChangeHandler as defineDocChangeHandler_alias_1 }
 
@@ -519,14 +526,7 @@ export { defineFocusChangeHandler as defineFocusChangeHandler_alias_1 }
  *
  * @public
  */
-declare function defineHistory({ depth, newGroupDelay, }?: HistoryOptions): Extension<    {
-Nodes: never;
-Marks: never;
-Commands: {
-readonly undo: [];
-readonly redo: [];
-};
-}>;
+declare function defineHistory({ depth, newGroupDelay, }?: HistoryOptions): HistoryExtension;
 export { defineHistory }
 export { defineHistory as defineHistory_alias_1 }
 
@@ -542,7 +542,7 @@ export { defineKeyDownHandler as defineKeyDownHandler_alias_1 }
 /**
  * @public
  */
-declare function defineKeymap(keymap: Keymap): Extension;
+declare function defineKeymap(keymap: Keymap): PlainExtension;
 export { defineKeymap }
 export { defineKeymap as defineKeymap_alias_1 }
 
@@ -559,11 +559,9 @@ export { defineKeyPressHandler as defineKeyPressHandler_alias_1 }
  * @public
  */
 declare function defineMarkAttr<MarkType extends string = string, AttrName extends string = string, AttrType = any>(options: MarkAttrOptions<MarkType, AttrName, AttrType>): Extension<{
-    Nodes: never;
     Marks: {
         [K in MarkType]: AttrType;
     };
-    Commands: never;
 }>;
 export { defineMarkAttr }
 export { defineMarkAttr as defineMarkAttr_alias_1 }
@@ -575,8 +573,6 @@ declare function defineMarkSpec<Mark extends string, Attrs extends AnyAttrs = An
     Marks: {
         [K in Mark]: Attrs;
     };
-    Nodes: never;
-    Commands: never;
 }>;
 export { defineMarkSpec }
 export { defineMarkSpec as defineMarkSpec_alias_1 }
@@ -586,7 +582,7 @@ export { defineMarkSpec as defineMarkSpec_alias_1 }
  *
  * @public
  */
-declare function defineMountHandler(handler: MountHandler): Extension<ExtensionTyping<any, any, any>>;
+declare function defineMountHandler(handler: MountHandler): PlainExtension;
 export { defineMountHandler }
 export { defineMountHandler as defineMountHandler_alias_1 }
 
@@ -601,8 +597,6 @@ declare function defineNodeAttr<NodeType extends string = string, AttrName exten
             [K in AttrName]: AttrType;
         };
     };
-    Marks: never;
-    Commands: never;
 }>;
 export { defineNodeAttr }
 export { defineNodeAttr as defineNodeAttr_alias_1 }
@@ -616,8 +610,6 @@ declare function defineNodeSpec<Node extends string, Attrs extends AnyAttrs = An
     Nodes: {
         [K in Node]: Attrs;
     };
-    Marks: never;
-    Commands: never;
 }>;
 export { defineNodeSpec }
 export { defineNodeSpec as defineNodeSpec_alias_1 }
@@ -645,13 +637,7 @@ export { defineNodeViewFactory as defineNodeViewFactory_alias_1 }
  *
  * Defines a paragraph node spec as the highest priority, because it should be the default block node for most cases.
  */
-declare function defineParagraph(): Extension<    {
-Nodes: {
-paragraph: Attrs_2;
-};
-Marks: never;
-Commands: never;
-}>;
+declare function defineParagraph(): ParagraphExtension;
 export { defineParagraph }
 export { defineParagraph as defineParagraph_alias_1 }
 
@@ -660,13 +646,7 @@ export { defineParagraph as defineParagraph_alias_1 }
  *
  * Defines a paragraph node spec.
  */
-export declare function defineParagraphSpec(): Extension<    {
-Nodes: {
-paragraph: Attrs_2;
-};
-Marks: never;
-Commands: never;
-}>;
+export declare function defineParagraphSpec(): ParagraphSpecExtension;
 
 /**
  * @public
@@ -687,7 +667,7 @@ export { definePasteHandler as definePasteHandler_alias_1 }
  */
 declare function definePlugin(plugin: Plugin_2 | Plugin_2[] | ((context: {
     schema: Schema;
-}) => Plugin_2 | Plugin_2[])): Extension;
+}) => Plugin_2 | Plugin_2[])): PlainExtension;
 export { definePlugin }
 export { definePlugin as definePlugin_alias_1 }
 
@@ -703,48 +683,34 @@ export { defineScrollToSelectionHandler as defineScrollToSelectionHandler_alias_
 /**
  * @internal
  */
-export declare function defineTestExtension(): Extension<{
-    Nodes: SimplifyDeeper<    {
-    paragraph: Attrs_2;
-    doc: Attrs_2;
-    text: Attrs_2;
-    heading: Attrs_2;
-    }>;
-    Marks: SimplifyDeeper<    {
-    bold: Attrs_2;
-    italic: Attrs_2;
-    }>;
-    Commands: {
-        insertText: [{
-            text: string;
-            from?: number;
-            to?: number;
-        }];
-        insertNode: [options: InsertNodeOptions];
-        removeNode: [options: RemoveNodeOptions];
-        wrap: [WrapOptions];
-        setBlockType: [options: SetBlockTypeOptions];
-        setNodeAttrs: [options: SetNodeAttrsOptions];
-        selectAll: [];
-        addMark: [options: AddMarkOptions];
-        removeMark: [options: RemoveMarkOptions];
-        unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
-        unsetMark: [options?: UnsetMarkOptions | undefined];
-        readonly undo: [];
-        readonly redo: [];
-    };
-}>;
+export declare function defineTestExtension(): Union<readonly [BaseCommandsExtension, PlainExtension, DocExtension, HistoryExtension, Extension<{
+Nodes: {
+paragraph: Attrs_2;
+};
+}>, TextExtension, Extension<{
+Marks: {
+bold: Attrs_2;
+};
+}>, Extension<{
+Marks: {
+italic: Attrs_2;
+};
+}>, Extension<{
+Nodes: {
+heading: Attrs_2;
+};
+}>, Extension<{
+Nodes: {
+codeBlock: {
+language: string;
+};
+};
+}>]>;
 
 /**
  * @public
  */
-declare function defineText(): Extension<    {
-Nodes: {
-text: Attrs_2;
-};
-Marks: never;
-Commands: never;
-}>;
+declare function defineText(): TextExtension;
 export { defineText }
 export { defineText as defineText_alias_1 }
 
@@ -780,7 +746,7 @@ export { defineTripleClickOnHandler as defineTripleClickOnHandler_alias_1 }
  *
  * @public
  */
-declare function defineUnmountHandler(handler: UnmountHandler): Extension<ExtensionTyping<any, any, any>>;
+declare function defineUnmountHandler(handler: UnmountHandler): PlainExtension;
 export { defineUnmountHandler }
 export { defineUnmountHandler as defineUnmountHandler_alias_1 }
 
@@ -789,7 +755,7 @@ export { defineUnmountHandler as defineUnmountHandler_alias_1 }
  *
  * @public
  */
-declare function defineUpdateHandler(handler: UpdateHandler): Extension<ExtensionTyping<any, any, any>>;
+declare function defineUpdateHandler(handler: UpdateHandler): PlainExtension;
 export { defineUpdateHandler }
 export { defineUpdateHandler as defineUpdateHandler_alias_1 }
 
@@ -805,6 +771,17 @@ declare type DocChangeHandler = (view: EditorView, prevState: EditorState) => vo
 export { DocChangeHandler }
 export { DocChangeHandler as DocChangeHandler_alias_1 }
 
+/**
+ * @internal
+ */
+declare type DocExtension = Extension<{
+    Nodes: {
+        doc: Attrs;
+    };
+}>;
+export { DocExtension }
+export { DocExtension as DocExtension_alias_1 }
+
 /**
  * @internal
  */
@@ -882,7 +859,7 @@ declare class Editor<E extends Extension = any> {
     /**
      * @internal
      */
-    static create(instance: any): Editor<any>;
+    static create(instance: any): Editor;
     /**
      * Whether the editor is mounted.
      */
@@ -1078,9 +1055,9 @@ export { Extension as Extension_alias_1 }
  * @internal
  */
 declare interface ExtensionTyping<N extends NodeTyping | never = never, M extends MarkTyping | never = never, C extends CommandTyping | never = never> {
-    Nodes: N;
-    Marks: M;
-    Commands: C;
+    Nodes?: N;
+    Marks?: M;
+    Commands?: C;
 }
 export { ExtensionTyping }
 export { ExtensionTyping as ExtensionTyping_alias_1 }
@@ -1209,7 +1186,7 @@ export declare class FacetExtensionImpl<Input, Output> extends BaseExtension {
     /**
      * @internal
      */
-    createTree(priority: Priority): FacetNode<any, any>;
+    createTree(priority: Priority): FacetNode;
 }
 
 export declare class FacetNode<I = any, O = any> {
@@ -1299,6 +1276,18 @@ export declare type GroupedEntries<T extends Record<string, any>> = {
 
 export declare function groupEntries<T extends Record<string, any>>(entries: ObjectEntries<T>[]): GroupedEntries<T>;
 
+/**
+ * @internal
+ */
+declare type HistoryExtension = Extension<{
+    Commands: {
+        undo: [];
+        redo: [];
+    };
+}>;
+export { HistoryExtension }
+export { HistoryExtension as HistoryExtension_alias_1 }
+
 /**
  * Options for {@link defineHistory}.
  *
@@ -1346,6 +1335,8 @@ declare function htmlFromNode(node: ProseMirrorNode, options?: DOMSerializerOpti
 export { htmlFromNode }
 export { htmlFromNode as htmlFromNode_alias_1 }
 
+export declare function includesMark(marks: readonly Mark[], markType: MarkType, attrs?: Attrs | null): boolean;
+
 /**
  * Returns a command that inserts the given node at the current selection or at
  * the given position.
@@ -1391,11 +1382,16 @@ export { InsertNodeOptions as InsertNodeOptions_alias_1 }
  *
  * @public
  */
-export declare function insertText({ text, from, to, }: {
+export declare function insertText({ text, from, to }: InsertTextOptions): Command;
+
+/**
+ * @public
+ */
+export declare type InsertTextOptions = {
     text: string;
     from?: number;
     to?: number;
-}): Command;
+};
 
 /**
  * @internal
@@ -1441,6 +1437,7 @@ export { isMark as isMark_alias_1 }
 /**
  * Returns true if the given mark is missing in some part of the range.
  * Returns false if the entire range has the given mark.
+ * Returns true if the mark is not allowed in the range.
  *
  * @internal
  */
@@ -1473,6 +1470,13 @@ declare function isProseMirrorNode(node: unknown): node is ProseMirrorNode;
 export { isProseMirrorNode }
 export { isProseMirrorNode as isProseMirrorNode_alias_1 }
 
+/**
+ * Check if `subset` is a subset of `superset`.
+ *
+ * @internal
+ */
+export declare function isSubset(subset: Record<string, unknown>, superset: Record<string, unknown>): boolean;
+
 /**
  * @internal
  */
@@ -1856,6 +1860,22 @@ export declare type ObjectEntries<T extends Record<string, any>> = {
 
 export declare function objectEqual<T>(a: T, b: T): boolean;
 
+/**
+ * @internal
+ */
+declare type ParagraphExtension = ParagraphSpecExtension;
+export { ParagraphExtension }
+export { ParagraphExtension as ParagraphExtension_alias_1 }
+
+/**
+ * @internal
+ */
+declare type ParagraphSpecExtension = Extension<{
+    Nodes: {
+        paragraph: Attrs;
+    };
+}>;
+
 declare type PasteHandler = (view: EditorView, event: ClipboardEvent, slice: Slice) => boolean | void;
 export { PasteHandler }
 export { PasteHandler as PasteHandler_alias_1 }
@@ -1877,6 +1897,19 @@ declare type PickSubType<Type, ParentType> = Type extends ParentType ? [ParentTy
 export { PickSubType }
 export { PickSubType as PickSubType_alias_1 }
 
+/**
+ * An extension that does not define any nodes, marks, or commands.
+ *
+ * @internal
+ */
+declare type PlainExtension = Extension<{
+    Nodes: never;
+    Marks: never;
+    Commands: never;
+}>;
+export { PlainExtension }
+export { PlainExtension as PlainExtension_alias_1 }
+
 /**
  * @internal
  */
@@ -2092,51 +2125,29 @@ export declare function setupEditorExtension<E extends Extension>(options: Edito
  * @internal
  */
 export declare function setupTest(): {
-    editor: TestEditor<Extension<{
-        Nodes: SimplifyDeeper<    {
-        paragraph: Attrs_2;
-        doc: Attrs_2;
-        text: Attrs_2;
-        heading: Attrs_2;
-        }>;
-        Marks: SimplifyDeeper<    {
-        bold: Attrs_2;
-        italic: Attrs_2;
-        }>;
-        Commands: {
-            insertText: [{
-                text: string;
-                from?: number;
-                to?: number;
-            }];
-            insertNode: [options: InsertNodeOptions];
-            removeNode: [options: RemoveNodeOptions];
-            wrap: [WrapOptions];
-            setBlockType: [options: SetBlockTypeOptions];
-            setNodeAttrs: [options: SetNodeAttrsOptions];
-            selectAll: [];
-            addMark: [options: AddMarkOptions];
-            removeMark: [options: RemoveMarkOptions];
-            unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
-            unsetMark: [options?: UnsetMarkOptions | undefined];
-            readonly undo: [];
-            readonly redo: [];
-        };
-    }>>;
-    n: ToNodeAction<SimplifyDeeper<    {
-    paragraph: {
-    readonly [x: string]: any;
+    editor: TestEditor<Union<readonly [BaseCommandsExtension, PlainExtension, DocExtension, HistoryExtension, Extension<{
+    Nodes: {
+    paragraph: Attrs_2;
     };
-    doc: {
-    readonly [x: string]: any;
+    }>, TextExtension, Extension<{
+    Marks: {
+    bold: Attrs_2;
     };
-    text: {
-    readonly [x: string]: any;
+    }>, Extension<{
+    Marks: {
+    italic: Attrs_2;
     };
-    heading: {
-    readonly [x: string]: any;
+    }>, Extension<{
+    Nodes: {
+    heading: Attrs_2;
     };
-    }>>;
+    }>, Extension<{
+    Nodes: {
+    codeBlock: {
+    language: string;
+    };
+    };
+    }>]>>;
     m: ToMarkAction<SimplifyDeeper<    {
     bold: {
     readonly [x: string]: any;
@@ -2145,6 +2156,26 @@ export declare function setupTest(): {
     readonly [x: string]: any;
     };
     }>>;
+    n: {
+        p: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        doc: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        paragraph: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        text: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        codeBlock: NodeAction<    {
+        language: string;
+        }>;
+        heading: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+    };
 };
 
 /**
@@ -2168,7 +2199,7 @@ export { SimplifyDeeper as SimplifyDeeper_alias_1 }
 /**
  * @internal
  */
-declare type SimplifyUnion<T> = Simplify<UnionToIntersection<T>>;
+declare type SimplifyUnion<T> = Simplify<UnionToIntersection<T extends undefined ? never : T>>;
 export { SimplifyUnion }
 export { SimplifyUnion as SimplifyUnion_alias_1 }
 
@@ -2261,6 +2292,17 @@ declare class TestEditor<E extends Extension = Extension> extends Editor<E> {
 export { TestEditor }
 export { TestEditor as TestEditor_alias_1 }
 
+/**
+ * @internal
+ */
+declare type TextExtension = Extension<{
+    Nodes: {
+        text: Attrs;
+    };
+}>;
+export { TextExtension }
+export { TextExtension as TextExtension_alias_1 }
+
 declare type TextInputHandler = (view: EditorView, from: number, to: number, text: string) => boolean | void;
 export { TextInputHandler }
 export { TextInputHandler as TextInputHandler_alias_1 }
@@ -2351,6 +2393,17 @@ export { TripleClickOnHandler as TripleClickOnHandler_alias_1 }
  */
 export declare type Tuple5<T> = [T, T, T, T, T];
 
+/**
+ * @internal
+ */
+declare type Union<E extends readonly Extension[]> = Extension<{
+    Nodes: ExtractNodes<E[number]>;
+    Marks: ExtractMarks<E[number]>;
+    Commands: ExtractCommands<E[number]>;
+}>;
+export { Union }
+export { Union as Union_alias_1 }
+
 /**
  * Merge multiple extensions into one.
  *
@@ -2369,11 +2422,14 @@ export declare type Tuple5<T> = [T, T, T, T, T];
  *
  * @public
  */
-declare function union<const E extends Extension | readonly Extension[]>(extension: E): UnionExtension<E>;
+declare function union<const E extends readonly Extension[]>(...exts: E): Union<E>;
+
+declare function union<const E extends readonly Extension[]>(exts: E): Union<E>;
 export { union }
 export { union as union_alias_1 }
 
 /**
+ * @deprecated Use `Union` instead.
  * @internal
  */
 declare type UnionExtension<E extends Extension | readonly Extension[]> = E extends readonly Extension[] ? Extension<{

package/dist/{chunk-52BNHWWJ.js → chunk-MOSGJZHV.js}

@@ -512,15 +512,36 @@ function defineDefaultState({
   ]);
 }
 
+// src/utils/is-subset.ts
+function isSubset(subset, superset) {
+  return Object.keys(subset).every((key) => subset[key] === superset[key]);
+}
+
+// src/utils/includes-mark.ts
+function includesMark(marks, markType, attrs) {
+  attrs = attrs || {};
+  return marks.some((mark) => {
+    return mark.type === markType && isSubset(attrs, mark.attrs);
+  });
+}
+
 // src/utils/is-mark-absent.ts
 function isMarkAbsent(node, from, to, markType, attrs) {
-  const mark = attrs ? markType.create(attrs) : markType;
   let missing = false;
+  let available = false;
   node.nodesBetween(from, to, (node2, pos, parent) => {
-    if (missing) return false;
-    missing = !mark.isInSet(node2.marks) && !!parent && parent.type.allowsMarkType(markType);
+    if (missing) {
+      return false;
+    }
+    const allowed = (parent == null ? void 0 : parent.type.allowsMarkType(markType)) && !node2.marks.some((m) => m.type !== markType && m.type.excludes(markType));
+    if (allowed) {
+      available = true;
+      if (!includesMark(node2.marks, markType, attrs)) {
+        missing = true;
+      }
+    }
   });
-  return missing;
+  return available ? missing : true;
 }
 
 // src/utils/is-mark-active.ts
@@ -528,8 +549,8 @@ function isMarkActive(state, type, attrs) {
   const { from, $from, to, empty } = state.selection;
   const markType = getMarkType(state.schema, type);
   if (empty) {
-    const mark = attrs ? markType.create(attrs) : markType;
-    return !!mark.isInSet(state.storedMarks || $from.marks());
+    const marks = state.storedMarks || $from.marks();
+    return includesMark(marks, markType, attrs);
   } else {
     return !isMarkAbsent(state.doc, from, to, markType, attrs);
   }
@@ -589,12 +610,10 @@ var UnionExtensionImpl = class extends BaseExtension {
 };
 
 // src/editor/union.ts
-function union(extension) {
-  const array = Array.isArray(extension) ? extension : [extension];
-  assert(array.length > 0, "At least one extension is required");
-  return new UnionExtensionImpl(
-    array
-  );
+function union(...exts) {
+  const extensions = exts.flat();
+  assert(extensions.length > 0, "At least one extension is required");
+  return new UnionExtensionImpl(extensions);
 }
 
 // src/editor/editor.ts

package/dist/prosekit-core-test.js

@@ -5,7 +5,7 @@ import {
   createMarkActions,
   createNodeActions,
   setupEditorExtension
-} from "./chunk-52BNHWWJ.js";
+} from "./chunk-MOSGJZHV.js";
 
 // src/test/test-editor.ts
 import { EditorState, NodeSelection, TextSelection } from "@prosekit/pm/state";

package/dist/prosekit-core.d.ts

@@ -36,9 +36,11 @@ export { EditorNotFoundError_alias_1 as EditorNotFoundError } from './_tsup-dts-
 export { ProseKitError_alias_1 as ProseKitError } from './_tsup-dts-rollup';
 export { defineBaseCommands } from './_tsup-dts-rollup';
 export { defineCommands } from './_tsup-dts-rollup';
+export { BaseCommandsExtension } from './_tsup-dts-rollup';
 export { defineDefaultState } from './_tsup-dts-rollup';
 export { DefaultStateOptions } from './_tsup-dts-rollup';
 export { defineDoc } from './_tsup-dts-rollup';
+export { DocExtension } from './_tsup-dts-rollup';
 export { defineDocChangeHandler } from './_tsup-dts-rollup';
 export { DocChangeHandler } from './_tsup-dts-rollup';
 export { defineDOMEventHandler } from './_tsup-dts-rollup';
@@ -76,12 +78,14 @@ export { MountHandler } from './_tsup-dts-rollup';
 export { UnmountHandler } from './_tsup-dts-rollup';
 export { UpdateHandler } from './_tsup-dts-rollup';
 export { defineHistory } from './_tsup-dts-rollup';
+export { HistoryExtension } from './_tsup-dts-rollup';
 export { HistoryOptions } from './_tsup-dts-rollup';
 export { defineKeymap } from './_tsup-dts-rollup';
 export { keymapFacet } from './_tsup-dts-rollup';
 export { Keymap } from './_tsup-dts-rollup';
 export { KeymapPayload } from './_tsup-dts-rollup';
 export { defineBaseKeymap } from './_tsup-dts-rollup';
+export { BaseKeymapExtension } from './_tsup-dts-rollup';
 export { defineMarkAttr } from './_tsup-dts-rollup';
 export { defineMarkSpec } from './_tsup-dts-rollup';
 export { MarkAttrOptions } from './_tsup-dts-rollup';
@@ -97,10 +101,12 @@ export { defineNodeViewFactory } from './_tsup-dts-rollup';
 export { NodeViewComponentOptions } from './_tsup-dts-rollup';
 export { NodeViewFactoryOptions } from './_tsup-dts-rollup';
 export { defineParagraph } from './_tsup-dts-rollup';
+export { ParagraphExtension } from './_tsup-dts-rollup';
 export { definePlugin } from './_tsup-dts-rollup';
 export { pluginFacet } from './_tsup-dts-rollup';
 export { PluginPayload } from './_tsup-dts-rollup';
 export { defineText } from './_tsup-dts-rollup';
+export { TextExtension } from './_tsup-dts-rollup';
 export { defineFacet } from './_tsup-dts-rollup';
 export { Facet } from './_tsup-dts-rollup';
 export { defineFacetPayload } from './_tsup-dts-rollup';
@@ -116,6 +122,8 @@ export { ExtractMarkActions } from './_tsup-dts-rollup';
 export { ExtractMarks } from './_tsup-dts-rollup';
 export { ExtractNodeActions } from './_tsup-dts-rollup';
 export { ExtractNodes } from './_tsup-dts-rollup';
+export { PlainExtension } from './_tsup-dts-rollup';
+export { Union } from './_tsup-dts-rollup';
 export { UnionExtension } from './_tsup-dts-rollup';
 export { CommandAction } from './_tsup-dts-rollup';
 export { CommandTyping } from './_tsup-dts-rollup';
@@ -136,6 +144,7 @@ export { canUseRegexLookbehind } from './_tsup-dts-rollup';
 export { clsx } from './_tsup-dts-rollup';
 export { collectNodes } from './_tsup-dts-rollup';
 export { NodeContent } from './_tsup-dts-rollup';
+export { containsInlineNode } from './_tsup-dts-rollup';
 export { defaultBlockAt } from './_tsup-dts-rollup';
 export { isApple } from './_tsup-dts-rollup';
 export { _getId } from './_tsup-dts-rollup';

package/dist/prosekit-core.js

@@ -35,7 +35,7 @@ import {
   stateFromJSON,
   toReversed,
   union
-} from "./chunk-52BNHWWJ.js";
+} from "./chunk-MOSGJZHV.js";
 
 // src/commands/add-mark.ts
 import "@prosekit/pm/model";
@@ -453,11 +453,7 @@ function withPriority(extension, priority) {
 }
 
 // src/commands/insert-text.ts
-function insertText({
-  text,
-  from,
-  to
-}) {
+function insertText({ text, from, to }) {
   return (state, dispatch) => {
     if (text) {
       dispatch == null ? void 0 : dispatch(state.tr.insertText(text, from, to));
@@ -545,16 +541,16 @@ function defineNodeAttr(options) {
 }
 var nodeSpecFacet = defineFacet({
   reducer: (payloads) => {
-    let nodes = OrderedMap2.from({});
+    let specs = OrderedMap2.from({});
     let topNodeName = void 0;
     const specPayloads = payloads.map((input) => input[0]).filter(isNotNull);
     const attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
     for (const { name, topNode, ...spec } of specPayloads) {
-      assert(!nodes.get(name), `Node type ${name} can only be defined once`);
+      assert(!specs.get(name), `Node type ${name} can only be defined once`);
       if (topNode) {
         topNodeName = name;
       }
-      nodes = nodes.addToStart(name, spec);
+      specs = specs.addToStart(name, spec);
     }
     for (const {
       type,
@@ -564,7 +560,7 @@ var nodeSpecFacet = defineFacet({
       toDOM,
       parseDOM
     } of attrPayloads) {
-      const spec = nodes.get(type);
+      const spec = specs.get(type);
       assert(spec, `Node type ${type} must be defined`);
       if (!spec.attrs) {
         spec.attrs = {};
@@ -629,7 +625,7 @@ var nodeSpecFacet = defineFacet({
         }
       }
     }
-    return { nodes, topNode: topNodeName };
+    return { nodes: specs, topNode: topNodeName };
   },
   parent: schemaSpecFacet,
   singleton: true
@@ -663,17 +659,17 @@ import { PluginKey, ProseMirrorPlugin as ProseMirrorPlugin2 } from "@prosekit/pm
 import "@prosekit/pm/model";
 import { Plugin } from "@prosekit/pm/state";
 function definePlugin(plugin) {
-  if (plugin instanceof Plugin) {
-    return defineFacetPayload(pluginFacet, [() => [plugin]]);
-  }
-  if (Array.isArray(plugin) && plugin.every((p) => p instanceof Plugin)) {
-    return defineFacetPayload(pluginFacet, [() => plugin]);
+  if (plugin instanceof Plugin || Array.isArray(plugin) && plugin.every((p) => p instanceof Plugin)) {
+    return definePluginPayload(() => plugin);
   }
   if (typeof plugin === "function") {
-    return defineFacetPayload(pluginFacet, [plugin]);
+    return definePluginPayload(plugin);
   }
   throw new TypeError("Invalid plugin");
 }
+function definePluginPayload(payload) {
+  return defineFacetPayload(pluginFacet, [payload]);
+}
 var pluginFacet = defineFacet({
   reducer: (payloads) => {
     return ({ schema }) => {
@@ -698,13 +694,16 @@ var pluginFacet = defineFacet({
 
 // src/extensions/events/plugin-view.ts
 function defineMountHandler(handler) {
-  return defineFacetPayload(pluginViewFacet, [["mount", handler]]);
+  return definePluginViewFacetPayload(["mount", handler]);
 }
 function defineUpdateHandler(handler) {
-  return defineFacetPayload(pluginViewFacet, [["update", handler]]);
+  return definePluginViewFacetPayload(["update", handler]);
 }
 function defineUnmountHandler(handler) {
-  return defineFacetPayload(pluginViewFacet, [["unmount", handler]]);
+  return definePluginViewFacetPayload(["unmount", handler]);
+}
+function definePluginViewFacetPayload(input) {
+  return defineFacetPayload(pluginViewFacet, [input]);
 }
 var pluginViewFacet = defineFacet({
   reduce: () => {
@@ -1058,10 +1057,14 @@ var customBaseKeymap = {
 function defineBaseKeymap(options) {
   var _a;
   const priority = (_a = options == null ? void 0 : options.priority) != null ? _a : 1 /* low */;
-  return withPriority(defineKeymap(customBaseKeymap), priority);
+  return withPriority(
+    defineKeymap(customBaseKeymap),
+    priority
+  );
 }
 
 // src/extensions/mark-spec.ts
+import OrderedMap3 from "orderedmap";
 function defineMarkSpec(options) {
   const payload = [options, void 0];
   return defineFacetPayload(markSpecFacet, [payload]);
@@ -1072,14 +1075,12 @@ function defineMarkAttr(options) {
 }
 var markSpecFacet = defineFacet({
   reducer: (payloads) => {
-    const marks = {};
+    let specs = OrderedMap3.from({});
     const specPayloads = payloads.map((input) => input[0]).filter(isNotNull);
     const attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
     for (const { name, ...spec } of specPayloads) {
-      if (marks[name]) {
-        throw new ProseKitError(`Mark type ${name} has already been defined`);
-      }
-      marks[name] = spec;
+      assert(!specs.get(name), `Mark type ${name} can only be defined once`);
+      specs = specs.addToStart(name, spec);
     }
     for (const {
       type,
@@ -1088,12 +1089,8 @@ var markSpecFacet = defineFacet({
       toDOM,
       parseDOM
     } of attrPayloads) {
-      const spec = marks[type];
-      if (!spec) {
-        throw new ProseKitError(
-          `Mark type ${type} must be defined before defining attributes`
-        );
-      }
+      const spec = specs.get(type);
+      assert(spec, `Mark type ${type} must be defined`);
       if (!spec.attrs) {
         spec.attrs = {};
       }
@@ -1146,7 +1143,7 @@ var markSpecFacet = defineFacet({
         }
       }
     }
-    return { marks, nodes: {} };
+    return { marks: specs, nodes: {} };
   },
   parent: schemaSpecFacet,
   singleton: true
@@ -1274,6 +1271,16 @@ function collectNodes(content) {
   throw new ProseKitError(`Invalid node content: ${typeof content}`);
 }
 
+// src/utils/contains-inline-node.ts
+function containsInlineNode(doc, from, to) {
+  let found = false;
+  doc.nodesBetween(from, to, (node) => {
+    if (found) return false;
+    if (node.isInline) found = true;
+  });
+  return found;
+}
+
 // src/utils/default-block-at.ts
 function defaultBlockAt(match) {
   for (let i = 0; i < match.edgeCount; i++) {
@@ -1335,6 +1342,7 @@ export {
   canUseRegexLookbehind,
   clsx,
   collectNodes,
+  containsInlineNode,
   createEditor,
   defaultBlockAt,
   defineBaseCommands,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -43,13 +43,13 @@
     "clsx": "^2.1.1",
     "orderedmap": "^2.1.1",
     "prosemirror-splittable": "^0.1.1",
-    "type-fest": "^4.22.1",
-    "@prosekit/pm": "^0.1.6"
+    "type-fest": "^4.23.0",
+    "@prosekit/pm": "^0.1.7"
   },
   "devDependencies": {
-    "tsup": "^8.1.2",
+    "tsup": "^8.2.2",
     "typescript": "^5.5.3",
-    "vitest": "^2.0.3",
+    "vitest": "^2.0.4",
     "@prosekit/dev": "0.0.0"
   },
   "scripts": {