@prosekit/core 0.0.17 → 0.0.19

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

@@ -1,3 +1,4 @@
+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';
@@ -12,7 +13,9 @@ 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 { NodeSelection } from '@prosekit/pm/state';
 import type { NodeSpec } from '@prosekit/pm/model';
 import { NodeType } from '@prosekit/pm/model';
 import { NodeType as NodeType_2 } from 'prosemirror-model';
@@ -23,8 +26,10 @@ import { ProseMirrorFragment } from '@prosekit/pm/model';
 import { ProseMirrorNode } from '@prosekit/pm/model';
 import { Schema } from '@prosekit/pm/model';
 import type { SchemaSpec } from '@prosekit/pm/model';
-import { Selection as Selection_2 } from 'prosemirror-state';
+import { Selection as Selection_2 } from '@prosekit/pm/state';
+import { Selection as Selection_3 } from 'prosemirror-state';
 import type { Simplify } from 'type-fest';
+import { TextSelection } from '@prosekit/pm/state';
 import { Transaction } from '@prosekit/pm/state';
 import type { UnionToIntersection } from 'type-fest';
 import { UserProjectConfigExport } from 'vitest/dist/config.js';
@@ -34,15 +39,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;
@@ -58,6 +72,28 @@ 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[]> {
@@ -91,7 +127,7 @@ declare type ConverterTuple = Tuple5<FacetConverter | undefined>;
 /**
  * @public
  */
-declare function createEditor<E extends Extension>({ extension, defaultDoc, defaultSelection, }: EditorOptions<E>): Editor<E>;
+declare function createEditor<E extends Extension>({ extension, defaultDoc, defaultHTML, defaultSelection, }: EditorOptions<E>): Editor<E>;
 export { createEditor }
 export { createEditor as createEditor_alias_1 }
 
@@ -105,13 +141,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.
+     */
+    defaultDoc?: NodeJson;
+    /**
+     * A HTML string representing the starting document to use when creating the
+     * editor.
      */
-    doc?: NodeJson;
+    defaultHTML?: string;
     /**
-     * A JSON representation of a ProseMirror selection.
+     * A JSON object representing the starting selection to use when creating the
+     * editor. It's only used when `defaultDoc` or `defaultHTML` is also provided.
      */
-    selection?: SelectionJson;
+    defaultSelection?: SelectionJson;
 }
 export { DefaultStateOptions }
 export { DefaultStateOptions as DefaultStateOptions_alias_1 }
@@ -143,6 +186,18 @@ 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 }
@@ -163,7 +218,7 @@ 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 }
 
@@ -181,7 +236,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 }
 
