@prosekit/core 0.0.16 → 0.0.18

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

@@ -12,6 +12,7 @@ import type { IsEqual } from 'type-fest';
 import { Mark } from '@prosekit/pm/model';
 import type { MarkSpec } from '@prosekit/pm/model';
 import { MarkType } from '@prosekit/pm/model';
+import { MarkType as MarkType_2 } from 'prosemirror-model';
 import { Node as Node_2 } from 'prosemirror-model';
 import type { NodeSpec } from '@prosekit/pm/model';
 import { NodeType } from '@prosekit/pm/model';
@@ -34,15 +35,24 @@ declare type Action = (options: {
     view?: EditorView;
 }) => boolean;
 
+/**
+ * Add the given mark to the inline content.
+ */
 declare function addMark(options: {
+    /**
+     * The type of the mark to add.
+     */
     type: string | MarkType;
+    /**
+     * The attributes of the mark to add.
+     */
     attrs?: Attrs | null;
     /**
-     * The start position of the mark. By default it will be the start position of current selection.
+     * The start position of the document. By default it will be the start position of current selection.
      */
     from?: number;
     /**
-     * The end position of the mark. By default it will be the end position of current selection.
+     * The end position of the document. By default it will be the end position of current selection.
      */
     to?: number;
 }): Command;
@@ -56,6 +66,30 @@ export declare function applyAction(operator: Action): Command;
  */
 export declare function assertTypeEqual<T, U>(_val: IsEqual<T, U>): void;
 
+export declare function attrsMatch(nodeOrMark: ProseMirrorNode | Mark, attrs: Attrs): boolean;
+
+export declare abstract class BaseExtension<T extends ExtensionTyping = ExtensionTyping> implements Extension<T> {
+    extension: Extension | Extension[];
+    priority?: Priority;
+    _type?: T;
+    /**
+     * @internal
+     *
+     * Whether this extension has payload that can be converted to a schema.
+     *
+     * Notice that this does not mean that the extension has a schema. For
+     * example, a `FacetExtension` with a `schemaFacet` will return `true` for
+     * this property, but will return `null` for `schema`.
+     */
+    abstract hasSchema: boolean;
+    /**
+     * @internal
+     *
+     * The schema that this extension represents.
+     */
+    abstract schema: Schema | null;
+}
+
 export declare function collectNodes(content: NodeContent): ProseMirrorNode[];
 
 export declare interface CommandApplier<Args extends any[] = any[]> {
@@ -63,7 +97,9 @@ export declare interface CommandApplier<Args extends any[] = any[]> {
     canApply(...args: Args): boolean;
 }
 
-/** @internal */
+/**
+ * @internal
+ */
 declare interface CommandArgs {
     [name: string]: any[];
 }
@@ -84,8 +120,10 @@ export declare type Converters = ConverterTuple[];
 
 declare type ConverterTuple = Tuple5<FacetConverter | undefined>;
 
-/** @public */
-declare function createEditor<E extends Extension>({ extension, defaultDoc, defaultSelection, }: EditorOptions<E>): Editor<E>;
+/**
+ * @public
+ */
+declare function createEditor<E extends Extension>({ extension, defaultDoc, defaultHTML, defaultSelection, }: EditorOptions<E>): Editor<E>;
 export { createEditor }
 export { createEditor as createEditor_alias_1 }
 
@@ -99,13 +137,20 @@ export declare const default_alias_1: UserProjectConfigExport;
 
 declare interface DefaultStateOptions {
     /**
-     * A JSON representation of a ProseMirror document.
+     * A JSON object representing the starting document to use when creating the
+     * editor.
      */
-    doc?: NodeJson;
+    defaultDoc?: NodeJson;
     /**
-     * A JSON representation of a ProseMirror selection.
+     * A HTML string representing the starting document to use when creating the
+     * editor.
      */
-    selection?: SelectionJson;
+    defaultHTML?: string;
+    /**
+     * A JSON object representing the starting selection to use when creating the
+     * editor. It's only used when `defaultDoc` or `defaultHTML` is also provided.
+     */
+    defaultSelection?: SelectionJson;
 }
 export { DefaultStateOptions }
 export { DefaultStateOptions as DefaultStateOptions_alias_1 }
@@ -137,12 +182,26 @@ declare function defineBaseCommands(): Extension<{
             to?: number | undefined;
         }];
         selectAll: [];
+        addMark: [options: {
+            type: string | MarkType_2;
+            attrs?: Attrs_2 | null | undefined;
+            from?: number | undefined;
+            to?: number | undefined;
+        }];
+        removeMark: [options: {
+            type: string | MarkType_2;
+            attrs?: Attrs_2 | null | undefined;
+            from?: number | undefined;
+            to?: number | undefined;
+        }];
     };
 }>;
 export { defineBaseCommands }
 export { defineBaseCommands as defineBaseCommands_alias_1 }
 
-/** @public */
+/**
+ * @public
+ */
 declare function defineBaseKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 export { defineBaseKeymap }
 export { defineBaseKeymap as defineBaseKeymap_alias_1 }
