@prosekit/core 0.0.4 → 0.0.6

package/dist/prosekit-core.d.ts

@@ -1,4 +1,4 @@
-import { MarkType, Attrs, Schema, ProseMirrorNode, NodeType, MarkSpec, NodeSpec } from '@prosekit/pm/model';
+import { MarkType, Attrs, NodeType, Schema, ProseMirrorNode, MarkSpec, NodeSpec } from '@prosekit/pm/model';
 import { Command, EditorStateConfig, Plugin } from '@prosekit/pm/state';
 import { EditorView, NodeViewConstructor, DirectEditorProps } from '@prosekit/pm/view';
 import { ConditionalExcept, EmptyObject, Simplify, UnionToIntersection } from 'type-fest';
@@ -10,6 +10,12 @@ interface ToggleMarkOptions {
 }
 declare function toggleMark(options: ToggleMarkOptions): Command;
 
+interface ToggleNodeOptions {
+    type: string | NodeType;
+    attrs?: Attrs | null;
+}
+declare function toggleNode(options: ToggleNodeOptions): Command;
+
 type CommandDispatcher<Args extends any[] = any[]> = (...arg: Args) => boolean;
 type CommandCreator<Args extends any[] = any[]> = (...arg: Args) => Command;
 /** @internal */
@@ -120,25 +126,36 @@ declare class Editor<E extends Extension = any> {
     mount(place: HTMLElement | null | undefined | void): void;
     unmount(): void;
     use(extension: Extension): VoidFunction;
+    isNodeActive(nodeType: string | NodeType, attrs?: Attrs): boolean;
+    isMarkActive(markType: string | MarkType, attrs?: Attrs): boolean;
+}
+
+interface Slot<Input, Output> {
+    create: (inputs: Input[]) => Output;
+    update: (inputs: Input[]) => Output | null;
 }
 
 /** @public */
 interface FacetOptions<Input, Output> {
-    combine: (inputs: Input[]) => Output;
+    combine?: (inputs: Input[]) => Output;
+    slot?: () => Slot<Input, Output>;
     next: Facet<Output, any>;
+    single?: boolean;
 }
 /** @public */
 declare class Facet<Input, Output> {
     /** @internal */
     readonly index: number;
     /** @internal */
-    readonly combine: (inputs: Input[]) => Output;
+    readonly slot: () => Slot<Input, Output>;
     /** @internal */
     readonly next: Facet<Output, any> | null;
+    /** @internal */
+    readonly single: boolean;
     private constructor();
-    static define<Input, Output>({ combine, next }: FacetOptions<Input, Output>): Facet<Input, Output>;
+    static define<Input, Output>({ slot, combine, next, single, }: FacetOptions<Input, Output>): Facet<Input, Output>;
     /** @internal */
-    static defineSlot<Input>({ combine, }: Omit<FacetOptions<Input, Input>, 'next'>): Facet<Input, Input>;
+    static defineSlot<Input>(options: Omit<FacetOptions<Input, Input>, 'next'>): Facet<Input, Input>;
     extension(inputs: Input[]): FacetExtension<Input, Output>;
 }
 /** @public */
@@ -286,4 +303,4 @@ declare function getMarkType(schema: Schema, type: string | MarkType): MarkType;
 /** @internal */
 declare function getNodeType(schema: Schema, type: string | NodeType): NodeType;
 
