alinea 1.7.0 → 2.0.0-preview.0

package/dist/field/richtext/RichTextField.view.js

@@ -1,2496 +1,434 @@
 import {
-  FloatingMenuPlugin
-} from "../../chunks/chunk-3DIW62EI.js";
+  EditorContent,
+  useEditor
+} from "../../chunks/chunk-7ORQ7BYK.js";
+import "../../chunks/chunk-TL7ZW6BX.js";
 import {
-  Editor,
-  Extension,
-  Fragment,
-  Node,
-  NodeView,
-  Plugin,
-  PluginKey,
-  Slice,
-  TextSelection,
-  getRenderedAttributes,
-  mergeAttributes
-} from "../../chunks/chunk-FKWEJTSK.js";
+  useAtomValue,
+  useSetAtom,
+  useStore
+} from "../../chunks/chunk-U4VOHNR2.js";
+import "../../chunks/chunk-Y7XOMJOC.js";
+import "../../chunks/chunk-RKDPDEF7.js";
 import {
   dist_default
-} from "../../chunks/chunk-A5O3N2GS.js";
+} from "../../chunks/chunk-I4OYYAX5.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/field/richtext/RichTextField.view.tsx
+import { Label } from "alinea/components";
+import { createId } from "alinea/core/Id";
+import { BlockNode, Node } from "alinea/core/TextDoc";
+import { Type } from "alinea/core/Type";
+import { isRecord } from "alinea/core/util/Objects";
+import { rootEditor } from "alinea/dashboard/atoms/editor";
+import {
+  useEditor as useDashboardEditor,
+  useFieldError,
+  useFieldNode,
+  useFieldOptions
+} from "alinea/dashboard/hooks";
+import {
+  configureRichTextExtensions
+} from "./RichTextField.js";
+import { PickTextLink, usePickTextLink } from "./PickTextLink.js";
 import {
-  ContentFormat,
-  ContentString,
-  ContentType,
-  Doc,
-  Item,
-  RelativePosition,
-  Snapshot,
-  UndoManager,
-  YText,
-  YXmlElement,
-  YXmlText,
-  applyUpdateV2,
-  createAbsolutePositionFromRelativePosition,
-  createDeleteSet,
-  createID,
-  createRelativePositionFromTypeIndex,
-  createSnapshot,
-  doc,
-  findRootTypeKey,
-  isBrowser,
-  isDeleted,
-  isParentOf,
-  iterateDeletedStructs,
-  keys,
-  oneOf,
-  snapshot,
-  timeout,
-  typeListToArraySnapshot
-} from "../../chunks/chunk-QUIANN6B.js";
+  useCallback,
+  useEffect,
+  useId,
+  useMemo,
+  useRef,
+  useState,
+  useSyncExternalStore
+} from "react";
+import { createPortal } from "react-dom";
+import { RichTextBlock } from "./RichTextBlock.js";
 import {
-  create,
-  max,
-  methodUnimplemented,
-  min,
-  unexpectedCase
-} from "../../chunks/chunk-AJJSW27C.js";
-import "../../chunks/chunk-NZLE2WMY.js";
+  richTextStructureAtom
+} from "./RichTextBlocks.js";
+import {
+  RichTextBlockHosts
+} from "./RichTextBlockHost.js";
+import { editorContent, editorNodes } from "./RichTextDocument.js";
+import {
+  defaultExtensionConfig,
+  richTextBlockClipboard,
+  richTextBlockExtensions,
+  richTextDocumentExtension
+} from "./RichTextExtensions.js";
+import {
+  blockAttributes,
+  decodeBlockValue,
+  encodeBlockValue,
+  richTextBlockValueAttribute
+} from "./RichTextBlockValue.js";
 
