@prosekit/core 0.6.1 → 0.7.1

package/dist/chunk-YWQGKV6X.js

@@ -0,0 +1,863 @@
+// src/error.ts
+var ProseKitError = class extends Error {
+}, EditorNotFoundError = class extends ProseKitError {
+  constructor() {
+    super(
+      "Unable to find editor. Pass it as an argument or call this function inside a ProseKit component."
+    );
+  }
+}, DOMDocumentNotFoundError = class extends ProseKitError {
+  constructor() {
+    super(
+      "Unable to find browser Document. When not in the browser environment, you need to pass a DOM Document."
+    );
+  }
+};
+
+// src/utils/get-mark-type.ts
+import "@prosekit/pm/model";
+function getMarkType(schema, type) {
+  if (typeof type == "string") {
+    let markType = schema.marks[type];
+    if (!markType)
+      throw new ProseKitError(`Cannot find mark type "${type}"`);
+    return markType;
+  }
+  return type;
+}
+
+// src/utils/assert.ts
+function assert(condition, message = "Assertion failed") {
+  if (!condition)
+    throw new ProseKitError(message);
+}
+
+// src/utils/get-node-type.ts
+import "@prosekit/pm/model";
+function getNodeType(schema, type) {
+  if (typeof type == "string") {
+    let nodeType = schema.nodes[type];
+    if (!nodeType)
+      throw new ProseKitError(`Cannot find ProseMirror node type "${type}"`);
+    return nodeType;
+  }
+  return type;
+}
+
+// src/types/priority.ts
+var Priority = /* @__PURE__ */ ((Priority2) => (Priority2[Priority2.lowest = 0] = "lowest", Priority2[Priority2.low = 1] = "low", Priority2[Priority2.default = 2] = "default", Priority2[Priority2.high = 3] = "high", Priority2[Priority2.highest = 4] = "highest", Priority2))(Priority || {});
+
+// src/facets/facet.ts
+var facetCount = 0, Facet = class {
+  /**
+   * @internal
+   */
+  constructor(parent, singleton, _reducer, _reduce) {
+    this._reducer = _reducer;
+    this._reduce = _reduce;
+    /**
+     * @internal
+     */
+    this.index = facetCount++;
+    assert((_reduce || _reducer) && !(_reduce && _reducer)), this.parent = parent, this.singleton = singleton, this.path = parent ? [...parent.path, this.index] : [];
+  }
+  get reducer() {
+    var _a, _b;
+    return (_b = this._reducer) != null ? _b : (_a = this._reduce) == null ? void 0 : _a.call(this);
+  }
+};
+function defineFacet(options) {
+  var _a;
+  return new Facet(
+    options.parent,
+    (_a = options.singleton) != null ? _a : !1,
+    options.reducer,
+    options.reduce
+  );
+}
+
+// src/facets/base-extension.ts
+import "@prosekit/pm/model";
+
+// src/utils/array.ts
+function uniqPush(prev, next) {
+  let result = [...prev];
+  for (let item of next)
+    result.includes(item) || result.push(item);
+  return result;
+}
+function arraySubstract(a, b) {
+  return a.filter((x) => !b.includes(x));
+}
+function toReversed(arr) {
+  var _a, _b;
+  return (_b = (_a = arr.toReversed) == null ? void 0 : _a.call(arr)) != null ? _b : [...arr].reverse();
+}
+
+// src/utils/is-not-null.ts
+function isNotNull(value) {
+  return value != null;
+}
+
+// src/facets/facet-node.ts
+function zip5(a, b, mapper) {
+  return [
+    mapper(a[0], b[0]),
+    mapper(a[1], b[1]),
+    mapper(a[2], b[2]),
+    mapper(a[3], b[3]),
+    mapper(a[4], b[4])
+  ];
+}
+function unionInput(a, b) {
+  return !a && !b ? null : uniqPush(a != null ? a : [], b != null ? b : []);
+}
+function subtractInput(a, b) {
+  return a ? b ? arraySubstract(a, b) : [...a] : null;
+}
+function unionChildren(a, b) {
+  let merged = new Map(a);
+  for (let [key, valueB] of b.entries()) {
+    let valueA = a.get(key);
+    merged.set(key, valueA ? unionFacetNode(valueA, valueB) : valueB);
+  }
+  return merged;
+}
+function subtractChildren(a, b) {
+  let merged = new Map(a);
+  for (let [key, valueB] of b.entries()) {
+    let valueA = a.get(key);
+    valueA && merged.set(key, subtractFacetNode(valueA, valueB));
+  }
+  return merged;
+}
+function unionFacetNode(a, b) {
+  return assert(a.facet === b.facet), new FacetNode(
+    a.facet,
+    zip5(a.inputs, b.inputs, unionInput),
+    unionChildren(a.children, b.children),
+    a.reducers
+  );
+}
+function subtractFacetNode(a, b) {
+  return assert(a.facet === b.facet), new FacetNode(
+    a.facet,
+    zip5(a.inputs, b.inputs, subtractInput),
+    subtractChildren(a.children, b.children),
+    a.reducers
+  );
+}
+var FacetNode = class {
+  constructor(facet, inputs = [null, null, null, null, null], children = /* @__PURE__ */ new Map(), reducers = [
+    null,
+    null,
+    null,
+    null,
+    null
+  ]) {
+    this.facet = facet;
+    this.inputs = inputs;
+    this.children = children;
+    this.reducers = reducers;
+    this.output = null;
+  }
+  calcOutput() {
+    var _a, _b, _c;
+    let inputs = [null, null, null, null, null], output = [null, null, null, null, null];
+    for (let pri = 0; pri < 5; pri++) {
+      let input = this.inputs[pri];
+      input && (inputs[pri] = [...input]);
+    }
+    for (let child of this.children.values()) {
+      let childOutput = child.getOutput();
+      for (let pri = 0; pri < 5; pri++)
+        childOutput[pri] && (inputs[pri] || (inputs[pri] = [])).push(childOutput[pri]);
+    }
+    if (this.facet.singleton) {
+      let reducer = (_a = this.reducers)[_b = 2 /* default */] || (_a[_b] = this.facet.reducer), input = inputs.filter(isNotNull).flat();
+      output[2 /* default */] = reducer(input);
+    } else
+      for (let pri = 0; pri < 5; pri++) {
+        let input = inputs[pri];
+        if (input) {
+          let reducer = (_c = this.reducers)[pri] || (_c[pri] = this.facet.reducer);
+          output[pri] = reducer(input);
+        }
+      }
+    return output;
+  }
+  getOutput() {
+    return this.output || (this.output = this.calcOutput()), this.output;
+  }
+  getSingletonOutput() {
+    return assert(this.facet.singleton), this.getOutput()[2 /* default */];
+  }
+  getRootOutput() {
+    assert(this.isRoot());
+    let output = this.getSingletonOutput();
+    return assert(output), output;
+  }
+  isRoot() {
+    return !this.facet.parent;
+  }
+};
+
+// src/facets/schema.ts
+import { Schema as Schema3 } from "@prosekit/pm/model";
+
+// src/facets/root.ts
+function rootReducer(inputs) {
+  var _a;
+  let schema, commands, stateFunc, view;
+  for (let input of inputs)
+    schema = input.schema || schema, commands = input.commands || commands, stateFunc = input.state || stateFunc, view = input.view || view;
+  let state = schema && ((_a = stateFunc == null ? void 0 : stateFunc({ schema })) != null ? _a : { schema });
+  return { schema, state, commands, view };
+}
+var rootFacet = new Facet(
+  null,
+  !0,
+  rootReducer
+);
+
+// src/facets/schema.ts
+var schemaFacet = defineFacet({
+  reducer: (specs) => {
+    assert(specs.length <= 1);
+    let spec = specs[0];
+    return { schema: spec ? new Schema3(spec) : null };
+  },
+  parent: rootFacet,
+  singleton: !0
+});
+
+// src/facets/base-extension.ts
+var BaseExtension = class {
+  constructor() {
+    this.extension = [];
+    this.trees = [null, null, null, null, null];
+  }
+  /**
+   * @internal
+   */
+  getTree(priority) {
+    var _a, _b;
+    let pri = (_a = priority != null ? priority : this.priority) != null ? _a : 2 /* default */;
+    return (_b = this.trees)[pri] || (_b[pri] = this.createTree(pri));
+  }
+  /**
+   * @internal
+   */
+  findFacetOutput(facet) {
+    var _a;
+    let node = this.getTree();
+    for (let index of facet.path)
+      node = node == null ? void 0 : node.children.get(index);
+    return (_a = node == null ? void 0 : node.getOutput()) != null ? _a : null;
+  }
+  get schema() {
+    var _a, _b;
+    let output = this.findFacetOutput(schemaFacet);
+    return (_b = (_a = output == null ? void 0 : output.find(Boolean)) == null ? void 0 : _a.schema) != null ? _b : null;
+  }
+};
+
+// src/facets/facet-extension.ts
+var FacetExtensionImpl = class extends BaseExtension {
+  /**
+   * @internal
+   */
+  constructor(facet, payloads) {
+    super();
+    this.facet = facet;
+    this.payloads = payloads;
+  }
+  /**
+   * @internal
+   */
+  createTree(priority) {
+    var _a;
+    let pri = (_a = this.priority) != null ? _a : priority, inputs = [null, null, null, null, null];
+    inputs[pri] = [...this.payloads];
+    let node = new FacetNode(this.facet, inputs);
+    for (; node.facet.parent; ) {
+      let children = /* @__PURE__ */ new Map([[node.facet.index, node]]);
+      node = new FacetNode(node.facet.parent, void 0, children);
+    }
+    return node;
+  }
+};
+function defineFacetPayload(facet, payloads) {
+  return new FacetExtensionImpl(facet, payloads);
+}
+
+// src/utils/parse.ts
+import { DOMParser, DOMSerializer } from "@prosekit/pm/model";
+import { EditorState } from "@prosekit/pm/state";
+
+// src/utils/get-dom-api.ts
+function findGlobalBrowserDocument() {
+  if (typeof document != "undefined")
+    return document;
+  if (typeof globalThis != "undefined" && globalThis.document)
+    return globalThis.document;
+}
+function findGlobalBrowserWindow() {
+  if (typeof window != "undefined")
+    return window;
+  if (typeof globalThis != "undefined" && globalThis.window)
+    return globalThis.window;
+}
+function findBrowserDocument(options) {
+  var _a, _b, _c;
+  return (_c = (_a = options == null ? void 0 : options.document) != null ? _a : findGlobalBrowserDocument()) != null ? _c : (_b = findGlobalBrowserWindow()) == null ? void 0 : _b.document;
+}
+function findBrowserWindow(options) {
+  var _a, _b, _c, _d;
+  return (_d = (_b = (_a = options == null ? void 0 : options.document) == null ? void 0 : _a.defaultView) != null ? _b : findGlobalBrowserWindow()) != null ? _d : (_c = findBrowserDocument(options)) == null ? void 0 : _c.defaultView;
+}
+function getBrowserDocument(options) {
+  let doc = findBrowserDocument(options);
+  if (doc) return doc;
+  throw new DOMDocumentNotFoundError();
+}
+function getBrowserWindow(options) {
+  let win = findBrowserWindow(options);
+  if (win) return win;
+  throw new DOMDocumentNotFoundError();
+}
+
+// src/utils/parse.ts
+function jsonFromState(state) {
+  return state.toJSON();
+}
+function stateFromJSON(json, options) {
+  return EditorState.fromJSON({ schema: options.schema }, json);
+}
+function jsonFromNode(node) {
+  return node.toJSON();
+}
+function nodeFromJSON(json, options) {
+  return options.schema.nodeFromJSON(json);
+}
+function nodeFromElement(element, options) {
+  let { DOMParser: CustomDOMParser, schema, ...parseOptions } = options;
+  return (CustomDOMParser || DOMParser).fromSchema(schema).parse(element, parseOptions);
+}
+function elementFromNode(node, options) {
+  let Serializer = (options == null ? void 0 : options.DOMSerializer) || DOMSerializer, document2 = getBrowserDocument(options), schema = node.type.schema, serializer = Serializer.fromSchema(schema);
+  return schema.topNodeType !== node.type ? serializer.serializeNode(node, { document: document2 }) : serializer.serializeFragment(
+    node.content,
+    { document: document2 },
+    document2.createElement("div")
+  );
+}
+function elementFromHTML(html, options) {
+  let win = getBrowserWindow(options);
+  return new win.DOMParser().parseFromString(`<body><div>${html}</div></body>`, "text/html").body.firstElementChild;
+}
+function htmlFromElement(element) {
+  return element.outerHTML;
+}
+function nodeFromHTML(html, options) {
+  return nodeFromElement(elementFromHTML(html, options), options);
+}
+function htmlFromNode(node, options) {
+  return elementFromNode(node, options).outerHTML;
+}
+function jsonFromElement(element, options) {
+  return jsonFromNode(nodeFromElement(element, options));
+}
+function elementFromJSON(json, options) {
+  return elementFromNode(nodeFromJSON(json, options), options);
+}
+function jsonFromHTML(html, options) {
+  return jsonFromElement(elementFromHTML(html, options), options);
+}
+function htmlFromJSON(json, options) {
+  return htmlFromElement(elementFromJSON(json, options));
+}
+
+// src/extensions/default-state.ts
+import { Selection } from "@prosekit/pm/state";
+
+// src/facets/state.ts
+var stateFacet = defineFacet({
+  reduce: () => {
+    let callbacks = [], state = (ctx) => {
+      var _a, _b, _c, _d, _e, _f;
+      let configs = callbacks.map((cb) => cb(ctx)), config = {
+        schema: ctx.schema,
+        storedMarks: [],
+        plugins: []
+      };
+      for (let 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 = uniqPush((_e = config.plugins) != null ? _e : [], (_f = c.plugins) != null ? _f : []);
+      return assert(
+        config.doc || config.schema,
+        "Can't create state without a schema nor a document"
+      ), config.doc && (config.schema = void 0), config;
+    };
+    return function(inputs) {
+      return callbacks = inputs, { state };
+    };
+  },
+  singleton: !0,
+  parent: rootFacet
+});
+
+// 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 defineFacetPayload(stateFacet, [
+    ({ schema }) => {
+      let config = {};
+      return defaultHTML && (typeof defaultHTML == "string" ? defaultDoc = jsonFromHTML(defaultHTML, { schema }) : defaultDoc = jsonFromElement(defaultHTML, { schema })), defaultDoc && (config.doc = schema.nodeFromJSON(defaultDoc), defaultSelection && (config.selection = Selection.fromJSON(config.doc, defaultSelection))), config;
+    }
+  ]);
+}
+
+// src/utils/is-mark-absent.ts
+function isMarkAbsent(node, from, to, markType, attrs) {
+  let mark = attrs ? markType.create(attrs) : markType, missing = !1;
+  return node.nodesBetween(from, to, (node2, pos, parent) => {
+    if (missing) return !1;
+    missing = !mark.isInSet(node2.marks) && !!parent && parent.type.allowsMarkType(markType);
+  }), missing;
+}
+
+// src/utils/is-mark-active.ts
+function isMarkActive(state, type, attrs) {
+  let { from, $from, to, empty } = state.selection, markType = getMarkType(state.schema, type);
+  return empty ? !!(attrs ? markType.create(attrs) : markType).isInSet(state.storedMarks || $from.marks()) : !isMarkAbsent(state.doc, from, to, markType, attrs);
+}
+
+// src/utils/type-assertion.ts
+import { Mark, ProseMirrorNode } from "@prosekit/pm/model";
+import {
+  AllSelection,
+  NodeSelection,
+  TextSelection
+} from "@prosekit/pm/state";
+function isProseMirrorNode(node) {
+  return node instanceof ProseMirrorNode;
+}
+function isMark(mark) {
+  return mark instanceof Mark;
+}
+function isTextSelection(sel) {
+  return sel instanceof TextSelection;
+}
+function isNodeSelection(sel) {
+  return sel instanceof NodeSelection;
+}
+function isAllSelection(sel) {
+  return sel instanceof AllSelection;
+}
+
+// src/facets/union-extension.ts
+var UnionExtensionImpl = class extends BaseExtension {
+  /**
+   * @internal
+   */
+  constructor(extension = []) {
+    super();
+    this.extension = extension;
+  }
+  /**
+   * @internal
+   */
+  createTree(priority) {
+    var _a;
+    let pri = (_a = this.priority) != null ? _a : priority, extensions = [...this.extension];
+    extensions.sort((a, b) => {
+      var _a2, _b;
+      return ((_a2 = a.priority) != null ? _a2 : pri) - ((_b = b.priority) != null ? _b : pri);
+    });
+    let children = extensions.map((ext) => ext.getTree(pri));
+    assert(children.length > 0);
+    let node = children[0];
+    for (let i = 1; i < children.length; i++)
+      node = unionFacetNode(node, children[i]);
+    return node;
+  }
+};
+
+// src/editor/union.ts
+function union(extension) {
+  let array = Array.isArray(extension) ? extension : [extension];
+  return assert(array.length > 0, "At least one extension is required"), new UnionExtensionImpl(
+    array
+  );
+}
+
+// src/editor/editor.ts
+import "@prosekit/pm/model";
+import { EditorState as EditorState2 } from "@prosekit/pm/state";
+import { EditorView } from "@prosekit/pm/view";
+
+// src/utils/deep-equals.ts
+import OrderedMap from "orderedmap";
+function deepEquals(a, b) {
+  if (a === b)
+    return !0;
+  if (!a || !b)
+    return !1;
+  if (Array.isArray(a) && Array.isArray(b))
+    return a.length === b.length && a.every((x, i) => deepEquals(x, b[i]));
+  if (a instanceof OrderedMap && b instanceof OrderedMap)
+    return a.size === b.size && deepEquals(a.toObject(), b.toObject());
+  if (typeof a == "object" && typeof b == "object") {
+    let aKeys = Object.keys(a), bKeys = Object.keys(b);
+    return aKeys.length === bKeys.length && aKeys.every((key) => deepEquals(a[key], b[key]));
+  }
+  return !1;
+}
+
+// src/editor/builder.ts
+import "@prosekit/pm/model";
+
+// src/utils/attrs-match.ts
+function attrsMatch(nodeOrMark, attrs) {
+  let currentAttrs = nodeOrMark.attrs;
+  for (let [key, value] of Object.entries(attrs))
+    if (currentAttrs[key] !== value)
+      return !1;
+  return !0;
+}
+
+// src/utils/is-node-active.ts
+function isNodeActive(state, type, attrs) {
+  let $pos = state.selection.$from, nodeType = getNodeType(state.schema, type);
+  for (let depth = $pos.depth; depth >= 0; depth--) {
+    let node = $pos.node(depth);
+    if (node.type === nodeType && (!attrs || attrsMatch(node, attrs)))
+      return !0;
+  }
+  return !1;
+}
+
+// src/editor/builder.ts
+function createNodeBuilders(schema, getState, createNode = defaultCreateNode) {
+  let builders = {};
+  for (let type of Object.values(schema.nodes)) {
+    let builder = (...args) => buildNode(type, args, createNode);
+    builder.isActive = (attrs) => {
+      let state = getState();
+      return state ? isNodeActive(state, type, attrs) : !1;
+    }, builders[type.name] = builder;
+  }
+  return builders;
+}
+function createMarkBuilders(schema, getState, applyMark = defaultApplyMark) {
+  let builders = {};
+  for (let type of Object.values(schema.marks)) {
+    let builder = (...args) => buildMark(type, args, applyMark);
+    builder.isActive = (attrs) => {
+      let state = getState();
+      return state ? isMarkActive(state, type, attrs) : !1;
+    }, builders[type.name] = builder;
+  }
+  return builders;
+}
+function buildMark(type, args, applyMark) {
+  let [attrs, children] = normalizeArgs(args), mark = type.create(attrs);
+  return applyMark(mark, flattenChildren(type.schema, children));
+}
+var defaultApplyMark = (mark, children) => children.map((child) => child.mark([mark]));
+function buildNode(type, args, createNode) {
+  let [attrs, children] = normalizeArgs(args);
+  return createNode(type, attrs, flattenChildren(type.schema, children));
+}
+var defaultCreateNode = (type, attrs, children) => {
+  let node = type.createAndFill(attrs, children);
+  return assert(node, `Failed to create node ${type.name}`), node;
+};
+function flattenChildren(schema, children) {
+  let nodes = [];
+  for (let child of children)
+    if (typeof child == "string")
+      child && nodes.push(schema.text(child, null));
+    else if (Array.isArray(child))
+      nodes.push(...flattenChildren(schema, child));
+    else if (isProseMirrorNode(child))
+      nodes.push(child);
+    else
+      throw new ProseKitError(`Invalid node child: ${typeof child}`);
+  return nodes;
+}
+function normalizeArgs(args) {
+  let [attrs, ...children] = args;
+  return isNodeChild(attrs) ? (children.unshift(attrs), [null, children]) : typeof attrs == "object" ? [attrs, children] : [null, children];
+}
+function isNodeChild(value) {
+  return value ? typeof value == "string" || Array.isArray(value) || isProseMirrorNode(value) : !1;
+}
+
+// src/editor/editor.ts
+function setupEditorExtension(options) {
+  let { defaultDoc, defaultHTML, defaultSelection } = options;
+  return defaultDoc || defaultHTML ? union([
+    options.extension,
+    defineDefaultState({
+      defaultDoc,
+      defaultHTML,
+      defaultSelection
+    })
+  ]) : options.extension;
+}
+function createEditor(options) {
+  let extension = setupEditorExtension(options);
+  return Editor.create(new EditorInstance(extension));
+}
+var EditorInstance = class {
+  constructor(extension) {
+    this.view = null;
+    this.commandAppliers = {};
+    this.getState = () => {
+      var _a;
+      return ((_a = this.view) == null ? void 0 : _a.state) || this.directEditorProps.state;
+    };
+    this.tree = extension.getTree();
+    let payload = this.tree.getRootOutput(), schema = payload.schema, stateConfig = payload.state;
+    assert(schema && stateConfig, "Schema must be defined");
+    let state = EditorState2.create(stateConfig);
+    if (payload.commands)
+      for (let [name, commandCreator] of Object.entries(payload.commands))
+        this.defineCommand(name, commandCreator);
+    this.nodeBuilders = createNodeBuilders(state.schema, this.getState), this.markBuilders = createMarkBuilders(state.schema, this.getState), this.schema = state.schema, this.directEditorProps = { state, ...payload.view };
+  }
+  updateState(state) {
+    this.view ? this.view.updateState(state) : this.directEditorProps.state = state;
+  }
+  updateExtension(extension, add) {
+    var _a, _b, _c, _d;
+    let view = this.view;
+    if (!view || view.isDestroyed)
+      return;
+    let tree = extension.getTree(), payload = tree.getRootOutput();
+    if (payload != null && payload.schema)
+      throw new ProseKitError("Schema cannot be changed");
+    if (payload != null && payload.view)
+      throw new ProseKitError("View cannot be changed");
+    let oldPayload = this.tree.getRootOutput(), oldPlugins = [...(_b = (_a = view.state) == null ? void 0 : _a.plugins) != null ? _b : []];
+    this.tree = add ? unionFacetNode(this.tree, tree) : subtractFacetNode(this.tree, tree);
+    let newPayload = this.tree.getRootOutput(), newPlugins = [...(_d = (_c = newPayload == null ? void 0 : newPayload.state) == null ? void 0 : _c.plugins) != null ? _d : []];
+    if (!deepEquals(oldPlugins, newPlugins)) {
+      let state = view.state.reconfigure({ plugins: newPlugins });
+      view.updateState(state);
+    }
+    if (newPayload != null && newPayload.commands && !deepEquals(oldPayload == null ? void 0 : oldPayload.commands, newPayload == null ? void 0 : newPayload.commands)) {
+      let commands = newPayload.commands, names = Object.keys(commands);
+      for (let name of names)
+        this.defineCommand(name, commands[name]);
+    }
+  }
+  mount(place) {
+    if (this.view)
+      throw new ProseKitError("Editor is already mounted");
+    if (!place)
+      throw new ProseKitError("Can't mount editor without a place");
+    this.view = new EditorView({ mount: place }, this.directEditorProps);
+  }
+  unmount() {
+    if (!this.view)
+      throw new ProseKitError("Editor is not mounted yet");
+    this.directEditorProps.state = this.view.state, this.view.destroy(), this.view = null;
+  }
+  get mounted() {
+    return !!this.view && !this.view.isDestroyed;
+  }
+  get assertView() {
+    if (!this.view)
+      throw new ProseKitError("Editor is not mounted");
+    return this.view;
+  }
+  definePlugins(plugins) {
+    let view = this.assertView, state = view.state, newPlugins = [...plugins, ...state.plugins], newState = state.reconfigure({ plugins: newPlugins });
+    view.setProps({ state: newState });
+  }
+  removePlugins(plugins) {
+    let view = this.view;
+    if (!view) return;
+    let state = view.state, newPlugins = state.plugins.filter((p) => !plugins.includes(p)), newState = state.reconfigure({ plugins: newPlugins });
+    view.setProps({ state: newState });
+  }
+  defineCommand(name, commandCreator) {
+    let applier = (...args) => {
+      let view = this.view;
+      return assert(view, `Cannot call command "${name}" before the editor is mounted`), commandCreator(...args)(view.state, view.dispatch.bind(view), view);
+    };
+    applier.canApply = (...args) => {
+      let view = this.view;
+      return view ? commandCreator(...args)(view.state, void 0, view) : !1;
+    }, this.commandAppliers[name] = applier;
+  }
+  removeCommand(name) {
+    delete this.commandAppliers[name];
+  }
+}, Editor = class _Editor {
+  /**
+   * @internal
+   */
+  constructor(instance) {
+    this.afterMounted = [];
+    this.instance = instance, this.mount = this.mount.bind(this), this.unmount = this.unmount.bind(this), this.use = this.use.bind(this);
+  }
+  /**
+   * @internal
+   */
+  static create(instance) {
+    if (!(instance instanceof EditorInstance))
+      throw new TypeError("Invalid EditorInstance");
+    return new _Editor(instance);
+  }
+  /**
+   * Whether the editor is mounted.
+   */
+  get mounted() {
+    return this.instance.mounted;
+  }
+  /**
+   * The editor view.
+   */
+  get view() {
+    return this.instance.assertView;
+  }
+  /**
+   * The editor schema.
+   */
+  get schema() {
+    return this.instance.schema;
+  }
+  /**
+   * All commands defined by the editor.
+   */
+  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 : !1;
+  }
+  /**
+   * Mount the editor to the given HTML element.
+   * Pass `null` or `undefined` to unmount the editor.
+   */
+  mount(place) {
+    if (!place)
+      return this.unmount();
+    this.instance.mount(place), this.afterMounted.forEach((callback) => callback());
+  }
+  /**
+   * Unmount the editor. This is equivalent to `mount(null)`.
+   */
+  unmount() {
+    this.mounted && this.instance.unmount();
+  }
+  /**
+   * Focus the editor.
+   */
+  focus() {
+    var _a;
+    (_a = this.instance.view) == null || _a.focus();
+  }
+  /**
+   * Blur the editor.
+   */
+  blur() {
+    var _a;
+    (_a = this.instance.view) == null || _a.dom.blur();
+  }
+  /**
+   * Register an extension to the editor. Return a function to unregister the
+   * extension.
+   */
+  use(extension) {
+    if (!this.mounted) {
+      let canceled = !1, lazyRemove = null, lazyCreate = () => {
+        canceled || (lazyRemove = this.use(extension));
+      };
+      return this.afterMounted.push(lazyCreate), () => {
+        canceled = !0, lazyRemove == null || lazyRemove();
+      };
+    }
+    return this.instance.updateExtension(extension, !0), () => this.instance.updateExtension(extension, !1);
+  }
+  /**
+   * The editor's current state.
+   */
+  get state() {
+    return this.instance.getState();
+  }
+  /**
+   * Update the editor's state.
+   *
+   * @remarks
+   *
+   * This is an advanced method. Use it only if you have a specific reason to
+   * directly manipulate the editor's state.
+   */
+  updateState(state) {
+    this.instance.updateState(state);
+  }
+  get nodes() {
+    return this.instance.nodeBuilders;
+  }
+  get marks() {
+    return this.instance.markBuilders;
+  }
+};
+
+export {
+  ProseKitError,
+  EditorNotFoundError,
+  getMarkType,
+  assert,
+  getNodeType,
+  isNodeActive,
+  Priority,
+  toReversed,
+  isNotNull,
+  defineFacet,
+  rootFacet,
+  schemaFacet,
+  defineFacetPayload,
+  stateFacet,
+  jsonFromState,
+  stateFromJSON,
+  jsonFromNode,
+  nodeFromJSON,
+  nodeFromElement,
+  elementFromNode,
+  nodeFromHTML,
+  htmlFromNode,
+  elementFromJSON,
+  jsonFromHTML,
+  htmlFromJSON,
+  defineDefaultState,
+  isMarkAbsent,
+  isMarkActive,
+  isProseMirrorNode,
+  isMark,
+  isTextSelection,
+  isNodeSelection,
+  isAllSelection,
+  createNodeBuilders,
+  createMarkBuilders,
+  union,
+  setupEditorExtension,
+  createEditor,
+  EditorInstance,
+  Editor
+};