@prosekit/core 0.0.0-next-20230627094841

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 ocavue
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/prosekit-core.js

@@ -0,0 +1,696 @@
+// src/commands/toggle-mark.ts
+import { toggleMark as baseToggleMark } from "@prosekit/pm/commands";
+
+// src/error.ts
+var ProseKitError = class extends Error {
+};
+
+// src/utils/get-mark-type.ts
+function getMarkType(schema, type) {
+  if (typeof type === "string") {
+    const markType = schema.marks[type];
+    if (!markType) {
+      throw new ProseKitError(`Cannot find mark type "${type}"`);
+    }
+    return markType;
+  }
+  return type;
+}
+
+// src/commands/toggle-mark.ts
+function toggleMark(options) {
+  return (state, dispatch, view) => {
+    return baseToggleMark(
+      getMarkType(state.schema, options.type),
+      options.attrs
+    )(state, dispatch, view);
+  };
+}
+
+// src/editor/editor.ts
+import { Schema } from "@prosekit/pm/model";
+import { EditorState } from "@prosekit/pm/state";
+import { EditorView } from "@prosekit/pm/view";
+
+// src/types/void-function.ts
+function voidFunction() {
+}
+
+// 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/facet.ts
+var nextIndex = 0;
+var Facet = class _Facet {
+  constructor(combine, next) {
+    /** @internal */
+    this.index = nextIndex++;
+    this.combine = combine;
+    this.next = next;
+  }
+  static define({ combine, next }) {
+    return new _Facet(combine, next);
+  }
+  /** @internal */
+  static defineSlot({
+    combine
+  }) {
+    return new _Facet(combine, null);
+  }
+  extension(inputs) {
+    return new FacetExtension(this, inputs);
+  }
+};
+var FacetExtension = class {
+  constructor(facet, inputs) {
+    this.facet = facet;
+    this.inputs = inputs;
+  }
+};
+function sortFacets(unsorted) {
+  var _a;
+  const facets = unsorted.filter((val) => val);
+  const facetMap = [];
+  const inbounds = [];
+  let facetCount = 0;
+  for (const facet of facets) {
+    const index = facet.index;
+    if (facetMap[index] != null) {
+      continue;
+    }
+    if (inbounds[index] == null) {
+      inbounds[index] = 0;
+    }
+    facetCount++;
+    facetMap[index] = facet;
+    if (facet.next) {
+      const nextIndex2 = facet.next.index;
+      if (inbounds[nextIndex2] == null) {
+        inbounds[nextIndex2] = 0;
+      }
+      inbounds[nextIndex2] += 1;
+      if (facetMap[nextIndex2] == null) {
+        facets.push(facet.next);
+      }
+    }
+  }
+  const sortedFacets = [];
+  const sortedIndexes = [];
+  inbounds.forEach((inbound, index) => {
+    if (inbound === 0) {
+      sortedIndexes.push(index);
+    }
+  });
+  for (const index of sortedIndexes) {
+    const facet = facetMap[index];
+    sortedFacets.push(facet);
+    const nextIndex2 = (_a = facet.next) == null ? void 0 : _a.index;
+    if (nextIndex2 == null)
+      continue;
+    inbounds[nextIndex2] -= 1;
+    if (inbounds[nextIndex2] === 0) {
+      sortedIndexes.push(nextIndex2);
+    }
+  }
+  if (facetCount !== sortedFacets.length) {
+    throw new Error(`Facet has circular dependency`);
+  }
+  return sortedFacets;
+}
+
+// src/editor/slot.ts
+import OrderedMap from "orderedmap";
+var schemaSlot = Facet.defineSlot({
+  combine: (specs) => {
+    var _a;
+    let nodes = OrderedMap.from({});
+    let marks = OrderedMap.from({});
+    let topNode = void 0;
+    for (const spec of specs) {
+      nodes = nodes.append(spec.nodes);
+      marks = marks.append((_a = spec.marks) != null ? _a : {});
+      topNode = topNode != null ? topNode : spec.topNode;
+    }
+    return { nodes, marks, topNode };
+  }
+});
+var stateSlot = Facet.defineSlot({
+  combine: (callbacks) => {
+    return (ctx) => {
+      var _a, _b, _c, _d, _e;
+      const configs = callbacks.map((cb) => cb(ctx));
+      const config = {
+        schema: ctx.schema,
+        storedMarks: [],
+        plugins: []
+      };
+      for (const c of configs) {
+        config.schema = (_a = config.schema) != null ? _a : c.schema;
+        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 : []];
+      }
+      if (!config.doc && !config.schema) {
+        throw new Error("Can't create state without a schema nor a document");
+      }
+      if (config.doc) {
+        config.schema = void 0;
+      }
+      return config;
+    };
+  }
+});
+var viewSlot = Facet.defineSlot({
+  combine: (props) => {
+    return Object.assign({}, ...props);
+  }
+});
+var commandSlot = Facet.defineSlot({
+  combine: (inputs) => {
+    return Object.assign({}, ...inputs);
+  }
+});
+
+// src/editor/flatten.ts
+function flatten(root) {
+  var _a;
+  const extensions = [root];
+  const priorities = [2 /* default */];
+  const facets = [];
+  const inputs = [];
+  while (extensions.length > 0) {
+    const ext = extensions.pop();
+    const pri = priorities.pop();
+    if (ext instanceof FacetExtension) {
+      const facet = ext.facet;
+      if (!facets[facet.index]) {
+        facets[facet.index] = facet;
+        inputs[facet.index] = [[], [], [], [], []];
+      }
+      const facetInputs = ext.inputs;
+      inputs[facet.index][pri].push(...facetInputs);
+    } else if (ext.extension) {
+      const p = (_a = ext.priority) != null ? _a : pri;
+      if (Array.isArray(ext.extension)) {
+        for (const e of ext.extension) {
+          extensions.push(e);
+          priorities.push(p);
+        }
+      } else {
+        extensions.push(ext.extension);
+        priorities.push(p);
+      }
+    } else {
+      throw new Error("Invalid 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 (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);
+        }
+      }
+    } 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");
+      }
+    }
+  }
+  return { schemaInput, stateInput, viewInput, commandInput };
+}
+
+// src/editor/editor.ts
+function createEditor({
+  extension
+}) {
+  const { schemaInput, stateInput, viewInput, commandInput } = flatten(extension);
+  if (!schemaInput) {
+    throw new Error("Schema must be defined");
+  }
+  const schema = new Schema(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);
+}
+var EditorInstance = class {
+  constructor(directEditorProps) {
+    this.directEditorProps = directEditorProps;
+    this.view = null;
+    this.commandDispatchers = {};
+    this.mount.bind(this);
+    this.unmount.bind(this);
+    this.schema = directEditorProps.state.schema;
+  }
+  mount(place) {
+    if (this.view) {
+      throw new Error("Editor is already mounted");
+    }
+    if (!place) {
+      throw new Error("Can't mount editor without a place");
+    }
+    this.view = new EditorView(place, this.directEditorProps);
+  }
+  unmount() {
+    if (!this.view) {
+      throw new Error("Editor is not mounted yet");
+    }
+    this.view.destroy();
+    this.view = null;
+  }
+  get assertView() {
+    if (!this.view)
+      throw new Error("Editor is not mounted");
+    return this.view;
+  }
+  addPlugins(plugins) {
+    const view = this.assertView;
+    const state = view.state;
+    const newPlugins = [...plugins, ...state.plugins];
+    const newState = state.reconfigure({ plugins: newPlugins });
+    view.setProps({ state: newState });
+  }
+  removePlugins(plugins) {
+    const view = this.view;
+    if (!view)
+      return;
+    const state = view.state;
+    const newPlugins = state.plugins.filter((p) => !plugins.includes(p));
+    const newState = state.reconfigure({ plugins: newPlugins });
+    view.setProps({ state: newState });
+  }
+  addCommand(name, commandCreator) {
+    const dispatcher = (...args) => {
+      const view = this.assertView;
+      const command = commandCreator(...args);
+      return command(view.state, view.dispatch.bind(view), view);
+    };
+    this.commandDispatchers[name] = dispatcher;
+  }
+  removeCommand(name) {
+    delete this.commandDispatchers[name];
+  }
+};
+var Editor = class _Editor {
+  constructor(instance) {
+    this.afterMounted = [];
+    this.instance = instance;
+  }
+  /** @internal */
+  static create(instance) {
+    if (!(instance instanceof EditorInstance)) {
+      throw new TypeError("Editor's instance is not EditorInstance");
+    }
+    return new _Editor(instance);
+  }
+  get mounted() {
+    return !!this.instance.view;
+  }
+  get view() {
+    return this.instance.assertView;
+  }
+  get schema() {
+    return this.instance.schema;
+  }
+  get commands() {
+    return this.instance.commandDispatchers;
+  }
+  mount(place) {
+    this.instance.mount(place);
+    this.afterMounted.forEach((callback) => callback());
+  }
+  unmount() {
+    this.instance.unmount();
+  }
+  use(extension) {
+    if (!this.mounted) {
+      let lazyRemove = null;
+      const lazyCreate = () => {
+        lazyRemove = this.use(extension);
+      };
+      this.afterMounted.push(lazyCreate);
+      return () => {
+        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;
+  }
+};
+
+// src/editor/type-utils.ts
+function defineExtension(extension) {
+  if (extension && Array.isArray(extension)) {
+    return { extension };
+  }
+  return extension;
+}
+
+// src/editor/with-priority.ts
+function withPriority(extension, priority) {
+  return { extension, priority };
+}
+
+// src/extensions/command.ts
+import { AllSelection, Selection } from "@prosekit/pm/state";
+import { findWrapping, insertPoint } from "@prosekit/pm/transform";
+function addCommands(commands) {
+  return commandSlot.extension([commands]);
+}
+function addBaseCommands() {
+  return addCommands({
+    insertText: ({
+      text,
+      from,
+      to
+    }) => {
+      return (state, dispatch) => {
+        if (text) {
+          dispatch == null ? void 0 : dispatch(state.tr.insertText(text, from, to));
+        }
+        return true;
+      };
+    },
+    insertNode: ({ node, pos }) => {
+      return (state, dispatch) => {
+        const insertPos = insertPoint(
+          state.doc,
+          pos != null ? pos : state.selection.to,
+          node.type
+        );
+        if (insertPos == null)
+          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;
+      };
+    },
+    wrap: ({
+      nodeType,
+      attrs
+    }) => {
+      return (state, dispatch) => {
+        const { $from, $to } = state.selection;
+        const range = $from.blockRange($to);
+        if (!range)
+          return false;
+        const wrapping = findWrapping(range, nodeType, attrs);
+        if (!wrapping)
+          return false;
+        dispatch == null ? void 0 : dispatch(state.tr.wrap(range, wrapping));
+        return true;
+      };
+    },
+    setBlockType: ({
+      nodeType,
+      attrs,
+      from,
+      to
+    }) => {
+      return (state, dispatch) => {
+        from = from != null ? from : state.selection.from;
+        to = from != null ? from : state.selection.from;
+        dispatch == null ? void 0 : dispatch(state.tr.setBlockType(from, to, nodeType, attrs));
+        return true;
+      };
+    },
+    selectAll: () => {
+      return (state, dispatch) => {
+        dispatch == null ? void 0 : dispatch(state.tr.setSelection(new AllSelection(state.doc)));
+        return true;
+      };
+    }
+  });
+}
+
+// src/extensions/node-spec.ts
+function addNodeSpec(options) {
+  return nodeSpecFacet.extension([options]);
+}
+var nodeSpecFacet = Facet.define({
+  combine: (options) => {
+    const nodes = {};
+    let topNode = void 0;
+    for (const { name, spec, topNode: isTopNode } of options) {
+      if (nodes[name]) {
+        throw new Error(`Node type ${name} has already been defined`);
+      }
+      nodes[name] = spec;
+      if (isTopNode && !topNode) {
+        topNode = name;
+      }
+    }
+    return { nodes, topNode };
+  },
+  next: schemaSlot
+});
+
+// src/extensions/doc.ts
+function addDoc() {
+  return addNodeSpec({
+    name: "doc",
+    spec: {
+      content: "block+"
+    }
+  });
+}
+
+// src/extensions/input-rules.ts
+import { inputRules } from "@prosekit/pm/inputrules";
+
+// src/extensions/plugin.ts
+function addPlugin({ plugins }) {
+  if (typeof plugins === "function") {
+    return pluginFacet.extension([plugins]);
+  } else if (Array.isArray(plugins)) {
+    return pluginFacet.extension([() => plugins]);
+  } else {
+    throw new TypeError("plugins must be a function or an array");
+  }
+}
+var pluginFacet = Facet.define({
+  combine: (callbacks) => {
+    return ({ schema }) => {
+      const plugins = callbacks.flatMap((func) => func({ schema }));
+      return { plugins };
+    };
+  },
+  next: stateSlot
+});
+
+// src/extensions/input-rules.ts
+function addInputRule(rules) {
+  return inputRuleFacet.extension([rules]);
+}
+var inputRuleFacet = Facet.define({
+  combine: (inputs) => {
+    return (context) => {
+      const rules = inputs.flatMap((callback) => callback(context));
+      return [inputRules({ rules })];
+    };
+  },
+  next: pluginFacet
+});
+
+// src/extensions/keymap.ts
+import { baseKeymap, chainCommands } from "@prosekit/pm/commands";
+import { keymap as createKeymapPlugin } from "@prosekit/pm/keymap";
+function addKeymap(keymap) {
+  return keymapFacet.extension([keymap]);
+}
+function addBaseKeymap() {
+  return addKeymap(baseKeymap);
+}
+var keymapFacet = Facet.define({
+  combine: (keymaps) => {
+    const keymap = mergeKeymaps(keymaps);
+    const plugin = createKeymapPlugin(keymap);
+    return () => [plugin];
+  },
+  next: pluginFacet
+});
+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);
+    }
+  }
+  return Object.fromEntries(
+    Object.entries(bindings).map(([key, commands]) => [
+      key,
+      chainCommands(...commands)
+    ])
+  );
+}
+
+// src/extensions/mark-spec.ts
+function addMarkSpec(options) {
+  return markSpecFacet.extension([options]);
+}
+var markSpecFacet = Facet.define({
+  combine: (options) => {
+    const marks = {};
+    for (const { name, spec } of options) {
+      if (marks[name]) {
+        throw new Error(`Mark type ${name} has already been defined`);
+      }
+      marks[name] = spec;
+    }
+    return { marks, nodes: {} };
+  },
+  next: schemaSlot
+});
+
+// src/extensions/node-view.ts
+import { Plugin as Plugin2 } from "@prosekit/pm/state";
+function addNodeView(options) {
+  return nodeViewFacet.extension([options]);
+}
+var nodeViewFacet = Facet.define({
+  combine: (inputs) => {
+    const nodeViews = {};
+    for (const input of inputs) {
+      if (!nodeViews[input.name]) {
+        nodeViews[input.name] = input.constructor;
+      }
+    }
+    return () => [new Plugin2({ props: { nodeViews } })];
+  },
+  next: pluginFacet
+});
+
+// src/extensions/paragraph.ts
+function addParagraph() {
+  return addNodeSpec({
+    name: "paragraph",
+    spec: {
+      content: "inline*",
+      group: "block",
+      parseDOM: [{ tag: "p" }],
+      toDOM() {
+        return ["p", 0];
+      }
+    }
+  });
+}
+
+// src/extensions/text.ts
+function addText() {
+  return addNodeSpec({
+    name: "text",
+    spec: {
+      group: "inline"
+    }
+  });
+}
+
+// src/utils/get-node-type.ts
+function getNodeType(schema, type) {
+  if (typeof type === "string") {
+    const nodeType = schema.nodes[type];
+    if (!nodeType) {
+      throw new ProseKitError(`Cannot find node type "${type}"`);
+    }
+    return nodeType;
+  }
+  return type;
+}
+export {
+  Editor,
+  Facet,
+  FacetExtension,
+  Priority,
+  ProseKitError,
+  addBaseCommands,
+  addBaseKeymap,
+  addCommands,
+  addDoc,
+  addInputRule,
+  addKeymap,
+  addMarkSpec,
+  addNodeSpec,
+  addNodeView,
+  addParagraph,
+  addPlugin,
+  addText,
+  createEditor,
+  defineExtension,
+  getMarkType,
+  getNodeType,
+  toggleMark,
+  withPriority
+};

