@prosekit/core 0.7.7 → 0.7.8

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

@@ -5,11 +5,13 @@ import type { ContentMatch } from '@prosekit/pm/model';
 import { config as default_alias_1 } from '@prosekit/dev/config-vitest';
 import type { DirectEditorProps } from '@prosekit/pm/view';
 import type { DOMEventMap } from '@prosekit/pm/view';
+import type { DOMOutputSpec } from '@prosekit/pm/model';
 import { DOMParser as DOMParser_2 } from '@prosekit/pm/model';
 import { DOMSerializer } from '@prosekit/pm/model';
 import { EditorState } from '@prosekit/pm/state';
 import type { EditorStateConfig } from '@prosekit/pm/state';
 import { EditorView } from '@prosekit/pm/view';
+import { Fragment } from '@prosekit/pm/model';
 import type { IsEqual } from 'type-fest';
 import { Mark } from '@prosekit/pm/model';
 import type { MarkSpec } from '@prosekit/pm/model';
@@ -32,7 +34,8 @@ import { SchemaSpec } from '@prosekit/pm/model';
 import { Selection as Selection_2 } from '@prosekit/pm/state';
 import { Selection as Selection_3 } from 'prosemirror-state';
 import type { Simplify } from 'type-fest';
-import type { Slice } from '@prosekit/pm/model';
+import { Slice } from '@prosekit/pm/model';
+import type { TagParseRule } from '@prosekit/pm/model';
 import { TextSelection } from '@prosekit/pm/state';
 import { Transaction } from '@prosekit/pm/state';
 import type { UnionToIntersection } from 'type-fest';
@@ -120,6 +123,12 @@ export declare function assertTypeEqual<T, U>(_val: IsEqual<T, U>): void;
  */
 export declare function assertTypeEqual_alias_1<T, U>(_val: IsEqual<T, U>): void;
 
+declare interface AttrOptions {
+    attr: string;
+    toDOM?: (value: unknown) => [key: string, value: string] | null | undefined;
+    parseDOM?: (node: HTMLElement) => unknown;
+}
+
 export declare function attrsMatch(nodeOrMark: ProseMirrorNode | Mark, attrs: Attrs): boolean;
 
 /**
@@ -224,10 +233,6 @@ declare interface BaseNodeViewOptions {
 export { BaseNodeViewOptions }
 export { BaseNodeViewOptions as BaseNodeViewOptions_alias_1 }
 
-export declare function baseToggleMark(markType: MarkType, attrs?: Attrs | null, options?: {
-    removeWhenPresent: boolean;
-}): Command;
-
 declare type BoldExtension = Extension<{
     Marks: {
         bold: Attrs;
@@ -269,9 +274,20 @@ declare type CodeBlockExtension = Extension<{
     };
 }>;
 
+/**
+ * Collects all children of a node or a fragment, and returns them as an array.
+ *
+ * @public
+ */
+declare function collectChildren(parent: ProseMirrorNode | Fragment): ProseMirrorNode[];
+export { collectChildren }
+export { collectChildren as collectChildren_alias_1 }
+
 /**
  * Collects all nodes from a given content.
  *
+ * @deprecated Use `collectChildren` instead.
+ *
  * @public
  */
 declare function collectNodes(content: NodeContent): ProseMirrorNode[];
@@ -389,7 +405,7 @@ declare interface DefaultStateOptions {
     defaultHTML?: string | HTMLElement;
     /**
      * A JSON object representing the starting selection to use when creating the
-     * editor. It's only used when `defaultDoc` or `defaultHTML` is also provided.
+     * editor. It's only used when `defaultContent` is also provided.
      */
     defaultSelection?: SelectionJSON;
 }
@@ -450,9 +466,11 @@ export { defineCommands as defineCommands_alias_1 }
 /**
  * Define a default state for the editor.
  *
+ * @param options
+ *
  * @public
  */
-declare function defineDefaultState(options: DefaultStateOptions): PlainExtension;
+declare function defineDefaultState({ defaultSelection, defaultContent, defaultDoc, defaultHTML, }: DefaultStateOptions): PlainExtension;
 export { defineDefaultState }
 export { defineDefaultState as defineDefaultState_alias_1 }
 
@@ -554,6 +572,8 @@ export { defineFocusChangeHandler as defineFocusChangeHandler_alias_1 }
 /**
  * Add undo/redo history to the editor.
  *
+ * @param options
+ *
  * @public
  */
 declare function defineHistory({ depth, newGroupDelay, }?: HistoryOptions): HistoryExtension;
@@ -1017,7 +1037,7 @@ declare interface EditorOptions<E extends Extension> {
     defaultHTML?: string | HTMLElement;
     /**
      * A JSON object representing the starting selection to use when creating the
-     * editor. It's only used when `defaultDoc` or `defaultHTML` is also provided.
+     * editor. It's only used when `defaultContent` is also provided.
      */
     defaultSelection?: SelectionJSON;
 }
@@ -1252,10 +1272,63 @@ export declare function findBrowserWindow(options?: {
     document?: Document;
 }): (Window & typeof globalThis) | null | undefined;
 
