@prosekit/core 0.7.6 → 0.7.7

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

@@ -1,6 +1,5 @@
 import { AllSelection } from '@prosekit/pm/state';
 import { Attrs } from '@prosekit/pm/model';
-import { Attrs as Attrs_2 } from 'prosemirror-model';
 import { Command } from '@prosekit/pm/state';
 import type { ContentMatch } from '@prosekit/pm/model';
 import { config as default_alias_1 } from '@prosekit/dev/config-vitest';
@@ -229,6 +228,12 @@ export declare function baseToggleMark(markType: MarkType, attrs?: Attrs | null,
     removeWhenPresent: boolean;
 }): Command;
 
+declare type BoldExtension = Extension<{
+    Marks: {
+        bold: Attrs;
+    };
+}>;
+
 export declare function buildNode(type: NodeType, args: [Attrs | NodeChild | null | undefined, ...NodeChild[]], createNode: CreateNodeFunction): ProseMirrorNode;
 
 export declare function cache<T>(fn: () => T): () => T;
@@ -256,6 +261,14 @@ declare const clsx: (...args: Array<string | boolean | null | undefined>) => str
 export { clsx }
 export { clsx as clsx_alias_1 }
 
+declare type CodeBlockExtension = Extension<{
+    Nodes: {
+        codeBlock: {
+            language: string;
+        };
+    };
+}>;
+
 /**
  * Collects all nodes from a given content.
  *
@@ -317,12 +330,12 @@ export { createEditor as createEditor_alias_1 }
 /**
  * @internal
  */
-export declare function createMarkActions(schema: Schema, getState: () => EditorState | null | undefined, applyMark?: ApplyMarkFunction): Record<string, MarkAction>;
+export declare function createMarkActions(schema: Schema, getState: GetStateFunction, applyMark?: ApplyMarkFunction): Record<string, MarkAction>;
 
 /**
  * @internal
  */
-export declare function createNodeActions(schema: Schema, getState: () => EditorState | null | undefined, createNode?: CreateNodeFunction): Record<string, NodeAction>;
+export declare function createNodeActions(schema: Schema, getState: GetStateFunction, createNode?: CreateNodeFunction): Record<string, NodeAction>;
 
 export declare const createNodeForTest: CreateNodeFunction;
 
@@ -351,15 +364,27 @@ declare function defaultBlockAt(match: ContentMatch): NodeType_2 | null;
 export { defaultBlockAt }
 export { defaultBlockAt as defaultBlockAt_alias_1 }
 