package/dist/style.css

@@ -0,0 +1,52 @@
+/* ../../node_modules/.pnpm/prosemirror-view@1.31.5/node_modules/prosemirror-view/style/prosemirror.css */
+.ProseMirror {
+  position: relative;
+}
+.ProseMirror {
+  word-wrap: break-word;
+  white-space: pre-wrap;
+  white-space: break-spaces;
+  -webkit-font-variant-ligatures: none;
+  font-variant-ligatures: none;
+  font-feature-settings: "liga" 0;
+}
+.ProseMirror pre {
+  white-space: pre-wrap;
+}
+.ProseMirror li {
+  position: relative;
+}
+.ProseMirror-hideselection *::selection {
+  background: transparent;
+}
+.ProseMirror-hideselection *::-moz-selection {
+  background: transparent;
+}
+.ProseMirror-hideselection {
+  caret-color: transparent;
+}
+.ProseMirror-selectednode {
+  outline: 2px solid #8cf;
+}
+li.ProseMirror-selectednode {
+  outline: none;
+}
+li.ProseMirror-selectednode:after {
+  content: "";
+  position: absolute;
+  left: -32px;
+  right: -2px;
+  top: -2px;
+  bottom: -2px;
+  border: 2px solid #8cf;
+  pointer-events: none;
+}
+img.ProseMirror-separator {
+  display: inline !important;
+  border: none !important;
+  margin: 0 !important;
+}
+
+/* ../pm/src/view/style/prosemirror.css */
+
+/* src/style.css */

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@prosekit/core",
+  "type": "module",
+  "version": "0.0.0-next-20230627094841",
+  "private": false,
+  "author": {
+    "name": "ocavue",
+    "email": "ocavue@gmail.com"
+  },
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/ocavue",
+  "homepage": "https://github.com/ocavue/prosekit#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ocavue/prosekit.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/ocavue/prosekit/issues"
+  },
+  "keywords": [
+    "ProseMirror"
+  ],
+  "sideEffects": false,
+  "main": "./dist/prosekit-core.js",
+  "module": "./dist/prosekit-core.js",
+  "exports": {
+    ".": {
+      "types": "./dist/prosekit-core.d.ts",
+      "import": "./dist/prosekit-core.js",
+      "default": "./dist/prosekit-core.js"
+    },
+    "./style.css": {
+      "default": "./dist/style.css"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@prosekit/pm": "0.0.0-next-20230627094841",
+    "orderedmap": "^2.1.1",
+    "type-fest": "^3.12.0"
+  },
+  "devDependencies": {
+    "tsup": "^7.1.0",
+    "typescript": "^5.1.3",
+    "vitest": "^0.32.2",
+    "@prosekit/dev": "0.0.0"
+  },
+  "scripts": {
+    "build:tsup": "tsup",
+    "build:tsc": "tsc -b tsconfig.json"
+  },
+  "types": "./dist/prosekit-core.d.ts"
+}