-export declare function findParentNode(nodeType: NodeType, $pos: ResolvedPos): {
-    from: number | null;
-    to: number | null;
-};
+/**
+ * Find the closest parent node that satisfies the predicate.
+ *
+ * @public
+ */
+declare function findParentNode(
+/**
+ * The predicate to test the parent node.
+ */
+predicate: (node: ProseMirrorNode) => boolean, 
+/**
+ * The position to start searching from.
+ */
+$pos: ResolvedPos): FindParentNodeResult | undefined;
+export { findParentNode }
+export { findParentNode as findParentNode_alias_1 }
+
+/**
+ * Finds the closest parent node that matches the given node type.
+ *
+ * @public
+ */
+declare function findParentNodeOfType(
+/**
+ * The type of the node to remove.
+ */
+type: NodeType | string, 
+/**
+ * The position to start searching from.
+ */
+$pos: ResolvedPos): FindParentNodeResult | undefined;
+export { findParentNodeOfType }
+export { findParentNodeOfType as findParentNodeOfType_alias_1 }
+
+/**
+ * @public
+ */
+declare interface FindParentNodeResult {
+    /**
+     * The closest parent node that satisfies the predicate.
+     */
+    node: ProseMirrorNode;
+    /**
+     * The position directly before the node.
+     */
+    pos: number;
+    /**
+     * The position at the start of the node.
+     */
+    start: number;
+    /**
+     * The depth of the node.
+     */
+    depth: number;
+}
+export { FindParentNodeResult }
+export { FindParentNodeResult as FindParentNodeResult_alias_1 }
 
 /**
  * A function that is called when the editor gains or loses focus.
@@ -1316,12 +1389,12 @@ export declare function getNodeTypes(schema: Schema, types: string | NodeType |
 
 declare type GetStateFunction = () => EditorState | null | undefined;
 
-export declare type GroupedEntries<T extends Record<string, any>> = {
+export declare function groupBy<K extends PropertyKey, T>(items: Iterable<T>, keySelector: (item: T) => K): Partial<Record<K, T[]>>;
+
+export declare function groupEntries<T extends Record<string, any>>(entries: ObjectEntries<T>[]): {
     [K in keyof T]?: T[K][];
 };
 
-export declare function groupEntries<T extends Record<string, any>>(entries: ObjectEntries<T>[]): GroupedEntries<T>;
-
 declare type HeadingExtension = Extension<{
     Nodes: {
         heading: Attrs;
@@ -1429,6 +1502,8 @@ declare interface InsertNodeOptions {
 export { InsertNodeOptions }
 export { InsertNodeOptions as InsertNodeOptions_alias_1 }
 
+export declare function insertOutputSpecAttrs(dom: DOMOutputSpec, attrs: Array<[key: string, value: string]>): DOMOutputSpec;
+
 /**
  * Returns a command that inserts the given text.
  *
@@ -1446,7 +1521,9 @@ export declare type InsertTextOptions = {
 };
 
 /**
- * @internal
+ * Checks if the given object is a `AllSelection` instance.
+ *
+ * @public
  */
 declare function isAllSelection(sel: Selection_2): sel is AllSelection;
 export { isAllSelection }
@@ -1470,6 +1547,15 @@ export { isAtBlockStart as isAtBlockStart_alias_1 }
 
 export declare function isElement(el: unknown): el is Element;
 
+/**
+ * Checks if the given object is a `Fragment` instance.
+ *
+ * @public
+ */
+declare function isFragment(fragment: unknown): fragment is Fragment;
+export { isFragment }
+export { isFragment as isFragment_alias_1 }
+
 /**
  * Check if the selection is in a code block.
  *
@@ -1480,7 +1566,9 @@ export { isInCodeBlock }
 export { isInCodeBlock as isInCodeBlock_alias_1 }
 
 /**
- * @internal
+ * Checks if the given object is a `Mark` instance.
+ *
+ * @public
  */
 declare function isMark(mark: unknown): mark is Mark;
 export { isMark }
@@ -1507,30 +1595,46 @@ export { isMarkActive as isMarkActive_alias_1 }
 export declare function isNodeActive(state: EditorState, type: string | NodeType, attrs?: Attrs | null): boolean;
 
 /**
- * @internal
+ * Checks if the given object is a `NodeSelection` instance.
+ *
+ * @public
  */
 declare function isNodeSelection(sel: Selection_2): sel is NodeSelection;
 export { isNodeSelection }
 export { isNodeSelection as isNodeSelection_alias_1 }
 
-export declare function isNotNull<T>(value: T | null | undefined): value is T;
+/**
+ * @internal
+ */
+export declare function isNotNullish<T>(value: T | null | undefined | void): value is T;
 
 export declare function isObject(v: unknown): v is Record<string, unknown>;
 
 /**
- * @internal
+ * Checks if the given object is a `ProseMirrorNode` instance.
  */
 declare function isProseMirrorNode(node: unknown): node is ProseMirrorNode;
 export { isProseMirrorNode }
 export { isProseMirrorNode as isProseMirrorNode_alias_1 }
 
 /**
- * @internal
+ * Checks if the given object is a `Selection` instance.
+ *
+ * @public
  */
 declare function isSelection(sel: unknown): sel is Selection_2;
 export { isSelection }
 export { isSelection as isSelection_alias_1 }
 
+/**
+ * Checks if the given object is a `Slice` instance.
+ *
+ * @public
+ */
+declare function isSlice(slice: unknown): slice is Slice;
+export { isSlice }
+export { isSlice as isSlice_alias_1 }
+
 /**
  * Check if `subset` is a subset of `superset`.
  *
@@ -1539,7 +1643,9 @@ export { isSelection as isSelection_alias_1 }
 export declare function isSubset(subset: Record<string, unknown>, superset: Record<string, unknown>): boolean;
 
 /**
- * @internal
+ * Checks if the given object is a `TextSelection` instance.
+ *
+ * @public
  */
 declare function isTextSelection(sel: Selection_2): sel is TextSelection;
 export { isTextSelection }
@@ -1668,13 +1774,18 @@ declare interface MarkAttrOptions<MarkName extends string = string, AttrName ext
      */
     attr: AttrName;
     /**
-     * Returns the attribute key and value to be set on the DOM node.
+     * Returns the attribute key and value to be set on the HTML element.
+     *
+     * If the returned `key` is `"style"`, the value is a string of CSS properties and will
+     * be prepended to the existing `style` attribute on the DOM node.
+     *
+     * @param value - The value of the attribute of current ProseMirror node.
      */
-    toDOM?: (value: any) => [key: string, value: string] | null | void;
+    toDOM?: (value: AttrType) => [key: string, value: string] | null | undefined;
     /**
      * Parses the attribute value from the DOM.
      */
-    parseDOM?: (node: HTMLElement) => any;
+    parseDOM?: (node: HTMLElement) => AttrType;
 }
 export { MarkAttrOptions }
 export { MarkAttrOptions as MarkAttrOptions_alias_1 }
