@prosekit/core 0.8.0 → 0.8.1

package/dist/chunk-B3WEP4DD.js

@@ -1,1188 +0,0 @@
-// src/error.ts
-var ProseKitError = class extends Error {
-};
-var EditorNotFoundError = class extends ProseKitError {
-  constructor() {
-    super(
-      "Unable to find editor. Pass it as an argument or call this function inside a ProseKit component."
-    );
-  }
-};
-var 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
-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/utils/assert.ts
-function assert(condition, message = "Assertion failed") {
-  if (!condition) {
-    throw new ProseKitError(message);
-  }
-}
-
-// 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 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";
-  return Priority2;
-})(Priority || {});
-
-// src/facets/facet.ts
-var facetCount = 0;
-var 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() {
-    return this._reducer ?? this._reduce?.();
-  }
-};
-function defineFacet(options) {
-  return new Facet(
-    options.parent,
-    options.singleton ?? false,
-    options.reducer,
-    options.reduce
-  );
-}
-
-// src/utils/type-assertion.ts
-import {
-  Fragment,
-  Mark,
-  ProseMirrorNode,
-  Slice
-} from "@prosekit/pm/model";
-import {
-  AllSelection,
-  NodeSelection,
-  Selection,
-  TextSelection
-} from "@prosekit/pm/state";
-function isProseMirrorNode(node) {
-  return node instanceof ProseMirrorNode;
-}
-function isMark(mark) {
-  return mark instanceof Mark;
-}
-function isFragment(fragment) {
-  return fragment instanceof Fragment;
-}
-function isSlice(slice) {
-  return slice instanceof Slice;
-}
-function isSelection(sel) {
-  return sel instanceof Selection;
-}
-function isTextSelection(sel) {
-  return sel instanceof TextSelection;
-}
-function isNodeSelection(sel) {
-  return sel instanceof NodeSelection;
-}
-function isAllSelection(sel) {
-  return sel instanceof AllSelection;
-}
-function isNotNullish(value) {
-  return value != null;
-}
-
-// src/facets/schema.ts
-import {
-  Schema
-} from "@prosekit/pm/model";
-
-// src/facets/root.ts
-function rootReducer(inputs) {
-  let schema;
-  let commands;
-  let stateFunc;
-  let view;
-  for (const input of inputs) {
-    schema = input.schema || schema;
-    commands = input.commands || commands;
-    stateFunc = input.state || stateFunc;
-    view = input.view || view;
-  }
-  const state = schema && (stateFunc?.({ schema }) ?? { schema });
-  return { schema, state, commands, view };
-}
-var rootFacet = new Facet(null, true, rootReducer);
-
-// src/facets/schema.ts
-var schemaFacet = defineFacet({
-  reducer: (specs) => {
-    assert(specs.length <= 1);
-    const spec = specs[0];
-    const schema = spec ? new Schema(spec) : null;
-    return { schema };
-  },
-  parent: rootFacet,
-  singleton: true
-});
-
-// src/facets/base-extension.ts
-var BaseExtension = class {
-  constructor() {
-    this.trees = [null, null, null, null, null];
-  }
-  /**
-   * @internal
-   */
-  getTree(priority) {
-    var _a;
-    const pri = priority ?? this.priority ?? 2 /* default */;
-    return (_a = this.trees)[pri] || (_a[pri] = this.createTree(pri));
-  }
-  /**
-   * @internal
-   */
-  findFacetOutput(facet) {
-    let node = this.getTree();
-    for (const index of facet.path) {
-      node = node?.children.get(index);
-    }
-    return node?.getOutput() ?? null;
-  }
-  get schema() {
-    const output = this.findFacetOutput(schemaFacet);
-    return output?.find(Boolean)?.schema ?? null;
-  }
-};
-
-// src/utils/array.ts
-function uniqPush(prev, next) {
-  const result = [...prev];
-  for (const item of next) {
-    if (!result.includes(item)) {
-      result.push(item);
-    }
-  }
-  return result;
-}
-function arraySubstract(a, b) {
-  return a.filter((x) => !b.includes(x));
-}
-function toReversed(arr) {
-  return arr.toReversed?.() ?? [...arr].reverse();
-}
-
-// 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) {
-  if (!a && !b) return null;
-  return uniqPush(a ?? [], b ?? []);
-}
-function subtractInput(a, b) {
-  if (!a) return null;
-  if (!b) return [...a];
-  return arraySubstract(a, b);
-}
-function unionChildren(a, b) {
-  const merged = new Map(a);
-  for (const [key, valueB] of b.entries()) {
-    const valueA = a.get(key);
-    merged.set(key, valueA ? unionFacetNode(valueA, valueB) : valueB);
-  }
-  return merged;
-}
-function subtractChildren(a, b) {
-  const merged = new Map(a);
-  for (const [key, valueB] of b.entries()) {
-    const valueA = a.get(key);
-    if (valueA) {
-      merged.set(key, subtractFacetNode(valueA, valueB));
-    }
-  }
-  return merged;
-}
-function unionFacetNode(a, b) {
-  assert(a.facet === b.facet);
-  return new FacetNode(
-    a.facet,
-    zip5(a.inputs, b.inputs, unionInput),
-    unionChildren(a.children, b.children),
-    a.reducers
-  );
-}
-function subtractFacetNode(a, b) {
-  assert(a.facet === b.facet);
-  return 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;
-    const inputs = [null, null, null, null, null];
-    const output = [null, null, null, null, null];
-    for (let pri = 0; pri < 5; pri++) {
-      const input = this.inputs[pri];
-      if (input) {
-        inputs[pri] = [...input];
-      }
-    }
-    for (const child of this.children.values()) {
-      const childOutput = child.getOutput();
-      for (let pri = 0; pri < 5; pri++) {
-        if (childOutput[pri]) {
-          const input = inputs[pri] || (inputs[pri] = []);
-          input.push(childOutput[pri]);
-        }
-      }
-    }
-    if (this.facet.singleton) {
-      const reducer = (_a = this.reducers)[_b = 2 /* default */] || (_a[_b] = this.facet.reducer);
-      const input = inputs.filter(isNotNullish).flat();
-      output[2 /* default */] = reducer(input);
-    } else {
-      for (let pri = 0; pri < 5; pri++) {
-        const input = inputs[pri];
-        if (input) {
-          const reducer = (_c = this.reducers)[pri] || (_c[pri] = this.facet.reducer);
-          output[pri] = reducer(input);
-        }
-      }
-    }
-    return output;
-  }
-  getOutput() {
-    if (!this.output) {
-      this.output = this.calcOutput();
-    }
-    return this.output;
-  }
-  getSingletonOutput() {
-    assert(this.facet.singleton);
-    return this.getOutput()[2 /* default */];
-  }
-  getRootOutput() {
-    assert(this.isRoot());
-    const output = this.getSingletonOutput();
-    assert(output);
-    return output;
-  }
-  isRoot() {
-    return !this.facet.parent;
-  }
-};
-
-// src/facets/facet-extension.ts
-var FacetExtensionImpl = class extends BaseExtension {
-  /**
-   * @internal
-   */
-  constructor(facet, payloads) {
-    super();
-    this.facet = facet;
-    this.payloads = payloads;
-  }
-  /**
-   * @internal
-   */
-  createTree(priority) {
-    const pri = this.priority ?? priority;
-    const inputs = [null, null, null, null, null];
-    inputs[pri] = [...this.payloads];
-    let node = new FacetNode(this.facet, inputs);
-    while (node.facet.parent) {
-      const 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/is-object.ts
-function isObject(v) {
-  return typeof v === "object" && v != null;
-}
-
-// src/utils/is-element.ts
-var ELEMENT_NODE = 1;
-function isElement(el) {
-  return isObject(el) && el.nodeType === ELEMENT_NODE && typeof el.nodeName === "string";
-}
-
-// 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) {
-  return options?.document ?? findGlobalBrowserDocument() ?? findGlobalBrowserWindow()?.document;
-}
-function findBrowserWindow(options) {
-  return options?.document?.defaultView ?? findGlobalBrowserWindow() ?? findBrowserDocument(options)?.defaultView ?? void 0;
-}
-function getBrowserDocument(options) {
-  const doc = findBrowserDocument(options);
-  if (doc) return doc;
-  throw new DOMDocumentNotFoundError();
-}
-function getBrowserWindow(options) {
-  const 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) {
-  const { DOMParser: CustomDOMParser, schema, ...parseOptions } = options;
-  return (CustomDOMParser || DOMParser).fromSchema(schema).parse(element, parseOptions);
-}
-function elementFromNode(node, options) {
-  const Serializer = options?.DOMSerializer || DOMSerializer;
-  const document2 = getBrowserDocument(options);
-  const schema = node.type.schema;
-  const serializer = Serializer.fromSchema(schema);
-  if (schema.topNodeType !== node.type) {
-    return serializer.serializeNode(node, { document: document2 });
-  } else {
-    return serializer.serializeFragment(
-      node.content,
-      { document: document2 },
-      document2.createElement("div")
-    );
-  }
-}
-function elementFromHTML(html, options) {
-  const win = getBrowserWindow(options);
-  const parser = new win.DOMParser();
-  return parser.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 as Selection3
-} from "@prosekit/pm/state";
-
-// src/facets/state.ts
-var stateFacet = defineFacet({
-  reduce: () => {
-    let callbacks = [];
-    const state = (ctx) => {
-      const configs = callbacks.map((cb) => cb(ctx));
-      const config = {
-        schema: ctx.schema,
-        storedMarks: [],
-        plugins: []
-      };
-      for (const c of configs) {
-        config.schema = config.schema ?? c.schema;
-        config.doc = config.doc ?? c.doc;
-        config.selection = config.selection ?? c.selection;
-        config.storedMarks = [...config.storedMarks, ...c.storedMarks ?? []];
-        config.plugins = uniqPush(config.plugins ?? [], c.plugins ?? []);
-      }
-      assert(
-        config.doc || config.schema,
-        "Can't create state without a schema nor a document"
-      );
-      if (config.doc) {
-        config.schema = void 0;
-      }
-      return config;
-    };
-    return function reducer(inputs) {
-      callbacks = inputs;
-      return { state };
-    };
-  },
-  singleton: true,
-  parent: rootFacet
-});
-
-// src/utils/editor-content.ts
-import { Selection as Selection2 } from "@prosekit/pm/state";
-function getEditorContentJSON(schema, content) {
-  if (typeof content === "string") {
-    return jsonFromHTML(content, { schema });
-  } else if (isElement(content)) {
-    return jsonFromElement(content, { schema });
-  } else {
-    return content;
-  }
-}
-function getEditorContentNode(schema, content) {
-  if (isProseMirrorNode(content)) {
-    return content;
-  }
-  return schema.nodeFromJSON(getEditorContentJSON(schema, content));
-}
-function getEditorContentDoc(schema, content) {
-  const doc = getEditorContentNode(schema, content);
-  assert(
-    doc.type.schema === schema,
-    "Document schema does not match editor schema"
-  );
-  assert(
-    doc.type === schema.topNodeType,
-    `Document type does not match editor top node type. Expected ${schema.topNodeType.name}, got ${doc.type.name}`
-  );
-  return doc;
-}
-function getEditorSelection(doc, selection) {
-  if (isSelection(selection)) {
-    assert(selection.$head.doc === doc, "Selection and doc do not match");
-    return selection;
-  }
-  if (selection === "start") {
-    return Selection2.atStart(doc);
-  }
-  if (selection === "end") {
-    return Selection2.atEnd(doc);
-  }
-  return Selection2.fromJSON(doc, selection);
-}
-
-// src/extensions/default-state.ts
-function defineDefaultState({
-  defaultSelection,
-  defaultContent,
-  defaultDoc,
-  defaultHTML
-}) {
-  const defaultDocContent = defaultContent || defaultDoc || defaultHTML;
-  return defineFacetPayload(stateFacet, [
-    ({ schema }) => {
-      const config = {};
-      if (defaultDocContent) {
-        const json = getEditorContentJSON(schema, defaultDocContent);
-        config.doc = schema.nodeFromJSON(json);
-        if (defaultSelection) {
-          config.selection = Selection3.fromJSON(config.doc, defaultSelection);
-        }
-      }
-      return config;
-    }
-  ]);
-}
-
-// src/utils/is-subset.ts
-function isSubset(subset, superset) {
-  return Object.keys(subset).every((key) => subset[key] === superset[key]);
-}
-
-// src/utils/includes-mark.ts
-function includesMark(marks, markType, attrs) {
-  attrs = attrs || {};
-  return marks.some((mark) => {
-    return mark.type === markType && isSubset(attrs, mark.attrs);
-  });
-}
-
-// src/utils/is-mark-absent.ts
-function isMarkAbsent(node, from, to, markType, attrs) {
-  let missing = false;
-  let available = false;
-  node.nodesBetween(from, to, (node2, pos, parent) => {
-    if (missing) {
-      return false;
-    }
-    const allowed = parent?.type.allowsMarkType(markType) && !node2.marks.some((m) => m.type !== markType && m.type.excludes(markType));
-    if (allowed) {
-      available = true;
-      if (!includesMark(node2.marks, markType, attrs)) {
-        missing = true;
-      }
-    }
-  });
-  return available ? missing : true;
-}
-
-// src/utils/is-mark-active.ts
-function isMarkActive(state, type, attrs) {
-  const { from, $from, to, empty } = state.selection;
-  const markType = getMarkType(state.schema, type);
-  if (empty) {
-    const marks = state.storedMarks || $from.marks();
-    return includesMark(marks, markType, attrs);
-  } else {
-    return !isMarkAbsent(state.doc, from, to, markType, attrs);
-  }
-}
-
-// src/facets/union-extension.ts
-var UnionExtensionImpl = class extends BaseExtension {
-  /**
-   * @internal
-   */
-  constructor(extension = []) {
-    super();
-    this.extension = extension;
-  }
-  /**
-   * @internal
-   */
-  createTree(priority) {
-    const pri = this.priority ?? priority;
-    const extensions = [...this.extension];
-    extensions.sort((a, b) => (a.priority ?? pri) - (b.priority ?? pri));
-    const 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(...exts) {
-  const extensions = exts.flat();
-  assert(extensions.length > 0, "At least one extension is required");
-  return new UnionExtensionImpl(extensions);
-}
-
-// src/editor/editor.ts
-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 true;
-  }
-  if (!a || !b) {
-    return false;
-  }
-  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") {
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    return aKeys.length === bKeys.length && aKeys.every((key) => deepEquals(a[key], b[key]));
-  }
-  return false;
-}
-
-// src/editor/action.ts
-import mapValues from "just-map-values";
-
-// src/utils/attrs-match.ts
-function attrsMatch(nodeOrMark, attrs) {
-  const currentAttrs = nodeOrMark.attrs;
-  for (const [key, value] of Object.entries(attrs)) {
-    if (currentAttrs[key] !== value) {
-      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 || attrsMatch(node, attrs))) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// src/editor/action.ts
-function createNodeActions(schema, getState, createNode = defaultCreateNode) {
-  return mapValues(schema.nodes, (type) => createNodeAction(type, getState, createNode));
-}
-function createNodeAction(type, getState, createNode) {
-  const action = (...args) => buildNode(type, args, createNode);
-  action.isActive = (attrs) => {
-    const state = getState();
-    return state ? isNodeActive(state, type, attrs) : false;
-  };
-  return action;
-}
-function createMarkActions(schema, getState, applyMark = defaultApplyMark) {
-  return mapValues(schema.marks, (type) => createMarkAction(type, getState, applyMark));
-}
-function createMarkAction(type, getState, applyMark) {
-  const action = (...args) => buildMark(type, args, applyMark);
-  action.isActive = (attrs) => {
-    const state = getState();
-    return state ? isMarkActive(state, type, attrs) : false;
-  };
-  return action;
-}
-function buildMark(type, args, applyMark) {
-  const [attrs, children] = normalizeArgs(args);
-  const mark = type.create(attrs);
-  return applyMark(mark, flattenChildren(type.schema, children));
-}
-var defaultApplyMark = (mark, children) => {
-  return children.map((node) => node.mark(mark.addToSet(node.marks)));
-};
-function buildNode(type, args, createNode) {
-  const [attrs, children] = normalizeArgs(args);
-  return createNode(type, attrs, flattenChildren(type.schema, children));
-}
-var defaultCreateNode = (type, attrs, children) => {
-  const node = type.createAndFill(attrs, children);
-  assert(node, `Failed to create node ${type.name}`);
-  return node;
-};
-function flattenChildren(schema, children) {
-  const nodes = [];
-  for (const child of children) {
-    if (typeof child === "string") {
-      if (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) {
-  const [attrs, ...children] = args;
-  if (isNodeChild(attrs)) {
-    children.unshift(attrs);
-    return [null, children];
-  } else if (typeof attrs === "object") {
-    return [attrs, children];
-  } else {
-    return [null, children];
-  }
-}
-function isNodeChild(value) {
-  if (!value) {
-    return false;
-  }
-  return typeof value === "string" || Array.isArray(value) || isProseMirrorNode(value);
-}
-
-// src/editor/editor.ts
-function setupEditorExtension(options) {
-  if (options.defaultContent || options.defaultDoc || options.defaultHTML) {
-    return union(
-      options.extension,
-      defineDefaultState(options)
-    );
-  }
-  return options.extension;
-}
-function createEditor(options) {
-  const extension = setupEditorExtension(options);
-  const instance = new EditorInstance(extension);
-  return new Editor(instance);
-}
-var EditorInstance = class {
-  constructor(extension) {
-    this.view = null;
-    this.commands = {};
-    this.afterMounted = [];
-    this.getState = () => {
-      return this.view?.state || this.directEditorProps.state;
-    };
-    this.dispatch = (tr) => {
-      if (this.view) {
-        this.view.dispatch(tr);
-      } else {
-        this.directEditorProps.state = this.directEditorProps.state.apply(tr);
-      }
-    };
-    /**
-     * Return a JSON object representing the editor's current document.
-     */
-    this.getDocJSON = () => {
-      const state = this.getState();
-      return jsonFromNode(state.doc);
-    };
-    /**
-     * Return a HTML string representing the editor's current document.
-     */
-    this.getDocHTML = (options) => {
-      const serializer = this.getProp("clipboardSerializer");
-      const DOMSerializer2 = serializer ? { fromSchema: () => serializer } : void 0;
-      const doc = this.getDoc();
-      return htmlFromNode(doc, { ...options, DOMSerializer: DOMSerializer2 });
-    };
-    this.tree = extension.getTree();
-    const payload = this.tree.getRootOutput();
-    const schema = payload.schema;
-    const stateConfig = payload.state;
-    assert(schema && stateConfig, "Schema must be defined");
-    const state = EditorState2.create(stateConfig);
-    if (payload.commands) {
-      for (const [name, commandCreator] of Object.entries(payload.commands)) {
-        this.defineCommand(name, commandCreator);
-      }
-    }
-    this.nodes = createNodeActions(state.schema, this.getState);
-    this.marks = createMarkActions(state.schema, this.getState);
-    this.schema = state.schema;
-    this.directEditorProps = { state, ...payload.view };
-  }
-  getDoc() {
-    return this.getState().doc;
-  }
-  getProp(propName) {
-    return this.view?.someProp(propName) ?? this.directEditorProps[propName];
-  }
-  updateState(state) {
-    if (this.view) {
-      this.view.updateState(state);
-    } else {
-      this.directEditorProps.state = state;
-    }
-  }
-  setContent(content, selection) {
-    const doc = getEditorContentDoc(this.schema, content);
-    doc.check();
-    const sel = getEditorSelection(doc, selection || "start");
-    const oldState = this.getState();
-    if (doc.eq(oldState.doc) && (!selection || sel.eq(oldState.selection))) {
-      return;
-    }
-    const newState = EditorState2.create({
-      doc,
-      selection: sel,
-      plugins: oldState.plugins
-    });
-    this.updateState(newState);
-  }
-  updateExtension(extension, add) {
-    const view = this.view;
-    if (!view || view.isDestroyed) {
-      return;
-    }
-    const tree = extension.getTree();
-    const payload = tree.getRootOutput();
-    if (payload?.schema) {
-      throw new ProseKitError("Schema cannot be changed");
-    }
-    if (payload?.view) {
-      throw new ProseKitError("View cannot be changed");
-    }
-    const oldPayload = this.tree.getRootOutput();
-    const oldPlugins = [...view.state?.plugins ?? []];
-    this.tree = add ? unionFacetNode(this.tree, tree) : subtractFacetNode(this.tree, tree);
-    const newPayload = this.tree.getRootOutput();
-    const newPlugins = [...newPayload?.state?.plugins ?? []];
-    if (!deepEquals(oldPlugins, newPlugins)) {
-      const state = view.state.reconfigure({ plugins: newPlugins });
-      view.updateState(state);
-    }
-    if (newPayload?.commands && !deepEquals(oldPayload?.commands, newPayload?.commands)) {
-      const commands = newPayload.commands;
-      const names = Object.keys(commands);
-      for (const name of names) {
-        this.defineCommand(name, commands[name]);
-      }
-    }
-  }
-  use(extension) {
-    if (!this.mounted) {
-      let canceled = false;
-      let lazyRemove = null;
-      const lazyCreate = () => {
-        if (!canceled) {
-          lazyRemove = this.use(extension);
-        }
-      };
-      this.afterMounted.push(lazyCreate);
-      return () => {
-        canceled = true;
-        lazyRemove?.();
-      };
-    }
-    this.updateExtension(extension, true);
-    return () => this.updateExtension(extension, false);
-  }
-  mount(place) {
-    if (this.view) {
-      throw new ProseKitError("Editor is already mounted");
-    }
-    this.view = new EditorView({ mount: place }, this.directEditorProps);
-    this.afterMounted.forEach((callback) => callback());
-  }
-  unmount() {
-    if (!this.view) return;
-    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) {
-    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 });
-  }
-  exec(command) {
-    const state = this.getState();
-    return command(state, this.dispatch, this.view ?? void 0);
-  }
-  canExec(command) {
-    const state = this.getState();
-    return command(state, void 0, this.view ?? void 0);
-  }
-  defineCommand(name, commandCreator) {
-    const action = (...args) => {
-      const command = commandCreator(...args);
-      return this.exec(command);
-    };
-    const canExec = (...args) => {
-      const command = commandCreator(...args);
-      return this.canExec(command);
-    };
-    action.canApply = canExec;
-    action.canExec = canExec;
-    this.commands[name] = action;
-  }
-  removeCommand(name) {
-    delete this.commands[name];
-  }
-};
-var Editor = class {
-  /**
-   * @internal
-   */
-  constructor(instance) {
-    /**
-     * Mount the editor to the given HTML element.
-     * Pass `null` or `undefined` to unmount the editor.
-     */
-    this.mount = (place) => {
-      if (place) {
-        this.instance.mount(place);
-      } else {
-        this.instance.unmount();
-      }
-    };
-    /**
-     * Unmount the editor. This is equivalent to `mount(null)`.
-     */
-    this.unmount = () => {
-      this.instance.unmount();
-    };
-    /**
-     * Focus the editor.
-     */
-    this.focus = () => {
-      this.instance.view?.focus();
-    };
-    /**
-     * Blur the editor.
-     */
-    this.blur = () => {
-      this.instance.view?.dom.blur();
-    };
-    /**
-     * Register an extension to the editor. Return a function to unregister the
-     * extension.
-     */
-    this.use = (extension) => {
-      return this.instance.use(extension);
-    };
-    /**
-     * 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.
-     */
-    this.updateState = (state) => {
-      this.instance.updateState(state);
-    };
-    /**
-     * Update the editor's document and selection.
-     *
-     * @param content - The new document to set. It can be one of the following:
-     *   - A ProseMirror node instance
-     *   - A ProseMirror node JSON object
-     *   - An HTML string
-     *   - An HTML element instance
-     * @param selection - Optional. Specifies the new selection. It can be one of the following:
-     *   - A ProseMirror selection instance
-     *   - A ProseMirror selection JSON object
-     *   - The string "start" (to set selection at the beginning, default value)
-     *   - The string "end" (to set selection at the end)
-     */
-    this.setContent = (content, selection) => {
-      return this.instance.setContent(content, selection);
-    };
-    /**
-     * Return a JSON object representing the editor's current document.
-     */
-    this.getDocJSON = () => {
-      return this.instance.getDocJSON();
-    };
-    /**
-     * Return a HTML string representing the editor's current document.
-     */
-    this.getDocHTML = (options) => {
-      return this.instance.getDocHTML(options);
-    };
-    /**
-     * Execute the given command. Return `true` if the command was successfully
-     * executed, otherwise `false`.
-     */
-    this.exec = (command) => {
-      return this.instance.exec(command);
-    };
-    /**
-     * Check if the given command can be executed. Return `true` if the command
-     * can be executed, otherwise `false`.
-     */
-    this.canExec = (command) => {
-      return this.instance.canExec(command);
-    };
-    if (!(instance instanceof EditorInstance)) {
-      throw new TypeError("Invalid EditorInstance");
-    }
-    this.instance = 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;
-  }
-  /**
-   * The editor's current state.
-   */
-  get state() {
-    return this.instance.getState();
-  }
-  /**
-   * Whether the editor is focused.
-   */
-  get focused() {
-    return this.instance.view?.hasFocus() ?? false;
-  }
-  /**
-   * All {@link CommandAction}s defined by the editor.
-   */
-  get commands() {
-    return this.instance.commands;
-  }
-  /**
-   * All {@link NodeAction}s defined by the editor.
-   */
-  get nodes() {
-    return this.instance.nodes;
-  }
-  /**
-   * All {@link MarkAction}s defined by the editor.
-   */
-  get marks() {
-    return this.instance.marks;
-  }
-};
-
-export {
-  ProseKitError,
-  EditorNotFoundError,
-  getMarkType,
-  assert,
-  getNodeType,
-  isNodeActive,
-  Priority,
-  defineFacet,
-  rootFacet,
-  schemaFacet,
-  toReversed,
-  isProseMirrorNode,
-  isMark,
-  isFragment,
-  isSlice,
-  isSelection,
-  isTextSelection,
-  isNodeSelection,
-  isAllSelection,
-  isNotNullish,
-  defineFacetPayload,
-  stateFacet,
-  isElement,
-  jsonFromState,
-  stateFromJSON,
-  jsonFromNode,
-  nodeFromJSON,
-  nodeFromElement,
-  elementFromNode,
-  nodeFromHTML,
-  htmlFromNode,
-  elementFromJSON,
-  jsonFromHTML,
-  htmlFromJSON,
-  defineDefaultState,
-  isMarkAbsent,
-  isMarkActive,
-  createNodeActions,
-  createMarkActions,
-  union,
-  setupEditorExtension,
-  createEditor,
-  EditorInstance,
-  Editor
-};