-export { CommandArgs, Editor, EditorOptions, Extension, ExtensionTyping, ExtractCommandCreators, ExtractCommandDispatchers, ExtractMarks, ExtractNodes, Facet, FacetExtension, FacetOptions, Keymap, MarkSpecOptions, NodeSpecOptions, NodeViewOptions, PluginFacetInput, PluginOptions, Priority, ProseKitError, SimplifyUnion, StateConfigCallback, StateConfigContext, ViewProps, addBaseCommands, addBaseKeymap, addCommands, addDoc, addInputRule, addKeymap, addMarkSpec, addNodeSpec, addNodeView, addParagraph, addPlugin, addText, createEditor, defineExtension, getMarkType, getNodeType, pluginFacet, toggleMark, withPriority };
+export { CommandArgs, Editor, EditorOptions, Extension, ExtensionTyping, ExtractCommandCreators, ExtractCommandDispatchers, ExtractMarks, ExtractNodes, Facet, FacetExtension, FacetOptions, Keymap, MarkSpecOptions, NodeSpecOptions, NodeViewOptions, PluginFacetInput, PluginOptions, Priority, ProseKitError, SimplifyExtension, SimplifyUnion, StateConfigCallback, StateConfigContext, ToggleMarkOptions, ToggleNodeOptions, ViewProps, addBaseCommands, addBaseKeymap, addCommands, addDoc, addInputRule, addKeymap, addMarkSpec, addNodeSpec, addNodeView, addParagraph, addPlugin, addText, createEditor, defineExtension, getMarkType, getNodeType, pluginFacet, toggleMark, toggleNode, withPriority };

package/dist/prosekit-core.js

@@ -32,13 +32,94 @@ function toggleMark(options) {
   };
 }
 
+// src/commands/toggle-node.ts
+import { setBlockType } from "@prosekit/pm/commands";
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+
+// src/utils/get-node-type.ts
+import "@prosekit/pm/model";
+function getNodeType(schema, type) {
+  if (typeof type === "string") {
+    const nodeType = schema.nodes[type];
+    if (!nodeType) {
+      throw new ProseKitError(`Cannot find ProseMirror node type "${type}"`);
+    }
+    return nodeType;
+  }
+  return type;
+}
+
+// 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])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/utils/is-node-active.ts
+function isNodeActive(state, type, attrs) {
+  const $pos = state.selection.$from;
+  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))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/commands/toggle-node.ts
+function toggleNode(options) {
+  return (state, dispatch, view) => {
+    if (isNodeActive(state, options.type, options.attrs)) {
+      const defaultType = state.schema.topNodeType.contentMatch.defaultType;
+      if (!defaultType) {
+        return false;
+      }
+      return setBlockType(defaultType)(state, dispatch, view);
+    } else {
+      const nodeType = getNodeType(state.schema, options.type);
+      return setBlockType(nodeType, options.attrs)(state, dispatch, view);
+    }
+  };
+}
+
 // src/editor/editor.ts
-import { Schema as Schema2 } from "@prosekit/pm/model";
+import { Schema as Schema3 } from "@prosekit/pm/model";
 import { EditorState } from "@prosekit/pm/state";
 import { EditorView } from "@prosekit/pm/view";
 
-// src/types/void-function.ts
-function voidFunction() {
+// 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, to } = state.selection;
+  return state.doc.rangeHasMark(from, to, mark);
 }
 
 // src/types/priority.ts
@@ -51,23 +132,57 @@ var Priority = /* @__PURE__ */ ((Priority2) => {
   return Priority2;
 })(Priority || {});
 