+/**
+ * @public
+ */
 declare interface DefaultStateOptions {
+    /**
+     * The starting document to use when creating the editor. It can be a
+     * ProseMirror node JSON object, a HTML string, or a HTML element instance.
+     */
+    defaultContent?: NodeJSON | string | HTMLElement;
     /**
      * A JSON object representing the starting document to use when creating the
      * editor.
+     *
+     * @deprecated Use `defaultContent` instead.
      */
     defaultDoc?: NodeJSON;
     /**
      * A HTML element or a HTML string representing the starting document to use
      * when creating the editor.
+     *
+     * @deprecated Use `defaultContent` instead.
      */
     defaultHTML?: string | HTMLElement;
     /**
@@ -422,7 +447,12 @@ declare function defineCommands<T extends Record<string, CommandCreator> = Recor
 export { defineCommands }
 export { defineCommands as defineCommands_alias_1 }
 
-declare function defineDefaultState({ defaultDoc, defaultHTML, defaultSelection, }: DefaultStateOptions): PlainExtension;
+/**
+ * Define a default state for the editor.
+ *
+ * @public
+ */
+declare function defineDefaultState(options: DefaultStateOptions): PlainExtension;
 export { defineDefaultState }
 export { defineDefaultState as defineDefaultState_alias_1 }
 
@@ -685,27 +715,9 @@ export { defineScrollToSelectionHandler as defineScrollToSelectionHandler_alias_
  */
 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;
+paragraph: Attrs;
 };
-};
-}>]>;
+}>, TextExtension, BoldExtension, ItalicExtension, LinkExtension, HeadingExtension, CodeBlockExtension]>;
 
 /**
  * @public
@@ -851,15 +863,10 @@ export { DropHandler as DropHandler_alias_1 }
  */
 declare class Editor<E extends Extension = any> {
     private instance;
-    private afterMounted;
     /**
      * @internal
      */
     constructor(instance: EditorInstance);
-    /**
-     * @internal
-     */
-    static create(instance: any): Editor;
     /**
      * Whether the editor is mounted.
      */
@@ -872,6 +879,10 @@ declare class Editor<E extends Extension = any> {
      * The editor schema.
      */
     get schema(): Schema<ExtractNodeNames<E>, ExtractMarkNames<E>>;
+    /**
+     * The editor's current state.
+     */
+    get state(): EditorState;
     /**
      * Whether the editor is focused.
      */
@@ -880,28 +891,24 @@ declare class Editor<E extends Extension = any> {
      * Mount the editor to the given HTML element.
      * Pass `null` or `undefined` to unmount the editor.
      */
-    mount(place: HTMLElement | null | undefined): void;
+    mount: (place: HTMLElement | null | undefined) => void;
     /**
      * Unmount the editor. This is equivalent to `mount(null)`.
      */
-    unmount(): void;
+    unmount: () => void;
     /**
      * Focus the editor.
      */
-    focus(): void;
+    focus: () => void;
     /**
      * Blur the editor.
      */
-    blur(): void;
+    blur: () => void;
     /**
      * Register an extension to the editor. Return a function to unregister the
      * extension.
      */
-    use(extension: Extension): VoidFunction;
-    /**
-     * The editor's current state.
-     */
-    get state(): EditorState;
+    use: (extension: Extension) => VoidFunction;
     /**
      * Update the editor's state.
      *
@@ -910,7 +917,22 @@ declare class Editor<E extends Extension = any> {
      * This is an advanced method. Use it only if you have a specific reason to
      * directly manipulate the editor's state.
      */
-    updateState(state: EditorState): void;
+    updateState: (state: EditorState) => void;
+    /**
+     * Update the editor's document and selection.
+     *
+     * @param content - The new document to set. It can be one of the following:
+     *   - A ProseMirror node instance
+     *   - A ProseMirror node JSON object
+     *   - An HTML string
+     *   - An HTML element instance
+     * @param selection - Optional. Specifies the new selection. It can be one of the following:
+     *   - A ProseMirror selection instance
+     *   - A ProseMirror selection JSON object
+     *   - The string "start" (to set selection at the beginning, default value)
+     *   - The string "end" (to set selection at the end)
+     */
+    setContent: (content: ProseMirrorNode | NodeJSON | string | HTMLElement, selection?: SelectionJSON | Selection_2 | "start" | "end") => void;
     /**
      * All {@link CommandAction}s defined by the editor.
      */
@@ -928,6 +950,8 @@ export { Editor }
 export { Editor as Editor_alias_1 }
 
 /**
+ * An internal class to make TypeScript generic type easier to use.
+ *
  * @internal
  */
 export declare class EditorInstance {
@@ -938,10 +962,13 @@ export declare class EditorInstance {
     commands: Record<string, CommandAction>;
     private tree;
     private directEditorProps;
+    private afterMounted;
     constructor(extension: Extension);
     getState: () => EditorState;
     updateState(state: EditorState): void;
-    updateExtension(extension: Extension, add: boolean): void;
+    setContent(content: NodeJSON | string | HTMLElement | ProseMirrorNode, selection?: SelectionJSON | Selection_2 | 'start' | 'end'): void;
+    private updateExtension;
+    use(extension: Extension): VoidFunction;
     mount(place: HTMLElement): void;
     unmount(): void;
     get mounted(): boolean;
@@ -969,14 +996,23 @@ declare interface EditorOptions<E extends Extension> {
      * The extension to use when creating the editor.
      */
     extension: E;
+    /**
+     * The starting document to use when creating the editor. It can be a
+     * ProseMirror node JSON object, a HTML string, or a HTML element instance.
+     */
+    defaultContent?: NodeJSON | string | HTMLElement;
     /**
      * A JSON object representing the starting document to use when creating the
      * editor.
+     *
+     * @deprecated Use `defaultContent` instead.
      */
     defaultDoc?: NodeJSON;
     /**
      * A HTML element or a HTML string representing the starting document to use
      * when creating the editor.
+     *
+     * @deprecated Use `defaultContent` instead.
      */
     defaultHTML?: string | HTMLElement;
     /**
@@ -1242,6 +1278,14 @@ export declare function getBrowserWindow(options?: {
 
 export declare function getCustomSelection(state: EditorState, from?: number | null, to?: number | null): Selection_3;
 
+export declare function getEditorContentDoc(schema: Schema, content: NodeJSON | string | HTMLElement | ProseMirrorNode): ProseMirrorNode;
+
+export declare function getEditorContentJSON(schema: Schema, content: NodeJSON | string | HTMLElement): NodeJSON;
+
+export declare function getEditorContentNode(schema: Schema, content: NodeJSON | string | HTMLElement | ProseMirrorNode): ProseMirrorNode;
+
+export declare function getEditorSelection(doc: ProseMirrorNode, selection: SelectionJSON | Selection_2 | 'start' | 'end'): Selection_2;
+
 /**
  * Returns a unique id in the current process that can be used in various places.
  *
@@ -1270,12 +1314,20 @@ export { getNodeType as getNodeType_alias_1 }
  */
 export declare function getNodeTypes(schema: Schema, types: string | NodeType | string[] | NodeType[]): NodeType[];
 
+declare type GetStateFunction = () => EditorState | null | undefined;
+
 export declare type GroupedEntries<T extends Record<string, any>> = {
     [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;
+    };
+}>;
+
 /**
  * @internal
  */
@@ -1416,7 +1468,7 @@ declare function isAtBlockStart(state: EditorState, view?: EditorView): Resolved
 export { isAtBlockStart }
 export { isAtBlockStart as isAtBlockStart_alias_1 }
 
-export declare function isElement(value: unknown): value is Element;
+export declare function isElement(el: unknown): el is Element;
 
 /**
  * Check if the selection is in a code block.
@@ -1463,6 +1515,8 @@ export { isNodeSelection as isNodeSelection_alias_1 }
 
 export declare function isNotNull<T>(value: T | null | undefined): value is T;
 
+export declare function isObject(v: unknown): v is Record<string, unknown>;
+
 /**
  * @internal
  */
@@ -1470,6 +1524,13 @@ declare function isProseMirrorNode(node: unknown): node is ProseMirrorNode;
 export { isProseMirrorNode }
 export { isProseMirrorNode as isProseMirrorNode_alias_1 }
 
+/**
+ * @internal
+ */
+declare function isSelection(sel: unknown): sel is Selection_2;
+export { isSelection }
+export { isSelection as isSelection_alias_1 }
+
 /**
  * Check if `subset` is a subset of `superset`.
  *
@@ -1484,6 +1545,12 @@ declare function isTextSelection(sel: Selection_2): sel is TextSelection;
 export { isTextSelection }
 export { isTextSelection as isTextSelection_alias_1 }
 
+declare type ItalicExtension = Extension<{
+    Marks: {
+        italic: Attrs;
+    };
+}>;
+
 /**
  * Serialize a HTML element to a ProseMirror document JSON object.
  *
@@ -1556,6 +1623,16 @@ declare type KeyPressHandler = (view: EditorView, event: KeyboardEvent) => boole
 export { KeyPressHandler }
 export { KeyPressHandler as KeyPressHandler_alias_1 }
 
+declare interface LinkAttrs {
+    href: string;
+}
+
+declare type LinkExtension = Extension<{
+    Marks: {
+        link: LinkAttrs;
+    };
+}>;
+
 /**
  * A function for creating a mark with optional attributes and any number of
  * children.
@@ -1768,7 +1845,10 @@ export { nodeFromJSON as nodeFromJSON_alias_1 }
  */
 declare interface NodeJSON {
     type: string;
-    marks?: Array<any>;
+    marks?: Array<{
+        type: string;
+        attrs?: Record<string, any>;
+    }>;
     text?: string;
     content?: NodeJSON[];
     attrs?: Record<string, any>;
@@ -2127,27 +2207,9 @@ export declare function setupEditorExtension<E extends Extension>(options: Edito
 export declare function setupTest(): {
     editor: TestEditor<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;
+    paragraph: Attrs;
     };
-    };
-    }>]>>;
+    }>, TextExtension, BoldExtension, ItalicExtension, LinkExtension, HeadingExtension, CodeBlockExtension]>>;
     m: ToMarkAction<SimplifyDeeper<    {
     bold: {
     readonly [x: string]: any;
@@ -2155,6 +2217,9 @@ export declare function setupTest(): {
     italic: {
     readonly [x: string]: any;
     };
+    link: {
+    href: string;
+    };
     }>>;
     n: {
         p: NodeAction<    {
@@ -2169,12 +2234,12 @@ export declare function setupTest(): {
         text: NodeAction<    {
         readonly [x: string]: any;
         }>;
-        codeBlock: NodeAction<    {
-        language: string;
-        }>;
         heading: NodeAction<    {
         readonly [x: string]: any;
         }>;
+        codeBlock: NodeAction<    {
+        language: string;
+        }>;
     };
 };
 

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

@@ -440,8 +440,35 @@ 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 } from "@prosekit/pm/state";
+import { Selection as Selection3 } from "@prosekit/pm/state";
 
 // src/facets/state.ts
 var stateFacet = defineFacet({
@@ -480,31 +507,74 @@ var stateFacet = defineFacet({
   parent: rootFacet
 });
 
-// src/extensions/default-state.ts
-function defineDefaultState({
-  defaultDoc,
-  defaultHTML,
-  defaultSelection
-}) {
-  if (defaultHTML && defaultDoc) {
-    throw new ProseKitError(
-      "Only one of defaultHTML and defaultDoc can be provided"
-    );
+// src/utils/editor-content.ts
+import { Selection as Selection2 } from "@prosekit/pm/state";
+
+// src/utils/is-object.ts
+function isObject(v) {
+  return typeof v === "object" && v != null;
+}
+
+// src/utils/is-element.ts
+var ELEMENT_NODE = 1;
+function isElement(el) {
+  return isObject(el) && el.nodeType === ELEMENT_NODE && typeof el.nodeName === "string";
+}
+
+// src/utils/editor-content.ts
+function getEditorContentJSON(schema, content) {
+  if (typeof content === "string") {
+    return jsonFromHTML(content, { schema });
+  } else if (isElement(content)) {
+    return jsonFromElement(content, { schema });
+  } else {
+    return content;
+  }
+}
+function getEditorContentNode(schema, content) {
+  if (isProseMirrorNode(content)) {
+    return content;
   }
+  return schema.nodeFromJSON(getEditorContentJSON(schema, content));
+}
+function getEditorContentDoc(schema, content) {
+  const doc = getEditorContentNode(schema, content);
+  assert(
+    doc.type.schema === schema,
+    "Document schema does not match editor schema"
+  );
+  assert(
+    doc.type === schema.topNodeType,
+    `Document type does not match editor top node type. Expected ${schema.topNodeType.name}, got ${doc.type.name}`
+  );
+  return doc;
+}
+function getEditorSelection(doc, selection) {
+  if (isSelection(selection)) {
+    assert(selection.$head.doc === doc, "Selection and doc do not match");
+    return selection;
+  }
+  if (selection === "start") {
+    return Selection2.atStart(doc);
+  }
+  if (selection === "end") {
+    return Selection2.atEnd(doc);
+  }
+  return Selection2.fromJSON(doc, selection);
+}
+
+// src/extensions/default-state.ts
+function defineDefaultState(options) {
+  const { defaultSelection, defaultContent, defaultDoc, defaultHTML } = options;
+  const defaultDocContent = defaultContent || defaultDoc || defaultHTML;
   return defineFacetPayload(stateFacet, [
     ({ schema }) => {
       const config = {};
-      if (defaultHTML) {
-        if (typeof defaultHTML === "string") {
-          defaultDoc = jsonFromHTML(defaultHTML, { schema });
-        } else {
-          defaultDoc = jsonFromElement(defaultHTML, { schema });
-        }
-      }
-      if (defaultDoc) {
-        config.doc = schema.nodeFromJSON(defaultDoc);
+      if (defaultDocContent) {
+        const json = getEditorContentJSON(schema, defaultDocContent);
+        config.doc = schema.nodeFromJSON(json);
         if (defaultSelection) {
-          config.selection = Selection.fromJSON(config.doc, defaultSelection);
+          config.selection = Selection3.fromJSON(config.doc, defaultSelection);
         }
       }
       return config;
@@ -556,29 +626,6 @@ function isMarkActive(state, type, attrs) {
   }
 }
 
-// src/utils/type-assertion.ts
-import { Mark, ProseMirrorNode } from "@prosekit/pm/model";
-import {
-  AllSelection,
-  NodeSelection,
-  TextSelection
-} from "@prosekit/pm/state";
-function isProseMirrorNode(node) {
-  return node instanceof ProseMirrorNode;
-}
-function isMark(mark) {
-  return mark instanceof Mark;
-}
-function isTextSelection(sel) {
-  return sel instanceof TextSelection;
-}
-function isNodeSelection(sel) {
-  return sel instanceof NodeSelection;
-}
-function isAllSelection(sel) {
-  return sel instanceof AllSelection;
-}
-
 // src/facets/union-extension.ts
 var UnionExtensionImpl = class extends BaseExtension {
   /**
@@ -646,6 +693,7 @@ function deepEquals(a, b) {
 
 // src/editor/action.ts
 import "@prosekit/pm/model";
+import mapValues from "just-map-values";
 
 // src/utils/attrs-match.ts
 function attrsMatch(nodeOrMark, attrs) {
@@ -673,28 +721,32 @@ function isNodeActive(state, type, attrs) {
 
 // src/editor/action.ts
 function createNodeActions(schema, getState, createNode = defaultCreateNode) {
-  const builders = {};
-  for (const type of Object.values(schema.nodes)) {
-    const builder = (...args) => buildNode(type, args, createNode);
-    builder.isActive = (attrs) => {
-      const state = getState();
-      return state ? isNodeActive(state, type, attrs) : false;
-    };
-    builders[type.name] = builder;
-  }
-  return builders;
+  return mapValues(
+    schema.nodes,
+    (type) => createNodeAction(type, getState, createNode)
+  );
+}
+function createNodeAction(type, getState, createNode) {
+  const action = (...args) => buildNode(type, args, createNode);
+  action.isActive = (attrs) => {
+    const state = getState();
+    return state ? isNodeActive(state, type, attrs) : false;
+  };
+  return action;
 }
 function createMarkActions(schema, getState, applyMark = defaultApplyMark) {
-  const builders = {};
-  for (const type of Object.values(schema.marks)) {
-    const builder = (...args) => buildMark(type, args, applyMark);
-    builder.isActive = (attrs) => {
-      const state = getState();
-      return state ? isMarkActive(state, type, attrs) : false;
-    };
-    builders[type.name] = builder;
-  }
-  return builders;
+  return mapValues(
+    schema.marks,
+    (type) => createMarkAction(type, getState, applyMark)
+  );
+}
+function createMarkAction(type, getState, applyMark) {
+  const action = (...args) => buildMark(type, args, applyMark);
+  action.isActive = (attrs) => {
+    const state = getState();
+    return state ? isMarkActive(state, type, attrs) : false;
+  };
+  return action;
 }
 function buildMark(type, args, applyMark) {
   const [attrs, children] = normalizeArgs(args);
@@ -702,7 +754,7 @@ function buildMark(type, args, applyMark) {
   return applyMark(mark, flattenChildren(type.schema, children));
 }
 var defaultApplyMark = (mark, children) => {
-  return children.map((child) => child.mark([mark]));
+  return children.map((node) => node.mark(mark.addToSet(node.marks)));
 };
 function buildNode(type, args, createNode) {
   const [attrs, children] = normalizeArgs(args);
@@ -750,27 +802,24 @@ function isNodeChild(value) {
 
 // src/editor/editor.ts
 function setupEditorExtension(options) {
-  const { defaultDoc, defaultHTML, defaultSelection } = options;
-  if (defaultDoc || defaultHTML) {
+  if (options.defaultContent || options.defaultDoc || options.defaultHTML) {
     return union([
       options.extension,
-      defineDefaultState({
-        defaultDoc,
-        defaultHTML,
-        defaultSelection
-      })
+      defineDefaultState(options)
     ]);
   }
   return options.extension;
 }
 function createEditor(options) {
   const extension = setupEditorExtension(options);
-  return Editor.create(new EditorInstance(extension));
+  const instance = new EditorInstance(extension);
+  return new Editor(instance);
 }
 var EditorInstance = class {
   constructor(extension) {
     this.view = null;
     this.commands = {};
+    this.afterMounted = [];
     this.getState = () => {
       var _a;
       return ((_a = this.view) == null ? void 0 : _a.state) || this.directEditorProps.state;
@@ -798,6 +847,21 @@ var EditorInstance = class {
       this.directEditorProps.state = state;
     }
   }
+  setContent(content, selection) {
+    const doc = getEditorContentDoc(this.schema, content);
+    doc.check();
+    const sel = getEditorSelection(doc, selection || "start");
+    const oldState = this.getState();
+    if (doc.eq(oldState.doc) && (!selection || sel.eq(oldState.selection))) {
+      return;
+    }
+    const newState = EditorState2.create({
+      doc,
+      selection: sel,
+      plugins: oldState.plugins
+    });
+    this.updateState(newState);
+  }
   updateExtension(extension, add) {
     var _a, _b, _c, _d;
     const view = this.view;
@@ -829,19 +893,33 @@ var EditorInstance = class {
       }
     }
   }
+  use(extension) {
+    if (!this.mounted) {
+      let canceled = false;
+      let lazyRemove = null;
+      const lazyCreate = () => {
+        if (!canceled) {
+          lazyRemove = this.use(extension);
+        }
+      };
+      this.afterMounted.push(lazyCreate);
+      return () => {
+        canceled = true;
+        lazyRemove == null ? void 0 : lazyRemove();
+      };
+    }
+    this.updateExtension(extension, true);
+    return () => this.updateExtension(extension, false);
+  }
   mount(place) {
     if (this.view) {
       throw new ProseKitError("Editor is already mounted");
     }
-    if (!place) {
-      throw new ProseKitError("Can't mount editor without a place");
-    }
     this.view = new EditorView({ mount: place }, this.directEditorProps);
+    this.afterMounted.forEach((callback) => callback());
   }
   unmount() {
-    if (!this.view) {
-      throw new ProseKitError("Editor is not mounted yet");
-    }
+    if (!this.view) return;
     this.directEditorProps.state = this.view.state;
     this.view.destroy();
     this.view = null;
@@ -891,25 +969,81 @@ var EditorInstance = class {
     delete this.commands[name];
   }
 };
-var Editor = class _Editor {
+var Editor = class {
   /**
    * @internal
    */
   constructor(instance) {
-    this.afterMounted = [];
-    this.instance = instance;
-    this.mount = this.mount.bind(this);
-    this.unmount = this.unmount.bind(this);
-    this.use = this.use.bind(this);
-  }
-  /**
-   * @internal
-   */
-  static create(instance) {
+    /**
+     * Mount the editor to the given HTML element.
+     * Pass `null` or `undefined` to unmount the editor.
+     */
+    this.mount = (place) => {
+      if (place) {
+        this.instance.mount(place);
+      } else {
+        this.instance.unmount();
+      }
+    };
+    /**
+     * Unmount the editor. This is equivalent to `mount(null)`.
+     */
+    this.unmount = () => {
+      this.instance.unmount();
+    };
+    /**
+     * Focus the editor.
+     */
+    this.focus = () => {
+      var _a;
+      (_a = this.instance.view) == null ? void 0 : _a.focus();
+    };
+    /**
+     * Blur the editor.
+     */
+    this.blur = () => {
+      var _a;
+      (_a = this.instance.view) == null ? void 0 : _a.dom.blur();
+    };
+    /**
+     * Register an extension to the editor. Return a function to unregister the
+     * extension.
+     */
+    this.use = (extension) => {
+      return this.instance.use(extension);
+    };
+    /**
+     * Update the editor's state.
+     *
+     * @remarks
+     *
+     * This is an advanced method. Use it only if you have a specific reason to
+     * directly manipulate the editor's state.
+     */
+    this.updateState = (state) => {
+      this.instance.updateState(state);
+    };
+    /**
+     * Update the editor's document and selection.
+     *
+     * @param content - The new document to set. It can be one of the following:
+     *   - A ProseMirror node instance
+     *   - A ProseMirror node JSON object
+     *   - An HTML string
+     *   - An HTML element instance
+     * @param selection - Optional. Specifies the new selection. It can be one of the following:
+     *   - A ProseMirror selection instance
+     *   - A ProseMirror selection JSON object
+     *   - The string "start" (to set selection at the beginning, default value)
+     *   - The string "end" (to set selection at the end)
+     */
+    this.setContent = (content, selection) => {
+      return this.instance.setContent(content, selection);
+    };
     if (!(instance instanceof EditorInstance)) {
       throw new TypeError("Invalid EditorInstance");
     }
-    return new _Editor(instance);
+    this.instance = instance;
   }
   /**
    * Whether the editor is mounted.
@@ -929,68 +1063,6 @@ var Editor = class _Editor {
   get schema() {
     return this.instance.schema;
   }
-  /**
-   * Whether the editor is focused.
-   */
-  get focused() {
-    var _a, _b;
-    return (_b = (_a = this.instance.view) == null ? void 0 : _a.hasFocus()) != null ? _b : false;
-  }
-  /**
-   * Mount the editor to the given HTML element.
-   * Pass `null` or `undefined` to unmount the editor.
-   */
-  mount(place) {
-    if (!place) {
-      return this.unmount();
-    }
-    this.instance.mount(place);
-    this.afterMounted.forEach((callback) => callback());
-  }
-  /**
-   * Unmount the editor. This is equivalent to `mount(null)`.
-   */
-  unmount() {
-    if (this.mounted) {
-      this.instance.unmount();
-    }
-  }
-  /**
-   * Focus the editor.
-   */
-  focus() {
-    var _a;
-    (_a = this.instance.view) == null ? void 0 : _a.focus();
-  }
-  /**
-   * Blur the editor.
-   */
-  blur() {
-    var _a;
-    (_a = this.instance.view) == null ? void 0 : _a.dom.blur();
-  }
-  /**
-   * Register an extension to the editor. Return a function to unregister the
-   * extension.
-   */
-  use(extension) {
-    if (!this.mounted) {
-      let canceled = false;
-      let lazyRemove = null;
-      const lazyCreate = () => {
-        if (!canceled) {
-          lazyRemove = this.use(extension);
-        }
-      };
-      this.afterMounted.push(lazyCreate);
-      return () => {
-        canceled = true;
-        lazyRemove == null ? void 0 : lazyRemove();
-      };
-    }
-    this.instance.updateExtension(extension, true);
-    return () => this.instance.updateExtension(extension, false);
-  }
   /**
    * The editor's current state.
    */
@@ -998,15 +1070,11 @@ var Editor = class _Editor {
     return this.instance.getState();
   }
   /**
-   * Update the editor's state.
-   *
-   * @remarks
-   *
-   * This is an advanced method. Use it only if you have a specific reason to
-   * directly manipulate the editor's state.
+   * Whether the editor is focused.
    */
-  updateState(state) {
-    this.instance.updateState(state);
+  get focused() {
+    var _a, _b;
+    return (_b = (_a = this.instance.view) == null ? void 0 : _a.hasFocus()) != null ? _b : false;
   }
   /**
    * All {@link CommandAction}s defined by the editor.
@@ -1043,6 +1111,7 @@ export {
   schemaFacet,
   defineFacetPayload,
   stateFacet,
+  isElement,
   jsonFromState,
   stateFromJSON,
   jsonFromNode,
@@ -1054,14 +1123,15 @@ export {
   elementFromJSON,
   jsonFromHTML,
   htmlFromJSON,
-  defineDefaultState,
-  isMarkAbsent,
-  isMarkActive,
   isProseMirrorNode,
   isMark,
+  isSelection,
   isTextSelection,
   isNodeSelection,
   isAllSelection,
+  defineDefaultState,
+  isMarkAbsent,
+  isMarkActive,
   createNodeActions,
   createMarkActions,
   union,

package/dist/prosekit-core-test.js

@@ -4,11 +4,12 @@ import {
   assert,
   createMarkActions,
   createNodeActions,
+  isProseMirrorNode,
   setupEditorExtension
-} from "./chunk-MOSGJZHV.js";
+} from "./chunk-MDJ2B4IL.js";
 
 // src/test/test-editor.ts
-import { EditorState, NodeSelection, TextSelection } from "@prosekit/pm/state";
+import { NodeSelection, TextSelection } from "@prosekit/pm/state";
 
 // src/test/test-builder.ts
 var createNodeForTest = (type, attrs, children) => {
@@ -53,7 +54,7 @@ var createNodeForTest = (type, attrs, children) => {
 };
 var applyMarkForTest = (mark, children) => {
   return children.map((node) => {
-    const newNode = node.mark([mark]);
+    const newNode = node.mark(mark.addToSet(node.marks));
     newNode.tags = node.tags;
     return newNode;
   });
@@ -85,6 +86,12 @@ var TestEditorInstance = class extends EditorInstance {
     this.nodes = createNodeActions(this.schema, this.getState, createNodeForTest);
     this.marks = createMarkActions(this.schema, this.getState, applyMarkForTest);
   }
+  setContent(content, selection) {
+    return super.setContent(
+      content,
+      isProseMirrorNode(content) && !selection ? getSelection(content) : selection
+    );
+  }
 };
 var TestEditor = class extends Editor {
   constructor(instance) {
@@ -104,21 +111,7 @@ var TestEditor = class extends Editor {
    * ```
    */
   set(doc) {
-    assert(
-      doc.type.schema === this.schema,
-      "Document schema does not match editor schema"
-    );
-    assert(
-      doc.type === this.schema.topNodeType,
-      "Document type does not match editor top node type"
-    );
-    const selection = getSelection(doc);
-    const state = EditorState.create({
-      doc,
-      selection,
-      plugins: this.state.plugins
-    });
-    this.updateState(state);
+    return this.setContent(doc);
   }
   dispatchEvent(event) {
     this.view.dispatchEvent(event);
@@ -126,7 +119,8 @@ var TestEditor = class extends Editor {
 };
 function createTestEditor(options) {
   const extension = setupEditorExtension(options);
-  return new TestEditor(new TestEditorInstance(extension));
+  const instance = new TestEditorInstance(extension);
+  return new TestEditor(instance);
 }
 export {
   createTestEditor

package/dist/prosekit-core.d.ts

@@ -174,6 +174,7 @@ export { isAllSelection } 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 { isTextSelection } from './_tsup-dts-rollup';
 export { withSkipCodeBlock } from './_tsup-dts-rollup';
 export { OBJECT_REPLACEMENT_CHARACTER } from './_tsup-dts-rollup';

package/dist/prosekit-core.js

@@ -15,6 +15,7 @@ import {
   htmlFromJSON,
   htmlFromNode,
   isAllSelection,
+  isElement,
   isMark,
   isMarkAbsent,
   isMarkActive,
@@ -22,6 +23,7 @@ import {
   isNodeSelection,
   isNotNull,
   isProseMirrorNode,
+  isSelection,
   isTextSelection,
   jsonFromHTML,
   jsonFromNode,
@@ -35,7 +37,7 @@ import {
   stateFromJSON,
   toReversed,
   union
-} from "./chunk-MOSGJZHV.js";
+} from "./chunk-MDJ2B4IL.js";
 
 // src/commands/add-mark.ts
 import "@prosekit/pm/model";
@@ -524,12 +526,6 @@ var schemaSpecFacet = defineFacet({
   singleton: true
 });
 
-// src/utils/is-element.ts
-var hasElement = typeof Element !== "undefined";
-function isElement(value) {
-  return hasElement && value instanceof Element;
-}
-
 // src/extensions/node-spec.ts
 function defineNodeSpec(options) {
   const payload = [options, void 0];
@@ -959,6 +955,7 @@ var isApple = typeof navigator !== "undefined" ? /Mac|iP(hone|[ao]d)/.test(navig
 import { chainCommands } from "@prosekit/pm/commands";
 import { keydownHandler } from "@prosekit/pm/keymap";
 import { Plugin as Plugin2, PluginKey as PluginKey4 } from "@prosekit/pm/state";
+import mapValues from "just-map-values";
 function defineKeymap(keymap2) {
   return defineFacetPayload(keymapFacet, [keymap2]);
 }
@@ -994,12 +991,10 @@ function mergeKeymaps(keymaps) {
       commands2.push(command);
     }
   }
-  return Object.fromEntries(
-    Object.entries(bindings).map(([key, commands2]) => [
-      key,
-      chainCommands(...commands2)
-    ])
-  );
+  return mapValues(bindings, mergeCommands);
+}
+function mergeCommands(commands2) {
+  return chainCommands(...commands2);
 }
 var keymapPluginKey = new PluginKey4("prosekit-keymap");
 
@@ -1399,6 +1394,7 @@ export {
   isMarkActive,
   isNodeSelection,
   isProseMirrorNode,
+  isSelection,
   isTextSelection,
   jsonFromHTML,
   jsonFromNode,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -41,6 +41,7 @@
   ],
   "dependencies": {
     "clsx": "^2.1.1",
+    "just-map-values": "^3.2.0",
     "orderedmap": "^2.1.1",
     "prosemirror-splittable": "^0.1.1",
     "type-fest": "^4.23.0",