-// node_modules/lib0/mutex.js
-var createMutex = () => {
-  let token = true;
-  return (f, g) => {
-    if (token) {
-      token = false;
-      try {
-        f();
-      } finally {
-        token = true;
-      }
-    } else if (g !== void 0) {
-      g();
-    }
-  };
+// src/field/richtext/RichTextField.module.css
+var RichTextField_default = {
+  "RichTextFieldView-unsupportedBlock": "alinea-RichTextFieldView-unsupportedBlock",
+  "RichTextFieldViewUnsupportedBlock": "alinea-RichTextFieldView-unsupportedBlock",
+  "RichTextFieldView": "alinea-RichTextFieldView",
+  "RichTextFieldCompactView": "alinea-RichTextFieldCompactView"
 };
 
-// node_modules/lib0/diff.js
-var highSurrogateRegex = /[\uD800-\uDBFF]/;
-var lowSurrogateRegex = /[\uDC00-\uDFFF]/;
-var simpleDiffString = (a, b) => {
-  let left = 0;
-  let right = 0;
-  while (left < a.length && left < b.length && a[left] === b[left]) {
-    left++;
-  }
-  if (left > 0 && highSurrogateRegex.test(a[left - 1])) left--;
-  while (right + left < a.length && right + left < b.length && a[a.length - right - 1] === b[b.length - right - 1]) {
-    right++;
-  }
-  if (right > 0 && lowSurrogateRegex.test(a[a.length - right])) right--;
-  return {
-    index: left,
-    remove: a.length - left - right,
-    insert: b.slice(left, b.length - right)
-  };
-};
-var simpleDiff = simpleDiffString;
-
-// node_modules/y-prosemirror/src/plugins/keys.js
-var ySyncPluginKey = new PluginKey("y-sync");
-var yUndoPluginKey = new PluginKey("y-undo");
-var yCursorPluginKey = new PluginKey("yjs-cursor");
-
-// node_modules/y-prosemirror/src/plugins/sync-plugin.js
-var isVisible = (item, snapshot2) => snapshot2 === void 0 ? !item.deleted : snapshot2.sv.has(item.id.client) && /** @type {number} */
-snapshot2.sv.get(item.id.client) > item.id.clock && !isDeleted(snapshot2.ds, item.id);
-var defaultColors = [{ light: "#ecd44433", dark: "#ecd444" }];
-var getUserColor = (colorMapping, colors, user) => {
-  if (!colorMapping.has(user)) {
-    if (colorMapping.size < colors.length) {
-      const usedColors = create();
-      colorMapping.forEach((color) => usedColors.add(color));
-      colors = colors.filter((color) => !usedColors.has(color));
-    }
-    colorMapping.set(user, oneOf(colors));
-  }
-  return (
-    /** @type {ColorDef} */
-    colorMapping.get(user)
+// src/field/richtext/RichTextField.view.tsx
+import { RichTextInsertMenu } from "./RichTextInsertMenu.js";
+import { documentUpdateAtom } from "./RichTextState.js";
+import { RichTextToolbar } from "./RichTextToolbar.js";
+import { PickTextAnchor, usePickTextAnchor } from "./PickTextAnchor.js";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var styles = dist_default(RichTextField_default);
+function RichTextFieldView({
+  field
+}) {
+  const options = useFieldOptions(field);
+  const error = useFieldError(field);
+  const fieldNode = useFieldNode(field);
+  const store = useStore();
+  const { blocks, structure } = useAtomValue(
+    useMemo(() => richTextStructureAtom(fieldNode), [fieldNode])
   );
-};
-var ySyncPlugin = (yXmlFragment, {
-  colors = defaultColors,
-  colorMapping = /* @__PURE__ */ new Map(),
-  permanentUserData = null,
-  onFirstRender = () => {
-  },
-  mapping
-} = {}) => {
-  let initialContentChanged = false;
-  const binding = new ProsemirrorBinding(yXmlFragment, mapping);
-  const plugin = new Plugin({
-    props: {
-      editable: (state) => {
-        const syncState = ySyncPluginKey.getState(state);
-        return syncState.snapshot == null && syncState.prevSnapshot == null;
-      }
-    },
-    key: ySyncPluginKey,
-    state: {
-      /**
-       * @returns {any}
-       */
-      init: (_initargs, _state) => {
-        return {
-          type: yXmlFragment,
-          doc: yXmlFragment.doc,
-          binding,
-          snapshot: null,
-          prevSnapshot: null,
-          isChangeOrigin: false,
-          isUndoRedoOperation: false,
-          addToHistory: true,
-          colors,
-          colorMapping,
-          permanentUserData
-        };
-      },
-      apply: (tr, pluginState) => {
-        const change = tr.getMeta(ySyncPluginKey);
-        if (change !== void 0) {
-          pluginState = Object.assign({}, pluginState);
-          for (const key in change) {
-            pluginState[key] = change[key];
-          }
-        }
-        pluginState.addToHistory = tr.getMeta("addToHistory") !== false;
-        pluginState.isChangeOrigin = change !== void 0 && !!change.isChangeOrigin;
-        pluginState.isUndoRedoOperation = change !== void 0 && !!change.isChangeOrigin && !!change.isUndoRedoOperation;
-        if (binding.prosemirrorView !== null) {
-          if (change !== void 0 && (change.snapshot != null || change.prevSnapshot != null)) {
-            timeout(0, () => {
-              if (binding.prosemirrorView == null) {
-                return;
-              }
-              if (change.restore == null) {
-                binding._renderSnapshot(
-                  change.snapshot,
-                  change.prevSnapshot,
-                  pluginState
-                );
-              } else {
-                binding._renderSnapshot(
-                  change.snapshot,
-                  change.snapshot,
-                  pluginState
-                );
-                delete pluginState.restore;
-                delete pluginState.snapshot;
-                delete pluginState.prevSnapshot;
-                binding.mux(() => {
-                  binding._prosemirrorChanged(
-                    binding.prosemirrorView.state.doc
-                  );
-                });
-              }
-            });
-          }
-        }
-        return pluginState;
-      }
-    },
-    view: (view) => {
-      binding.initView(view);
-      if (mapping == null) {
-        binding._forceRerender();
-      }
-      onFirstRender();
-      return {
-        update: () => {
-          const pluginState = plugin.getState(view.state);
-          if (pluginState.snapshot == null && pluginState.prevSnapshot == null) {
-            if (
-              // If the content doesn't change initially, we don't render anything to Yjs
-              // If the content was cleared by a user action, we want to catch the change and
-              // represent it in Yjs
-              initialContentChanged || view.state.doc.content.findDiffStart(
-                view.state.doc.type.createAndFill().content
-              ) !== null
-            ) {
-              initialContentChanged = true;
-              if (pluginState.addToHistory === false && !pluginState.isChangeOrigin) {
-                const yUndoPluginState = yUndoPluginKey.getState(view.state);
-                const um = yUndoPluginState && yUndoPluginState.undoManager;
-                if (um) {
-                  um.stopCapturing();
-                }
-              }
-              binding.mux(() => {
-                pluginState.doc.transact((tr) => {
-                  tr.meta.set("addToHistory", pluginState.addToHistory);
-                  binding._prosemirrorChanged(view.state.doc);
-                }, ySyncPluginKey);
-              });
-            }
-          }
-        },
-        destroy: () => {
-          binding.destroy();
-        }
-      };
-    }
-  });
-  return plugin;
-};
-var restoreRelativeSelection = (tr, relSel, binding) => {
-  if (relSel !== null && relSel.anchor !== null && relSel.head !== null) {
-    const anchor = relativePositionToAbsolutePosition(
-      binding.doc,
-      binding.type,
-      relSel.anchor,
-      binding.mapping
-    );
-    const head = relativePositionToAbsolutePosition(
-      binding.doc,
-      binding.type,
-      relSel.head,
-      binding.mapping
-    );
-    if (anchor !== null && head !== null) {
-      tr = tr.setSelection(TextSelection.create(tr.doc, anchor, head));
-    }
-  }
-};
-var getRelativeSelection = (pmbinding, state) => ({
-  anchor: absolutePositionToRelativePosition(
-    state.selection.anchor,
-    pmbinding.type,
-    pmbinding.mapping
-  ),
-  head: absolutePositionToRelativePosition(
-    state.selection.head,
-    pmbinding.type,
-    pmbinding.mapping
-  )
-});
-var ProsemirrorBinding = class {
-  /**
-   * @param {Y.XmlFragment} yXmlFragment The bind source
-   * @param {ProsemirrorMapping} mapping
-   */
-  constructor(yXmlFragment, mapping = /* @__PURE__ */ new Map()) {
-    this.type = yXmlFragment;
-    this.prosemirrorView = null;
-    this.mux = createMutex();
-    this.mapping = mapping;
-    this._observeFunction = this._typeChanged.bind(this);
-    this.doc = yXmlFragment.doc;
-    this.beforeTransactionSelection = null;
-    this.beforeAllTransactions = () => {
-      if (this.beforeTransactionSelection === null && this.prosemirrorView != null) {
-        this.beforeTransactionSelection = getRelativeSelection(
-          this,
-          this.prosemirrorView.state
-        );
-      }
-    };
-    this.afterAllTransactions = () => {
-      this.beforeTransactionSelection = null;
-    };
-    this._domSelectionInView = null;
-  }
-  /**
-   * Create a transaction for changing the prosemirror state.
-   *
-   * @returns
-   */
-  get _tr() {
-    return this.prosemirrorView.state.tr.setMeta("addToHistory", false);
-  }
-  _isLocalCursorInView() {
-    if (!this.prosemirrorView.hasFocus()) return false;
-    if (isBrowser && this._domSelectionInView === null) {
-      timeout(0, () => {
-        this._domSelectionInView = null;
-      });
-      this._domSelectionInView = this._isDomSelectionInView();
-    }
-    return this._domSelectionInView;
-  }
-  _isDomSelectionInView() {
-    const selection = this.prosemirrorView._root.getSelection();
-    if (selection == null || selection.anchorNode == null) return false;
-    const range = this.prosemirrorView._root.createRange();
-    range.setStart(selection.anchorNode, selection.anchorOffset);
-    range.setEnd(selection.focusNode, selection.focusOffset);
-    const rects = range.getClientRects();
-    if (rects.length === 0) {
-      if (range.startContainer && range.collapsed) {
-        range.selectNodeContents(range.startContainer);
-      }
-    }
-    const bounding = range.getBoundingClientRect();
-    const documentElement = doc.documentElement;
-    return bounding.bottom >= 0 && bounding.right >= 0 && bounding.left <= (window.innerWidth || documentElement.clientWidth || 0) && bounding.top <= (window.innerHeight || documentElement.clientHeight || 0);
-  }
-  /**
-   * @param {Y.Snapshot} snapshot
-   * @param {Y.Snapshot} prevSnapshot
-   */
-  renderSnapshot(snapshot2, prevSnapshot) {
-    if (!prevSnapshot) {
-      prevSnapshot = createSnapshot(createDeleteSet(), /* @__PURE__ */ new Map());
-    }
-    this.prosemirrorView.dispatch(
-      this._tr.setMeta(ySyncPluginKey, { snapshot: snapshot2, prevSnapshot })
-    );
-  }
-  unrenderSnapshot() {
-    this.mapping.clear();
-    this.mux(() => {
-      const fragmentContent = this.type.toArray().map(
-        (t) => createNodeFromYElement(
-          /** @type {Y.XmlElement} */
-          t,
-          this.prosemirrorView.state.schema,
-          this.mapping
-        )
-      ).filter((n) => n !== null);
-      const tr = this._tr.replace(
-        0,
-        this.prosemirrorView.state.doc.content.size,
-        new Slice(Fragment.from(fragmentContent), 0, 0)
-      );
-      tr.setMeta(ySyncPluginKey, { snapshot: null, prevSnapshot: null });
-      this.prosemirrorView.dispatch(tr);
-    });
-  }
-  _forceRerender() {
-    this.mapping.clear();
-    this.mux(() => {
-      const sel = this.beforeTransactionSelection !== null ? null : this.prosemirrorView.state.selection;
-      const fragmentContent = this.type.toArray().map(
-        (t) => createNodeFromYElement(
-          /** @type {Y.XmlElement} */
-          t,
-          this.prosemirrorView.state.schema,
-          this.mapping
-        )
-      ).filter((n) => n !== null);
-      const tr = this._tr.replace(
-        0,
-        this.prosemirrorView.state.doc.content.size,
-        new Slice(Fragment.from(fragmentContent), 0, 0)
-      );
-      if (sel) {
-        const clampedAnchor = min(max(sel.anchor, 0), tr.doc.content.size);
-        const clampedHead = min(max(sel.head, 0), tr.doc.content.size);
-        tr.setSelection(TextSelection.create(tr.doc, clampedAnchor, clampedHead));
-      }
-      this.prosemirrorView.dispatch(
-        tr.setMeta(ySyncPluginKey, { isChangeOrigin: true, binding: this })
-      );
-    });
-  }
-  /**
-   * @param {Y.Snapshot|Uint8Array} snapshot
-   * @param {Y.Snapshot|Uint8Array} prevSnapshot
-   * @param {Object} pluginState
-   */
-  _renderSnapshot(snapshot2, prevSnapshot, pluginState) {
-    let historyDoc = this.doc;
-    if (!snapshot2) {
-      snapshot2 = snapshot(this.doc);
-    }
-    if (snapshot2 instanceof Uint8Array || prevSnapshot instanceof Uint8Array) {
-      if (!(snapshot2 instanceof Uint8Array) || !(prevSnapshot instanceof Uint8Array)) {
-        unexpectedCase();
-      }
-      historyDoc = new Doc({ gc: false });
-      applyUpdateV2(historyDoc, prevSnapshot);
-      prevSnapshot = snapshot(historyDoc);
-      applyUpdateV2(historyDoc, snapshot2);
-      snapshot2 = snapshot(historyDoc);
-    }
-    this.mapping.clear();
-    this.mux(() => {
-      historyDoc.transact((transaction) => {
-        const pud = pluginState.permanentUserData;
-        if (pud) {
-          pud.dss.forEach((ds) => {
-            iterateDeletedStructs(transaction, ds, (_item) => {
-            });
-          });
-        }
-        const computeYChange = (type, id) => {
-          const user = type === "added" ? pud.getUserByClientId(id.client) : pud.getUserByDeletedId(id);
-          return {
-            user,
-            type,
-            color: getUserColor(
-              pluginState.colorMapping,
-              pluginState.colors,
-              user
-            )
-          };
-        };
-        const fragmentContent = typeListToArraySnapshot(
-          this.type,
-          new Snapshot(prevSnapshot.ds, snapshot2.sv)
-        ).map((t) => {
-          if (!t._item.deleted || isVisible(t._item, snapshot2) || isVisible(t._item, prevSnapshot)) {
-            return createNodeFromYElement(
-              t,
-              this.prosemirrorView.state.schema,
-              /* @__PURE__ */ new Map(),
-              snapshot2,
-              prevSnapshot,
-              computeYChange
-            );
-          } else {
-            return null;
-          }
-        }).filter((n) => n !== null);
-        const tr = this._tr.replace(
-          0,
-          this.prosemirrorView.state.doc.content.size,
-          new Slice(Fragment.from(fragmentContent), 0, 0)
-        );
-        this.prosemirrorView.dispatch(
-          tr.setMeta(ySyncPluginKey, { isChangeOrigin: true })
-        );
-      }, ySyncPluginKey);
-    });
-  }
-  /**
-   * @param {Array<Y.YEvent<any>>} events
-   * @param {Y.Transaction} transaction
-   */
-  _typeChanged(events, transaction) {
-    if (this.prosemirrorView == null) return;
-    const syncState = ySyncPluginKey.getState(this.prosemirrorView.state);
-    if (events.length === 0 || syncState.snapshot != null || syncState.prevSnapshot != null) {
-      this.renderSnapshot(syncState.snapshot, syncState.prevSnapshot);
-      return;
-    }
-    this.mux(() => {
-      const delType = (_, type) => this.mapping.delete(type);
-      iterateDeletedStructs(
-        transaction,
-        transaction.deleteSet,
-        (struct) => {
-          if (struct.constructor === Item) {
-            const type = (
-              /** @type {Y.ContentType} */
-              /** @type {Y.Item} */
-              struct.content.type
-            );
-            type && this.mapping.delete(type);
-          }
-        }
-      );
-      transaction.changed.forEach(delType);
-      transaction.changedParentTypes.forEach(delType);
-      const fragmentContent = this.type.toArray().map(
-        (t) => createNodeIfNotExists(
-          /** @type {Y.XmlElement | Y.XmlHook} */
-          t,
-          this.prosemirrorView.state.schema,
-          this.mapping
-        )
-      ).filter((n) => n !== null);
-      let tr = this._tr.replace(
-        0,
-        this.prosemirrorView.state.doc.content.size,
-        new Slice(Fragment.from(fragmentContent), 0, 0)
-      );
-      restoreRelativeSelection(tr, this.beforeTransactionSelection, this);
-      tr = tr.setMeta(ySyncPluginKey, { isChangeOrigin: true, isUndoRedoOperation: transaction.origin instanceof UndoManager });
-      if (this.beforeTransactionSelection !== null && this._isLocalCursorInView()) {
-        tr.scrollIntoView();
-      }
-      this.prosemirrorView.dispatch(tr);
-    });
-  }
-  _prosemirrorChanged(doc2) {
-    this.doc.transact(() => {
-      updateYFragment(this.doc, this.type, doc2, this.mapping);
-      this.beforeTransactionSelection = getRelativeSelection(
-        this,
-        this.prosemirrorView.state
-      );
-    }, ySyncPluginKey);
-  }
-  /**
-   * View is ready to listen to changes. Register observers.
-   * @param {any} prosemirrorView
-   */
-  initView(prosemirrorView) {
-    if (this.prosemirrorView != null) this.destroy();
-    this.prosemirrorView = prosemirrorView;
-    this.doc.on("beforeAllTransactions", this.beforeAllTransactions);
-    this.doc.on("afterAllTransactions", this.afterAllTransactions);
-    this.type.observeDeep(this._observeFunction);
-  }
-  destroy() {
-    if (this.prosemirrorView == null) return;
-    this.prosemirrorView = null;
-    this.type.unobserveDeep(this._observeFunction);
-    this.doc.off("beforeAllTransactions", this.beforeAllTransactions);
-    this.doc.off("afterAllTransactions", this.afterAllTransactions);
-  }
-};
-var createNodeIfNotExists = (el, schema, mapping, snapshot2, prevSnapshot, computeYChange) => {
-  const node = (
-    /** @type {PModel.Node} */
-    mapping.get(el)
+  const blocksById = useMemo(
+    () => new Map(blocks.map((block) => [block.id, block])),
+    [blocks]
   );
-  if (node === void 0) {
-    if (el instanceof YXmlElement) {
-      return createNodeFromYElement(
-        el,
-        schema,
-        mapping,
-        snapshot2,
-        prevSnapshot,
-        computeYChange
-      );
-    } else {
-      throw methodUnimplemented();
-    }
-  }
-  return node;
-};
-var createNodeFromYElement = (el, schema, mapping, snapshot2, prevSnapshot, computeYChange) => {
-  const children = [];
-  const createChildren = (type) => {
-    if (type.constructor === YXmlElement) {
-      const n = createNodeIfNotExists(
-        type,
-        schema,
-        mapping,
-        snapshot2,
-        prevSnapshot,
-        computeYChange
-      );
-      if (n !== null) {
-        children.push(n);
-      }
-    } else {
-      const nextytext = type._item.right?.content.type;
-      if (nextytext instanceof YText && !nextytext._item.deleted && nextytext._item.id.client === nextytext.doc.clientID) {
-        type.applyDelta([
-          { retain: type.length },
-          ...nextytext.toDelta()
-        ]);
-        nextytext.doc.transact((tr) => {
-          nextytext._item.delete(tr);
-        });
-      }
-      const ns = createTextNodesFromYText(
-        type,
-        schema,
-        mapping,
-        snapshot2,
-        prevSnapshot,
-        computeYChange
-      );
-      if (ns !== null) {
-        ns.forEach((textchild) => {
-          if (textchild !== null) {
-            children.push(textchild);
-          }
-        });
-      }
-    }
-  };
-  if (snapshot2 === void 0 || prevSnapshot === void 0) {
-    el.toArray().forEach(createChildren);
-  } else {
-    typeListToArraySnapshot(el, new Snapshot(prevSnapshot.ds, snapshot2.sv)).forEach(createChildren);
-  }
-  try {
-    const attrs = el.getAttributes(snapshot2);
-    if (snapshot2 !== void 0) {
-      if (!isVisible(
-        /** @type {Y.Item} */
-        el._item,
-        snapshot2
-      )) {
-        attrs.ychange = computeYChange ? computeYChange(
-          "removed",
-          /** @type {Y.Item} */
-          el._item.id
-        ) : { type: "removed" };
-      } else if (!isVisible(
-        /** @type {Y.Item} */
-        el._item,
-        prevSnapshot
-      )) {
-        attrs.ychange = computeYChange ? computeYChange(
-          "added",
-          /** @type {Y.Item} */
-          el._item.id
-        ) : { type: "added" };
-      }
-    }
-    const node = schema.node(el.nodeName, attrs, children);
-    mapping.set(el, node);
-    return node;
-  } catch (e) {
-    el.doc.transact((transaction) => {
-      el._item.delete(transaction);
-    }, ySyncPluginKey);
-    mapping.delete(el);
-    return null;
-  }
-};
-var createTextNodesFromYText = (text, schema, _mapping, snapshot2, prevSnapshot, computeYChange) => {
-  const nodes = [];
-  const deltas = text.toDelta(snapshot2, prevSnapshot, computeYChange);
-  try {
-    for (let i = 0; i < deltas.length; i++) {
-      const delta = deltas[i];
-      const marks = [];
-      for (const markName in delta.attributes) {
-        marks.push(schema.mark(markName, delta.attributes[markName]));
-      }
-      nodes.push(schema.text(delta.insert, marks));
-    }
-  } catch (e) {
-    text.doc.transact((transaction) => {
-      text._item.delete(transaction);
-    }, ySyncPluginKey);
-    return null;
-  }
-  return nodes;
-};
-var createTypeFromTextNodes = (nodes, mapping) => {
-  const type = new YXmlText();
-  const delta = nodes.map((node) => ({
-    // @ts-ignore
-    insert: node.text,
-    attributes: marksToAttributes(node.marks)
-  }));
-  type.applyDelta(delta);
-  mapping.set(type, nodes);
-  return type;
-};
-var createTypeFromElementNode = (node, mapping) => {
-  const type = new YXmlElement(node.type.name);
-  for (const key in node.attrs) {
-    const val = node.attrs[key];
-    if (val !== null && key !== "ychange") {
-      type.setAttribute(key, val);
-    }
-  }
-  type.insert(
-    0,
-    normalizePNodeContent(node).map(
-      (n) => createTypeFromTextOrElementNode(n, mapping)
-    )
+  const blocksByIdRef = useRef(blocksById);
+  blocksByIdRef.current = blocksById;
+  const lastEditorDocument = useRef();
+  const pendingExternalDocument = useRef();
+  const documentKey = documentStructureKey(structure);
+  if (lastEditorDocument.current && lastEditorDocument.current !== documentKey)
+    pendingExternalDocument.current = documentKey;
+  const updateDocument = useSetAtom(
+    useMemo(() => documentUpdateAtom(fieldNode), [fieldNode])
   );
-  mapping.set(type, node);
-  return type;
-};
-var createTypeFromTextOrElementNode = (node, mapping) => node instanceof Array ? createTypeFromTextNodes(node, mapping) : createTypeFromElementNode(node, mapping);
-var isObject = (val) => typeof val === "object" && val !== null;
-var equalAttrs = (pattrs, yattrs) => {
-  const keys2 = Object.keys(pattrs).filter((key) => pattrs[key] !== null);
-  let eq = keys2.length === Object.keys(yattrs).filter((key) => yattrs[key] !== null).length;
-  for (let i = 0; i < keys2.length && eq; i++) {
-    const key = keys2[i];
-    const l = pattrs[key];
-    const r = yattrs[key];
-    eq = key === "ychange" || l === r || isObject(l) && isObject(r) && equalAttrs(l, r);
-  }
-  return eq;
-};
-var normalizePNodeContent = (pnode) => {
-  const c = pnode.content.content;
-  const res = [];
-  for (let i = 0; i < c.length; i++) {
-    const n = c[i];
-    if (n.isText) {
-      const textNodes = [];
-      for (let tnode = c[i]; i < c.length && tnode.isText; tnode = c[++i]) {
-        textNodes.push(tnode);
-      }
-      i--;
-      res.push(textNodes);
-    } else {
-      res.push(n);
-    }
-  }
-  return res;
-};
-var equalYTextPText = (ytext, ptexts) => {
-  const delta = ytext.toDelta();
-  return delta.length === ptexts.length && delta.every(
-    (d, i) => d.insert === /** @type {any} */
-    ptexts[i].text && keys(d.attributes || {}).length === ptexts[i].marks.length && ptexts[i].marks.every(
-      (mark) => equalAttrs(d.attributes[mark.type.name] || {}, mark.attrs)
-    )
+  const hosts = useMemo(() => new RichTextBlockHosts(), []);
+  const pendingBlocks = useRef(/* @__PURE__ */ new Map());
+  const [activeEditor, setActiveEditor] = useState();
+  const [focused, setFocused] = useState(false);
+  const [innerBlockFocused, setInnerBlockFocused] = useState(false);
+  const root = useRef(null);
+  const ownerId = useId();
+  const picker = usePickTextLink();
+  const anchorPicker = usePickTextAnchor();
+  const dashboardEditor = useDashboardEditor();
+  const entryAnchors = rootEditor(dashboardEditor).anchors;
+  const getEntryAnchors = useCallback(
+    () => store.get(entryAnchors).map((anchor) => anchor.id),
+    [entryAnchors, store]
   );
-};
-var equalYTypePNode = (ytype, pnode) => {
-  if (ytype instanceof YXmlElement && !(pnode instanceof Array) && matchNodeName(ytype, pnode)) {
-    const normalizedContent = normalizePNodeContent(pnode);
-    return ytype._length === normalizedContent.length && equalAttrs(ytype.getAttributes(), pnode.attrs) && ytype.toArray().every(
-      (ychild, i) => equalYTypePNode(ychild, normalizedContent[i])
+  const readOnly = Boolean(options.readOnly || fieldNode.readOnly);
+  const extensions = useMemo(() => {
+    const configured = Object.values(
+      configureRichTextExtensions(
+        options.extensions,
+        defaultExtensionConfig(getEntryAnchors)
+      )
     );
-  }
-  return ytype instanceof YXmlText && pnode instanceof Array && equalYTextPText(ytype, pnode);
-};
-var mappedIdentity = (mapped, pcontent) => mapped === pcontent || mapped instanceof Array && pcontent instanceof Array && mapped.length === pcontent.length && mapped.every(
-  (a, i) => pcontent[i] === a
-);
-var computeChildEqualityFactor = (ytype, pnode, mapping) => {
-  const yChildren = ytype.toArray();
-  const pChildren = normalizePNodeContent(pnode);
-  const pChildCnt = pChildren.length;
-  const yChildCnt = yChildren.length;
-  const minCnt = min(yChildCnt, pChildCnt);
-  let left = 0;
-  let right = 0;
-  let foundMappedChild = false;
-  for (; left < minCnt; left++) {
-    const leftY = yChildren[left];
-    const leftP = pChildren[left];
-    if (mappedIdentity(mapping.get(leftY), leftP)) {
-      foundMappedChild = true;
-    } else if (!equalYTypePNode(leftY, leftP)) {
-      break;
-    }
-  }
-  for (; left + right < minCnt; right++) {
-    const rightY = yChildren[yChildCnt - right - 1];
-    const rightP = pChildren[pChildCnt - right - 1];
-    if (mappedIdentity(mapping.get(rightY), rightP)) {
-      foundMappedChild = true;
-    } else if (!equalYTypePNode(rightY, rightP)) {
-      break;
-    }
-  }
-  return {
-    equalityFactor: left + right,
-    foundMappedChild
-  };
-};
-var ytextTrans = (ytext) => {
-  let str = "";
-  let n = ytext._start;
-  const nAttrs = {};
-  while (n !== null) {
-    if (!n.deleted) {
-      if (n.countable && n.content instanceof ContentString) {
-        str += n.content.str;
-      } else if (n.content instanceof ContentFormat) {
-        nAttrs[n.content.key] = null;
-      }
-    }
-    n = n.right;
-  }
-  return {
-    str,
-    nAttrs
-  };
-};
-var updateYText = (ytext, ptexts, mapping) => {
-  mapping.set(ytext, ptexts);
-  const { nAttrs, str } = ytextTrans(ytext);
-  const content = ptexts.map((p) => ({
-    insert: (
-      /** @type {any} */
-      p.text
-    ),
-    attributes: Object.assign({}, nAttrs, marksToAttributes(p.marks))
-  }));
-  const { insert, remove, index } = simpleDiff(
-    str,
-    content.map((c) => c.insert).join("")
-  );
-  ytext.delete(index, remove);
-  ytext.insert(index, insert);
-  ytext.applyDelta(
-    content.map((c) => ({ retain: c.insert.length, attributes: c.attributes }))
-  );
-};
-var marksToAttributes = (marks) => {
-  const pattrs = {};
-  marks.forEach((mark) => {
-    if (mark.type.name !== "ychange") {
-      pattrs[mark.type.name] = mark.attrs;
-    }
-  });
-  return pattrs;
-};
-var updateYFragment = (y, yDomFragment, pNode, mapping) => {
-  if (yDomFragment instanceof YXmlElement && yDomFragment.nodeName !== pNode.type.name) {
-    throw new Error("node name mismatch!");
-  }
-  mapping.set(yDomFragment, pNode);
-  if (yDomFragment instanceof YXmlElement) {
-    const yDomAttrs = yDomFragment.getAttributes();
-    const pAttrs = pNode.attrs;
-    for (const key in pAttrs) {
-      if (pAttrs[key] !== null) {
-        if (yDomAttrs[key] !== pAttrs[key] && key !== "ychange") {
-          yDomFragment.setAttribute(key, pAttrs[key]);
-        }
-      } else {
-        yDomFragment.removeAttribute(key);
-      }
-    }
-    for (const key in yDomAttrs) {
-      if (pAttrs[key] === void 0) {
-        yDomFragment.removeAttribute(key);
-      }
-    }
-  }
-  const pChildren = normalizePNodeContent(pNode);
-  const pChildCnt = pChildren.length;
-  const yChildren = yDomFragment.toArray();
-  const yChildCnt = yChildren.length;
-  const minCnt = min(pChildCnt, yChildCnt);
-  let left = 0;
-  let right = 0;
-  for (; left < minCnt; left++) {
-    const leftY = yChildren[left];
-    const leftP = pChildren[left];
-    if (!mappedIdentity(mapping.get(leftY), leftP)) {
-      if (equalYTypePNode(leftY, leftP)) {
-        mapping.set(leftY, leftP);
-      } else {
-        break;
-      }
-    }
-  }
-  for (; right + left + 1 < minCnt; right++) {
-    const rightY = yChildren[yChildCnt - right - 1];
-    const rightP = pChildren[pChildCnt - right - 1];
-    if (!mappedIdentity(mapping.get(rightY), rightP)) {
-      if (equalYTypePNode(rightY, rightP)) {
-        mapping.set(rightY, rightP);
-      } else {
-        break;
-      }
-    }
-  }
-  y.transact(() => {
-    while (yChildCnt - left - right > 0 && pChildCnt - left - right > 0) {
-      const leftY = yChildren[left];
-      const leftP = pChildren[left];
-      const rightY = yChildren[yChildCnt - right - 1];
-      const rightP = pChildren[pChildCnt - right - 1];
-      if (leftY instanceof YXmlText && leftP instanceof Array) {
-        if (!equalYTextPText(leftY, leftP)) {
-          updateYText(leftY, leftP, mapping);
-        }
-        left += 1;
-      } else {
-        let updateLeft = leftY instanceof YXmlElement && matchNodeName(leftY, leftP);
-        let updateRight = rightY instanceof YXmlElement && matchNodeName(rightY, rightP);
-        if (updateLeft && updateRight) {
-          const equalityLeft = computeChildEqualityFactor(
-            /** @type {Y.XmlElement} */
-            leftY,
-            /** @type {PModel.Node} */
-            leftP,
-            mapping
-          );
-          const equalityRight = computeChildEqualityFactor(
-            /** @type {Y.XmlElement} */
-            rightY,
-            /** @type {PModel.Node} */
-            rightP,
-            mapping
-          );
-          if (equalityLeft.foundMappedChild && !equalityRight.foundMappedChild) {
-            updateRight = false;
-          } else if (!equalityLeft.foundMappedChild && equalityRight.foundMappedChild) {
-            updateLeft = false;
-          } else if (equalityLeft.equalityFactor < equalityRight.equalityFactor) {
-            updateLeft = false;
-          } else {
-            updateRight = false;
-          }
-        }
-        if (updateLeft) {
-          updateYFragment(
-            y,
-            /** @type {Y.XmlFragment} */
-            leftY,
-            /** @type {PModel.Node} */
-            leftP,
-            mapping
-          );
-          left += 1;
-        } else if (updateRight) {
-          updateYFragment(
-            y,
-            /** @type {Y.XmlFragment} */
-            rightY,
-            /** @type {PModel.Node} */
-            rightP,
-            mapping
-          );
-          right += 1;
-        } else {
-          mapping.delete(yDomFragment.get(left));
-          yDomFragment.delete(left, 1);
-          yDomFragment.insert(left, [
-            createTypeFromTextOrElementNode(leftP, mapping)
-          ]);
-          left += 1;
-        }
-      }
-    }
-    const yDelLen = yChildCnt - left - right;
-    if (yChildCnt === 1 && pChildCnt === 0 && yChildren[0] instanceof YXmlText) {
-      mapping.delete(yChildren[0]);
-      yChildren[0].delete(0, yChildren[0].length);
-    } else if (yDelLen > 0) {
-      yDomFragment.slice(left, left + yDelLen).forEach((type) => mapping.delete(type));
-      yDomFragment.delete(left, yDelLen);
-    }
-    if (left + right < pChildCnt) {
-      const ins = [];
-      for (let i = left; i < pChildCnt - right; i++) {
-        ins.push(createTypeFromTextOrElementNode(pChildren[i], mapping));
-      }
-      yDomFragment.insert(left, ins);
-    }
-  }, ySyncPluginKey);
-};
-var matchNodeName = (yElement, pNode) => !(pNode instanceof Array) && yElement.nodeName === pNode.type.name;
-
-// node_modules/y-prosemirror/src/lib.js
-var absolutePositionToRelativePosition = (pos, type, mapping) => {
-  if (pos === 0) {
-    return createRelativePositionFromTypeIndex(type, 0, -1);
-  }
-  let n = type._first === null ? null : (
-    /** @type {Y.ContentType} */
-    type._first.content.type
+    const blocks2 = richTextBlockExtensions(options.schema, hosts);
+    return [
+      richTextDocumentExtension(blocks2.length > 0),
+      richTextBlockClipboard,
+      ...configured.filter((extension) => extension.name !== "doc"),
+      ...blocks2
+    ];
+  }, [getEntryAnchors, hosts, options.extensions, options.schema]);
+  const content = useMemo(
+    () => editorContent(store.get(fieldNode.value)),
+    [fieldNode, store]
   );
-  while (n !== null && type !== n) {
-    if (n instanceof YXmlText) {
-      if (n._length >= pos) {
-        return createRelativePositionFromTypeIndex(n, pos, -1);
-      } else {
-        pos -= n._length;
-      }
-      if (n._item !== null && n._item.next !== null) {
-        n = /** @type {Y.ContentType} */
-        n._item.next.content.type;
-      } else {
-        do {
-          n = n._item === null ? null : n._item.parent;
-          pos--;
-        } while (n !== type && n !== null && n._item !== null && n._item.next === null);
-        if (n !== null && n !== type) {
-          n = n._item === null ? null : (
-            /** @type {Y.ContentType} */
-            /** @type Y.Item */
-            n._item.next.content.type
-          );
-        }
-      }
-    } else {
-      const pNodeSize = (
-        /** @type {any} */
-        (mapping.get(n) || { nodeSize: 0 }).nodeSize
-      );
-      if (n._first !== null && pos < pNodeSize) {
-        n = /** @type {Y.ContentType} */
-        n._first.content.type;
-        pos--;
-      } else {
-        if (pos === 1 && n._length === 0 && pNodeSize > 1) {
-          return new RelativePosition(n._item === null ? null : n._item.id, n._item === null ? findRootTypeKey(n) : null, null);
-        }
-        pos -= pNodeSize;
-        if (n._item !== null && n._item.next !== null) {
-          n = /** @type {Y.ContentType} */
-          n._item.next.content.type;
-        } else {
-          if (pos === 0) {
-            n = n._item === null ? n : n._item.parent;
-            return new RelativePosition(n._item === null ? null : n._item.id, n._item === null ? findRootTypeKey(n) : null, null);
-          }
-          do {
-            n = /** @type {Y.Item} */
-            n._item.parent;
-            pos--;
-          } while (n !== type && /** @type {Y.Item} */
-          n._item.next === null);
-          if (n !== type) {
-            n = /** @type {Y.ContentType} */
-            /** @type {Y.Item} */
-            /** @type {Y.Item} */
-            n._item.next.content.type;
-          }
-        }
-      }
-    }
-    if (n === null) {
-      throw unexpectedCase();
-    }
-    if (pos === 0 && n.constructor !== YXmlText && n !== type) {
-      return createRelativePosition(n._item.parent, n._item);
-    }
-  }
-  return createRelativePositionFromTypeIndex(type, type._length, -1);
-};
-var createRelativePosition = (type, item) => {
-  let typeid = null;
-  let tname = null;
-  if (type._item === null) {
-    tname = findRootTypeKey(type);
-  } else {
-    typeid = createID(type._item.id.client, type._item.id.clock);
-  }
-  return new RelativePosition(typeid, tname, item.id);
-};
-var relativePositionToAbsolutePosition = (y, documentType, relPos, mapping) => {
-  const decodedPos = createAbsolutePositionFromRelativePosition(relPos, y);
-  if (decodedPos === null || decodedPos.type !== documentType && !isParentOf(documentType, decodedPos.type._item)) {
-    return null;
-  }
-  let type = decodedPos.type;
-  let pos = 0;
-  if (type.constructor === YXmlText) {
-    pos = decodedPos.index;
-  } else if (type._item === null || !type._item.deleted) {
-    let n = type._first;
-    let i = 0;
-    while (i < type._length && i < decodedPos.index && n !== null) {
-      if (!n.deleted) {
-        const t = (
-          /** @type {Y.ContentType} */
-          n.content.type
-        );
-        i++;
-        if (t instanceof YXmlText) {
-          pos += t._length;
-        } else {
-          pos += /** @type {any} */
-          mapping.get(t).nodeSize;
-        }
-      }
-      n = /** @type {Y.Item} */
-      n.right;
-    }
-    pos += 1;
-  }
-  while (type !== documentType && type._item !== null) {
-    const parent = type._item.parent;
-    if (parent._item === null || !parent._item.deleted) {
-      pos += 1;
-      let n = (
-        /** @type {Y.AbstractType} */
-        parent._first
-      );
-      while (n !== null) {
-        const contentType = (
-          /** @type {Y.ContentType} */
-          n.content.type
-        );
-        if (contentType === type) {
-          break;
-        }
-        if (!n.deleted) {
-          if (contentType instanceof YXmlText) {
-            pos += contentType._length;
-          } else {
-            pos += /** @type {any} */
-            mapping.get(contentType).nodeSize;
-          }
-        }
-        n = n.right;
-      }
-    }
-    type = /** @type {Y.AbstractType} */
-    parent;
-  }
-  return pos - 1;
-};
-function yXmlFragmentToProsemirrorJSON(xmlFragment) {
-  const items = xmlFragment.toArray();
-  function serialize(item) {
-    let response;
-    if (!item.nodeName) {
-      const delta = item.toDelta();
-      response = delta.map((d) => {
-        const text = {
-          type: "text",
-          text: d.insert
-        };
-        if (d.attributes) {
-          text.marks = Object.keys(d.attributes).map((type) => {
-            const attrs = d.attributes[type];
-            const mark = {
-              type
-            };
-            if (Object.keys(attrs)) {
-              mark.attrs = attrs;
-            }
-            return mark;
-          });
-        }
-        return text;
-      });
-    } else {
-      response = {
-        type: item.nodeName
-      };
-      const attrs = item.getAttributes();
-      if (Object.keys(attrs).length) {
-        response.attrs = attrs;
-      }
-      const children = item.toArray();
-      if (children.length) {
-        response.content = children.map(serialize).flat();
-      }
-    }
-    return response;
-  }
-  return {
-    type: "doc",
-    content: items.map(serialize)
-  };
-}
-
-// node_modules/y-prosemirror/src/plugins/undo-plugin.js
-var undo = (state) => {
-  const undoManager = yUndoPluginKey.getState(state).undoManager;
-  if (undoManager != null) {
-    undoManager.undo();
-    return true;
-  }
-};
-var redo = (state) => {
-  const undoManager = yUndoPluginKey.getState(state).undoManager;
-  if (undoManager != null) {
-    undoManager.redo();
-    return true;
-  }
-};
-var defaultProtectedNodes = /* @__PURE__ */ new Set(["paragraph"]);
-var defaultDeleteFilter = (item, protectedNodes) => !(item instanceof Item) || !(item.content instanceof ContentType) || !(item.content.type instanceof YText || item.content.type instanceof YXmlElement && protectedNodes.has(item.content.type.nodeName)) || item.content.type._length === 0;
-var yUndoPlugin = ({ protectedNodes = defaultProtectedNodes, trackedOrigins = [], undoManager = null } = {}) => new Plugin({
-  key: yUndoPluginKey,
-  state: {
-    init: (initargs, state) => {
-      const ystate = ySyncPluginKey.getState(state);
-      const _undoManager = undoManager || new UndoManager(ystate.type, {
-        trackedOrigins: new Set([ySyncPluginKey].concat(trackedOrigins)),
-        deleteFilter: (item) => defaultDeleteFilter(item, protectedNodes),
-        captureTransaction: (tr) => tr.meta.get("addToHistory") !== false
-      });
+  const resolveBlock = useCallback(
+    function resolveBlock2(id, typeName, snapshot) {
+      const pending = pendingBlocks.current.get(id);
+      if (pending) return pending;
+      const part = blocksByIdRef.current.get(id);
+      if (part) {
+        const value = store.get(part.node.value);
+        if (Node.isBlock(value)) return value;
+      }
+      if (snapshot?.[Node.type] === typeName) return snapshot;
+      const type = options.schema?.[typeName];
+      if (!type) return;
       return {
-        undoManager: _undoManager,
-        prevSel: null,
-        hasUndoOps: _undoManager.undoStack.length > 0,
-        hasRedoOps: _undoManager.redoStack.length > 0
+        [Node.type]: typeName,
+        [BlockNode.id]: id,
+        ...Type.initialValue(type)
       };
     },
-    /**
-     * @returns {any}
-     */
-    apply: (tr, val, oldState, state) => {
-      const binding = ySyncPluginKey.getState(state).binding;
-      const undoManager2 = val.undoManager;
-      const hasUndoOps = undoManager2.undoStack.length > 0;
-      const hasRedoOps = undoManager2.redoStack.length > 0;
-      if (binding) {
-        return {
-          undoManager: undoManager2,
-          prevSel: getRelativeSelection(binding, oldState),
-          hasUndoOps,
-          hasRedoOps
-        };
-      } else {
-        if (hasUndoOps !== val.hasUndoOps || hasRedoOps !== val.hasRedoOps) {
-          return Object.assign({}, val, {
-            hasUndoOps: undoManager2.undoStack.length > 0,
-            hasRedoOps: undoManager2.redoStack.length > 0
-          });
-        } else {
-          return val;
-        }
-      }
+    [options.schema, store]
+  );
+  const editor = useEditor({
+    content,
+    extensions,
+    editable: !readOnly,
+    onCreate({ editor: editor2 }) {
+      setEditorReadOnly(editor2, readOnly);
+      lastEditorDocument.current = documentStructureKey(
+        editorNodes(editor2.getJSON(), resolveBlock)
+      );
+    },
+    onFocus({ editor: editor2 }) {
+      setActiveEditor(editor2);
+      setFocused(true);
+    },
+    onUpdate({ editor: editor2, transaction }) {
+      if (!transaction.docChanged) return;
+      const next = editorNodes(editor2.getJSON(), resolveBlock);
+      const nextKey = documentStructureKey(next);
+      if (pendingExternalDocument.current && nextKey === lastEditorDocument.current)
+        return;
+      lastEditorDocument.current = nextKey;
+      if (nextKey === pendingExternalDocument.current)
+        pendingExternalDocument.current = void 0;
+      updateDocument(next);
+      for (const node of next)
+        if (Node.isBlock(node))
+          pendingBlocks.current.delete(String(node[BlockNode.id]));
     }
-  },
-  view: (view) => {
-    const ystate = ySyncPluginKey.getState(view.state);
-    const undoManager2 = yUndoPluginKey.getState(view.state).undoManager;
-    undoManager2.on("stack-item-added", ({ stackItem }) => {
-      const binding = ystate.binding;
-      if (binding) {
-        stackItem.meta.set(binding, yUndoPluginKey.getState(view.state).prevSel);
-      }
+  });
+  useEffect(() => {
+    if (editor) setEditorReadOnly(editor, readOnly);
+  }, [editor, readOnly]);
+  useEffect(() => {
+    if (!editor) return;
+    const current = editorNodes(editor.getJSON(), resolveBlock);
+    if (documentKey === documentStructureKey(current)) return;
+    const documentValue = store.get(fieldNode.value);
+    editor.commands.setContent(editorContent(documentValue), {
+      emitUpdate: false
     });
-    undoManager2.on("stack-item-popped", ({ stackItem }) => {
-      const binding = ystate.binding;
-      if (binding) {
-        binding.beforeTransactionSelection = stackItem.meta.get(binding) || binding.beforeTransactionSelection;
-      }
+    lastEditorDocument.current = documentKey;
+    pendingExternalDocument.current = void 0;
+  }, [documentKey, editor, fieldNode, resolveBlock, store]);
+  const toolbarTarget = typeof document === "undefined" ? null : document.getElementById("alinea-toolbar");
+  function insertBlock(block) {
+    if (!editor || editor.state.selection.$from.depth !== 1) return;
+    const id = String(block[BlockNode.id]);
+    pendingBlocks.current.set(id, block);
+    const inserted = editor.chain().insertContent({ type: block[Node.type], attrs: { [BlockNode.id]: id } }).run();
+    if (!inserted) pendingBlocks.current.delete(id);
+  }
+  function checkFocus() {
+    requestAnimationFrame(() => {
+      const target = document.activeElement;
+      setFocused(ownsFocus(target));
+      setInnerBlockFocused(isInnerBlockField(target));
     });
-    return {
-      destroy: () => {
-        undoManager2.destroy();
-      }
-    };
-  }
-});
-
-// node_modules/@tiptap/extension-collaboration/dist/index.js
-var Collaboration = Extension.create({
-  name: "collaboration",
-  priority: 1e3,
-  addOptions() {
-    return {
-      document: null,
-      field: "default",
-      fragment: null
-    };
-  },
-  addStorage() {
-    return {
-      isDisabled: false
-    };
-  },
-  onCreate() {
-    if (this.editor.extensionManager.extensions.find((extension) => extension.name === "history")) {
-      console.warn('[tiptap warn]: "@tiptap/extension-collaboration" comes with its own history support and is not compatible with "@tiptap/extension-history".');
-    }
-  },
-  addCommands() {
-    return {
-      undo: () => ({ tr, state, dispatch }) => {
-        tr.setMeta("preventDispatch", true);
-        const undoManager = yUndoPluginKey.getState(state).undoManager;
-        if (undoManager.undoStack.length === 0) {
-          return false;
-        }
-        if (!dispatch) {
-          return true;
-        }
-        return undo(state);
-      },
-      redo: () => ({ tr, state, dispatch }) => {
-        tr.setMeta("preventDispatch", true);
-        const undoManager = yUndoPluginKey.getState(state).undoManager;
-        if (undoManager.redoStack.length === 0) {
-          return false;
-        }
-        if (!dispatch) {
-          return true;
-        }
-        return redo(state);
-      }
-    };
-  },
-  addKeyboardShortcuts() {
-    return {
-      "Mod-z": () => this.editor.commands.undo(),
-      "Mod-y": () => this.editor.commands.redo(),
-      "Shift-Mod-z": () => this.editor.commands.redo()
-    };
-  },
-  addProseMirrorPlugins() {
-    var _a;
-    const fragment = this.options.fragment ? this.options.fragment : this.options.document.getXmlFragment(this.options.field);
-    const yUndoPluginInstance = yUndoPlugin(this.options.yUndoOptions);
-    const originalUndoPluginView = yUndoPluginInstance.spec.view;
-    yUndoPluginInstance.spec.view = (view) => {
-      const { undoManager } = yUndoPluginKey.getState(view.state);
-      if (undoManager.restore) {
-        undoManager.restore();
-        undoManager.restore = () => {
-        };
-      }
-      const viewRet = originalUndoPluginView ? originalUndoPluginView(view) : void 0;
-      return {
-        destroy: () => {
-          const hasUndoManSelf = undoManager.trackedOrigins.has(undoManager);
-          const observers = undoManager._observers;
-          undoManager.restore = () => {
-            if (hasUndoManSelf) {
-              undoManager.trackedOrigins.add(undoManager);
-            }
-            undoManager.doc.on("afterTransaction", undoManager.afterTransactionHandler);
-            undoManager._observers = observers;
-          };
-          if (viewRet === null || viewRet === void 0 ? void 0 : viewRet.destroy) {
-            viewRet.destroy();
-          }
-        }
-      };
-    };
-    const ySyncPluginOptions = {
-      ...this.options.ySyncOptions,
-      onFirstRender: this.options.onFirstRender
-    };
-    const ySyncPluginInstance = ySyncPlugin(fragment, ySyncPluginOptions);
-    if (this.editor.options.enableContentCheck) {
-      (_a = fragment.doc) === null || _a === void 0 ? void 0 : _a.on("beforeTransaction", () => {
-        try {
-          const jsonContent = yXmlFragmentToProsemirrorJSON(fragment);
-          if (jsonContent.content.length === 0) {
-            return;
-          }
-          this.editor.schema.nodeFromJSON(jsonContent).check();
-        } catch (error) {
-          this.editor.emit("contentError", {
-            error,
-            editor: this.editor,
-            disableCollaboration: () => {
-              var _a2;
-              (_a2 = fragment.doc) === null || _a2 === void 0 ? void 0 : _a2.destroy();
-              this.storage.isDisabled = true;
-            }
-          });
-          return false;
-        }
-      });
-    }
-    return [
-      ySyncPluginInstance,
-      yUndoPluginInstance,
-      // Only add the filterInvalidContent plugin if content checking is enabled
-      this.editor.options.enableContentCheck && new Plugin({
-        key: new PluginKey("filterInvalidContent"),
-        filterTransaction: () => {
-          var _a2;
-          if (this.storage.isDisabled) {
-            (_a2 = fragment.doc) === null || _a2 === void 0 ? void 0 : _a2.destroy();
-            return true;
-          }
-          return true;
-        }
-      })
-    ].filter(Boolean);
-  }
-});
-
-// node_modules/@tiptap/react/dist/index.js
-import React, { forwardRef, useState, useDebugValue, useLayoutEffect, useEffect, useRef, createContext, useContext } from "react";
-import ReactDOM, { flushSync } from "react-dom";
-var shim = { exports: {} };
-var useSyncExternalStoreShim_production_min = {};
-var hasRequiredUseSyncExternalStoreShim_production_min;
-function requireUseSyncExternalStoreShim_production_min() {
-  if (hasRequiredUseSyncExternalStoreShim_production_min) return useSyncExternalStoreShim_production_min;
-  hasRequiredUseSyncExternalStoreShim_production_min = 1;
-  var e = React;
-  function h(a, b) {
-    return a === b && (0 !== a || 1 / a === 1 / b) || a !== a && b !== b;
   }
-  var k = "function" === typeof Object.is ? Object.is : h, l = e.useState, m = e.useEffect, n = e.useLayoutEffect, p = e.useDebugValue;
-  function q(a, b) {
-    var d = b(), f = l({ inst: { value: d, getSnapshot: b } }), c = f[0].inst, g = f[1];
-    n(function() {
-      c.value = d;
-      c.getSnapshot = b;
-      r(c) && g({ inst: c });
-    }, [a, d, b]);
-    m(function() {
-      r(c) && g({ inst: c });
-      return a(function() {
-        r(c) && g({ inst: c });
-      });
-    }, [a]);
-    p(d);
-    return d;
+  function handleBlur(nextTarget) {
+    if (nextTarget instanceof HTMLElement) {
+      setFocused(ownsFocus(nextTarget));
+      setInnerBlockFocused(isInnerBlockField(nextTarget));
+    } else checkFocus();
   }
-  function r(a) {
-    var b = a.getSnapshot;
-    a = a.value;
-    try {
-      var d = b();
-      return !k(a, d);
-    } catch (f) {
-      return true;
-    }
+  function ownsFocus(target) {
+    if (!(target instanceof HTMLElement)) return false;
+    const richText = target.closest("[data-richtext-field]");
+    if (richText && richText !== root.current) return false;
+    if (root.current?.contains(target)) return true;
+    const toolbar = target.closest("[data-richtext-toolbar-owner]");
+    return toolbar?.dataset.richtextToolbarOwner === ownerId;
   }
-  function t(a, b) {
-    return b();
+  function isInnerBlockField(target) {
+    return target instanceof HTMLElement && root.current?.contains(target) === true && target.closest("[data-richtext-block-editor]") !== null;
   }
-  var u = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? t : q;
-  useSyncExternalStoreShim_production_min.useSyncExternalStore = void 0 !== e.useSyncExternalStore ? e.useSyncExternalStore : u;
-  return useSyncExternalStoreShim_production_min;
-}
-var useSyncExternalStoreShim_development = {};
-var hasRequiredUseSyncExternalStoreShim_development;
-function requireUseSyncExternalStoreShim_development() {
-  if (hasRequiredUseSyncExternalStoreShim_development) return useSyncExternalStoreShim_development;
-  hasRequiredUseSyncExternalStoreShim_development = 1;
-  if (process.env.NODE_ENV !== "production") {
-    (function() {
-      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") {
-        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
-      }
-      var React$1 = React;
-      var ReactSharedInternals = React$1.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
-      function error(format) {
-        {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(PickTextLink, { picker }),
+    /* @__PURE__ */ jsx(PickTextAnchor, { picker: anchorPicker }),
+    /* @__PURE__ */ jsx(
+      Label,
+      {
+        description: options.help,
+        errorMessage: error,
+        isRequired: options.required,
+        label: options.label,
+        shared: options.shared,
+        children: /* @__PURE__ */ jsxs(
+          "div",
           {
-            for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-              args[_key2 - 1] = arguments[_key2];
-            }
-            printWarning("error", format, args);
-          }
-        }
-      }
-      function printWarning(level, format, args) {
-        {
-          var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
-          var stack = ReactDebugCurrentFrame.getStackAddendum();
-          if (stack !== "") {
-            format += "%s";
-            args = args.concat([stack]);
+            ref: root,
+            className: styles.RichTextFieldView(),
+            "data-richtext-field": ownerId,
+            "data-inline": options.inline || void 0,
+            "data-invalid": Boolean(error) || void 0,
+            "data-focused": focused && !innerBlockFocused && !readOnly ? "true" : void 0,
+            "data-read-only": readOnly || void 0,
+            onFocusCapture: (event) => {
+              setFocused(ownsFocus(event.target));
+              setInnerBlockFocused(isInnerBlockField(event.target));
+            },
+            onBlurCapture: (event) => handleBlur(event.relatedTarget),
+            children: [
+              editor && !readOnly && options.schema && /* @__PURE__ */ jsx(
+                RichTextInsertMenu,
+                {
+                  editor,
+                  schema: options.schema,
+                  onInsert: insertBlock
+                }
+              ),
+              /* @__PURE__ */ jsx(EditorContent, { editor }),
+              editor && /* @__PURE__ */ jsx(
+                RichTextBlockPortals,
+                {
+                  blocksById,
+                  editor,
+                  hosts,
+                  pendingBlocks: pendingBlocks.current,
+                  readOnly,
+                  schema: options.schema,
+                  store
+                }
+              )
+            ]
           }
-          var argsWithFormat = args.map(function(item) {
-            return String(item);
-          });
-          argsWithFormat.unshift("Warning: " + format);
-          Function.prototype.apply.call(console[level], console, argsWithFormat);
-        }
-      }
-      function is(x, y) {
-        return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
+        )
       }
-      var objectIs = typeof Object.is === "function" ? Object.is : is;
-      var useState3 = React$1.useState, useEffect3 = React$1.useEffect, useLayoutEffect2 = React$1.useLayoutEffect, useDebugValue2 = React$1.useDebugValue;
-      var didWarnOld18Alpha = false;
-      var didWarnUncachedGetSnapshot = false;
-      function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
-        {
-          if (!didWarnOld18Alpha) {
-            if (React$1.startTransition !== void 0) {
-              didWarnOld18Alpha = true;
-              error("You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release.");
-            }
-          }
-        }
-        var value = getSnapshot();
+    ),
+    toolbarTarget && editor && activeEditor === editor && focused && !readOnly ? createPortal(
+      /* @__PURE__ */ jsx(
+        RichTextToolbar,
         {
-          if (!didWarnUncachedGetSnapshot) {
-            var cachedValue = getSnapshot();
-            if (!objectIs(value, cachedValue)) {
-              error("The result of getSnapshot should be cached to avoid an infinite loop");
-              didWarnUncachedGetSnapshot = true;
-            }
-          }
-        }
-        var _useState = useState3({
-          inst: {
-            value,
-            getSnapshot
+          editor,
+          enableTables: options.enableTables,
+          ownerId,
+          pickLink: picker.pickLink,
+          pickAnchor: anchorPicker.pickAnchor,
+          getEntryAnchors,
+          toolbar: options.toolbar,
+          onFocusChange: (next, nextTarget) => {
+            if (next) setFocused(true);
+            else handleBlur(nextTarget ?? null);
           }
-        }), inst = _useState[0].inst, forceUpdate = _useState[1];
-        useLayoutEffect2(function() {
-          inst.value = value;
-          inst.getSnapshot = getSnapshot;
-          if (checkIfSnapshotChanged(inst)) {
-            forceUpdate({
-              inst
-            });
-          }
-        }, [subscribe, value, getSnapshot]);
-        useEffect3(function() {
-          if (checkIfSnapshotChanged(inst)) {
-            forceUpdate({
-              inst
-            });
-          }
-          var handleStoreChange = function() {
-            if (checkIfSnapshotChanged(inst)) {
-              forceUpdate({
-                inst
-              });
-            }
-          };
-          return subscribe(handleStoreChange);
-        }, [subscribe]);
-        useDebugValue2(value);
-        return value;
-      }
-      function checkIfSnapshotChanged(inst) {
-        var latestGetSnapshot = inst.getSnapshot;
-        var prevValue = inst.value;
-        try {
-          var nextValue = latestGetSnapshot();
-          return !objectIs(prevValue, nextValue);
-        } catch (error2) {
-          return true;
         }
-      }
-      function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {
-        return getSnapshot();
-      }
-      var canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
-      var isServerEnvironment = !canUseDOM;
-      var shim2 = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore;
-      var useSyncExternalStore$2 = React$1.useSyncExternalStore !== void 0 ? React$1.useSyncExternalStore : shim2;
-      useSyncExternalStoreShim_development.useSyncExternalStore = useSyncExternalStore$2;
-      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") {
-        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
-      }
-    })();
-  }
-  return useSyncExternalStoreShim_development;
+      ),
+      toolbarTarget
+    ) : null
+  ] });
 }
-if (process.env.NODE_ENV === "production") {
-  shim.exports = requireUseSyncExternalStoreShim_production_min();
-} else {
-  shim.exports = requireUseSyncExternalStoreShim_development();
+function setEditorReadOnly(editor, readOnly) {
+  if (editor.isDestroyed) return;
+  editor.setEditable(!readOnly, false);
+  editor.view.dom.contentEditable = readOnly ? "false" : "plaintext-only";
 }
-var shimExports = shim.exports;
-var mergeRefs = (...refs) => {
-  return (node) => {
-    refs.forEach((ref) => {
-      if (typeof ref === "function") {
-        ref(node);
-      } else if (ref) {
-        ref.current = node;
-      }
-    });
-  };
-};
-var Portals = ({ contentComponent }) => {
-  const renderers = shimExports.useSyncExternalStore(contentComponent.subscribe, contentComponent.getSnapshot, contentComponent.getServerSnapshot);
-  return React.createElement(React.Fragment, null, Object.values(renderers));
-};
-function getInstance() {
-  const subscribers = /* @__PURE__ */ new Set();
-  let renderers = {};
-  return {
-    /**
-     * Subscribe to the editor instance's changes.
-     */
-    subscribe(callback) {
-      subscribers.add(callback);
-      return () => {
-        subscribers.delete(callback);
-      };
-    },
-    getSnapshot() {
-      return renderers;
-    },
-    getServerSnapshot() {
-      return renderers;
-    },
-    /**
-     * Adds a new NodeView Renderer to the editor.
-     */
-    setRenderer(id, renderer) {
-      renderers = {
-        ...renderers,
-        [id]: ReactDOM.createPortal(renderer.reactElement, renderer.element, id)
-      };
-      subscribers.forEach((subscriber) => subscriber());
-    },
-    /**
-     * Removes a NodeView Renderer from the editor.
-     */
-    removeRenderer(id) {
-      const nextRenderers = { ...renderers };
-      delete nextRenderers[id];
-      renderers = nextRenderers;
-      subscribers.forEach((subscriber) => subscriber());
-    }
-  };
-}
-var PureEditorContent = class extends React.Component {
-  constructor(props) {
-    var _a;
-    super(props);
-    this.editorContentRef = React.createRef();
-    this.initialized = false;
-    this.state = {
-      hasContentComponentInitialized: Boolean((_a = props.editor) === null || _a === void 0 ? void 0 : _a.contentComponent)
-    };
-  }
-  componentDidMount() {
-    this.init();
-  }
-  componentDidUpdate() {
-    this.init();
-  }
-  init() {
-    const editor = this.props.editor;
-    if (editor && !editor.isDestroyed && editor.options.element) {
-      if (editor.contentComponent) {
-        return;
-      }
-      const element = this.editorContentRef.current;
-      element.append(...editor.options.element.childNodes);
-      editor.setOptions({
-        element
-      });
-      editor.contentComponent = getInstance();
-      if (!this.state.hasContentComponentInitialized) {
-        this.unsubscribeToContentComponent = editor.contentComponent.subscribe(() => {
-          this.setState((prevState) => {
-            if (!prevState.hasContentComponentInitialized) {
-              return {
-                hasContentComponentInitialized: true
-              };
-            }
-            return prevState;
-          });
-          if (this.unsubscribeToContentComponent) {
-            this.unsubscribeToContentComponent();
+function RichTextBlockPortals({
+  blocksById,
+  editor,
+  hosts,
+  pendingBlocks,
+  readOnly,
+  schema,
+  store
+}) {
+  const mounted = useSyncExternalStore(
+    hosts.subscribe,
+    hosts.snapshot,
+    hosts.snapshot
+  );
+  function remove(host) {
+    const position = host.getPos();
+    if (typeof position !== "number") return;
+    editor.commands.deleteRange({ from: position, to: position + 1 });
+  }
+  function duplicate(host, part) {
+    const position = host.getPos();
+    if (typeof position !== "number") return;
+    const value = store.get(part.node.value);
+    if (!Node.isBlock(value)) return;
+    const id = createId();
+    const block = { ...value, [BlockNode.id]: id };
+    pendingBlocks.set(id, block);
+    const inserted = editor.chain().insertContentAt(position + 1, {
+      type: host.typeName,
+      attrs: { [BlockNode.id]: id }
+    }).run();
+    if (!inserted) pendingBlocks.delete(id);
+  }
+  return mounted.map((host) => {
+    const part = blocksById.get(host.id);
+    const type = schema?.[host.typeName];
+    if (!part || !type) return null;
+    return createPortal(
+      /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(RichTextBlockSnapshot, { editor, host, node: part.node }),
+        /* @__PURE__ */ jsx(
+          RichTextBlock,
+          {
+            id: part.id,
+            node: part.node,
+            type,
+            readOnly,
+            onDelete: () => remove(host),
+            onDuplicate: () => duplicate(host, part)
           }
-        });
-      }
-      editor.createNodeViews();
-      this.initialized = true;
-    }
-  }
-  componentWillUnmount() {
-    const editor = this.props.editor;
-    if (!editor) {
-      return;
-    }
-    this.initialized = false;
-    if (!editor.isDestroyed) {
-      editor.view.setProps({
-        nodeViews: {}
-      });
-    }
-    if (this.unsubscribeToContentComponent) {
-      this.unsubscribeToContentComponent();
-    }
-    editor.contentComponent = null;
-    if (!editor.options.element.firstChild) {
-      return;
-    }
-    const newElement = document.createElement("div");
-    newElement.append(...editor.options.element.childNodes);
-    editor.setOptions({
-      element: newElement
-    });
-  }
-  render() {
-    const { editor, innerRef, ...rest } = this.props;
-    return React.createElement(
-      React.Fragment,
-      null,
-      React.createElement("div", { ref: mergeRefs(innerRef, this.editorContentRef), ...rest }),
-      (editor === null || editor === void 0 ? void 0 : editor.contentComponent) && React.createElement(Portals, { contentComponent: editor.contentComponent })
+        )
+      ] }),
+      host.dom,
+      host.id
     );
-  }
-};
-var EditorContentWithKey = forwardRef((props, ref) => {
-  const key = React.useMemo(() => {
-    return Math.floor(Math.random() * 4294967295).toString();
-  }, [props.editor]);
-  return React.createElement(PureEditorContent, {
-    key,
-    innerRef: ref,
-    ...props
   });
-});
-var EditorContent = React.memo(EditorContentWithKey);
-var withSelector = { exports: {} };
-var withSelector_production_min = {};
-var hasRequiredWithSelector_production_min;
-function requireWithSelector_production_min() {
-  if (hasRequiredWithSelector_production_min) return withSelector_production_min;
-  hasRequiredWithSelector_production_min = 1;
-  var h = React, n = shimExports;
-  function p(a, b) {
-    return a === b && (0 !== a || 1 / a === 1 / b) || a !== a && b !== b;
-  }
-  var q = "function" === typeof Object.is ? Object.is : p, r = n.useSyncExternalStore, t = h.useRef, u = h.useEffect, v = h.useMemo, w = h.useDebugValue;
-  withSelector_production_min.useSyncExternalStoreWithSelector = function(a, b, e, l, g) {
-    var c = t(null);
-    if (null === c.current) {
-      var f = { hasValue: false, value: null };
-      c.current = f;
-    } else f = c.current;
-    c = v(function() {
-      function a2(a3) {
-        if (!c2) {
-          c2 = true;
-          d2 = a3;
-          a3 = l(a3);
-          if (void 0 !== g && f.hasValue) {
-            var b2 = f.value;
-            if (g(b2, a3)) return k = b2;
-          }
-          return k = a3;
-        }
-        b2 = k;
-        if (q(d2, a3)) return b2;
-        var e2 = l(a3);
-        if (void 0 !== g && g(b2, e2)) return b2;
-        d2 = a3;
-        return k = e2;
-      }
-      var c2 = false, d2, k, m = void 0 === e ? null : e;
-      return [function() {
-        return a2(b());
-      }, null === m ? void 0 : function() {
-        return a2(m());
-      }];
-    }, [b, e, l, g]);
-    var d = r(a, c[0], c[1]);
-    u(function() {
-      f.hasValue = true;
-      f.value = d;
-    }, [d]);
-    w(d);
-    return d;
-  };
-  return withSelector_production_min;
 }
-var withSelector_development = {};
-var hasRequiredWithSelector_development;
-function requireWithSelector_development() {
-  if (hasRequiredWithSelector_development) return withSelector_development;
-  hasRequiredWithSelector_development = 1;
-  if (process.env.NODE_ENV !== "production") {
-    (function() {
-      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") {
-        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
-      }
-      var React$1 = React;
-      var shim2 = shimExports;
-      function is(x, y) {
-        return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
-      }
-      var objectIs = typeof Object.is === "function" ? Object.is : is;
-      var useSyncExternalStore = shim2.useSyncExternalStore;
-      var useRef3 = React$1.useRef, useEffect3 = React$1.useEffect, useMemo2 = React$1.useMemo, useDebugValue2 = React$1.useDebugValue;
-      function useSyncExternalStoreWithSelector(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
-        var instRef = useRef3(null);
-        var inst;
-        if (instRef.current === null) {
-          inst = {
-            hasValue: false,
-            value: null
-          };
-          instRef.current = inst;
-        } else {
-          inst = instRef.current;
-        }
-        var _useMemo = useMemo2(function() {
-          var hasMemo = false;
-          var memoizedSnapshot;
-          var memoizedSelection;
-          var memoizedSelector = function(nextSnapshot) {
-            if (!hasMemo) {
-              hasMemo = true;
-              memoizedSnapshot = nextSnapshot;
-              var _nextSelection = selector(nextSnapshot);
-              if (isEqual !== void 0) {
-                if (inst.hasValue) {
-                  var currentSelection = inst.value;
-                  if (isEqual(currentSelection, _nextSelection)) {
-                    memoizedSelection = currentSelection;
-                    return currentSelection;
-                  }
-                }
-              }
-              memoizedSelection = _nextSelection;
-              return _nextSelection;
-            }
-            var prevSnapshot = memoizedSnapshot;
-            var prevSelection = memoizedSelection;
-            if (objectIs(prevSnapshot, nextSnapshot)) {
-              return prevSelection;
-            }
-            var nextSelection = selector(nextSnapshot);
-            if (isEqual !== void 0 && isEqual(prevSelection, nextSelection)) {
-              return prevSelection;
-            }
-            memoizedSnapshot = nextSnapshot;
-            memoizedSelection = nextSelection;
-            return nextSelection;
-          };
-          var maybeGetServerSnapshot = getServerSnapshot === void 0 ? null : getServerSnapshot;
-          var getSnapshotWithSelector = function() {
-            return memoizedSelector(getSnapshot());
-          };
-          var getServerSnapshotWithSelector = maybeGetServerSnapshot === null ? void 0 : function() {
-            return memoizedSelector(maybeGetServerSnapshot());
-          };
-          return [getSnapshotWithSelector, getServerSnapshotWithSelector];
-        }, [getSnapshot, getServerSnapshot, selector, isEqual]), getSelection = _useMemo[0], getServerSelection = _useMemo[1];
-        var value = useSyncExternalStore(subscribe, getSelection, getServerSelection);
-        useEffect3(function() {
-          inst.hasValue = true;
-          inst.value = value;
-        }, [value]);
-        useDebugValue2(value);
-        return value;
-      }
-      withSelector_development.useSyncExternalStoreWithSelector = useSyncExternalStoreWithSelector;
-      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") {
-        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
-      }
-    })();
-  }
-  return withSelector_development;
-}
-if (process.env.NODE_ENV === "production") {
-  withSelector.exports = requireWithSelector_production_min();
-} else {
-  withSelector.exports = requireWithSelector_development();
-}
-var withSelectorExports = withSelector.exports;
-var isDev = process.env.NODE_ENV !== "production";
-var isSSR = typeof window === "undefined";
-var isNext = isSSR || Boolean(typeof window !== "undefined" && window.next);
-var EditorContext = createContext({
-  editor: null
-});
-var EditorConsumer = EditorContext.Consumer;
-var useCurrentEditor = () => useContext(EditorContext);
-var FloatingMenu = (props) => {
-  const [element, setElement] = useState(null);
-  const { editor: currentEditor } = useCurrentEditor();
+function RichTextBlockSnapshot({
+  editor,
+  host,
+  node
+}) {
+  const value = useAtomValue(node.value);
   useEffect(() => {
-    var _a;
-    if (!element) {
-      return;
-    }
-    if (((_a = props.editor) === null || _a === void 0 ? void 0 : _a.isDestroyed) || (currentEditor === null || currentEditor === void 0 ? void 0 : currentEditor.isDestroyed)) {
-      return;
-    }
-    const { pluginKey = "floatingMenu", editor, tippyOptions = {}, shouldShow = null } = props;
-    const menuEditor = editor || currentEditor;
-    if (!menuEditor) {
-      console.warn("FloatingMenu component is not rendered inside of an editor component or does not have editor prop.");
-      return;
-    }
-    const plugin = FloatingMenuPlugin({
-      pluginKey,
-      editor: menuEditor,
-      element,
-      tippyOptions,
-      shouldShow
-    });
-    menuEditor.registerPlugin(plugin);
-    return () => {
-      menuEditor.unregisterPlugin(pluginKey);
-    };
-  }, [
-    props.editor,
-    currentEditor,
-    element
-  ]);
-  return React.createElement("div", { ref: setElement, className: props.className, style: { visibility: "hidden" } }, props.children);
-};
-var ReactNodeViewContext = createContext({
-  onDragStart: void 0
-});
-var useReactNodeView = () => useContext(ReactNodeViewContext);
-var NodeViewWrapper = React.forwardRef((props, ref) => {
-  const { onDragStart } = useReactNodeView();
-  const Tag = props.as || "div";
-  return (
-    // @ts-ignore
-    React.createElement(Tag, { ...props, ref, "data-node-view-wrapper": "", onDragStart, style: {
-      whiteSpace: "normal",
-      ...props.style
-    } })
-  );
-});
-function isClassComponent(Component) {
-  return !!(typeof Component === "function" && Component.prototype && Component.prototype.isReactComponent);
-}
-function isForwardRefComponent(Component) {
-  var _a;
-  return !!(typeof Component === "object" && ((_a = Component.$$typeof) === null || _a === void 0 ? void 0 : _a.toString()) === "Symbol(react.forward_ref)");
-}
-var ReactRenderer = class {
-  /**
-   * Immediately creates element and renders the provided React component.
-   */
-  constructor(component, { editor, props = {}, as = "div", className = "" }) {
-    this.ref = null;
-    this.id = Math.floor(Math.random() * 4294967295).toString();
-    this.component = component;
-    this.editor = editor;
-    this.props = props;
-    this.element = document.createElement(as);
-    this.element.classList.add("react-renderer");
-    if (className) {
-      this.element.classList.add(...className.split(" "));
-    }
-    if (this.editor.isInitialized) {
-      flushSync(() => {
-        this.render();
-      });
-    } else {
-      this.render();
-    }
-  }
-  /**
-   * Render the React component.
-   */
-  render() {
-    var _a;
-    const Component = this.component;
-    const props = this.props;
-    const editor = this.editor;
-    if (isClassComponent(Component) || isForwardRefComponent(Component)) {
-      props.ref = (ref) => {
-        this.ref = ref;
-      };
-    }
-    this.reactElement = React.createElement(Component, { ...props });
-    (_a = editor === null || editor === void 0 ? void 0 : editor.contentComponent) === null || _a === void 0 ? void 0 : _a.setRenderer(this.id, this);
-  }
-  /**
-   * Re-renders the React component with new props.
-   */
-  updateProps(props = {}) {
-    this.props = {
-      ...this.props,
-      ...props
-    };
-    this.render();
-  }
-  /**
-   * Destroy the React component.
-   */
-  destroy() {
-    var _a;
-    const editor = this.editor;
-    (_a = editor === null || editor === void 0 ? void 0 : editor.contentComponent) === null || _a === void 0 ? void 0 : _a.removeRenderer(this.id);
-  }
-  /**
-   * Update the attributes of the element that holds the React component.
-   */
-  updateAttributes(attributes) {
-    Object.keys(attributes).forEach((key) => {
-      this.element.setAttribute(key, attributes[key]);
-    });
-  }
-};
-var ReactNodeView = class extends NodeView {
-  /**
-   * Setup the React component.
-   * Called on initialization.
-   */
-  mount() {
-    const props = {
-      editor: this.editor,
-      node: this.node,
-      decorations: this.decorations,
-      innerDecorations: this.innerDecorations,
-      view: this.view,
-      selected: false,
-      extension: this.extension,
-      HTMLAttributes: this.HTMLAttributes,
-      getPos: () => this.getPos(),
-      updateAttributes: (attributes = {}) => this.updateAttributes(attributes),
-      deleteNode: () => this.deleteNode()
-    };
-    if (!this.component.displayName) {
-      const capitalizeFirstChar = (string) => {
-        return string.charAt(0).toUpperCase() + string.substring(1);
-      };
-      this.component.displayName = capitalizeFirstChar(this.extension.name);
-    }
-    const onDragStart = this.onDragStart.bind(this);
-    const nodeViewContentRef = (element) => {
-      if (element && this.contentDOMElement && element.firstChild !== this.contentDOMElement) {
-        element.appendChild(this.contentDOMElement);
-      }
-    };
-    const context = { onDragStart, nodeViewContentRef };
-    const Component = this.component;
-    const ReactNodeViewProvider = React.memo((componentProps) => {
-      return React.createElement(ReactNodeViewContext.Provider, { value: context }, React.createElement(Component, componentProps));
-    });
-    ReactNodeViewProvider.displayName = "ReactNodeView";
-    if (this.node.isLeaf) {
-      this.contentDOMElement = null;
-    } else if (this.options.contentDOMElementTag) {
-      this.contentDOMElement = document.createElement(this.options.contentDOMElementTag);
-    } else {
-      this.contentDOMElement = document.createElement(this.node.isInline ? "span" : "div");
-    }
-    if (this.contentDOMElement) {
-      this.contentDOMElement.dataset.nodeViewContentReact = "";
-      this.contentDOMElement.style.whiteSpace = "inherit";
-    }
-    let as = this.node.isInline ? "span" : "div";
-    if (this.options.as) {
-      as = this.options.as;
-    }
-    const { className = "" } = this.options;
-    this.handleSelectionUpdate = this.handleSelectionUpdate.bind(this);
-    this.renderer = new ReactRenderer(ReactNodeViewProvider, {
-      editor: this.editor,
-      props,
-      as,
-      className: `node-${this.node.type.name} ${className}`.trim()
-    });
-    this.editor.on("selectionUpdate", this.handleSelectionUpdate);
-    this.updateElementAttributes();
-  }
-  /**
-   * Return the DOM element.
-   * This is the element that will be used to display the node view.
-   */
-  get dom() {
-    var _a;
-    if (this.renderer.element.firstElementChild && !((_a = this.renderer.element.firstElementChild) === null || _a === void 0 ? void 0 : _a.hasAttribute("data-node-view-wrapper"))) {
-      throw Error("Please use the NodeViewWrapper component for your node view.");
-    }
-    return this.renderer.element;
-  }
-  /**
-   * Return the content DOM element.
-   * This is the element that will be used to display the rich-text content of the node.
-   */
-  get contentDOM() {
-    if (this.node.isLeaf) {
-      return null;
-    }
-    return this.contentDOMElement;
-  }
-  /**
-   * On editor selection update, check if the node is selected.
-   * If it is, call `selectNode`, otherwise call `deselectNode`.
-   */
-  handleSelectionUpdate() {
-    const { from, to } = this.editor.state.selection;
-    const pos = this.getPos();
-    if (typeof pos !== "number") {
-      return;
-    }
-    if (from <= pos && to >= pos + this.node.nodeSize) {
-      if (this.renderer.props.selected) {
-        return;
-      }
-      this.selectNode();
-    } else {
-      if (!this.renderer.props.selected) {
-        return;
-      }
-      this.deselectNode();
-    }
-  }
-  /**
-   * On update, update the React component.
-   * To prevent unnecessary updates, the `update` option can be used.
-   */
-  update(node, decorations, innerDecorations) {
-    const rerenderComponent = (props) => {
-      this.renderer.updateProps(props);
-      if (typeof this.options.attrs === "function") {
-        this.updateElementAttributes();
-      }
-    };
-    if (node.type !== this.node.type) {
-      return false;
-    }
-    if (typeof this.options.update === "function") {
-      const oldNode = this.node;
-      const oldDecorations = this.decorations;
-      const oldInnerDecorations = this.innerDecorations;
-      this.node = node;
-      this.decorations = decorations;
-      this.innerDecorations = innerDecorations;
-      return this.options.update({
-        oldNode,
-        oldDecorations,
-        newNode: node,
-        newDecorations: decorations,
-        oldInnerDecorations,
-        innerDecorations,
-        updateProps: () => rerenderComponent({ node, decorations, innerDecorations })
-      });
-    }
-    if (node === this.node && this.decorations === decorations && this.innerDecorations === innerDecorations) {
-      return true;
-    }
-    this.node = node;
-    this.decorations = decorations;
-    this.innerDecorations = innerDecorations;
-    rerenderComponent({ node, decorations, innerDecorations });
-    return true;
-  }
-  /**
-   * Select the node.
-   * Add the `selected` prop and the `ProseMirror-selectednode` class.
-   */
-  selectNode() {
-    this.renderer.updateProps({
-      selected: true
-    });
-    this.renderer.element.classList.add("ProseMirror-selectednode");
-  }
-  /**
-   * Deselect the node.
-   * Remove the `selected` prop and the `ProseMirror-selectednode` class.
-   */
-  deselectNode() {
-    this.renderer.updateProps({
-      selected: false
-    });
-    this.renderer.element.classList.remove("ProseMirror-selectednode");
-  }
-  /**
-   * Destroy the React component instance.
-   */
-  destroy() {
-    this.renderer.destroy();
-    this.editor.off("selectionUpdate", this.handleSelectionUpdate);
-    this.contentDOMElement = null;
-  }
-  /**
-   * Update the attributes of the top-level element that holds the React component.
-   * Applying the attributes defined in the `attrs` option.
-   */
-  updateElementAttributes() {
-    if (this.options.attrs) {
-      let attrsObj = {};
-      if (typeof this.options.attrs === "function") {
-        const extensionAttributes = this.editor.extensionManager.attributes;
-        const HTMLAttributes = getRenderedAttributes(this.node, extensionAttributes);
-        attrsObj = this.options.attrs({ node: this.node, HTMLAttributes });
-      } else {
-        attrsObj = this.options.attrs;
-      }
-      this.renderer.updateAttributes(attrsObj);
-    }
-  }
-};
-function ReactNodeViewRenderer(component, options) {
-  return (props) => {
-    if (!props.editor.contentComponent) {
-      return {};
-    }
-    return new ReactNodeView(component, props, options);
-  };
+    if (!Node.isBlock(value)) return;
+    const position = host.getPos();
+    if (typeof position !== "number") return;
+    const editorNode = editor.state.doc.nodeAt(position);
+    if (!editorNode || editorNode.type.name !== host.typeName) return;
+    const current = decodeBlockValue(
+      editorNode.attrs[richTextBlockValueAttribute]
+    );
+    if (encodeBlockValue(current) === encodeBlockValue(value)) return;
+    const transaction = editor.state.tr.setNodeMarkup(
+      position,
+      void 0,
+      blockAttributes(value)
+    );
+    transaction.setMeta("addToHistory", false);
+    editor.view.dispatch(transaction);
+  }, [editor, host, value]);
+  return null;
 }
-
-// src/field/richtext/RichTextField.view.tsx
-import { createId } from "alinea/core/Id";
-import { getType } from "alinea/core/Internal";
-import { BlockNode, ElementNode, Mark, Node as Node2, TextNode } from "alinea/core/TextDoc";
-import { Type } from "alinea/core/Type";
-import { entries, values } from "alinea/core/util/Objects";
-import { FormRow } from "alinea/dashboard/atoms/FormAtoms";
-import { InputForm } from "alinea/dashboard/editor/InputForm";
-import { useField, useFieldOptions } from "alinea/dashboard/editor/UseField";
-import { FieldToolbar } from "alinea/dashboard/view/entry/FieldToolbar";
-import { IconButton } from "alinea/dashboard/view/IconButton";
-import { InputLabel } from "alinea/dashboard/view/InputLabel";
-import { HStack, Icon, px, TextLabel } from "alinea/ui";
-import { DropdownMenu } from "alinea/ui/DropdownMenu";
-import { useForceUpdate } from "alinea/ui/hook/UseForceUpdate";
-import { useNonInitialEffect } from "alinea/ui/hook/UseNonInitialEffect";
-import IcRoundAddCircle from "alinea/ui/icons/IcRoundAddCircle";
-import { IcRoundClose } from "alinea/ui/icons/IcRoundClose";
-import { IcRoundDragHandle } from "alinea/ui/icons/IcRoundDragHandle";
-import { IcRoundNotes } from "alinea/ui/icons/IcRoundNotes";
-import { Sink } from "alinea/ui/Sink";
-import { useCallback, useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState2 } from "react";
-import { extensions as baseExtensions } from "./Extensions.js";
-import { PickTextLink, usePickTextLink } from "./PickTextLink.js";
-
-// src/field/richtext/RichTextField.module.scss
-var RichTextField_module_default = {
-  "hyphenate": "alinea-RichTextField-hyphenate",
-  "link": "alinea-RichTextField-link",
-  "p": "alinea-RichTextField-p",
-  "h5": "alinea-RichTextField-h5",
-  "h4": "alinea-RichTextField-h4",
-  "h3": "alinea-RichTextField-h3",
-  "h2": "alinea-RichTextField-h2",
-  "h1": "alinea-RichTextField-h1",
-  "is-flat": "alinea-RichTextField-is-flat",
-  "isFlat": "alinea-RichTextField-is-flat",
-  "monospace": "alinea-RichTextField-monospace",
-  "small": "alinea-RichTextField-small",
-  "root-editor": "alinea-RichTextField-editor",
-  "rootEditor": "alinea-RichTextField-editor",
-  "is-focus": "alinea-RichTextField-is-focus",
-  "isFocus": "alinea-RichTextField-is-focus",
-  "is-readonly": "alinea-RichTextField-is-readonly",
-  "isReadonly": "alinea-RichTextField-is-readonly",
-  "insert-trigger": "alinea-RichTextField-insert-trigger",
-  "insertTrigger": "alinea-RichTextField-insert-trigger"
-};
-
-// src/field/richtext/RichTextField.view.tsx
-import { RichTextToolbar } from "./RichTextToolbar.js";
-import { Fragment as Fragment2, jsx, jsxs } from "react/jsx-runtime";
-var styles = dist_default(RichTextField_module_default);
-function typeExtension(field, name, type) {
-  function View({ node, deleteNode }) {
-    const { [BlockNode.id]: id } = node.attrs;
-    const meta = getType(type);
-    const { readOnly } = useFieldOptions(field);
-    return /* @__PURE__ */ jsx(FormRow, { field, type, rowId: id, readOnly, children: /* @__PURE__ */ jsx(NodeViewWrapper, { children: /* @__PURE__ */ jsxs(Sink.Root, { style: { margin: `${px(18)} 0` }, children: [
-      /* @__PURE__ */ jsxs(Sink.Header, { children: [
-        /* @__PURE__ */ jsx(Sink.Options, { children: /* @__PURE__ */ jsx(
-          IconButton,
-          {
-            icon: meta.icon || IcRoundDragHandle,
-            "data-drag-handle": true,
-            style: { cursor: "grab" }
-          }
-        ) }),
-        /* @__PURE__ */ jsx(Sink.Title, { children: /* @__PURE__ */ jsx(TextLabel, { label: Type.label(type) }) }),
-        /* @__PURE__ */ jsx(Sink.Options, { children: /* @__PURE__ */ jsx(IconButton, { icon: IcRoundClose, onClick: deleteNode }) })
-      ] }),
-      /* @__PURE__ */ jsx(Sink.Content, { children: /* @__PURE__ */ jsx(InputForm, { type }) })
-    ] }) }) });
-  }
-  return Node.create({
-    name,
-    group: "block",
-    atom: true,
-    draggable: true,
-    parseHTML() {
-      return [{ tag: name }];
-    },
-    renderHTML({ HTMLAttributes }) {
-      return [name, mergeAttributes(HTMLAttributes)];
-    },
-    addNodeView() {
-      return ReactNodeViewRenderer(View);
-    },
-    addAttributes() {
-      return {
-        [BlockNode.id]: { default: null }
-      };
-    }
-  });
+function documentStructureKey(value) {
+  return stableStringify(
+    value.map(
+      (node) => Node.isBlock(node) ? { [Node.type]: node[Node.type], [BlockNode.id]: node[BlockNode.id] } : node
+    )
+  );
 }
-function schemaToExtensions(field, schema) {
-  if (!schema) return [];
-  return entries(schema).map(([name, type]) => {
-    return typeExtension(field, name, type);
-  });
+function stableStringify(value) {
+  if (Array.isArray(value))
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  if (isRecord(value))
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
+  return JSON.stringify(value) ?? String(value);
 }
-function InsertMenu({ editor, schema, onInsert }) {
-  const id = createId();
-  if (!schema) return null;
-  const blocks = entries(schema).map(([key, type]) => {
-    return /* @__PURE__ */ jsx(
-      DropdownMenu.Item,
-      {
-        onClick: () => {
-          onInsert(id, key);
-          editor.chain().focus().insertContent({
-            type: key,
-            attrs: { [BlockNode.id]: id }
-          }).run();
-        },
-        children: /* @__PURE__ */ jsxs(HStack, { center: true, gap: 8, children: [
-          /* @__PURE__ */ jsx(Icon, { icon: getType(type).icon ?? IcRoundAddCircle }),
-          /* @__PURE__ */ jsx(TextLabel, { label: Type.label(type) })
-        ] })
-      },
-      key
-    );
-  });
+function RichTextFieldCompactView({
+  value
+}) {
+  const text = previewText(value);
   return /* @__PURE__ */ jsx(
-    FloatingMenu,
+    "span",
     {
-      editor,
-      tippyOptions: {
-        zIndex: 1,
-        maxWidth: "none"
-      },
-      children: /* @__PURE__ */ jsxs(DropdownMenu.Root, { bottom: true, children: [
-        /* @__PURE__ */ jsxs(DropdownMenu.Trigger, { className: styles.insert.trigger(), children: [
-          /* @__PURE__ */ jsx(Icon, { icon: IcRoundAddCircle }),
-          /* @__PURE__ */ jsx("span", { children: "Insert block" })
-        ] }),
-        /* @__PURE__ */ jsx(DropdownMenu.Items, { children: blocks })
-      ] })
+      className: styles.RichTextFieldCompactView(),
+      "data-empty": text ? void 0 : "true",
+      children: text || "-"
     }
   );
 }
-function RichTextInput({
-  field
-}) {
-  const { value, mutator, options, error } = useField(field);
-  const forceUpdate = useForceUpdate();
-  const { fragment, insert } = mutator;
-  const picker = usePickTextLink();
-  const { readOnly, schema, enableTables, toolbar } = options;
-  const [focus, setFocus] = useState2(false);
-  const containerRef = useRef2(null);
-  const focusToggle = useCallback(
-    function focusToggle2(target) {
-      const element = target || document.activeElement;
-      const editorElement = () => containerRef.current?.querySelector(
-        `.${styles.root.editor()} > .ProseMirror`
-      );
-      const isInToolbar = element?.closest?.('[data-richtext-toolbar="true"]') !== null;
-      const editor2 = editorElement();
-      const isInEditor = !!editor2 && (editor2 === element || editor2.contains(element));
-      const isFocused = isInToolbar || isInEditor;
-      setFocus(isFocused);
-    },
-    [setFocus, containerRef]
-  );
-  const blocks = useMemo(() => {
-    return schemaToExtensions(field, schema);
-  }, [field, schema]);
-  const base = useMemo(() => {
-    return values(options.extensions ?? baseExtensions);
-  }, [options.extensions]);
-  const extensions = useMemo(() => {
-    return [Collaboration.configure({ fragment }), ...base, ...blocks];
-  }, [fragment, blocks, base]);
-  const content = useMemo(
-    () => ({
-      type: "doc",
-      content: value.map(toContent)
-    }),
-    [fragment]
-  );
-  const onFocus = useCallback(
-    ({ event }) => focusToggle(event.currentTarget),
-    [focusToggle]
-  );
-  const onBlur = useCallback(
-    ({ event }) => focusToggle(event.relatedTarget),
-    [focusToggle]
-  );
-  const isEditable = !options.readOnly && !readOnly;
-  const editor = useMemo(() => {
-    const doc2 = fragment.doc;
-    let editor2;
-    doc2.transact(() => {
-      editor2 = new Editor({
-        content,
-        onFocus,
-        onBlur,
-        extensions,
-        editable: isEditable
-      });
-    }, "self");
-    return editor2;
-  }, [fragment]);
-  useNonInitialEffect(() => {
-    editor.setOptions({ editable: isEditable });
-  }, [isEditable]);
-  useEffect2(() => {
-    editor.on("transaction", forceUpdate);
-    return () => editor.destroy();
-  }, [editor]);
-  return /* @__PURE__ */ jsxs(Fragment2, { children: [
-    isEditable && focus && /* @__PURE__ */ jsx(FieldToolbar.Slot, { children: /* @__PURE__ */ jsx(
-      RichTextToolbar,
-      {
-        editor,
-        focusToggle,
-        pickLink: picker.pickLink,
-        enableTables,
-        toolbar
-      }
-    ) }),
-    /* @__PURE__ */ jsx(PickTextLink, { picker }),
-    /* @__PURE__ */ jsxs(
-      InputLabel,
-      {
-        ...options,
-        focused: focus,
-        icon: IcRoundNotes,
-        empty: editor.isEmpty,
-        ref: containerRef,
-        error,
-        children: [
-          /* @__PURE__ */ jsx(InsertMenu, { editor, schema, onInsert: insert }),
-          /* @__PURE__ */ jsx(
-            EditorContent,
-            {
-              className: styles.root.editor({ focus, readonly: options.readOnly }),
-              editor
-            }
-          )
-        ]
-      }
-    )
-  ] });
-}
-function toContent(node) {
-  if (Node2.isText(node))
-    return {
-      type: "text",
-      text: node[TextNode.text],
-      marks: node[TextNode.marks]?.map((mark) => {
-        const { [Mark.type]: type, ...attrs } = mark;
-        const res = Object.fromEntries(
-          entries(attrs).map(([key, value]) => {
-            if (key.startsWith("_")) return [`data-${key.slice(1)}`, value];
-            return [key, value];
-          })
-        );
-        return { type, attrs: res };
-      })
-    };
-  if (Node2.isElement(node)) {
-    const { [Node2.type]: type, [ElementNode.content]: content, ...attrs } = node;
-    return { type, content: content?.map(toContent), attrs };
-  }
-  if (Node2.isBlock(node)) {
-    const { [Node2.type]: type } = node;
-    return { type, attrs: { [BlockNode.id]: node[BlockNode.id] } };
-  }
-  throw new TypeError("Invalid node");
+function previewText(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value))
+    return value.map(previewText).filter(Boolean).join(" ");
+  if (!isRecord(value)) return "";
+  return [previewText(value.text), previewText(value.content)].filter(Boolean).join(" ");
 }
 export {
-  RichTextInput
+  RichTextFieldCompactView,
+  RichTextFieldView
 };
-/*! Bundled license information:
-
-@tiptap/react/dist/index.js:
-  (**
-   * @license React
-   * use-sync-external-store-shim.production.min.js
-   *
-   * Copyright (c) Facebook, Inc. and its affiliates.
-   *
-   * This source code is licensed under the MIT license found in the
-   * LICENSE file in the root directory of this source tree.
-   *)
-  (**
-   * @license React
-   * use-sync-external-store-shim.development.js
-   *
-   * Copyright (c) Facebook, Inc. and its affiliates.
-   *
-   * This source code is licensed under the MIT license found in the
-   * LICENSE file in the root directory of this source tree.
-   *)
-
-@tiptap/react/dist/index.js:
-  (**
-   * @license React
-   * use-sync-external-store-shim/with-selector.production.min.js
-   *
-   * Copyright (c) Facebook, Inc. and its affiliates.
-   *
-   * This source code is licensed under the MIT license found in the
-   * LICENSE file in the root directory of this source tree.
-   *)
-  (**
-   * @license React
-   * use-sync-external-store-shim/with-selector.development.js
-   *
-   * Copyright (c) Facebook, Inc. and its affiliates.
-   *
-   * This source code is licensed under the MIT license found in the
-   * LICENSE file in the root directory of this source tree.
-   *)
-*/