@@ -327,15 +382,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>;
@@ -347,6 +421,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 }
@@ -431,13 +511,17 @@ declare class Facet<Input, Output> {
      * @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>;
+    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 }
@@ -453,14 +537,14 @@ export declare interface FacetConverter<Input = any, Output = any> {
 /**
  * @public
  */
-declare class FacetExtension<Input, Output> {
+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
@@ -474,7 +558,11 @@ declare interface FacetOptions<Input, Output> {
 export { FacetOptions }
 export { FacetOptions as FacetOptions_alias_1 }
 
-export declare function getCustomSelection(state: EditorState, from?: number | null, to?: number | null): Selection_2;
+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_3;
 
 export declare function getFacetCount(): number;
 
@@ -492,6 +580,20 @@ 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;
@@ -516,15 +618,46 @@ export declare function insertText({ text, from, to, }: {
     to?: number;
 }): Command;
 
+/**
+ * @internal
+ */
+declare function isAllSelection(sel: Selection_2): sel is AllSelection;
+export { isAllSelection }
+export { isAllSelection as isAllSelection_alias_1 }
+
 export declare const isMac: boolean;
 
-export declare function isMark(mark: unknown): mark is Mark;
+/**
+ * @internal
+ */
+declare function isMark(mark: unknown): mark is Mark;
+export { isMark }
+export { isMark as isMark_alias_1 }
 
 export declare function isMarkActive(state: EditorState, type: string | MarkType, attrs?: Attrs | null): boolean;
 
 export declare function isNodeActive(state: EditorState, type: string | NodeType, attrs?: Attrs | null): boolean;
 
-export declare function isProseMirrorNode(node: unknown): node is ProseMirrorNode;
+/**
+ * @internal
+ */
+declare function isNodeSelection(sel: Selection_2): sel is NodeSelection;
+export { isNodeSelection }
+export { isNodeSelection as isNodeSelection_alias_1 }
+
+/**
+ * @internal
+ */
+declare function isProseMirrorNode(node: unknown): node is ProseMirrorNode;
+export { isProseMirrorNode }
+export { isProseMirrorNode as isProseMirrorNode_alias_1 }
+
+/**
+ * @internal
+ */
+declare function isTextSelection(sel: Selection_2): sel is TextSelection;
+export { isTextSelection }
+export { isTextSelection as isTextSelection_alias_1 }
 
 /**
  * @public
@@ -604,6 +737,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;
@@ -649,6 +784,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;
@@ -661,8 +820,8 @@ export declare function selectAll(): Command;
  * @public
  */
 declare interface SelectionJson {
-    from: number;
-    to: number;
+    anchor: number;
+    head: number;
     type: string;
 }
 export { SelectionJson }
@@ -755,6 +914,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[];

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,12 @@ 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';
+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 { isTextSelection } 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";
 
@@ -198,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";
 
@@ -226,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() {
@@ -237,6 +263,10 @@ var Facet = class _Facet {
      * @internal
      */
     this.index = facetCount++;
+    /**
+     * @internal
+     */
+    this.isSchema = false;
     this.converter = converter;
     this.next = next;
     this.singleton = singleton;
@@ -263,13 +293,17 @@ var Facet = class _Facet {
     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));
   }
 };
 
@@ -304,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) => {
@@ -439,6 +452,7 @@ var schemaFacet = Facet.defineRootFacet({
     return { nodes, marks, topNode };
   }
 });
+schemaFacet.isSchema = true;
 
 // src/facets/view.ts
 var viewFacet = Facet.defineRootFacet({
@@ -447,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],
@@ -506,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;
@@ -631,26 +635,179 @@ 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";
+import {
+  AllSelection,
+  NodeSelection,
+  TextSelection as TextSelection2
+} from "@prosekit/pm/state";
+function isProseMirrorNode(node) {
+  return node instanceof ProseMirrorNode;
+}
+function isMark(mark) {
+  return mark instanceof Mark;
+}
+function isTextSelection(sel) {
+  return sel instanceof TextSelection2;
+}
+function isNodeSelection(sel) {
+  return sel instanceof NodeSelection;
+}
+function isAllSelection(sel) {
+  return sel instanceof AllSelection;
+}
+
+// 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);
+  }
+}
+
+// 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 extension;
+  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
       })
     ]);
   }
@@ -668,7 +825,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) {
@@ -859,7 +1016,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
@@ -877,10 +1036,10 @@ function insertText({
 }
 
 // src/commands/select-all.ts
-import { AllSelection } from "@prosekit/pm/state";
+import { AllSelection as AllSelection2 } from "@prosekit/pm/state";
 function selectAll() {
   return (state, dispatch) => {
-    dispatch == null ? void 0 : dispatch(state.tr.setSelection(new AllSelection(state.doc)));
+    dispatch == null ? void 0 : dispatch(state.tr.setSelection(new AllSelection2(state.doc)));
     return true;
   };
 }
@@ -936,7 +1095,9 @@ function defineBaseCommands() {
     insertNode: insertNode2,
     wrap,
     setBlockType,
-    selectAll
+    selectAll,
+    addMark,
+    removeMark
   });
 }
 
@@ -1233,7 +1394,6 @@ function defineText() {
 export {
   Editor,
   Facet,
-  FacetExtension,
   Priority,
   ProseKitError,
   addMark,
@@ -1254,10 +1414,20 @@ export {
   defineParagraph,
   definePlugin,
   defineText,
+  elementToJSON,
+  elementToNode,
   getMarkType,
   getNodeType,
+  htmlToJSON,
+  htmlToNode,
   insertNode,
+  isAllSelection,
+  isMark,
+  isNodeSelection,
+  isProseMirrorNode,
+  isTextSelection,
   pluginFacet,
+  removeMark,
   setBlockType,
   toggleMark,
   toggleNode,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "private": false,
   "author": {
     "name": "ocavue",