package/src/index.ts

@@ -0,0 +1,30 @@
+export { toggleMark } from './commands/toggle-mark'
+export { Editor, createEditor, type EditorOptions } from './editor/editor'
+export { Facet, FacetExtension, type FacetOptions } from './editor/facet'
+export { defineExtension } from './editor/type-utils'
+export { withPriority } from './editor/with-priority'
+export { ProseKitError } from './error'
+export { addBaseCommands, addCommands } from './extensions/command'
+export { addDoc } from './extensions/doc'
+export { addInputRule } from './extensions/input-rules'
+export { addBaseKeymap, addKeymap, type Keymap } from './extensions/keymap'
+export { addMarkSpec, type MarkSpecOptions } from './extensions/mark-spec'
+export { addNodeSpec, type NodeSpecOptions } from './extensions/node-spec'
+export { addNodeView, type NodeViewOptions } from './extensions/node-view'
+export { addParagraph } from './extensions/paragraph'
+export { addPlugin, type PluginOptions } from './extensions/plugin'
+export { addText } from './extensions/text'
+export { type CommandArgs as CommandArgs } from './types/command'
+export * from './types/editor'
+export {
+  type Extension,
+  type ExtractCommandCreators,
+  type ExtractCommandDispatchers,
+  type ExtractMarks,
+  type ExtractNodes,
+} from './types/extension'
+export { type ExtensionTyping } from './types/extension-typing'
+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'