@@ -1720,6 +1831,12 @@ declare function maybeRun<T, R = T extends (...args: any[]) => void ? ReturnType
 export { maybeRun }
 export { maybeRun as maybeRun_alias_1 }
 
+export declare function mergeObjects<T extends object>(...objects: Array<Partial<T> | null | undefined>): Partial<T>;
+
+export declare function mergeSpecs(a: NodeSpec, b: NodeSpec): NodeSpec;
+
+export declare function mergeSpecs(a: MarkSpec, b: MarkSpec): MarkSpec;
+
 /**
  * A function that is called when the editor view is mounted.
  *
@@ -1774,16 +1891,18 @@ declare interface NodeAttrOptions<NodeName extends string = string, AttrName ext
      */
     splittable?: boolean;
     /**
-     * Returns the attribute key and value to be set on the DOM node.
+     * Returns the attribute key and value to be set on the HTML element.
      *
-     * If the `key` is `"style"`, the value is a string of CSS properties and will
+     * If the returned `key` is `"style"`, the value is a string of CSS properties and will
      * be prepended to the existing `style` attribute on the DOM node.
+     *
+     * @param value - The value of the attribute of current ProseMirror node.
      */
-    toDOM?: (value: any) => [key: string, value: string] | null | void;
+    toDOM?: (value: AttrType) => [key: string, value: string] | null | undefined;
     /**
      * Parses the attribute value from the DOM.
      */
-    parseDOM?: (node: HTMLElement) => any;
+    parseDOM?: (node: HTMLElement) => AttrType;
 }
 export { NodeAttrOptions }
 export { NodeAttrOptions as NodeAttrOptions_alias_1 }
@@ -1806,6 +1925,8 @@ export { NodeChild as NodeChild_alias_1 }
 
 /**
  * @public
+ *
+ * @deprecated
  */
 declare type NodeContent = ProseMirrorNode | ProseMirrorFragment | NodeContent[];
 export { NodeContent }
@@ -2082,13 +2203,16 @@ declare interface RemoveNodeOptions {
      */
     type: string | NodeType;
     /**
-     * The document position to start searching node. By default it will be the anchor position of current selection.
+     * The document position to start searching node. By default it will be the
+     * anchor position of current selection.
      */
     pos?: number;
 }
 export { RemoveNodeOptions }
 export { RemoveNodeOptions as RemoveNodeOptions_alias_1 }
 