+// src/utils/uniq-array.ts
+function uniqPush(prev, next) {
+  const result = [...prev];
+  for (const item of next) {
+    if (!result.includes(item)) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+function uniqRemove(prev, next) {
+  const result = [...prev];
+  for (const item of next) {
+    const index = result.indexOf(item);
+    if (index !== -1) {
+      result.splice(index, 1);
+    }
+  }
+  return result;
+}
+
 // src/editor/facet.ts
 var nextIndex = 0;
 var Facet = class _Facet {
-  constructor(combine, next) {
+  constructor(slot, next, single) {
     /** @internal */
     this.index = nextIndex++;
-    this.combine = combine;
+    this.slot = slot;
     this.next = next;
+    this.single = single;
   }
-  static define({ combine, next }) {
-    return new _Facet(combine, next);
+  static define({
+    slot,
+    combine,
+    next,
+    single
+  }) {
+    const slotFn = slot ? slot : combine ? () => ({
+      create: combine,
+      update: combine
+    }) : null;
+    if (!slotFn) {
+      throw new ProseKitError(
+        "Facet must have either 'slot' or 'combine' option"
+      );
+    }
+    return new _Facet(slotFn, next, single != null ? single : false);
   }
   /** @internal */
-  static defineSlot({
-    combine
-  }) {
-    return new _Facet(combine, null);
+  static defineSlot(options) {
+    return _Facet.define(options);
   }
   extension(inputs) {
     return new FacetExtension(this, inputs);
@@ -130,7 +245,7 @@ function sortFacets(unsorted) {
   return sortedFacets;
 }
 
-// src/editor/slot.ts
+// src/editor/slots.ts
 import OrderedMap from "orderedmap";
 var schemaSlot = Facet.defineSlot({
   combine: (specs) => {
@@ -149,7 +264,7 @@ var schemaSlot = Facet.defineSlot({
 var stateSlot = Facet.defineSlot({
   combine: (callbacks) => {
     return (ctx) => {
-      var _a, _b, _c, _d, _e;
+      var _a, _b, _c, _d, _e, _f;
       const configs = callbacks.map((cb) => cb(ctx));
       const config = {
         schema: ctx.schema,
@@ -161,7 +276,7 @@ var stateSlot = Facet.defineSlot({
         config.doc = (_b = config.doc) != null ? _b : c.doc;
         config.selection = (_c = config.selection) != null ? _c : c.selection;
         config.storedMarks = [...config.storedMarks, ...(_d = c.storedMarks) != null ? _d : []];
-        config.plugins = [...config.plugins, ...(_e = c.plugins) != null ? _e : []];
+        config.plugins = uniqPush((_e = config.plugins) != null ? _e : [], (_f = c.plugins) != null ? _f : []);
       }
       if (!config.doc && !config.schema) {
         throw new Error("Can't create state without a schema nor a document");
@@ -185,7 +300,46 @@ var commandSlot = Facet.defineSlot({
 });
 
 // src/editor/flatten.ts
-function flatten(root) {
+function flattenInputTuple(inputTuple) {
+  return [
+    ...inputTuple[0],
+    ...inputTuple[1],
+    ...inputTuple[2],
+    ...inputTuple[3],
+    ...inputTuple[4]
+  ];
+}
+function mergeInputTuple(tupleA, tupleB) {
+  if (!tupleA)
+    return tupleB;
+  if (!tupleB)
+    return tupleA;
+  const [a0, a1, a2, a3, a4] = tupleA;
+  const [b0, b1, b2, b3, b4] = tupleB;
+  return [
+    uniqPush(a0, b0),
+    uniqPush(a1, b1),
+    uniqPush(a2, b2),
+    uniqPush(a3, b3),
+    uniqPush(a4, b4)
+  ];
+}
+function removeInputTuple(tupleA, tupleB) {
+  if (!tupleA)
+    return [[], [], [], [], []];
+  if (!tupleB)
+    return tupleA;
+  const [a0, a1, a2, a3, a4] = tupleA;
+  const [b0, b1, b2, b3, b4] = tupleB;
+  return [
+    uniqRemove(a0, b0),
+    uniqRemove(a1, b1),
+    uniqRemove(a2, b2),
+    uniqRemove(a3, b3),
+    uniqRemove(a4, b4)
+  ];
+}
+function extractFacets(root) {
   var _a;
   const extensions = [root];
   const priorities = [2 /* default */];
@@ -217,43 +371,97 @@ function flatten(root) {
       throw new Error("Invalid extension");
     }
   }
+  return [facets, inputs];
+}
+function updateExtension(prevInputs, prevSlots, extension, mode) {
+  const modifyInputTuple = mode === "add" ? mergeInputTuple : removeInputTuple;
+  const [facets, inputs] = extractFacets(extension);
   let schemaInput = null;
   let stateInput = null;
   let viewInput = null;
   let commandInput = null;
-  const sortedFacets = sortFacets(facets);
-  for (const facet of sortedFacets) {
-    const nextFacet = facet.next;
-    if (nextFacet) {
+  for (const facet of sortFacets(facets)) {
+    if (!inputs[facet.index]) {
+      continue;
+    }
+    const inputTuple = modifyInputTuple(
+      prevInputs[facet.index],
+      inputs[facet.index]
+    );
+    prevInputs[facet.index] = inputTuple;
+    if (facet.next && !facet.single) {
+      let hasOutput = false;
+      const outputTuple = [[], [], [], [], []];
       for (let pri = 0; pri < 5; pri++) {
-        const input = inputs[facet.index][pri];
-        if (input.length > 0) {
-          const output = facet.combine(input);
-          if (!inputs[nextFacet.index]) {
-            inputs[nextFacet.index] = [[], [], [], [], []];
-          }
-          inputs[nextFacet.index][pri].push(output);
+        const inputArray = inputTuple[pri];
+        if (inputArray.length === 0) {
+          continue;
         }
+        const slotTuple = prevSlots[facet.index] || (prevSlots[facet.index] = [
+          void 0,
+          void 0,
+          void 0,
+          void 0,
+          void 0
+        ]);
+        const prevSlot = slotTuple[pri];
+        const slot = prevSlot || facet.slot();
+        prevSlots[facet.index][pri] = slot;
+        const output = prevSlot ? slot.update(inputArray) : slot.create(inputArray);
+        if (!output) {
+          continue;
+        }
+        hasOutput = true;
+        outputTuple[pri].push(output);
+      }
+      if (!hasOutput) {
+        continue;
       }
-    } else if (inputs[facet.index]) {
-      const [i1, i2, i3, i4, i5] = inputs[facet.index];
-      const jointInputs = [...i1, ...i2, ...i3, ...i4, ...i5];
-      const output = facet.combine(jointInputs);
-      switch (facet) {
-        case schemaSlot:
-          schemaInput = output;
-          break;
-        case stateSlot:
-          stateInput = output;
-          break;
-        case viewSlot:
-          viewInput = output;
-          break;
-        case commandSlot:
-          commandInput = output;
-          break;
-        default:
-          throw new Error("Invalid facet");
+      inputs[facet.next.index] = modifyInputTuple(
+        inputs[facet.next.index],
+        outputTuple
+      );
+      continue;
+    } else {
+      const inputArray = flattenInputTuple(inputTuple);
+      const slotTuple = prevSlots[facet.index] || (prevSlots[facet.index] = [
+        void 0,
+        void 0,
+        void 0,
+        void 0,
+        void 0
+      ]);
+      const prevSlot = slotTuple[2 /* default */];
+      const slot = prevSlot || facet.slot();
+      prevSlots[facet.index][2 /* default */] = slot;
+      const output = prevSlot ? slot.update(inputArray) : slot.create(inputArray);
+      if (!output) {
+        continue;
+      }
+      const outputTuple = [[], [], [output], [], []];
+      if (facet.next) {
+        inputs[facet.next.index] = modifyInputTuple(
+          inputs[facet.next.index],
+          outputTuple
+        );
+        continue;
+      } else {
+        switch (facet) {
+          case schemaSlot:
+            schemaInput = output;
+            break;
+          case stateSlot:
+            stateInput = output;
+            break;
+          case viewSlot:
+            viewInput = output;
+            break;
+          case commandSlot:
+            commandInput = output;
+            break;
+          default:
+            throw new Error("Invalid facet");
+        }
       }
     }
   }
@@ -264,30 +472,58 @@ function flatten(root) {
 function createEditor({
   extension
 }) {
-  const { schemaInput, stateInput, viewInput, commandInput } = flatten(extension);
-  if (!schemaInput) {
-    throw new Error("Schema must be defined");
-  }
-  const schema = new Schema2(schemaInput);
-  const stateConfig = stateInput ? stateInput({ schema }) : { schema };
-  const state = EditorState.create(stateConfig);
-  const directEditorProps = { state, ...viewInput };
-  const instance = new EditorInstance(directEditorProps);
-  if (commandInput) {
-    for (const [name, commandCreator] of Object.entries(commandInput)) {
-      instance.addCommand(name, commandCreator);
-    }
-  }
-  return Editor.create(instance);
+  const instance = new EditorInstance(extension);
+  const editor = Editor.create(instance);
+  return editor;
 }
 var EditorInstance = class {
-  constructor(directEditorProps) {
-    this.directEditorProps = directEditorProps;
+  constructor(extension) {
     this.view = null;
     this.commandDispatchers = {};
+    this.inputs = [];
+    this.slots = [];
     this.mount = this.mount.bind(this);
     this.unmount = this.unmount.bind(this);
-    this.schema = directEditorProps.state.schema;
+    const { schemaInput, stateInput, viewInput, commandInput } = updateExtension(this.inputs, this.slots, extension, "add");
+    if (!schemaInput) {
+      throw new Error("Schema must be defined");
+    }
+    const schema = new Schema3(schemaInput);
+    const stateConfig = stateInput ? stateInput({ schema }) : { schema };
+    const state = EditorState.create(stateConfig);
+    if (commandInput) {
+      for (const [name, commandCreator] of Object.entries(commandInput)) {
+        this.addCommand(name, commandCreator);
+      }
+    }
+    this.directEditorProps = { state, ...viewInput };
+    this.schema = this.directEditorProps.state.schema;
+  }
+  updateExtension(extension, mode) {
+    var _a;
+    const { schemaInput, stateInput, viewInput, commandInput } = updateExtension(this.inputs, this.slots, extension, mode);
+    if (schemaInput) {
+      throw new ProseKitError("Schema cannot be changed");
+    }
+    if (viewInput) {
+      throw new ProseKitError("View cannot be changed");
+    }
+    const plugins = (_a = stateInput == null ? void 0 : stateInput({ schema: this.schema })) == null ? void 0 : _a.plugins;
+    if (plugins && plugins.length > 0) {
+      if (!this.view) {
+        throw new ProseKitError(
+          "Unexpected inner state: EditorInstance.view is not defined"
+        );
+      }
+      const state = this.view.state.reconfigure({ plugins });
+      this.view.updateState(state);
+    }
+    if (commandInput) {
+      const names = Object.keys(commandInput);
+      for (const name of names) {
+        this.addCommand(name, commandInput[name]);
+      }
+    }
   }
   mount(place) {
     if (this.view) {
@@ -349,7 +585,7 @@ var Editor = class _Editor {
   /** @internal */
   static create(instance) {
     if (!(instance instanceof EditorInstance)) {
-      throw new TypeError("Editor's instance is not EditorInstance");
+      throw new TypeError("Invalid EditorInstance");
     }
     return new _Editor(instance);
   }
@@ -388,33 +624,14 @@ var Editor = class _Editor {
         lazyRemove == null ? void 0 : lazyRemove();
       };
     }
-    const { schemaInput, stateInput, viewInput, commandInput } = flatten(extension);
-    if (schemaInput) {
-      throw new ProseKitError("Schema cannot be changed");
-    }
-    if (viewInput) {
-      throw new ProseKitError("View cannot be changed");
-    }
-    if (stateInput) {
-      const stateConfig = stateInput({ schema: this.schema });
-      const plugins = stateConfig.plugins;
-      if (plugins && plugins.length > 0) {
-        this.instance.addPlugins(plugins);
-        return () => this.instance.removePlugins(plugins);
-      }
-    }
-    if (commandInput) {
-      const names = Object.keys(commandInput);
-      for (const name of names) {
-        this.instance.addCommand(name, commandInput[name]);
-      }
-      return () => {
-        for (const name of names) {
-          this.instance.removeCommand(name);
-        }
-      };
-    }
-    return voidFunction;
+    this.instance.updateExtension(extension, "add");
+    return () => this.instance.updateExtension(extension, "remove");
+  }
+  isNodeActive(nodeType, attrs) {
+    return isNodeActive(this.view.state, nodeType, attrs);
+  }
+  isMarkActive(markType, attrs) {
+    return isMarkActive(this.view.state, markType, attrs);
   }
 };
 
@@ -433,7 +650,7 @@ function withPriority(extension, priority) {
 
 // src/extensions/command.ts
 import "@prosekit/pm/model";
-import { AllSelection, Selection } from "@prosekit/pm/state";
+import { AllSelection } from "@prosekit/pm/state";
 import { findWrapping, insertPoint } from "@prosekit/pm/transform";
 function addCommands(commands) {
   return commandSlot.extension([commands]);
@@ -463,8 +680,6 @@ function addBaseCommands() {
           return false;
         if (dispatch) {
           const tr = state.tr.insert(insertPos, node);
-          const $pos = tr.doc.resolve(insertPos);
-          tr.setSelection(Selection.near($pos));
           dispatch(tr);
         }
         return true;
@@ -583,8 +798,8 @@ var inputRuleFacet = Facet.define({
 
 // src/extensions/keymap.ts
 import { baseKeymap, chainCommands } from "@prosekit/pm/commands";
-import { keymap as createKeymapPlugin } from "@prosekit/pm/keymap";
-import "@prosekit/pm/state";
+import { keydownHandler } from "@prosekit/pm/keymap";
+import { Plugin as Plugin3, PluginKey } from "@prosekit/pm/state";
 function addKeymap(keymap) {
   return keymapFacet.extension([keymap]);
 }
@@ -592,20 +807,38 @@ function addBaseKeymap() {
   return addKeymap(baseKeymap);
 }
 var keymapFacet = Facet.define({
-  combine: (keymaps) => {
-    const keymap = mergeKeymaps(keymaps);
-    const plugin = createKeymapPlugin(keymap);
-    return () => [plugin];
+  slot: () => {
+    let handler = null;
+    const handlerWrapper = (view, event) => {
+      if (handler)
+        return handler(view, event);
+      return false;
+    };
+    const plugin = new Plugin3({
+      key: keymapPluginKey,
+      props: { handleKeyDown: handlerWrapper }
+    });
+    const pluginFunc = () => [plugin];
+    return {
+      create: (keymaps) => {
+        handler = keydownHandler(mergeKeymaps(keymaps));
+        return pluginFunc;
+      },
+      update: (keymaps) => {
+        handler = keydownHandler(mergeKeymaps(keymaps));
+        return null;
+      }
+    };
   },
-  next: pluginFacet
+  next: pluginFacet,
+  single: true
 });
 function mergeKeymaps(keymaps) {
   const bindings = {};
   for (const keymap of keymaps) {
     for (const [key, command] of Object.entries(keymap)) {
-      if (!bindings[key])
-        bindings[key] = [];
-      bindings[key].push(command);
+      const commands = bindings[key] || (bindings[key] = []);
+      commands.push(command);
     }
   }
   return Object.fromEntries(
@@ -615,6 +848,7 @@ function mergeKeymaps(keymaps) {
     ])
   );
 }
+var keymapPluginKey = new PluginKey("prosekit-keymap");
 
 // src/extensions/mark-spec.ts
 function addMarkSpec(options) {
@@ -677,19 +911,6 @@ function addText() {
     }
   });
 }
-
-// src/utils/get-node-type.ts
-import "@prosekit/pm/model";
-function getNodeType(schema, type) {
-  if (typeof type === "string") {
-    const nodeType = schema.nodes[type];
-    if (!nodeType) {
-      throw new ProseKitError(`Cannot find ProseMirror node type "${type}"`);
-    }
-    return nodeType;
-  }
-  return type;
-}
 export {
   Editor,
   Facet,
@@ -714,5 +935,6 @@ export {
   getNodeType,
   pluginFacet,
   toggleMark,
+  toggleNode,
   withPriority
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -40,7 +40,7 @@
   "dependencies": {
     "@prosekit/pm": "^0.0.3",
     "orderedmap": "^2.1.1",
-    "type-fest": "^3.13.1"
+    "type-fest": "^4.0.0"
   },
   "devDependencies": {
     "@prosekit/dev": "*",

package/src/index.ts

@@ -1,4 +1,5 @@
-export { toggleMark } from './commands/toggle-mark'
+export { toggleMark, type ToggleMarkOptions } from './commands/toggle-mark'
+export { toggleNode, type ToggleNodeOptions } from './commands/toggle-node'
 export { Editor, createEditor, type EditorOptions } from './editor/editor'
 export { Facet, FacetExtension, type FacetOptions } from './editor/facet'
 export { defineExtension } from './editor/type-utils'
@@ -27,6 +28,7 @@ export {
   type ExtractCommandDispatchers,
   type ExtractMarks,
   type ExtractNodes,
+  type SimplifyExtension,
 } from './types/extension'
 export { type ExtensionTyping } from './types/extension-typing'
 export { Priority } from './types/priority'