@@ -155,11 +214,13 @@ declare function defineCommands<T extends Record<string, CommandCreator> = Recor
 export { defineCommands }
 export { defineCommands as defineCommands_alias_1 }
 
-declare function defineDefaultState(options: DefaultStateOptions): Extension;
+declare function defineDefaultState({ defaultDoc, defaultHTML, defaultSelection, }: DefaultStateOptions): Extension;
 export { defineDefaultState }
 export { defineDefaultState as defineDefaultState_alias_1 }
 
-/** @public */
+/**
+ * @public
+ */
 declare function defineDoc(): Extension<    {
 NODES: "doc";
 }>;
@@ -171,7 +232,7 @@ export { defineDoc as defineDoc_alias_1 }
  */
 declare function defineEventHandler(options: {
     update?: VoidFunction;
-}): FacetExtension<VoidFunction, PluginPayload>;
+}): Extension<ExtensionTyping<string, string, CommandArgs>>;
 export { defineEventHandler }
 export { defineEventHandler as defineEventHandler_alias_1 }
 
@@ -196,7 +257,9 @@ declare function defineInputRule(rules: (context: {
 export { defineInputRule }
 export { defineInputRule as defineInputRule_alias_1 }
 
-/** @public */
+/**
+ * @public
+ */
 declare function defineKeymap(keymap: Keymap): Extension;
 export { defineKeymap }
 export { defineKeymap as defineKeymap_alias_1 }
@@ -261,19 +324,25 @@ declare function definePlugin(plugin: Plugin_2 | Plugin_2[] | ((context: {
 export { definePlugin }
 export { definePlugin as definePlugin_alias_1 }
 
-/** @public */
+/**
+ * @public
+ */
 declare function defineText(): Extension<    {
 NODES: "text";
 }>;
 export { defineText }
 export { defineText as defineText_alias_1 }
 
-/** @public */
+/**
+ * @public
+ */
 declare class Editor<E extends Extension = any> {
     private instance;
     private constructor();
     private afterMounted;
-    /** @internal */
+    /**
+     * @internal
+     */
     static create(instance: any): Editor<any>;
     get mounted(): boolean;
     get view(): EditorView;
@@ -296,7 +365,9 @@ declare class Editor<E extends Extension = any> {
 export { Editor }
 export { Editor as Editor_alias_1 }
 
-/** @public */
+/**
+ * @public
+ */
 declare interface EditorOptions<E extends Extension> {
     /**
      * The extension to use when creating the editor.
@@ -307,15 +378,34 @@ declare interface EditorOptions<E extends Extension> {
      * editor.
      */
     defaultDoc?: NodeJson;
+    /**
+     * A HTML string representing the starting document to use when creating the
+     * editor.
+     */
+    defaultHTML?: string;
     /**
      * A JSON object representing the starting selection to use when creating the
-     * editor. It's only used when `defaultDoc` is also provided.
+     * editor. It's only used when `defaultDoc` or `defaultHTML` is also provided.
      */
     defaultSelection?: SelectionJson;
 }
 export { EditorOptions }
 export { EditorOptions as EditorOptions_alias_1 }
 
+/**
+ * Parse a HTML element to a ProseMirror document JSON.
+ */
+declare function elementToJSON(element: HTMLElement, schema: Schema): NodeJson;
+export { elementToJSON }
+export { elementToJSON as elementToJSON_alias_1 }
+
+/**
+ * Parse a HTML element to a ProseMirror node.
+ */
+declare function elementToNode(element: HTMLElement, schema: Schema): ProseMirrorNode;
+export { elementToNode }
+export { elementToNode as elementToNode_alias_1 }
+
 declare type EmptyValue = undefined | null | EmptyObject;
 
 export declare type ExceptEmptyValue<T> = ConditionalExcept<T, EmptyValue>;
@@ -327,6 +417,12 @@ declare interface Extension<T extends ExtensionTyping = ExtensionTyping> {
     extension: Extension | Extension[];
     priority?: Priority;
     _type?: T;
+    /**
+     * @public
+     *
+     * The schema that this extension represents.
+     */
+    schema: Schema | null;
 }
 export { Extension }
 export { Extension as Extension_alias_1 }
@@ -391,42 +487,64 @@ export declare type ExtractNodesFromTyping<T extends ExtensionTyping> = ExtractK
  */
 export declare type ExtractTyping<E extends Extension> = E extends Extension<infer T> ? T : never;
 
-/** @public */
+/**
+ * @public
+ */
 declare class Facet<Input, Output> {
-    /** @internal */
+    /**
+     * @internal
+     */
     readonly index: number;
-    /** @internal */
+    /**
+     * @internal
+     */
     readonly converter: () => FacetConverter<Input, Output>;
-    /** @internal */
+    /**
+     * @internal
+     */
     readonly next: Facet<Output, any> | null;
-    /** @internal */
+    /**
+     * @internal
+     */
     readonly singleton: boolean;
+    /**
+     * @internal
+     */
+    isSchema: boolean;
     private constructor();
-    static define<Input, Output>({ converter: converter, convert: convert, next, singleton, }: FacetOptions<Input, Output>): Facet<Input, Output>;
-    /** @internal */
+    static define<Input, Output>({ converter, convert, next, singleton, }: FacetOptions<Input, Output>): Facet<Input, Output>;
+    /**
+     * @internal
+     */
     static defineRootFacet<Input>(options: Omit<FacetOptions<Input, Input>, 'next'>): Facet<Input, Input>;
-    extension(payloads: Input[]): FacetExtension<Input, Output>;
+    extension(payloads: Input[]): Extension;
 }
 export { Facet }
 export { Facet as Facet_alias_1 }
 
-/** @public */
+/**
+ * @public
+ */
 export declare interface FacetConverter<Input = any, Output = any> {
     create: (inputs: Input[]) => Output;
     update: (inputs: Input[]) => Output | null;
 }
 
-/** @public */
-declare class FacetExtension<Input, Output> {
+/**
+ * @public
+ */
+export declare class FacetExtensionImpl<Input, Output> extends BaseExtension {
     readonly facet: Facet<Input, Output>;
     readonly payloads: Input[];
     extension: Extension;
+    hasSchema: boolean;
+    schema: null;
     constructor(facet: Facet<Input, Output>, payloads: Input[]);
 }
-export { FacetExtension }
-export { FacetExtension as FacetExtension_alias_1 }
 
-/** @public */
+/**
+ * @public
+ */
 declare interface FacetOptions<Input, Output> {
     convert?: (payloads: Input[]) => Output;
     converter?: () => FacetConverter<Input, Output>;
@@ -436,20 +554,42 @@ declare interface FacetOptions<Input, Output> {
 export { FacetOptions }
 export { FacetOptions as FacetOptions_alias_1 }
 
+export declare function getBrowserDocument(): Document | undefined;
+
+export declare function getBrowserWindow(): (Window & typeof globalThis) | null | undefined;
+
 export declare function getCustomSelection(state: EditorState, from?: number | null, to?: number | null): Selection_2;
 
 export declare function getFacetCount(): number;
 
-/** @internal */
+/**
+ * @internal
+ */
 declare function getMarkType(schema: Schema, type: string | MarkType): MarkType;
 export { getMarkType }
 export { getMarkType as getMarkType_alias_1 }
 
-/** @internal */
+/**
+ * @internal
+ */
 declare function getNodeType(schema: Schema, type: string | NodeType): NodeType;
 export { getNodeType }
 export { getNodeType as getNodeType_alias_1 }
 
+/**
+ * Parse a HTML element to a ProseMirror document JSON.
+ */
+declare function htmlToJSON(html: string, schema: Schema): NodeJson;
+export { htmlToJSON }
+export { htmlToJSON as htmlToJSON_alias_1 }
+
+/**
+ * Parse a HTML string to a ProseMirror node.
+ */
+declare function htmlToNode(html: string, schema: Schema): ProseMirrorNode;
+export { htmlToNode }
+export { htmlToNode as htmlToNode_alias_1 }
+
 declare function insertNode(options: {
     node: ProseMirrorNode;
     pos?: number;
@@ -484,7 +624,9 @@ export declare function isNodeActive(state: EditorState, type: string | NodeType
 
 export declare function isProseMirrorNode(node: unknown): node is ProseMirrorNode;
 
-/** @public */
+/**
+ * @public
+ */
 declare interface Keymap {
     [key: string]: Command;
 }
@@ -560,6 +702,8 @@ declare interface NodeViewOptions {
 export { NodeViewOptions }
 export { NodeViewOptions as NodeViewOptions_alias_1 }
 
+export declare function notNull<T>(value: T | null | undefined): value is T;
+
 export declare function objectEqual<T>(a: T, b: T): boolean;
 
 declare type Payload = unknown;
@@ -568,12 +712,16 @@ export declare type Payloads = PayloadTuple[];
 
 declare type PayloadTuple = Tuple5<Payload[]>;
 
-/** @internal */
+/**
+ * @internal
+ */
 declare const pluginFacet: Facet<PluginPayload, StatePayload>;
 export { pluginFacet }
 export { pluginFacet as pluginFacet_alias_1 }
 
-/** @internal */
+/**
+ * @internal
+ */
 declare type PluginPayload = (context: {
     schema: Schema;
 }) => Plugin_2[];
@@ -601,6 +749,30 @@ declare class ProseKitError extends Error {
 export { ProseKitError }
 export { ProseKitError as ProseKitError_alias_1 }
 
+/**
+ * Remove the given mark from the inline content.
+ */
+declare function removeMark(options: {
+    /**
+     * The type of the mark to remove.
+     */
+    type: string | MarkType;
+    /**
+     * If attrs is given, remove precisely the mark with the given attrs. Otherwise, remove all marks of the given type.
+     */
+    attrs?: Attrs | null;
+    /**
+     * The start position of the document. By default it will be the start position of current selection.
+     */
+    from?: number;
+    /**
+     * The end position of the document. By default it will be the end position of current selection.
+     */
+    to?: number;
+}): Command;
+export { removeMark }
+export { removeMark as removeMark_alias_1 }
+
 export declare const schemaFacet: Facet<SchemaPayload, SchemaPayload>;
 
 export declare type SchemaPayload = SchemaSpec;
@@ -707,6 +879,15 @@ declare function union<E extends Extension | Extension[]>(extension: E): Simplif
 export { union }
 export { union as union_alias_1 }
 
+export declare class UnionExtensionImpl<T extends ExtensionTyping = ExtensionTyping> extends BaseExtension<T> implements Extension<T> {
+    extension: BaseExtension[];
+    private _schema;
+    private hasSchemaCount;
+    constructor(extension?: BaseExtension[]);
+    get hasSchema(): boolean;
+    get schema(): Schema | null;
+}
+
 export declare function uniqPush<T>(prev: readonly T[], next: readonly T[]): T[];
 
 export declare function uniqRemove<T>(prev: T[], next: T[]): T[];
@@ -724,7 +905,9 @@ export declare type ViewPayload = Omit<DirectEditorProps, 'state'>;
 
 export declare function voidFunction(): void;
 
-/** @public */
+/**
+ * @public
+ */
 declare function withPriority<T extends Extension>(extension: T, priority: Priority): T;
 export { withPriority }
 export { withPriority as withPriority_alias_1 }

package/dist/prosekit-core.d.ts

@@ -1,5 +1,6 @@
 export { addMark } from './_tsup-dts-rollup';
 export { insertNode } from './_tsup-dts-rollup';
+export { removeMark } from './_tsup-dts-rollup';
 export { setBlockType } from './_tsup-dts-rollup';
 export { toggleMark } from './_tsup-dts-rollup';
 export { toggleNode } from './_tsup-dts-rollup';
@@ -34,7 +35,6 @@ export { pluginFacet } from './_tsup-dts-rollup';
 export { PluginPayload } from './_tsup-dts-rollup';
 export { defineText } from './_tsup-dts-rollup';
 export { Facet } from './_tsup-dts-rollup';
-export { FacetExtension } from './_tsup-dts-rollup';
 export { FacetOptions } from './_tsup-dts-rollup';
 export { CommandArgs } from './_tsup-dts-rollup';
 export { Extension } from './_tsup-dts-rollup';
@@ -51,3 +51,7 @@ export { Priority } from './_tsup-dts-rollup';
 export { SimplifyUnion } from './_tsup-dts-rollup';
 export { getMarkType } from './_tsup-dts-rollup';
 export { getNodeType } from './_tsup-dts-rollup';
+export { elementToJSON } from './_tsup-dts-rollup';
+export { elementToNode } from './_tsup-dts-rollup';
+export { htmlToJSON } from './_tsup-dts-rollup';
+export { htmlToNode } from './_tsup-dts-rollup';

package/dist/prosekit-core.js

@@ -75,6 +75,24 @@ function insertNode(options) {
   };
 }
 
+// src/commands/remove-mark.ts
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+function removeMark(options) {
+  return (state, dispatch) => {
+    var _a, _b;
+    const markType = getMarkType(state.schema, options.type);
+    const mark = options.attrs ? markType.create(options.attrs) : markType;
+    const from = (_a = options.from) != null ? _a : state.selection.from;
+    const to = (_b = options.to) != null ? _b : state.selection.to;
+    if (from > to) {
+      return false;
+    }
+    dispatch == null ? void 0 : dispatch(state.tr.removeMark(from, to, mark));
+    return true;
+  };
+}
+
 // src/commands/set-block-type.ts
 import "@prosekit/pm/state";
 
@@ -154,30 +172,11 @@ import { setBlockType as setBlockType2 } from "@prosekit/pm/commands";
 import "@prosekit/pm/model";
 import "@prosekit/pm/state";
 
-// src/utils/object-euqal.ts
-function objectEqual(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (typeof a !== "object" || typeof b !== "object") {
-    return false;
-  }
-  if (a === null || b === null) {
-    return false;
-  }
-  if (Array.isArray(a) || Array.isArray(b)) {
-    return false;
-  }
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length) {
-    return false;
-  }
-  for (const key of aKeys) {
-    if (!bKeys.includes(key)) {
-      return false;
-    }
-    if (!objectEqual(a[key], b[key])) {
+// src/utils/attrs-match.ts
+function attrsMatch(nodeOrMark, attrs) {
+  const currentAttrs = nodeOrMark.attrs;
+  for (const [key, value] of Object.entries(attrs)) {
+    if (currentAttrs[key] !== value) {
       return false;
     }
   }
@@ -190,7 +189,7 @@ function isNodeActive(state, type, attrs) {
   const nodeType = getNodeType(state.schema, type);
   for (let depth = $pos.depth; depth >= 0; depth--) {
     const node = $pos.node(depth);
-    if (node.type === nodeType && (!attrs || objectEqual(attrs, node.attrs))) {
+    if (node.type === nodeType && (!attrs || attrsMatch(node, attrs))) {
       return true;
     }
   }
@@ -217,7 +216,7 @@ function toggleNode({
 }
 
 // src/editor/editor.ts
-import { Schema as Schema4 } from "@prosekit/pm/model";
+import { Schema as Schema6 } from "@prosekit/pm/model";
 import { EditorState } from "@prosekit/pm/state";
 import { EditorView } from "@prosekit/pm/view";
 
@@ -245,6 +244,14 @@ function uniqRemove(prev, next) {
   return result;
 }
 
+// src/facets/base-extension.ts
+import "@prosekit/pm/model";
+var BaseExtension = class {
+  constructor() {
+    this.extension = [];
+  }
+};
+
 // src/facets/facet.ts
 var facetCount = 0;
 function getFacetCount() {
@@ -252,8 +259,14 @@ function getFacetCount() {
 }
 var Facet = class _Facet {
   constructor(converter, next, singleton) {
-    /** @internal */
+    /**
+     * @internal
+     */
     this.index = facetCount++;
+    /**
+     * @internal
+     */
+    this.isSchema = false;
     this.converter = converter;
     this.next = next;
     this.singleton = singleton;
@@ -273,18 +286,24 @@ var Facet = class _Facet {
     }
     return new _Facet(converterFunction, next, singleton != null ? singleton : false);
   }
-  /** @internal */
+  /**
+   * @internal
+   */
   static defineRootFacet(options) {
     return _Facet.define(options);
   }
   extension(payloads) {
-    return new FacetExtension(this, payloads);
+    return new FacetExtensionImpl(this, payloads);
   }
 };
-var FacetExtension = class {
+var FacetExtensionImpl = class extends BaseExtension {
   constructor(facet, payloads) {
+    var _a;
+    super();
     this.facet = facet;
     this.payloads = payloads;
+    this.schema = null;
+    this.hasSchema = !!(facet.isSchema || ((_a = facet.next) == null ? void 0 : _a.isSchema));
   }
 };
 
@@ -319,118 +338,97 @@ var stateFacet = Facet.defineRootFacet({
   }
 });
 
-// src/extensions/default-state.ts
-function defineDefaultState(options) {
-  return stateFacet.extension([
-    ({ schema }) => {
-      const config = {};
-      if (options.doc) {
-        config.doc = schema.nodeFromJSON(options.doc);
-        if (options.selection) {
-          config.selection = Selection.fromJSON(config.doc, options.selection);
-        }
-      }
-      return config;
-    }
-  ]);
-}
+// src/utils/parse.ts
+import { DOMParser } from "@prosekit/pm/model";
 
-// src/utils/type-assertion.ts
-import { Mark, ProseMirrorNode } from "@prosekit/pm/model";
-function isProseMirrorNode(node) {
-  return node instanceof ProseMirrorNode;
+// src/utils/get-dom-api.ts
+function getGlobalBrowserDocument() {
+  if (typeof document !== "undefined") {
+    return document;
+  }
+  if (typeof globalThis !== "undefined" && globalThis.document) {
+    return globalThis.document;
+  }
 }
-function isMark(mark) {
-  return mark instanceof Mark;
+function getGlobalBrowserWindow() {
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof globalThis !== "undefined" && globalThis.window) {
+    return globalThis.window;
+  }
 }
-
-// src/utils/is-mark-active.ts
-function isMarkActive(state, type, attrs) {
+function getBrowserWindow() {
   var _a;
-  const markType = getMarkType(state.schema, type);
-  const mark = attrs ? markType.create(attrs) : markType;
-  const { from, to, $from, $to } = state.selection;
-  return state.doc.rangeHasMark(from, to, mark) || hasMark(
-    [...$from.marks(), ...$to.marks(), ...(_a = state.storedMarks) != null ? _a : []],
-    mark
-  );
-}
-function hasMark(marks, mark) {
-  if (marks.length === 0) {
-    return false;
-  }
-  if (isMark(mark)) {
-    return marks.some((m) => m.eq(mark));
-  } else {
-    return marks.some((m) => m.type === mark);
+  const win = getGlobalBrowserWindow();
+  if (win) {
+    return win;
   }
+  return (_a = getGlobalBrowserDocument()) == null ? void 0 : _a.defaultView;
 }
 
-// src/editor/builder.ts
-import "@prosekit/pm/model";
-function createNodeBuilder(getState, type) {
-  const builder = (...args) => buildNode(type, args);
-  builder.isActive = (attrs) => {
-    const state = getState();
-    return state ? isNodeActive(state, type, attrs) : false;
-  };
-  return builder;
+// src/utils/parse.ts
+function elementToNode(element, schema) {
+  return DOMParser.fromSchema(schema).parse(element);
 }
-function createMarkBuilder(getState, type) {
-  const builder = (...args) => buildMark(type, args);
-  builder.isActive = (attrs) => {
-    const state = getState();
-    return state ? isMarkActive(state, type, attrs) : false;
-  };
-  return builder;
+function elementToJSON(element, schema) {
+  return elementToNode(element, schema).toJSON();
 }
-function buildMark(type, args) {
-  const [attrs, children] = normalizeArgs(args);
-  return flattenChildren(type.schema, children, type.create(attrs));
+function htmlToNode(html, schema) {
+  return elementToNode(htmlToElement(html), schema);
 }
-function buildNode(type, args) {
-  const [attrs, children] = normalizeArgs(args);
-  const node = type.createAndFill(attrs, flattenChildren(type.schema, children));
-  if (!node) {
-    throw new ProseKitError(`Couldn't create node ${type.name}`);
-  }
-  return node;
+function htmlToJSON(html, schema) {
+  return elementToJSON(htmlToElement(html), schema);
 }
-function flattenChildren(schema, children, mark) {
-  const nodes = [];
-  for (const child of children) {
-    if (typeof child === "string") {
-      if (child) {
-        nodes.push(schema.text(child, mark ? [mark] : null));
-      }
-    } else if (Array.isArray(child)) {
-      nodes.push(...flattenChildren(schema, child, mark));
-    } else if (isProseMirrorNode(child)) {
-      nodes.push(mark ? child.mark(mark.addToSet(child.marks)) : child);
-    } else {
-      throw new ProseKitError(`Invalid node child: ${typeof child}`);
-    }
-  }
-  return nodes;
-}
-function normalizeArgs(args) {
-  const [attrs, ...children] = args;
-  if (isNodeChild(args)) {
-    children.unshift(args);
-    return [null, children];
-  } else if (typeof attrs === "object") {
-    return [attrs, children];
-  } else {
-    return [null, children];
+function htmlToElement(html) {
+  const win = getBrowserWindow();
+  if (!win) {
+    throw new ProseKitError(
+      "No Browser Document Found. You can only parse a HTML string in the browser environment."
+    );
   }
+  const parser = new win.DOMParser();
+  return parser.parseFromString(`<body>${html}</body>`, "text/html").body;
 }
-function isNodeChild(value) {
-  if (!value) {
-    return false;
+
+// 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"
+    );
   }
-  return typeof value === "string" || Array.isArray(value) || isProseMirrorNode(value);
+  return stateFacet.extension([
+    ({ schema }) => {
+      const config = {};
+      if (defaultHTML) {
+        defaultDoc = htmlToJSON(defaultHTML, schema);
+      }
+      if (defaultDoc) {
+        config.doc = schema.nodeFromJSON(defaultDoc);
+        if (defaultSelection) {
+          config.selection = Selection.fromJSON(config.doc, defaultSelection);
+        }
+      }
+      return config;
+    }
+  ]);
 }
 
+// src/types/priority.ts
+var Priority = /* @__PURE__ */ ((Priority2) => {
+  Priority2[Priority2["lowest"] = 4] = "lowest";
+  Priority2[Priority2["low"] = 3] = "low";
+  Priority2[Priority2["default"] = 2] = "default";
+  Priority2[Priority2["high"] = 1] = "high";
+  Priority2[Priority2["highest"] = 0] = "highest";
+  return Priority2;
+})(Priority || {});
+
 // src/facets/command.ts
 var commandFacet = Facet.defineRootFacet({
   convert: (inputs) => {
@@ -454,6 +452,7 @@ var schemaFacet = Facet.defineRootFacet({
     return { nodes, marks, topNode };
   }
 });
+schemaFacet.isSchema = true;
 
 // src/facets/view.ts
 var viewFacet = Facet.defineRootFacet({
@@ -462,17 +461,7 @@ var viewFacet = Facet.defineRootFacet({
   }
 });
 
-// src/types/priority.ts
-var Priority = /* @__PURE__ */ ((Priority2) => {
-  Priority2[Priority2["lowest"] = 4] = "lowest";
-  Priority2[Priority2["low"] = 3] = "low";
-  Priority2[Priority2["default"] = 2] = "default";
-  Priority2[Priority2["high"] = 1] = "high";
-  Priority2[Priority2["highest"] = 0] = "highest";
-  return Priority2;
-})(Priority || {});
-
-// src/editor/flatten.ts
+// src/facets/flatten.ts
 function flattenInputTuple(inputTuple) {
   return [
     ...inputTuple[0],
@@ -521,7 +510,7 @@ function extractFacets(root) {
   while (extensions.length > 0) {
     const ext = extensions.pop();
     const pri = priorities.pop();
-    if (ext instanceof FacetExtension) {
+    if (ext instanceof FacetExtensionImpl) {
       const facet = ext.facet;
       if (!facets[facet.index]) {
         facets[facet.index] = facet;
@@ -646,26 +635,165 @@ function updateExtension(prevInputs, prevConverters, extension, mode) {
   return { schemaInput, stateInput, viewInput, commandInput };
 }
 
-// src/editor/type-utils.ts
-function union(extension) {
-  if (extension && Array.isArray(extension)) {
-    return { extension };
+// src/utils/type-assertion.ts
+import { Mark, ProseMirrorNode } from "@prosekit/pm/model";
+function isProseMirrorNode(node) {
+  return node instanceof ProseMirrorNode;
+}
+function isMark(mark) {
+  return mark instanceof Mark;
+}
+
+// src/utils/is-mark-active.ts
+function isMarkActive(state, type, attrs) {
+  const markType = getMarkType(state.schema, type);
+  const mark = attrs ? markType.create(attrs) : markType;
+  const { from, $from, to, empty } = state.selection;
+  if (empty) {
+    return hasMark(state.storedMarks || $from.marks(), mark);
+  } else {
+    return state.doc.rangeHasMark(from, to, mark);
+  }
+}
+function hasMark(marks, mark) {
+  if (marks.length === 0) {
+    return false;
+  }
+  if (isMark(mark)) {
+    return marks.some((m) => m.eq(mark));
+  } else {
+    return marks.some((m) => m.type === mark);
   }
-  return extension;
+}
+
+// src/editor/builder.ts
+import "@prosekit/pm/model";
+function createNodeBuilder(getState, type) {
+  const builder = (...args) => buildNode(type, args);
+  builder.isActive = (attrs) => {
+    const state = getState();
+    return state ? isNodeActive(state, type, attrs) : false;
+  };
+  return builder;
+}
+function createMarkBuilder(getState, type) {
+  const builder = (...args) => buildMark(type, args);
+  builder.isActive = (attrs) => {
+    const state = getState();
+    return state ? isMarkActive(state, type, attrs) : false;
+  };
+  return builder;
+}
+function buildMark(type, args) {
+  const [attrs, children] = normalizeArgs(args);
+  return flattenChildren(type.schema, children, type.create(attrs));
+}
+function buildNode(type, args) {
+  const [attrs, children] = normalizeArgs(args);
+  const node = type.createAndFill(attrs, flattenChildren(type.schema, children));
+  if (!node) {
+    throw new ProseKitError(`Couldn't create node ${type.name}`);
+  }
+  return node;
+}
+function flattenChildren(schema, children, mark) {
+  const nodes = [];
+  for (const child of children) {
+    if (typeof child === "string") {
+      if (child) {
+        nodes.push(schema.text(child, mark ? [mark] : null));
+      }
+    } else if (Array.isArray(child)) {
+      nodes.push(...flattenChildren(schema, child, mark));
+    } else if (isProseMirrorNode(child)) {
+      nodes.push(mark ? child.mark(mark.addToSet(child.marks)) : child);
+    } else {
+      throw new ProseKitError(`Invalid node child: ${typeof child}`);
+    }
+  }
+  return nodes;
+}
+function normalizeArgs(args) {
+  const [attrs, ...children] = args;
+  if (isNodeChild(args)) {
+    children.unshift(args);
+    return [null, children];
+  } else if (typeof attrs === "object") {
+    return [attrs, children];
+  } else {
+    return [null, children];
+  }
+}
+function isNodeChild(value) {
+  if (!value) {
+    return false;
+  }
+  return typeof value === "string" || Array.isArray(value) || isProseMirrorNode(value);
+}
+
+// src/facets/union-extension.ts
+import { Schema as Schema5 } from "@prosekit/pm/model";
+var UnionExtensionImpl = class extends BaseExtension {
+  constructor(extension = []) {
+    super();
+    this.extension = extension;
+    this._schema = void 0;
+    this.hasSchemaCount = 0;
+    for (const e of extension) {
+      if (e instanceof BaseExtension) {
+        this.hasSchemaCount += e.hasSchema ? 1 : 0;
+      } else {
+        throw new ProseKitError("Invalid extension");
+      }
+    }
+  }
+  get hasSchema() {
+    return this.hasSchemaCount > 0;
+  }
+  get schema() {
+    var _a;
+    if (this._schema !== void 0) {
+      return this._schema;
+    }
+    if (this.hasSchemaCount === 0) {
+      this._schema = null;
+      return this._schema;
+    }
+    if (this.hasSchemaCount === 1) {
+      const schema = (_a = this.extension.find((e) => e.hasSchema)) == null ? void 0 : _a.schema;
+      if (schema) {
+        this._schema = schema;
+        return this._schema;
+      }
+    }
+    const { schemaInput } = updateExtension([], [], this, "add");
+    this._schema = schemaInput ? new Schema5(schemaInput) : null;
+    return this._schema;
+  }
+};
+
+// src/editor/union.ts
+function union(extension) {
+  const array = Array.isArray(extension) ? extension : [extension];
+  return new UnionExtensionImpl(
+    array
+  );
 }
 
 // src/editor/editor.ts
 function createEditor({
   extension,
   defaultDoc,
+  defaultHTML,
   defaultSelection
 }) {
-  if (defaultDoc) {
+  if (defaultDoc || defaultHTML) {
     extension = union([
       extension,
       defineDefaultState({
-        doc: defaultDoc,
-        selection: defaultSelection
+        defaultDoc,
+        defaultHTML,
+        defaultSelection
       })
     ]);
   }
@@ -683,7 +811,7 @@ var EditorInstance = class {
     if (!schemaInput) {
       throw new ProseKitError("Schema must be defined");
     }
-    const schema = new Schema4(schemaInput);
+    const schema = new Schema6(schemaInput);
     const stateConfig = stateInput ? stateInput({ schema }) : { schema };
     const state = EditorState.create(stateConfig);
     if (commandInput) {
@@ -805,7 +933,9 @@ var Editor = class _Editor {
     this.unmount = this.unmount.bind(this);
     this.use = this.use.bind(this);
   }
-  /** @internal */
+  /**
+   * @internal
+   */
   static create(instance) {
     if (!(instance instanceof EditorInstance)) {
       throw new TypeError("Invalid EditorInstance");
@@ -872,7 +1002,9 @@ var Editor = class _Editor {
 
 // src/editor/with-priority.ts
 function withPriority(extension, priority) {
-  return { extension, priority };
+  const result = union(extension);
+  result.priority = priority;
+  return result;
 }
 
 // src/commands/insert-text.ts
@@ -949,7 +1081,9 @@ function defineBaseCommands() {
     insertNode: insertNode2,
     wrap,
     setBlockType,
-    selectAll
+    selectAll,
+    addMark,
+    removeMark
   });
 }
 
@@ -1246,7 +1380,6 @@ function defineText() {
 export {
   Editor,
   Facet,
-  FacetExtension,
   Priority,
   ProseKitError,
   addMark,
@@ -1267,10 +1400,15 @@ export {
   defineParagraph,
   definePlugin,
   defineText,
+  elementToJSON,
+  elementToNode,
   getMarkType,
   getNodeType,
+  htmlToJSON,
+  htmlToNode,
   insertNode,
   pluginFacet,
+  removeMark,
   setBlockType,
   toggleMark,
   toggleNode,

package/dist/style.css

@@ -1,4 +1,4 @@
-/* ../../node_modules/.pnpm/prosemirror-view@1.32.1/node_modules/prosemirror-view/style/prosemirror.css */
+/* ../../node_modules/.pnpm/prosemirror-view@1.32.3/node_modules/prosemirror-view/style/prosemirror.css */
 .ProseMirror {
   position: relative;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -38,7 +38,7 @@
     "dist"
   ],
   "dependencies": {
-    "@prosekit/pm": "^0.0.6",
+    "@prosekit/pm": "^0.0.7",
     "orderedmap": "^2.1.1",
     "type-fest": "^4.6.0"
   },

package/src/index.ts

@@ -1,53 +0,0 @@
-export { addMark } from './commands/add-mark'
-export { insertNode } from './commands/insert-node'
-export { setBlockType } from './commands/set-block-type'
-export { toggleMark } from './commands/toggle-mark'
-export { toggleNode } from './commands/toggle-node'
-export { Editor, createEditor, type EditorOptions } from './editor/editor'
-export { union } from './editor/type-utils'
-export { withPriority } from './editor/with-priority'
-export { ProseKitError } from './error'
-export { defineBaseCommands, defineCommands } from './extensions/command'
-export {
-  defineDefaultState,
-  type DefaultStateOptions,
-} from './extensions/default-state'
-export { defineDoc } from './extensions/doc'
-export { defineEventHandler } from './extensions/event-handler'
-export { defineHistory } from './extensions/history'
-export { defineInputRule } from './extensions/input-rules'
-export {
-  defineBaseKeymap,
-  defineKeymap,
-  type Keymap,
-} from './extensions/keymap'
-export { defineMarkSpec, type MarkSpecOptions } from './extensions/mark-spec'
-export { defineNodeSpec, type NodeSpecOptions } from './extensions/node-spec'
-export { defineNodeView, type NodeViewOptions } from './extensions/node-view'
-export {
-  defineNodeViewEffect,
-  type NodeViewEffectOptions,
-} from './extensions/node-view-effect'
-export { defineParagraph } from './extensions/paragraph'
-export {
-  definePlugin,
-  pluginFacet,
-  type PluginPayload,
-} from './extensions/plugin'
-export { defineText } from './extensions/text'
-export { Facet, FacetExtension, type FacetOptions } from './facets/facet'
-export { type CommandArgs as CommandArgs } from './types/command'
-export {
-  type Extension,
-  type ExtractCommandAppliers,
-  type ExtractCommandCreators,
-  type ExtractMarks,
-  type ExtractNodes,
-  type SimplifyExtension,
-} from './types/extension'
-export { type ExtensionTyping } from './types/extension-typing'
-export type { NodeJson, SelectionJson, StateJson } from './types/model'
-export { Priority } from './types/priority'
-export { type SimplifyUnion } from './types/simplify-union'
-export { getMarkType } from './utils/get-mark-type'
-export { getNodeType } from './utils/get-node-type'