+export declare function removeUndefinedValues<T extends object>(obj: T): T;
+
 export declare const rootFacet: Facet<RootPayload, RootOutput>;
 
 export declare type RootOutput = {
@@ -2383,9 +2507,11 @@ export declare type ToCommandCreators<T extends CommandTyping> = {
 /**
  * Returns a command that toggles the given mark with the given attributes.
  *
+ * @param options
+ *
  * @public
  */
-declare function toggleMark({ type, attrs }: ToggleMarkOptions): Command;
+declare function toggleMark({ type, attrs, removeWhenPresent, enterInlineAtoms, }: ToggleMarkOptions): Command;
 export { toggleMark }
 export { toggleMark as toggleMark_alias_1 }
 
@@ -2393,8 +2519,30 @@ export { toggleMark as toggleMark_alias_1 }
  * @public
  */
 declare interface ToggleMarkOptions {
+    /**
+     * The mark type to toggle.
+     */
     type: string | MarkType;
+    /**
+     * The optional attributes to set on the mark.
+     */
     attrs?: Attrs | null;
+    /**
+     * Controls whether, when part of the selected range has the mark
+     * already and part doesn't, the mark is removed (`true`) or added
+     * (`false`).
+     *
+     * @default false
+     */
+    removeWhenPresent?: boolean;
+    /**
+     * Whether the command should act on the content of inline nodes marked as
+     * [atoms](https://prosemirror.net/docs/ref/#model.NodeSpec.atom) that are
+     * completely covered by a selection range.
+     *
+     * @default true
+     */
+    enterInlineAtoms?: boolean;
 }
 export { ToggleMarkOptions }
 export { ToggleMarkOptions as ToggleMarkOptions_alias_1 }
@@ -2403,6 +2551,8 @@ export { ToggleMarkOptions as ToggleMarkOptions_alias_1 }
  * Returns a command that set the selected textblocks to the given node type
  * with the given attributes.
  *
+ * @param options
+ *
  * @public
  */
 declare function toggleNode({ type, attrs }: ToggleNodeOptions): Command;
@@ -2633,12 +2783,13 @@ export { withSkipCodeBlock }
 export { withSkipCodeBlock as withSkipCodeBlock_alias_1 }
 
 /**
- * Returns a command that wraps the selected textblock with the given node type
- * with the given attributes.
+ * Returns a command that wraps the selected textblock with the given node type.
+ *
+ * @param options
  *
  * @public
  */
-declare function wrap({ nodeType, attrs }: WrapOptions): Command;
+declare function wrap(options: WrapOptions): Command;
 export { wrap }
 export { wrap as wrap_alias_1 }
 
@@ -2646,12 +2797,26 @@ export { wrap as wrap_alias_1 }
  * @public
  */
 declare interface WrapOptions {
+    /**
+     * The node type to wrap the selected textblock with.
+     */
+    type: NodeType | string;
+    /**
+     * @deprecated Use `nodeSpec` instead.
+     */
     nodeType: NodeType;
+    /**
+     * Optional attributes to apply to the node.
+     */
     attrs?: Attrs | null;
 }
 export { WrapOptions }
 export { WrapOptions as WrapOptions_alias_1 }
 
+export declare function wrapOutputSpecAttrs<T extends ProseMirrorNode | Mark, Args extends readonly unknown[]>(toDOM: (node: T, ...args: Args) => DOMOutputSpec, options: AttrOptions[]): (node: T, ...args: Args) => DOMOutputSpec;
+
+export declare function wrapTagParseRuleAttrs(rule: TagParseRule, options: AttrOptions[]): TagParseRule;
+
 export declare function zip<T, P>(a: T[], b: P[]): [T, P][];
 
 export { }

package/dist/{chunk-MDJ2B4IL.js → chunk-UKHJHMFE.js}

@@ -59,6 +59,42 @@ var Priority = /* @__PURE__ */ ((Priority2) => {
   return Priority2;
 })(Priority || {});
 
+// src/utils/type-assertion.ts
+import { Fragment, Mark, ProseMirrorNode, Slice } from "@prosekit/pm/model";
+import {
+  AllSelection,
+  NodeSelection,
+  Selection,
+  TextSelection
+} from "@prosekit/pm/state";
+function isProseMirrorNode(node) {
+  return node instanceof ProseMirrorNode;
+}
+function isMark(mark) {
+  return mark instanceof Mark;
+}
+function isFragment(fragment) {
+  return fragment instanceof Fragment;
+}
+function isSlice(slice) {
+  return slice instanceof Slice;
+}
+function isSelection(sel) {
+  return sel instanceof Selection;
+}
+function isTextSelection(sel) {
+  return sel instanceof TextSelection;
+}
+function isNodeSelection(sel) {
+  return sel instanceof NodeSelection;
+}
+function isAllSelection(sel) {
+  return sel instanceof AllSelection;
+}
+function isNotNullish(value) {
+  return value != null;
+}
+
 // src/facets/facet.ts
 var facetCount = 0;
 var Facet = class {
@@ -113,11 +149,6 @@ function toReversed(arr) {
   return (_b = (_a = arr.toReversed) == null ? void 0 : _a.call(arr)) != null ? _b : [...arr].reverse();
 }
 
-// src/utils/is-not-null.ts
-function isNotNull(value) {
-  return value != null;
-}
-
 // src/facets/facet-node.ts
 function zip5(a, b, mapper) {
   return [
@@ -208,7 +239,7 @@ var FacetNode = class {
     }
     if (this.facet.singleton) {
       const reducer = (_a = this.reducers)[_b = 2 /* default */] || (_a[_b] = this.facet.reducer);
-      const input = inputs.filter(isNotNull).flat();
+      const input = inputs.filter(isNotNullish).flat();
       output[2 /* default */] = reducer(input);
     } else {
       for (let pri = 0; pri < 5; pri++) {
@@ -440,33 +471,6 @@ function htmlFromJSON(json, options) {
   return htmlFromElement(elementFromJSON(json, options));
 }
 
-// src/utils/type-assertion.ts
-import { Mark, ProseMirrorNode } from "@prosekit/pm/model";
-import {
-  AllSelection,
-  NodeSelection,
-  TextSelection,
-  Selection
-} from "@prosekit/pm/state";
-function isProseMirrorNode(node) {
-  return node instanceof ProseMirrorNode;
-}
-function isMark(mark) {
-  return mark instanceof Mark;
-}
-function isSelection(sel) {
-  return sel instanceof Selection;
-}
-function isTextSelection(sel) {
-  return sel instanceof TextSelection;
-}
-function isNodeSelection(sel) {
-  return sel instanceof NodeSelection;
-}
-function isAllSelection(sel) {
-  return sel instanceof AllSelection;
-}
-
 // src/extensions/default-state.ts
 import { Selection as Selection3 } from "@prosekit/pm/state";
 
@@ -564,8 +568,12 @@ function getEditorSelection(doc, selection) {
 }
 
 // src/extensions/default-state.ts
-function defineDefaultState(options) {
-  const { defaultSelection, defaultContent, defaultDoc, defaultHTML } = options;
+function defineDefaultState({
+  defaultSelection,
+  defaultContent,
+  defaultDoc,
+  defaultHTML
+}) {
   const defaultDocContent = defaultContent || defaultDoc || defaultHTML;
   return defineFacetPayload(stateFacet, [
     ({ schema }) => {
@@ -1105,7 +1113,15 @@ export {
   isNodeActive,
   Priority,
   toReversed,
-  isNotNull,
+  isProseMirrorNode,
+  isMark,
+  isFragment,
+  isSlice,
+  isSelection,
+  isTextSelection,
+  isNodeSelection,
+  isAllSelection,
+  isNotNullish,
   defineFacet,
   rootFacet,
   schemaFacet,
@@ -1123,12 +1139,6 @@ export {
   elementFromJSON,
   jsonFromHTML,
   htmlFromJSON,
-  isProseMirrorNode,
-  isMark,
-  isSelection,
-  isTextSelection,
-  isNodeSelection,
-  isAllSelection,
   defineDefaultState,
   isMarkAbsent,
   isMarkActive,

package/dist/prosekit-core-test.js

@@ -6,7 +6,7 @@ import {
   createNodeActions,
   isProseMirrorNode,
   setupEditorExtension
-} from "./chunk-MDJ2B4IL.js";
+} from "./chunk-UKHJHMFE.js";
 
 // src/test/test-editor.ts
 import { NodeSelection, TextSelection } from "@prosekit/pm/state";

package/dist/prosekit-core.d.ts

@@ -142,11 +142,15 @@ export { SimplifyUnion } from './_tsup-dts-rollup';
 export { assert } from './_tsup-dts-rollup';
 export { canUseRegexLookbehind } from './_tsup-dts-rollup';
 export { clsx } from './_tsup-dts-rollup';
+export { collectChildren } 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 { findParentNode } from './_tsup-dts-rollup';
+export { FindParentNodeResult } from './_tsup-dts-rollup';
+export { findParentNodeOfType } from './_tsup-dts-rollup';
 export { _getId } from './_tsup-dts-rollup';
 export { getMarkType } from './_tsup-dts-rollup';
 export { getNodeType } from './_tsup-dts-rollup';
@@ -171,10 +175,12 @@ export { DOMParserOptions } from './_tsup-dts-rollup';
 export { DOMSerializerOptions } from './_tsup-dts-rollup';
 export { JSONParserOptions } from './_tsup-dts-rollup';
 export { isAllSelection } from './_tsup-dts-rollup';
+export { isFragment } from './_tsup-dts-rollup';
 export { isMark } from './_tsup-dts-rollup';
 export { isNodeSelection } from './_tsup-dts-rollup';
 export { isProseMirrorNode } from './_tsup-dts-rollup';
 export { isSelection } from './_tsup-dts-rollup';
+export { isSlice } from './_tsup-dts-rollup';
 export { isTextSelection } from './_tsup-dts-rollup';
 export { withSkipCodeBlock } from './_tsup-dts-rollup';
 export { OBJECT_REPLACEMENT_CHARACTER } from './_tsup-dts-rollup';

package/dist/prosekit-core.js

@@ -16,14 +16,16 @@ import {
   htmlFromNode,
   isAllSelection,
   isElement,
+  isFragment,
   isMark,
   isMarkAbsent,
   isMarkActive,
   isNodeActive,
   isNodeSelection,
-  isNotNull,
+  isNotNullish,
   isProseMirrorNode,
   isSelection,
+  isSlice,
   isTextSelection,
   jsonFromHTML,
   jsonFromNode,
@@ -37,7 +39,7 @@ import {
   stateFromJSON,
   toReversed,
   union
-} from "./chunk-MDJ2B4IL.js";
+} from "./chunk-UKHJHMFE.js";
 
 // src/commands/add-mark.ts
 import "@prosekit/pm/model";
@@ -159,34 +161,31 @@ function removeMark(options) {
 }
 
 // src/utils/find-parent-node.ts
-function findParentNode(nodeType, $pos) {
-  for (let depth = $pos.depth; depth > 0; depth -= 1) {
+function findParentNode(predicate, $pos) {
+  for (let depth = $pos.depth; depth >= 0; depth -= 1) {
     const node = $pos.node(depth);
-    if (node.type === nodeType) {
-      const from = $pos.before(depth);
-      const to = $pos.after(depth);
-      return {
-        from,
-        to
-      };
+    if (predicate(node)) {
+      const pos = depth === 0 ? 0 : $pos.before(depth);
+      const start = $pos.start(depth);
+      return { node, pos, start, depth };
     }
   }
-  return {
-    from: null,
-    to: null
-  };
+}
+
+// src/utils/find-parent-node-of-type.ts
+function findParentNodeOfType(type, $pos) {
+  const nodeType = getNodeType($pos.doc.type.schema, type);
+  return findParentNode((node) => node.type === nodeType, $pos);
 }
 
 // src/commands/remove-node.ts
 function removeNode(options) {
   return (state, dispatch) => {
-    const nodeType = getNodeType(state.schema, options.type);
     const $pos = typeof options.pos === "number" ? state.doc.resolve(options.pos) : state.selection.$anchor;
-    const { from, to } = findParentNode(nodeType, $pos);
-    if (from == null || to == null || from > to) {
-      return false;
-    }
-    dispatch == null ? void 0 : dispatch(state.tr.delete(from, to));
+    const found = findParentNodeOfType(options.type, $pos);
+    if (!found) return false;
+    const { pos, node } = found;
+    dispatch == null ? void 0 : dispatch(state.tr.delete(pos, pos + node.nodeSize));
     return true;
   };
 }
@@ -284,77 +283,18 @@ function setNodeAttrs(options) {
 }
 
 // src/commands/toggle-mark.ts
+import { toggleMark as baseToggleMark } from "@prosekit/pm/commands";
 import "@prosekit/pm/model";
-import "@prosekit/pm/state";
-function markApplies(doc, ranges, type) {
-  for (const { $from, $to } of ranges) {
-    let can = $from.depth == 0 ? doc.inlineContent && doc.type.allowsMarkType(type) : false;
-    doc.nodesBetween($from.pos, $to.pos, (node) => {
-      if (can) return false;
-      can = node.inlineContent && node.type.allowsMarkType(type);
-    });
-    if (can) return true;
-  }
-  return false;
-}
-function baseToggleMark(markType, attrs = null, options) {
-  const removeWhenPresent = (options && options.removeWhenPresent) !== false;
-  return function(state, dispatch) {
-    const { empty, $cursor, ranges } = state.selection;
-    if (empty && !$cursor || !markApplies(state.doc, ranges, markType))
-      return false;
-    if (dispatch) {
-      if ($cursor) {
-        if (markType.isInSet(state.storedMarks || $cursor.marks()))
-          dispatch(state.tr.removeStoredMark(markType));
-        else dispatch(state.tr.addStoredMark(markType.create(attrs)));
-      } else {
-        let add;
-        const tr = state.tr;
-        if (removeWhenPresent) {
-          add = !ranges.some(
-            (r) => state.doc.rangeHasMark(r.$from.pos, r.$to.pos, markType)
-          );
-        } else {
-          add = !ranges.every((r) => {
-            let missing = false;
-            tr.doc.nodesBetween(r.$from.pos, r.$to.pos, (node, pos, parent) => {
-              if (missing) return false;
-              missing = !markType.isInSet(node.marks) && !!parent && parent.type.allowsMarkType(markType) && !(node.isText && /^\s*$/.test(
-                node.textBetween(
-                  Math.max(0, r.$from.pos - pos),
-                  Math.min(node.nodeSize, r.$to.pos - pos)
-                )
-              ));
-            });
-            return !missing;
-          });
-        }
-        for (const { $from, $to } of ranges) {
-          if (!add) {
-            tr.removeMark($from.pos, $to.pos, markType);
-          } else {
-            let from = $from.pos, to = $to.pos;
-            const start = $from.nodeAfter, end = $to.nodeBefore;
-            const spaceStart = start && start.isText ? /^\s*/.exec(start.text)[0].length : 0;
-            const spaceEnd = end && end.isText ? /\s*$/.exec(end.text)[0].length : 0;
-            if (from + spaceStart < to) {
-              from += spaceStart;
-              to -= spaceEnd;
-            }
-            tr.addMark(from, to, markType.create(attrs));
-          }
-        }
-        dispatch(tr.scrollIntoView());
-      }
-    }
-    return true;
-  };
-}
-function toggleMark({ type, attrs }) {
+function toggleMark({
+  type,
+  attrs,
+  removeWhenPresent = false,
+  enterInlineAtoms = true
+}) {
   return (state, dispatch, view) => {
     return baseToggleMark(getMarkType(state.schema, type), attrs, {
-      removeWhenPresent: false
+      removeWhenPresent,
+      enterInlineAtoms
     })(state, dispatch, view);
   };
 }
@@ -435,12 +375,13 @@ function unsetMark(options) {
 // src/commands/wrap.ts
 import "@prosekit/pm/model";
 import { findWrapping } from "@prosekit/pm/transform";
-function wrap({ nodeType, attrs }) {
+function wrap(options) {
   return (state, dispatch) => {
     const { $from, $to } = state.selection;
     const range = $from.blockRange($to);
     if (!range) return false;
-    const wrapping = findWrapping(range, nodeType, attrs);
+    const nodeType = getNodeType(state.schema, options.type || options.nodeType);
+    const wrapping = findWrapping(range, nodeType, options.attrs);
     if (!wrapping) return false;
     dispatch == null ? void 0 : dispatch(state.tr.wrap(range, wrapping));
     return true;
@@ -504,6 +445,7 @@ function defineBaseCommands() {
 }
 
 // src/extensions/node-spec.ts
+import clone from "just-clone";
 import OrderedMap2 from "orderedmap";
 
 // src/facets/schema-spec.ts
@@ -526,6 +468,139 @@ var schemaSpecFacet = defineFacet({
   singleton: true
 });
 
+// src/utils/array-grouping.ts
+function groupBy(items, keySelector) {
+  const result = {};
+  for (const item of items) {
+    const key = keySelector(item);
+    const values = result[key] || (result[key] = []);
+    values.push(item);
+  }
+  return result;
+}
+function groupEntries(entries) {
+  const result = {};
+  for (const [key, value] of entries) {
+    const values = result[key] || (result[key] = []);
+    values.push(value);
+  }
+  return result;
+}
+
+// src/utils/remove-undefined-values.ts
+function removeUndefinedValues(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/utils/merge-objects.ts
+function mergeObjects(...objects) {
+  const filteredObjects = objects.filter(isNotNullish).map(removeUndefinedValues);
+  return Object.assign({}, ...filteredObjects);
+}
+
+// src/utils/merge-specs.ts
+function mergeSpecs(a, b) {
+  var _a, _b, _c, _d, _e, _f;
+  const attrs = {};
+  const attrNames = /* @__PURE__ */ new Set([
+    ...Object.keys((_a = a.attrs) != null ? _a : {}),
+    ...Object.keys((_b = b.attrs) != null ? _b : {})
+  ]);
+  for (const name of attrNames) {
+    const attrSpecA = (_c = a.attrs) == null ? void 0 : _c[name];
+    const attrSpecB = (_d = b.attrs) == null ? void 0 : _d[name];
+    const attrSpecMerged = mergeObjects(attrSpecA, attrSpecB);
+    if (attrSpecMerged) {
+      attrs[name] = attrSpecMerged;
+    }
+  }
+  const parseDOM = [...(_e = a.parseDOM) != null ? _e : [], ...(_f = b.parseDOM) != null ? _f : []];
+  return mergeObjects(a, b, { attrs, parseDOM });
+}
+
+// src/utils/output-spec.ts
+function wrapOutputSpecAttrs(toDOM, options) {
+  return (node, ...args) => {
+    const dom = toDOM(node, ...args);
+    const pairs = options.map((option) => {
+      var _a;
+      return (_a = option.toDOM) == null ? void 0 : _a.call(option, node.attrs[option.attr]);
+    }).filter(isNotNullish);
+    return insertOutputSpecAttrs(dom, pairs);
+  };
+}
+function wrapTagParseRuleAttrs(rule, options) {
+  const existingGetAttrs = rule.getAttrs;
+  const existingAttrs = rule.attrs;
+  return {
+    ...rule,
+    getAttrs: (dom) => {
+      var _a, _b;
+      const baseAttrs = (_b = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs) != null ? _b : {};
+      if (baseAttrs === false || !dom || !isElement(dom)) {
+        return baseAttrs != null ? baseAttrs : null;
+      }
+      const insertedAttrs = {};
+      for (const option of options) {
+        if (option.parseDOM) {
+          insertedAttrs[option.attr] = option.parseDOM(dom);
+        }
+      }
+      return { ...baseAttrs, ...insertedAttrs };
+    }
+  };
+}
+function insertOutputSpecAttrs(dom, attrs) {
+  if (!dom) {
+    return dom;
+  }
+  if (Array.isArray(dom)) {
+    const rest = dom.slice(1);
+    let oldAttrs;
+    if (rest.length > 0 && (rest[0] == null || typeof rest[0] === "object")) {
+      oldAttrs = rest.shift();
+    } else {
+      oldAttrs = {};
+    }
+    const newAttrs = setObjectAttributes(oldAttrs, attrs);
+    return [dom[0], newAttrs, ...rest];
+  }
+  if (isElement(dom)) {
+    return setElementAttributes(dom, attrs);
+  }
+  if (typeof dom === "object" && "dom" in dom && isElement(dom.dom)) {
+    return { ...dom, dom: setElementAttributes(dom.dom, attrs) };
+  }
+  return dom;
+}
+function setObjectAttributes(obj, attrs) {
+  obj = { ...obj };
+  for (const [key, value] of attrs) {
+    const oldValue = obj[key];
+    const newValue = key === "style" ? joinStyles(value, typeof oldValue === "string" ? oldValue : "") : value;
+    obj[key] = newValue;
+  }
+  return obj;
+}
+function setElementAttributes(element, attrs) {
+  element = element.cloneNode(true);
+  for (const [key, value] of attrs) {
+    const oldValue = element.getAttribute(key);
+    const newValue = key === "style" ? joinStyles(value, typeof oldValue === "string" ? oldValue : "") : value;
+    element.setAttribute(key, newValue);
+  }
+  return element;
+}
+function joinStyles(...styles) {
+  return styles.map((style) => style.trim().replace(/;$/, "")).filter(Boolean).join("; ");
+}
+
 // src/extensions/node-spec.ts
 function defineNodeSpec(options) {
   const payload = [options, void 0];
@@ -539,105 +614,50 @@ var nodeSpecFacet = defineFacet({
   reducer: (payloads) => {
     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);
+    const specPayloads = payloads.map((input) => input[0]).filter(isNotNullish);
+    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNullish);
     for (const { name, topNode, ...spec } of specPayloads) {
-      assert(!specs.get(name), `Node type ${name} can only be defined once`);
       if (topNode) {
         topNodeName = name;
       }
-      specs = specs.addToStart(name, spec);
+      const prevSpec = specs.get(name);
+      if (prevSpec) {
+        specs = specs.update(name, mergeSpecs(prevSpec, spec));
+      } else {
+        specs = specs.addToStart(name, spec);
+      }
     }
-    for (const {
-      type,
-      attr,
-      default: defaultValue,
-      splittable,
-      toDOM,
-      parseDOM
-    } of attrPayloads) {
-      const spec = specs.get(type);
-      assert(spec, `Node type ${type} must be defined`);
+    const groupedAttrs = groupBy(attrPayloads, (payload) => payload.type);
+    for (const [type, attrs] of Object.entries(groupedAttrs)) {
+      if (!attrs) continue;
+      const maybeSpec = specs.get(type);
+      assert(maybeSpec, `Node type ${type} must be defined`);
+      const spec = clone(maybeSpec);
       if (!spec.attrs) {
         spec.attrs = {};
       }
-      spec.attrs[attr] = {
-        default: defaultValue,
-        splittable
-      };
-      if (toDOM && spec.toDOM) {
-        const existingToDom = spec.toDOM;
-        spec.toDOM = (node) => {
-          const dom = existingToDom(node);
-          if (!dom) {
-            return dom;
-          }
-          const attrDOM = toDOM(node.attrs[attr]);
-          if (!attrDOM) {
-            return dom;
-          }
-          const [key, value] = attrDOM;
-          if (!key) {
-            return dom;
-          }
-          if (Array.isArray(dom)) {
-            if (typeof dom[1] === "object") {
-              return [
-                dom[0],
-                setObjectAttribute(
-                  dom[1],
-                  key,
-                  value
-                ),
-                ...dom.slice(2)
-              ];
-            } else {
-              return [dom[0], { [key]: value }, ...dom.slice(1)];
-            }
-          } else if (isElement(dom)) {
-            setElementAttribute(dom, key, value);
-          } else if (typeof dom === "object" && "dom" in dom && isElement(dom.dom)) {
-            setElementAttribute(dom.dom, key, value);
-          }
-          return dom;
+      for (const attr of attrs) {
+        spec.attrs[attr.attr] = {
+          default: attr.default,
+          validate: attr.validate,
+          splittable: attr.splittable
         };
       }
-      if (parseDOM && spec.parseDOM) {
-        for (const rule of spec.parseDOM) {
-          const existingGetAttrs = rule.getAttrs;
-          const existingAttrs = rule.attrs;
-          rule.getAttrs = (dom) => {
-            var _a;
-            const attrs = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs;
-            if (attrs === false || !dom || !isElement(dom)) {
-              return attrs != null ? attrs : null;
-            }
-            const value = parseDOM(dom);
-            return {
-              ...attrs,
-              [attr]: value
-            };
-          };
-        }
+      if (spec.toDOM) {
+        spec.toDOM = wrapOutputSpecAttrs(spec.toDOM, attrs);
+      }
+      if (spec.parseDOM) {
+        spec.parseDOM = spec.parseDOM.map(
+          (rule) => wrapTagParseRuleAttrs(rule, attrs)
+        );
       }
+      specs = specs.update(type, spec);
     }
     return { nodes: specs, topNode: topNodeName };
   },
   parent: schemaSpecFacet,
   singleton: true
 });
-function setObjectAttribute(obj, key, value) {
-  if (key === "style") {
-    value = `${value}${obj.style || ""}`;
-  }
-  return { ...obj, [key]: value };
-}
-function setElementAttribute(element, key, value) {
-  if (key === "style") {
-    value = `${value}${element.getAttribute("style") || ""}`;
-  }
-  element.setAttribute(key, value);
-}
 
 // src/extensions/doc.ts
 function defineDoc() {
@@ -777,20 +797,6 @@ function combineEventHandlers() {
   return [setHandlers, combinedEventHandler];
 }
 
-// src/utils/group-entries.ts
-function groupEntries(entries) {
-  const map = {};
-  for (const [key, value] of entries) {
-    const values = map[key];
-    if (!values) {
-      map[key] = [value];
-    } else {
-      values.push(value);
-    }
-  }
-  return map;
-}
-
 // src/extensions/events/dom-event.ts
 function defineDOMEventHandler(event, handler) {
   return defineFacetPayload(domEventFacet, [
@@ -1059,6 +1065,7 @@ function defineBaseKeymap(options) {
 }
 
 // src/extensions/mark-spec.ts
+import clone2 from "just-clone";
 import OrderedMap3 from "orderedmap";
 function defineMarkSpec(options) {
   const payload = [options, void 0];
@@ -1071,78 +1078,52 @@ function defineMarkAttr(options) {
 var markSpecFacet = defineFacet({
   reducer: (payloads) => {
     let specs = OrderedMap3.from({});
-    const specPayloads = payloads.map((input) => input[0]).filter(isNotNull);
-    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
+    const specPayloads = payloads.map((input) => input[0]).filter(isNotNullish);
+    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNullish);
     for (const { name, ...spec } of specPayloads) {
-      assert(!specs.get(name), `Mark type ${name} can only be defined once`);
-      specs = specs.addToStart(name, spec);
+      const prevSpec = specs.get(name);
+      if (prevSpec) {
+        specs = specs.update(name, mergeSpecs(prevSpec, spec));
+      } else {
+        specs = specs.addToStart(name, spec);
+      }
     }
-    for (const {
-      type,
-      attr,
-      default: defaultValue,
-      toDOM,
-      parseDOM
-    } of attrPayloads) {
-      const spec = specs.get(type);
-      assert(spec, `Mark type ${type} must be defined`);
+    const groupedAttrs = groupBy(attrPayloads, (payload) => payload.type);
+    for (const [type, attrs] of Object.entries(groupedAttrs)) {
+      if (!attrs) continue;
+      const maybeSpec = specs.get(type);
+      assert(maybeSpec, `Mark type ${type} must be defined`);
+      const spec = clone2(maybeSpec);
       if (!spec.attrs) {
         spec.attrs = {};
       }
-      spec.attrs[attr] = { default: defaultValue };
-      if (toDOM && spec.toDOM) {
-        const existingToDom = spec.toDOM;
-        spec.toDOM = (mark, inline) => {
-          const dom = existingToDom(mark, inline);
-          if (!dom) {
-            return dom;
-          }
-          const attrDOM = toDOM(mark.attrs[attr]);
-          if (!attrDOM) {
-            return dom;
-          }
-          const [key, value] = attrDOM;
-          if (!key) {
-            return dom;
-          }
-          if (Array.isArray(dom)) {
-            if (typeof dom[1] === "object") {
-              return [dom[0], { ...dom[1], [key]: value }, ...dom.slice(2)];
-            } else {
-              return [dom[0], { [key]: value }, ...dom.slice(1)];
-            }
-          } else if (isElement(dom)) {
-            dom.setAttribute(key, value);
-          } else if (typeof dom === "object" && "dom" in dom && isElement(dom.dom)) {
-            dom.dom.setAttribute(key, value);
-          }
-          return dom;
+      for (const attr of attrs) {
+        spec.attrs[attr.attr] = {
+          default: attr.default,
+          validate: attr.validate
         };
       }
-      if (parseDOM && spec.parseDOM) {
-        for (const rule of spec.parseDOM) {
-          const existingGetAttrs = rule.getAttrs;
-          const existingAttrs = rule.attrs;
-          rule.getAttrs = (dom) => {
-            var _a;
-            const attrs = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs;
-            if (attrs === false || !dom || !isElement(dom)) {
-              return attrs != null ? attrs : null;
-            }
-            const value = parseDOM(dom);
-            return {
-              ...attrs,
-              [attr]: value
-            };
-          };
-        }
+      if (spec.toDOM) {
+        spec.toDOM = wrapOutputSpecAttrs(spec.toDOM, attrs);
+      }
+      if (spec.parseDOM) {
+        spec.parseDOM = spec.parseDOM.map(
+          (rule) => wrapParseRuleAttrs(rule, attrs)
+        );
       }
+      specs = specs.update(type, spec);
     }
     return { marks: specs, nodes: {} };
   },
   parent: schemaSpecFacet,
   singleton: true
 });
+function wrapParseRuleAttrs(rule, attrs) {
+  if (rule.tag) {
+    return wrapTagParseRuleAttrs(rule, attrs);
+  }
+  return rule;
+}
 
 // src/extensions/node-view.ts
 import { PluginKey as PluginKey5, ProseMirrorPlugin as ProseMirrorPlugin5 } from "@prosekit/pm/state";
@@ -1182,8 +1163,8 @@ var nodeViewFactoryFacet = defineFacet({
   reducer: (inputs) => {
     if (isServer) return [];
     const nodeViews = {};
-    const factories = inputs.map((x) => x[0]).filter(isNotNull);
-    const options = inputs.map((x) => x[1]).filter(isNotNull);
+    const factories = inputs.map((x) => x[0]).filter(isNotNullish);
+    const options = inputs.map((x) => x[1]).filter(isNotNullish);
     for (const { group, name, args } of options) {
       const factory = factories.find((factory2) => factory2.group === group);
       if (!factory) continue;
@@ -1247,6 +1228,16 @@ var canUseRegexLookbehind = cache(() => {
 import clsxLite from "clsx/lite";
 var clsx = clsxLite;
 
+// src/utils/collect-children.ts
+import "@prosekit/pm/model";
+function collectChildren(parent) {
+  const children = [];
+  for (let i = 0; i < parent.childCount; i++) {
+    children.push(parent.child(i));
+  }
+  return children;
+}
+
 // src/utils/collect-nodes.ts
 import { ProseMirrorFragment, ProseMirrorNode as ProseMirrorNode2 } from "@prosekit/pm/model";
 function collectNodes(content) {
@@ -1336,6 +1327,7 @@ export {
   assert,
   canUseRegexLookbehind,
   clsx,
+  collectChildren,
   collectNodes,
   containsInlineNode,
   createEditor,
@@ -1380,6 +1372,8 @@ export {
   elementFromJSON,
   elementFromNode,
   expandMark,
+  findParentNode,
+  findParentNodeOfType,
   getMarkType,
   getNodeType,
   htmlFromJSON,
@@ -1388,6 +1382,7 @@ export {
   isAllSelection,
   isApple,
   isAtBlockStart,
+  isFragment,
   isInCodeBlock,
   isMark,
   isMarkAbsent,
@@ -1395,6 +1390,7 @@ export {
   isNodeSelection,
   isProseMirrorNode,
   isSelection,
+  isSlice,
   isTextSelection,
   jsonFromHTML,
   jsonFromNode,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.7.7",
+  "version": "0.7.8",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -41,14 +41,15 @@
   ],
   "dependencies": {
     "clsx": "^2.1.1",
+    "just-clone": "^6.2.0",
     "just-map-values": "^3.2.0",
     "orderedmap": "^2.1.1",
     "prosemirror-splittable": "^0.1.1",
     "type-fest": "^4.23.0",
-    "@prosekit/pm": "^0.1.7"
+    "@prosekit/pm": "^0.1.8"
   },
   "devDependencies": {
-    "tsup": "^8.2.2",
+    "tsup": "^8.2.3",
     "typescript": "^5.5.3",
     "vitest": "^2.0.4",
     "@prosekit/dev": "0.0.0"