@prosekit/core 0.2.2 → 0.2.4

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

@@ -3,6 +3,7 @@ import { Attrs } from '@prosekit/pm/model';
 import { Attrs as Attrs_2 } from 'prosemirror-model';
 import { Command } from '@prosekit/pm/state';
 import type { ConditionalExcept } from 'type-fest';
+import type { ContentMatch } from '@prosekit/pm/model';
 import type { DirectEditorProps } from '@prosekit/pm/view';
 import { EditorState } from '@prosekit/pm/state';
 import type { EditorStateConfig } from '@prosekit/pm/state';
@@ -120,6 +121,17 @@ declare interface BaseNodeViewOptions {
 export { BaseNodeViewOptions }
 export { BaseNodeViewOptions as BaseNodeViewOptions_alias_1 }
 
+/**
+ * A utility for constructing `className` strings conditionally.
+ *
+ * It is a re-export of [clsx/lite](https://www.npmjs.com/package/clsx) with stricter types.
+ *
+ * @public
+ */
+declare const clsx: (...args: Array<string | boolean | null | undefined>) => string;
+export { clsx }
+export { clsx as clsx_alias_1 }
+
 export declare function collectNodes(content: NodeContent): ProseMirrorNode[];
 
 export declare interface CommandApplier<Args extends any[] = any[]> {
@@ -169,6 +181,13 @@ export declare const default_alias_1: {
     };
 };
 
+/**
+ * @internal
+ */
+declare function defaultBlockAt(match: ContentMatch): NodeType_2 | null;
+export { defaultBlockAt }
+export { defaultBlockAt as defaultBlockAt_alias_1 }
+
 declare interface DefaultStateOptions {
     /**
      * A JSON object representing the starting document to use when creating the
@@ -286,6 +305,15 @@ declare function defineDocChangeHandler(handler: DocChangeHandler): Extension<Ex
 export { defineDocChangeHandler }
 export { defineDocChangeHandler as defineDocChangeHandler_alias_1 }
 
+/**
+ * Registers a event handler that is called when the editor gains or loses focus.
+ *
+ * @public
+ */
+declare function defineFocusChangeHandler(handler: FocusChangeHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineFocusChangeHandler }
+export { defineFocusChangeHandler as defineFocusChangeHandler_alias_1 }
+
 /**
  * Add undo/redo history to the editor.
  */
@@ -321,6 +349,13 @@ declare function defineKeymap(keymap: Keymap): Extension;
 export { defineKeymap }
 export { defineKeymap as defineKeymap_alias_1 }
 
+/**
+ * @public
+ */
+declare function defineMarkAttr(options: MarkAttrOptions): Extension;
+export { defineMarkAttr }
+export { defineMarkAttr as defineMarkAttr_alias_1 }
+
 /**
  * @public
  */
@@ -340,6 +375,17 @@ export { defineMountHandler }
 export { defineMountHandler as defineMountHandler_alias_1 }
 
 /**
+ * Defines an attribute for a node type.
+ *
+ * @public
+ */
+declare function defineNodeAttr(options: NodeAttrOptions): Extension;
+export { defineNodeAttr }
+export { defineNodeAttr as defineNodeAttr_alias_1 }
+
+/**
+ * Defines a node type.
+ *
  * @public
  */
 declare function defineNodeSpec<NodeName extends string>(options: NodeSpecOptions<NodeName>): Extension<{
@@ -443,12 +489,33 @@ declare class Editor<E extends Extension = any> {
      * @internal
      */
     static create(instance: any): Editor<any>;
+    /**
+     * Whether the editor is mounted.
+     */
     get mounted(): boolean;
+    /**
+     * The editor view.
+     */
     get view(): EditorView;
+    /**
+     * The editor schema.
+     */
     get schema(): Schema<ExtractNodes<E>, ExtractMarks<E>>;
     get commands(): ExtractCommandAppliers<E>;
+    /**
+     * Whether the editor is focused.
+     */
+    get focused(): boolean;
     mount(place: HTMLElement | null | undefined | void): void;
     unmount(): void;
+    /**
+     * Focus the editor.
+     */
+    focus(): void;
+    /**
+     * Blur the editor.
+     */
+    blur(): void;
     use(extension: Extension): VoidFunction;
     get nodes(): Record<ExtractNodes<E>, NodeBuilder>;
     get marks(): Record<ExtractMarks<E>, MarkBuilder>;
@@ -638,6 +705,17 @@ declare interface FacetOptions<Input, Output> {
 export { FacetOptions }
 export { FacetOptions as FacetOptions_alias_1 }
 
+/**
+ * A function that is called when the editor gains or loses focus.
+ *
+ * @param hasFocus - Whether the editor has focus.
+ *
+ * @public
+ */
+declare type FocusChangeHandler = (hasFocus: boolean) => void;
+export { FocusChangeHandler }
+export { FocusChangeHandler as FocusChangeHandler_alias_1 }
+
 export declare function getBrowserDocument(): Document | undefined;
 
 export declare function getBrowserWindow(): (Window & typeof globalThis) | null | undefined;
@@ -701,6 +779,8 @@ declare function isAllSelection(sel: Selection_2): sel is AllSelection;
 export { isAllSelection }
 export { isAllSelection as isAllSelection_alias_1 }
 
+export declare function isElement(value: unknown): value is Element;
+
 export declare const isMac: boolean;
 
 /**
@@ -796,6 +876,36 @@ declare type KeymapPayload = Keymap;
 export { KeymapPayload }
 export { KeymapPayload as KeymapPayload_alias_1 }
 
+/**
+ * @public
+ */
+declare interface MarkAttrOptions {
+    /**
+     * The name of the mark type.
+     */
+    type: string;
+    /**
+     * The name of the attribute.
+     */
+    attr: string;
+    /**
+     * The default value for this attribute, to use when no explicit value is
+     * provided. Attributes that have no default must be provided whenever a mark
+     * of a type that has them is created.
+     */
+    default?: any;
+    /**
+     * Returns the attribute key and value to be set on the DOM node.
+     */
+    toDOM?: (value: any) => [key: string, value: string] | null | void;
+    /**
+     * Parses the attribute value from the DOM.
+     */
+    parseDOM?: (node: HTMLElement) => any;
+}
+export { MarkAttrOptions }
+export { MarkAttrOptions as MarkAttrOptions_alias_1 }
+
 export declare interface MarkBuilder {
     (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode[];
     (...children: NodeChild[]): ProseMirrorNode[];
@@ -822,6 +932,36 @@ declare type MountHandler = (view: EditorView) => void;
 export { MountHandler }
 export { MountHandler as MountHandler_alias_1 }
 
+/**
+ * @public
+ */
+declare interface NodeAttrOptions {
+    /**
+     * The name of the node type.
+     */
+    type: string;
+    /**
+     * The name of the attribute.
+     */
+    attr: string;
+    /**
+     * The default value for this attribute, to use when no explicit value is
+     * provided. Attributes that have no default must be provided whenever a node
+     * of a type that has them is created.
+     */
+    default?: any;
+    /**
+     * Returns the attribute key and value to be set on the DOM node.
+     */
+    toDOM?: (value: any) => [key: string, value: string] | null | void;
+    /**
+     * Parses the attribute value from the DOM.
+     */
+    parseDOM?: (node: HTMLElement) => any;
+}
+export { NodeAttrOptions }
+export { NodeAttrOptions as NodeAttrOptions_alias_1 }
+
 export declare interface NodeBuilder {
     (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode;
     (...children: NodeChild[]): ProseMirrorNode;
@@ -906,6 +1046,13 @@ declare interface NodeViewOptions {
 export { NodeViewOptions }
 export { NodeViewOptions as NodeViewOptions_alias_1 }
 
+/**
+ * @internal
+ */
+declare const OBJECT_REPLACEMENT_CHARACTER = "\uFFFC";
+export { OBJECT_REPLACEMENT_CHARACTER }
+export { OBJECT_REPLACEMENT_CHARACTER as OBJECT_REPLACEMENT_CHARACTER_alias_1 }
+
 export declare function objectEqual<T>(a: T, b: T): boolean;
 
 declare type Payload = unknown;
@@ -931,6 +1078,8 @@ export { PluginPayload }
 export { PluginPayload as PluginPayload_alias_1 }
 
 /**
+ * ProseKit extension priority.
+ *
  * @public
  */
 declare const enum Priority {
@@ -1146,6 +1295,13 @@ declare function withPriority<T extends Extension>(extension: T, priority: Prior
 export { withPriority }
 export { withPriority as withPriority_alias_1 }
 
+/**
+ * @internal
+ */
+declare function withSkipCodeBlock(command: Command): Command;
+export { withSkipCodeBlock }
+export { withSkipCodeBlock as withSkipCodeBlock_alias_1 }
+
 export declare function wrap({ nodeType, attrs, }: {
     nodeType: NodeType;
     attrs?: Attrs | null;

package/dist/prosekit-core.d.ts

@@ -15,14 +15,16 @@ export { defineCommands } from './_tsup-dts-rollup';
 export { defineDefaultState } from './_tsup-dts-rollup';
 export { DefaultStateOptions } from './_tsup-dts-rollup';
 export { defineDoc } from './_tsup-dts-rollup';
+export { defineDocChangeHandler } from './_tsup-dts-rollup';
+export { DocChangeHandler } from './_tsup-dts-rollup';
+export { defineFocusChangeHandler } from './_tsup-dts-rollup';
+export { FocusChangeHandler } from './_tsup-dts-rollup';
 export { defineMountHandler } from './_tsup-dts-rollup';
 export { defineUnmountHandler } from './_tsup-dts-rollup';
 export { defineUpdateHandler } from './_tsup-dts-rollup';
 export { MountHandler } from './_tsup-dts-rollup';
 export { UnmountHandler } from './_tsup-dts-rollup';
 export { UpdateHandler } from './_tsup-dts-rollup';
-export { defineDocChangeHandler } from './_tsup-dts-rollup';
-export { DocChangeHandler } from './_tsup-dts-rollup';
 export { defineHistory } from './_tsup-dts-rollup';
 export { defineInputRule } from './_tsup-dts-rollup';
 export { defineBaseKeymap } from './_tsup-dts-rollup';
@@ -30,9 +32,13 @@ export { defineKeymap } from './_tsup-dts-rollup';
 export { keymapFacet } from './_tsup-dts-rollup';
 export { Keymap } from './_tsup-dts-rollup';
 export { KeymapPayload } from './_tsup-dts-rollup';
+export { defineMarkAttr } from './_tsup-dts-rollup';
 export { defineMarkSpec } from './_tsup-dts-rollup';
+export { MarkAttrOptions } from './_tsup-dts-rollup';
 export { MarkSpecOptions } from './_tsup-dts-rollup';
+export { defineNodeAttr } from './_tsup-dts-rollup';
 export { defineNodeSpec } from './_tsup-dts-rollup';
+export { NodeAttrOptions } from './_tsup-dts-rollup';
 export { NodeSpecOptions } from './_tsup-dts-rollup';
 export { defineNodeView } from './_tsup-dts-rollup';
 export { NodeViewOptions } from './_tsup-dts-rollup';
@@ -59,6 +65,8 @@ export { SelectionJSON } from './_tsup-dts-rollup';
 export { StateJSON } from './_tsup-dts-rollup';
 export { Priority } from './_tsup-dts-rollup';
 export { SimplifyUnion } from './_tsup-dts-rollup';
+export { clsx } from './_tsup-dts-rollup';
+export { defaultBlockAt } from './_tsup-dts-rollup';
 export { _getId } from './_tsup-dts-rollup';
 export { getMarkType } from './_tsup-dts-rollup';
 export { getNodeType } from './_tsup-dts-rollup';
@@ -75,3 +83,5 @@ export { isMark } from './_tsup-dts-rollup';
 export { isNodeSelection } from './_tsup-dts-rollup';
 export { isProseMirrorNode } 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

@@ -986,18 +986,34 @@ var Editor = class _Editor {
     }
     return new _Editor(instance);
   }
+  /**
+   * Whether the editor is mounted.
+   */
   get mounted() {
     return !!this.instance.view;
   }
+  /**
+   * The editor view.
+   */
   get view() {
     return this.instance.assertView;
   }
+  /**
+   * The editor schema.
+   */
   get schema() {
     return this.instance.schema;
   }
   get commands() {
     return this.instance.commandAppliers;
   }
+  /**
+   * 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(place) {
     if (!place) {
       return this.unmount();
@@ -1010,6 +1026,20 @@ var Editor = class _Editor {
       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();
+  }
   use(extension) {
     if (!this.mounted) {
       let lazyRemove = null;
@@ -1099,26 +1129,110 @@ function defineBaseCommands() {
   });
 }
 
+// src/utils/is-element.ts
+var hasElement = typeof Element !== "undefined";
+function isElement(value) {
+  return hasElement && value instanceof Element;
+}
+
+// src/utils/is-not-null.ts
+function isNotNull(value) {
+  return value != null;
+}
+
 // src/extensions/node-spec.ts
 function defineNodeSpec(options) {
-  return nodeSpecFacet.extension([options]);
+  const payload = [options, void 0];
+  return nodeSpecFacet.extension([payload]);
+}
+function defineNodeAttr(options) {
+  const payload = [void 0, options];
+  return nodeSpecFacet.extension([payload]);
 }
 var nodeSpecFacet = Facet.define({
-  convert: (options) => {
+  convert: (payloads) => {
     const nodes = {};
     let topNodeName = void 0;
-    for (const { name, topNode, ...spec } of options) {
+    const specPayloads = payloads.map((input) => input[0]).filter(isNotNull);
+    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
+    for (const { name, topNode, ...spec } of specPayloads) {
       if (nodes[name]) {
         throw new ProseKitError(`Node type ${name} has already been defined`);
       }
-      if (topNodeName && !topNode) {
+      if (topNode) {
         topNodeName = name;
       }
       nodes[name] = spec;
     }
+    for (const {
+      type,
+      attr,
+      default: defaultValue,
+      toDOM,
+      parseDOM
+    } of attrPayloads) {
+      const spec = nodes[type];
+      if (!spec) {
+        throw new ProseKitError(
+          `Node type ${type} must be defined before defining attributes`
+        );
+      }
+      if (!spec.attrs) {
+        spec.attrs = {};
+      }
+      spec.attrs[attr] = { default: defaultValue };
+      if (toDOM && spec.toDOM) {
+        const existingToDom = spec.toDOM;
+        spec.toDOM = (node) => {
+          const dom = existingToDom(node);
+          if (!dom) {
+            return dom;
+          }
+          const attrDOM = toDOM(node.attrs[attr]);
+          if (!attrDOM) {
+            return dom;
+          }
+          const [key, value] = attrDOM;
+          if (!key) {
+            return dom;
+          }
+          if (Array.isArray(dom)) {
+            if (typeof dom[1] === "object") {
+              return [dom[0], { ...dom[1], [key]: value }, ...dom.slice(2)];
+            } else {
+              return [dom[0], { [key]: value }, ...dom.slice(1)];
+            }
+          } else if (isElement(dom)) {
+            dom.setAttribute(key, value);
+          } else if (typeof dom === "object" && "dom" in dom && isElement(dom.dom)) {
+            dom.dom.setAttribute(key, value);
+          }
+          return dom;
+        };
+      }
+      if (parseDOM && spec.parseDOM) {
+        for (const rule of spec.parseDOM) {
+          const existingGetAttrs = rule.getAttrs;
+          const existingAttrs = rule.attrs;
+          rule.getAttrs = (dom) => {
+            var _a;
+            const attrs = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs;
+            if (attrs === false || !dom || !isElement(dom)) {
+              return attrs != null ? attrs : null;
+            }
+            const value = parseDOM(dom);
+            return {
+              ...attrs,
+              [attr]: value
+            };
+          };
+        }
+      }
+    }
     return { nodes, topNode: topNodeName };
   },
-  next: schemaFacet
+  next: schemaFacet,
+  singleton: true
 });
 
 // src/extensions/doc.ts
@@ -1242,6 +1356,28 @@ function defineDocChangeHandler(handler) {
   });
 }
 
+// src/extensions/events/focus.ts
+import { PluginKey as PluginKey2, ProseMirrorPlugin as ProseMirrorPlugin2 } from "@prosekit/pm/state";
+function defineFocusChangeHandler(handler) {
+  const handleFocus = () => handler(true);
+  const handleBlur = () => handler(false);
+  const plugin = new ProseMirrorPlugin2({
+    key: new PluginKey2("prosekit-focus-handler"),
+    view: (view) => {
+      const dom = view.dom;
+      dom.addEventListener("focus", handleFocus);
+      dom.addEventListener("blur", handleBlur);
+      return {
+        destroy: () => {
+          dom.removeEventListener("focus", handleFocus);
+          dom.removeEventListener("blur", handleBlur);
+        }
+      };
+    }
+  });
+  return definePlugin(plugin);
+}
+
 // src/extensions/history.ts
 import { history, redo, undo } from "@prosekit/pm/history";
 
@@ -1251,7 +1387,7 @@ var isMac = typeof navigator !== "undefined" ? /Mac|iP(hone|[ao]d)/.test(navigat
 // src/extensions/keymap.ts
 import { baseKeymap, chainCommands } from "@prosekit/pm/commands";
 import { keydownHandler } from "@prosekit/pm/keymap";
-import { Plugin as Plugin3, PluginKey as PluginKey2 } from "@prosekit/pm/state";
+import { Plugin as Plugin3, PluginKey as PluginKey3 } from "@prosekit/pm/state";
 function defineKeymap(keymap) {
   return keymapFacet.extension([keymap]);
 }
@@ -1302,7 +1438,7 @@ function mergeKeymaps(keymaps) {
     ])
   );
 }
-var keymapPluginKey = new PluginKey2("prosekit-keymap");
+var keymapPluginKey = new PluginKey3("prosekit-keymap");
 
 // src/extensions/history.ts
 function defineHistory() {
@@ -1351,24 +1487,97 @@ var inputRuleFacet = Facet.define({
 
 // src/extensions/mark-spec.ts
 function defineMarkSpec(options) {
-  return markSpecFacet.extension([options]);
+  const payload = [options, void 0];
+  return markSpecFacet.extension([payload]);
+}
+function defineMarkAttr(options) {
+  const payload = [void 0, options];
+  return markSpecFacet.extension([payload]);
 }
 var markSpecFacet = Facet.define({
-  convert: (options) => {
+  convert: (payloads) => {
     const marks = {};
-    for (const { name, ...spec } of options) {
+    const specPayloads = payloads.map((input) => input[0]).filter(isNotNull);
+    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
+    for (const { name, ...spec } of specPayloads) {
       if (marks[name]) {
         throw new ProseKitError(`Mark type ${name} has already been defined`);
       }
       marks[name] = spec;
     }
+    for (const {
+      type,
+      attr,
+      default: defaultValue,
+      toDOM,
+      parseDOM
+    } of attrPayloads) {
+      const spec = marks[type];
+      if (!spec) {
+        throw new ProseKitError(
+          `Mark type ${type} must be defined before defining attributes`
+        );
+      }
+      if (!spec.attrs) {
+        spec.attrs = {};
+      }
+      spec.attrs[attr] = { default: defaultValue };
+      if (toDOM && spec.toDOM) {
+        const existingToDom = spec.toDOM;
+        spec.toDOM = (mark, inline) => {
+          const dom = existingToDom(mark, inline);
+          if (!dom) {
+            return dom;
+          }
+          const attrDOM = toDOM(mark.attrs[attr]);
+          if (!attrDOM) {
+            return dom;
+          }
+          const [key, value] = attrDOM;
+          if (!key) {
+            return dom;
+          }
+          if (Array.isArray(dom)) {
+            if (typeof dom[1] === "object") {
+              return [dom[0], { ...dom[1], [key]: value }, ...dom.slice(2)];
+            } else {
+              return [dom[0], { [key]: value }, ...dom.slice(1)];
+            }
+          } else if (isElement(dom)) {
+            dom.setAttribute(key, value);
+          } else if (typeof dom === "object" && "dom" in dom && isElement(dom.dom)) {
+            dom.dom.setAttribute(key, value);
+          }
+          return dom;
+        };
+      }
+      if (parseDOM && spec.parseDOM) {
+        for (const rule of spec.parseDOM) {
+          const existingGetAttrs = rule.getAttrs;
+          const existingAttrs = rule.attrs;
+          rule.getAttrs = (dom) => {
+            var _a;
+            const attrs = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs;
+            if (attrs === false || !dom || !isElement(dom)) {
+              return attrs != null ? attrs : null;
+            }
+            const value = parseDOM(dom);
+            return {
+              ...attrs,
+              [attr]: value
+            };
+          };
+        }
+      }
+    }
     return { marks, nodes: {} };
   },
-  next: schemaFacet
+  next: schemaFacet,
+  singleton: true
 });
 
 // src/extensions/node-view.ts
-import { ProseMirrorPlugin as ProseMirrorPlugin2 } from "@prosekit/pm/state";
+import { ProseMirrorPlugin as ProseMirrorPlugin3 } from "@prosekit/pm/state";
 import "@prosekit/pm/view";
 function defineNodeView(options) {
   return nodeViewFacet.extension([options]);
@@ -1381,13 +1590,13 @@ var nodeViewFacet = Facet.define({
         nodeViews[input.name] = input.constructor;
       }
     }
-    return () => [new ProseMirrorPlugin2({ props: { nodeViews } })];
+    return () => [new ProseMirrorPlugin3({ props: { nodeViews } })];
   },
   next: pluginFacet
 });
 
 // src/extensions/node-view-effect.ts
-import { ProseMirrorPlugin as ProseMirrorPlugin3 } from "@prosekit/pm/state";
+import { ProseMirrorPlugin as ProseMirrorPlugin4 } from "@prosekit/pm/state";
 import "@prosekit/pm/view";
 function defineNodeViewFactory(options) {
   return nodeViewFactoryFacet.extension([options]);
@@ -1415,7 +1624,7 @@ var nodeViewFactoryFacet = Facet.define({
         nodeViews[name] = factory(args);
       }
     }
-    return () => [new ProseMirrorPlugin3({ props: { nodeViews } })];
+    return () => [new ProseMirrorPlugin4({ props: { nodeViews } })];
   },
   next: pluginFacet
 });
@@ -1444,31 +1653,70 @@ function defineText() {
   });
 }
 
+// src/utils/clsx.ts
+import clsxLite from "clsx/lite";
+var clsx = clsxLite;
+
+// src/utils/default-block-at.ts
+function defaultBlockAt(match) {
+  for (let i = 0; i < match.edgeCount; i++) {
+    const { type } = match.edge(i);
+    if (type.isTextblock && !type.hasRequiredAttrs())
+      return type;
+  }
+  return null;
+}
+
 // src/utils/get-id.ts
 var id = 0;
 function getId() {
   id = (id + 1) % Number.MAX_SAFE_INTEGER;
   return `id:${id}`;
 }
+
+// src/utils/unicode.ts
+var OBJECT_REPLACEMENT_CHARACTER = "\uFFFC";
+
+// src/utils/with-skip-code-block.ts
+function isCodeBlockType(type) {
+  return type.spec.code && type.isBlock;
+}
+function isInCodeBlock(selection) {
+  return isCodeBlockType(selection.$from.parent.type) || isCodeBlockType(selection.$to.parent.type);
+}
+function withSkipCodeBlock(command) {
+  return (state, dispatch, view) => {
+    if (isInCodeBlock(state.selection)) {
+      return false;
+    }
+    return command(state, dispatch, view);
+  };
+}
 export {
   Editor,
   Facet,
+  OBJECT_REPLACEMENT_CHARACTER,
   Priority,
   ProseKitError,
   getId as _getId,
   addMark,
+  clsx,
   createEditor,
+  defaultBlockAt,
   defineBaseCommands,
   defineBaseKeymap,
   defineCommands,
   defineDefaultState,
   defineDoc,
   defineDocChangeHandler,
+  defineFocusChangeHandler,
   defineHistory,
   defineInputRule,
   defineKeymap,
+  defineMarkAttr,
   defineMarkSpec,
   defineMountHandler,
+  defineNodeAttr,
   defineNodeSpec,
   defineNodeView,
   defineNodeViewFactory,
@@ -1500,5 +1748,6 @@ export {
   toggleMark,
   toggleNode,
   union,
-  withPriority
+  withPriority,
+  withSkipCodeBlock
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -36,6 +36,7 @@
   ],
   "dependencies": {
     "@prosekit/pm": "^0.1.1",
+    "clsx": "^2.1.0",
     "orderedmap": "^2.1.1",
     "type-fest": "^4.9.0"
   },
@@ -43,7 +44,7 @@
     "@prosekit/dev": "*",
     "tsup": "^8.0.1",
     "typescript": "^5.3.3",
-    "vitest": "^1.1.1"
+    "vitest": "^1.1.3"
   },
   "scripts": {
     "build:tsup": "tsup",

package/src/index.ts

@@ -14,6 +14,14 @@ export {
   type DefaultStateOptions,
 } from './extensions/default-state'
 export { defineDoc } from './extensions/doc'
+export {
+  defineDocChangeHandler,
+  type DocChangeHandler,
+} from './extensions/events/doc-change'
+export {
+  defineFocusChangeHandler,
+  type FocusChangeHandler,
+} from './extensions/events/focus'
 export {
   defineMountHandler,
   defineUnmountHandler,
@@ -22,10 +30,6 @@ export {
   type UnmountHandler,
   type UpdateHandler,
 } from './extensions/events/plugin-view'
-export {
-  defineDocChangeHandler,
-  type DocChangeHandler,
-} from './extensions/events/doc-change'
 export { defineHistory } from './extensions/history'
 export { defineInputRule } from './extensions/input-rules'
 export {
@@ -35,8 +39,18 @@ export {
   type Keymap,
   type KeymapPayload,
 } from './extensions/keymap'
-export { defineMarkSpec, type MarkSpecOptions } from './extensions/mark-spec'
-export { defineNodeSpec, type NodeSpecOptions } from './extensions/node-spec'
+export {
+  defineMarkAttr,
+  defineMarkSpec,
+  type MarkAttrOptions,
+  type MarkSpecOptions,
+} from './extensions/mark-spec'
+export {
+  defineNodeAttr,
+  defineNodeSpec,
+  type NodeAttrOptions,
+  type NodeSpecOptions,
+} from './extensions/node-spec'
 export { defineNodeView, type NodeViewOptions } from './extensions/node-view'
 export {
   defineNodeViewFactory,
@@ -64,6 +78,8 @@ 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 { clsx } from './utils/clsx'
+export { defaultBlockAt } from './utils/default-block-at'
 export { getId as _getId } from './utils/get-id'
 export { getMarkType } from './utils/get-mark-type'
 export { getNodeType } from './utils/get-node-type'
@@ -84,3 +100,5 @@ export {
   isProseMirrorNode,
   isTextSelection,
 } from './utils/type-assertion'
+export * from './utils/unicode'
+export { withSkipCodeBlock } from './utils/with-skip-code-block'