@portabletext/editor 1.48.14 → 1.49.0

package/lib/index.js

@@ -1,22 +1,22 @@
 import { c } from "react-compiler-runtime";
-import { useEffect, useContext, useRef, useState, useMemo, startTransition, useCallback, forwardRef, useImperativeHandle } from "react";
+import { useEffect, useRef, useState, useMemo, startTransition, useCallback, useContext, forwardRef, useImperativeHandle } from "react";
 import { useEffectEvent } from "use-effect-event";
-import { useEditor, getNodeBlock, getFirstBlock, getLastBlock, slateRangeToSelection, toSlateRange, debugWithName, EditorActorContext, fromSlateValue, KEY_TO_VALUE_ELEMENT, usePortableTextEditor, PortableTextEditor, isHotkey, moveRangeByOperation, isEqualToEmptyEditor, getEditorSnapshot } from "./_chunks-es/editor-provider.js";
+import { useEditor, getNodeBlock, getFirstBlock, getLastBlock, slateRangeToSelection, toSlateRange, debugWithName, usePortableTextEditor, PortableTextEditor, createEditorPriority, corePriority, EditorActorContext, getPointBlock, isHotkey, moveRangeByOperation, isEqualToEmptyEditor, fromSlateValue, KEY_TO_VALUE_ELEMENT, getEditorSnapshot } from "./_chunks-es/editor-provider.js";
 import { EditorProvider, defineSchema, defaultKeyGenerator, useEditorSelector, usePortableTextEditorSelection } from "./_chunks-es/editor-provider.js";
-import { jsxs, jsx, Fragment } from "react/jsx-runtime";
+import { jsx, Fragment, jsxs } from "react/jsx-runtime";
 import { useSelector, useActorRef } from "@xstate/react";
 import noop from "lodash/noop.js";
-import { Editor, Range, Element as Element$2, Text, Path, Transforms } from "slate";
-import { useSlateStatic, useSelected, ReactEditor, useSlate, Editable } from "slate-react";
-import { getBlockEndPoint, getBlockStartPoint, isKeyedSegment, parseBlocks } from "./_chunks-es/util.slice-blocks.js";
+import { Editor, Text, Range, Element as Element$1, Path, Transforms } from "slate";
+import { useSelected, useSlateStatic, useSlate, ReactEditor, Editable } from "slate-react";
+import { getBlockEndPoint, getBlockStartPoint, isKeyedSegment, parseInlineObject, parseTextBlock, parseBlockObject, parseBlocks } from "./_chunks-es/util.slice-blocks.js";
 import { isSelectionCollapsed, getFocusTextBlock, getFocusSpan, getSelectedBlocks, isSelectionExpanded, getSelectionStartBlock, getSelectionEndBlock, isOverlappingSelection, getFocusBlock, isSelectingEntireBlocks } from "./_chunks-es/selector.is-selecting-entire-blocks.js";
 import { getFocusInlineObject } from "./_chunks-es/selector.get-focus-inline-object.js";
 import { DOMEditor, isDOMNode } from "slate-dom";
 import { isSelectionCollapsed as isSelectionCollapsed$1 } from "./_chunks-es/util.is-selection-collapsed.js";
 import isEqual from "lodash/isEqual.js";
 import { getSelectionEndPoint } from "./_chunks-es/util.selection-point-to-block-offset.js";
-import { defineBehavior, forward } from "./behaviors/index.js";
 import uniq from "lodash/uniq.js";
+import { defineBehavior, forward } from "./behaviors/index.js";
 import { setup, fromCallback, assign, and } from "xstate";
 function EditorEventListener(props) {
   const $ = c(5), editor = useEditor(), on = useEffectEvent(props.on);
@@ -343,260 +343,6 @@ function getSelectionDomNodes({
     childNodes: childEntries.map(([childNode]) => DOMEditor.toDOMNode(slateEditor, childNode))
   };
 }
-function DefaultBlockObject(props) {
-  const $ = c(4);
-  let t0;
-  $[0] === Symbol.for("react.memo_cache_sentinel") ? (t0 = {
-    userSelect: "none"
-  }, $[0] = t0) : t0 = $[0];
-  let t1;
-  return $[1] !== props.value._key || $[2] !== props.value._type ? (t1 = /* @__PURE__ */ jsxs("div", { style: t0, children: [
-    "[",
-    props.value._type,
-    ": ",
-    props.value._key,
-    "]"
-  ] }), $[1] = props.value._key, $[2] = props.value._type, $[3] = t1) : t1 = $[3], t1;
-}
-function DefaultInlineObject(props) {
-  const $ = c(4);
-  let t0;
-  $[0] === Symbol.for("react.memo_cache_sentinel") ? (t0 = {
-    userSelect: "none"
-  }, $[0] = t0) : t0 = $[0];
-  let t1;
-  return $[1] !== props.value._key || $[2] !== props.value._type ? (t1 = /* @__PURE__ */ jsxs("span", { style: t0, children: [
-    "[",
-    props.value._type,
-    ": ",
-    props.value._key,
-    "]"
-  ] }), $[1] = props.value._key, $[2] = props.value._type, $[3] = t1) : t1 = $[3], t1;
-}
-function DropIndicator() {
-  const $ = c(1);
-  let t0;
-  return $[0] === Symbol.for("react.memo_cache_sentinel") ? (t0 = /* @__PURE__ */ jsx("div", { contentEditable: !1, className: "pt-drop-indicator", style: {
-    position: "absolute",
-    width: "100%",
-    height: 1,
-    borderBottom: "1px solid currentColor",
-    zIndex: 5
-  }, children: /* @__PURE__ */ jsx("span", {}) }), $[0] = t0) : t0 = $[0], t0;
-}
-debugWithName("components:Element");
-const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
-  display: "inline-block"
-}, Element$1 = ({
-  attributes,
-  children,
-  element,
-  schemaTypes,
-  readOnly,
-  renderBlock,
-  renderChild,
-  renderListItem,
-  renderStyle,
-  spellCheck
-}) => {
-  const editorActor = useContext(EditorActorContext), slateEditor = useSlateStatic(), selected = useSelected(), blockRef = useRef(null), inlineBlockObjectRef = useRef(null), focused = selected && slateEditor.selection && Range.isCollapsed(slateEditor.selection) || !1, [dragPositionBlock, setDragPositionBlock] = useState();
-  useEffect(() => {
-    const behavior = defineBehavior({
-      on: "drag.dragover",
-      guard: ({
-        snapshot,
-        event
-      }) => {
-        const dropFocusBlock = getFocusBlock({
-          context: {
-            ...snapshot.context,
-            selection: event.position.selection
-          }
-        });
-        if (!dropFocusBlock || dropFocusBlock.node._key !== element._key)
-          return !1;
-        const dragOrigin = snapshot.beta.internalDrag?.origin;
-        return !dragOrigin || getSelectedBlocks({
-          context: {
-            ...snapshot.context,
-            selection: dragOrigin.selection
-          }
-        }).some((draggedBlock) => draggedBlock.node._key === element._key) ? !1 : isSelectingEntireBlocks({
-          context: {
-            ...snapshot.context,
-            selection: dragOrigin.selection
-          }
-        });
-      },
-      actions: [({
-        event: event_0
-      }) => [{
-        type: "effect",
-        effect: () => {
-          setDragPositionBlock(event_0.position.block);
-        }
-      }]]
-    });
-    return editorActor.send({
-      type: "add behavior",
-      behavior
-    }), () => {
-      editorActor.send({
-        type: "remove behavior",
-        behavior
-      });
-    };
-  }, [editorActor, element._key]), useEffect(() => {
-    const behavior_0 = defineBehavior({
-      on: "drag.*",
-      guard: ({
-        event: event_1
-      }) => event_1.type !== "drag.dragover",
-      actions: [({
-        event: event_2
-      }) => [{
-        type: "effect",
-        effect: () => {
-          setDragPositionBlock(void 0);
-        }
-      }, forward(event_2)]]
-    });
-    return editorActor.send({
-      type: "add behavior",
-      behavior: behavior_0
-    }), () => {
-      editorActor.send({
-        type: "remove behavior",
-        behavior: behavior_0
-      });
-    };
-  }, [editorActor]);
-  const value = useMemo(() => fromSlateValue([element], schemaTypes.block.name, KEY_TO_VALUE_ELEMENT.get(slateEditor))[0], [slateEditor, element, schemaTypes.block.name]);
-  let renderedBlock = children, className;
-  const blockPath = useMemo(() => [{
-    _key: element._key
-  }], [element]);
-  if (typeof element._type != "string")
-    throw new Error("Expected element to have a _type property");
-  if (typeof element._key != "string")
-    throw new Error("Expected element to have a _key property");
-  if (slateEditor.isInline(element)) {
-    const path = ReactEditor.findPath(slateEditor, element), [block] = Editor.node(slateEditor, path, {
-      depth: 1
-    }), schemaType = schemaTypes.inlineObjects.find((_type) => _type.name === element._type);
-    if (!schemaType)
-      throw new Error("Could not find type for inline block element");
-    if (Element$2.isElement(block)) {
-      const elmPath = [{
-        _key: block._key
-      }, "children", {
-        _key: element._key
-      }];
-      return /* @__PURE__ */ jsxs("span", { ...attributes, children: [
-        children,
-        /* @__PURE__ */ jsxs("span", { draggable: !readOnly, className: "pt-inline-object", "data-testid": "pt-inline-object", ref: inlineBlockObjectRef, style: inlineBlockStyle, contentEditable: !1, children: [
-          renderChild && renderChild({
-            annotations: EMPTY_ANNOTATIONS,
-            // These inline objects currently doesn't support annotations. This is a limitation of the current PT spec/model.
-            children: /* @__PURE__ */ jsx(DefaultInlineObject, { value }),
-            editorElementRef: inlineBlockObjectRef,
-            focused,
-            path: elmPath,
-            schemaType,
-            selected,
-            type: schemaType,
-            value
-          }),
-          !renderChild && /* @__PURE__ */ jsx(DefaultInlineObject, { value })
-        ] }, element._key)
-      ] });
-    }
-    throw new Error("Block not found!");
-  }
-  if (element._type === schemaTypes.block.name) {
-    className = "pt-block pt-text-block";
-    const isListItem = "listItem" in element, style = "style" in element && element.style || "normal";
-    className = `pt-block pt-text-block pt-text-block-style-${style}`;
-    const blockStyleType = schemaTypes.styles.find((item) => item.value === style);
-    renderStyle && blockStyleType && (renderedBlock = renderStyle({
-      block: element,
-      children,
-      focused,
-      selected,
-      value: style,
-      path: blockPath,
-      schemaType: blockStyleType,
-      editorElementRef: blockRef
-    }));
-    let level;
-    if (isListItem && (typeof element.level == "number" && (level = element.level), className += ` pt-list-item pt-list-item-${element.listItem} pt-list-item-level-${level || 1}`), slateEditor.isListBlock(value) && isListItem && element.listItem) {
-      const listType = schemaTypes.lists.find((item_0) => item_0.value === element.listItem);
-      renderListItem && listType && (renderedBlock = renderListItem({
-        block: value,
-        children: renderedBlock,
-        focused,
-        selected,
-        value: element.listItem,
-        path: blockPath,
-        schemaType: listType,
-        level: value.level || 1,
-        editorElementRef: blockRef
-      }));
-    }
-    const renderProps = Object.defineProperty({
-      children: renderedBlock,
-      editorElementRef: blockRef,
-      focused,
-      level,
-      listItem: isListItem ? element.listItem : void 0,
-      path: blockPath,
-      selected,
-      style,
-      schemaType: schemaTypes.block,
-      value
-    }, "type", {
-      enumerable: !1,
-      get() {
-        return console.warn("Property 'type' is deprecated, use 'schemaType' instead."), schemaTypes.block;
-      }
-    }), propsOrDefaultRendered = renderBlock ? renderBlock(renderProps) : children;
-    return /* @__PURE__ */ jsxs("div", { ...attributes, className, spellCheck, children: [
-      dragPositionBlock === "start" ? /* @__PURE__ */ jsx(DropIndicator, {}) : null,
-      /* @__PURE__ */ jsx("div", { ref: blockRef, children: propsOrDefaultRendered }),
-      dragPositionBlock === "end" ? /* @__PURE__ */ jsx(DropIndicator, {}) : null
-    ] }, element._key);
-  }
-  const schemaType_0 = schemaTypes.blockObjects.find((_type_0) => _type_0.name === element._type);
-  if (!schemaType_0)
-    throw new Error(`Could not find schema type for block element of _type ${element._type}`);
-  className = "pt-block pt-object-block";
-  const block_0 = fromSlateValue([element], schemaTypes.block.name, KEY_TO_VALUE_ELEMENT.get(slateEditor))[0];
-  let renderedBlockFromProps;
-  if (renderBlock) {
-    const _props = Object.defineProperty({
-      children: /* @__PURE__ */ jsx(DefaultBlockObject, { value }),
-      editorElementRef: blockRef,
-      focused,
-      path: blockPath,
-      schemaType: schemaType_0,
-      selected,
-      value: block_0
-    }, "type", {
-      enumerable: !1,
-      get() {
-        return console.warn("Property 'type' is deprecated, use 'schemaType' instead."), schemaType_0;
-      }
-    });
-    renderedBlockFromProps = renderBlock(_props);
-  }
-  return /* @__PURE__ */ jsxs("div", { ...attributes, className, children: [
-    dragPositionBlock === "start" ? /* @__PURE__ */ jsx(DropIndicator, {}) : null,
-    children,
-    /* @__PURE__ */ jsx("div", { ref: blockRef, contentEditable: !1, draggable: !readOnly, children: renderedBlockFromProps || /* @__PURE__ */ jsx(DefaultBlockObject, { value }) }),
-    dragPositionBlock === "end" ? /* @__PURE__ */ jsx(DropIndicator, {}) : null
-  ] }, element._key);
-};
-Element$1.displayName = "Element";
 const debug$2 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (props) => {
   const {
     editorActor,
@@ -718,9 +464,352 @@ const debug$2 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     }
     return returnedChildren;
   }, [annotations, block, children, focused, leaf, marks, path, renderAnnotation, renderChild, renderDecorator, schemaTypes.annotations, schemaTypes.decorators, schemaTypes.span, selected]);
-  return useMemo(() => /* @__PURE__ */ jsx("span", { ...attributes, ref: spanRef, children: content }, leaf._key), [leaf, attributes, content]);
+  return useMemo(() => /* @__PURE__ */ jsx("span", { ...attributes, ref: spanRef, "data-child-key": leaf._key, "data-child-name": leaf._type, "data-child-type": "span", children: content }, leaf._key), [leaf, attributes, content]);
 };
 Leaf.displayName = "Leaf";
+function DropIndicator() {
+  const $ = c(1);
+  let t0;
+  return $[0] === Symbol.for("react.memo_cache_sentinel") ? (t0 = /* @__PURE__ */ jsx("div", { contentEditable: !1, className: "pt-drop-indicator", style: {
+    position: "absolute",
+    width: "100%",
+    height: 1,
+    borderBottom: "1px solid currentColor",
+    zIndex: 5
+  }, children: /* @__PURE__ */ jsx("span", {}) }), $[0] = t0) : t0 = $[0], t0;
+}
+function RenderDefaultBlockObject(props) {
+  const $ = c(4);
+  let t0;
+  $[0] === Symbol.for("react.memo_cache_sentinel") ? (t0 = {
+    userSelect: "none"
+  }, $[0] = t0) : t0 = $[0];
+  let t1;
+  return $[1] !== props.blockObject._key || $[2] !== props.blockObject._type ? (t1 = /* @__PURE__ */ jsxs("div", { style: t0, children: [
+    "[",
+    props.blockObject._type,
+    ": ",
+    props.blockObject._key,
+    "]"
+  ] }), $[1] = props.blockObject._key, $[2] = props.blockObject._type, $[3] = t1) : t1 = $[3], t1;
+}
+function RenderDefaultInlineObject(props) {
+  const $ = c(4);
+  let t0;
+  $[0] === Symbol.for("react.memo_cache_sentinel") ? (t0 = {
+    userSelect: "none"
+  }, $[0] = t0) : t0 = $[0];
+  let t1;
+  return $[1] !== props.inlineObject._key || $[2] !== props.inlineObject._type ? (t1 = /* @__PURE__ */ jsxs("span", { style: t0, children: [
+    "[",
+    props.inlineObject._type,
+    ": ",
+    props.inlineObject._key,
+    "]"
+  ] }), $[1] = props.inlineObject._key, $[2] = props.inlineObject._type, $[3] = t1) : t1 = $[3], t1;
+}
+function createCoreBlockElementBehaviorsConfig({
+  key,
+  onSetDragPositionBlock
+}) {
+  return [{
+    behavior: defineBehavior({
+      on: "drag.dragover",
+      guard: ({
+        snapshot,
+        event
+      }) => {
+        const dropFocusBlock = getFocusBlock({
+          context: {
+            ...snapshot.context,
+            selection: event.position.selection
+          }
+        });
+        if (!dropFocusBlock || dropFocusBlock.node._key !== key)
+          return !1;
+        const dragOrigin = snapshot.beta.internalDrag?.origin;
+        return !dragOrigin || getSelectedBlocks({
+          context: {
+            ...snapshot.context,
+            selection: dragOrigin.selection
+          }
+        }).some((draggedBlock) => draggedBlock.node._key === key) ? !1 : isSelectingEntireBlocks({
+          context: {
+            ...snapshot.context,
+            selection: dragOrigin.selection
+          }
+        });
+      },
+      actions: [({
+        event
+      }) => [{
+        type: "effect",
+        effect: () => {
+          onSetDragPositionBlock(event.position.block);
+        }
+      }]]
+    }),
+    priority: createEditorPriority({
+      reference: {
+        priority: corePriority,
+        importance: "lower"
+      }
+    })
+  }, {
+    behavior: defineBehavior({
+      on: "drag.*",
+      guard: ({
+        event
+      }) => event.type !== "drag.dragover",
+      actions: [({
+        event
+      }) => [{
+        type: "effect",
+        effect: () => {
+          onSetDragPositionBlock(void 0);
+        }
+      }, forward(event)]]
+    }),
+    priority: createEditorPriority({
+      reference: {
+        priority: corePriority,
+        importance: "lower"
+      }
+    })
+  }];
+}
+function useCoreBlockElementBehaviors(t0) {
+  const $ = c(5), {
+    key,
+    onSetDragPositionBlock
+  } = t0, editorActor = useContext(EditorActorContext);
+  let t1, t2;
+  $[0] !== editorActor || $[1] !== key || $[2] !== onSetDragPositionBlock ? (t1 = () => {
+    const behaviorConfigs = createCoreBlockElementBehaviorsConfig({
+      key,
+      onSetDragPositionBlock
+    });
+    for (const behaviorConfig of behaviorConfigs)
+      editorActor.send({
+        type: "add behavior",
+        behaviorConfig
+      });
+    return () => {
+      for (const behaviorConfig_0 of behaviorConfigs)
+        editorActor.send({
+          type: "remove behavior",
+          behaviorConfig: behaviorConfig_0
+        });
+    };
+  }, t2 = [editorActor, key, onSetDragPositionBlock], $[0] = editorActor, $[1] = key, $[2] = onSetDragPositionBlock, $[3] = t1, $[4] = t2) : (t1 = $[3], t2 = $[4]), useEffect(t1, t2);
+}
+function RenderBlockObject(props) {
+  const [dragPositionBlock, setDragPositionBlock] = useState(), blockObjectRef = useRef(null), slateEditor = useSlateStatic(), selected = useSelected(), editorActor = useContext(EditorActorContext);
+  useCoreBlockElementBehaviors({
+    key: props.element._key,
+    onSetDragPositionBlock: setDragPositionBlock
+  });
+  const legacySchemaType = useSelector(editorActor, (s) => s.context.getLegacySchema().blockObjects.find((blockObject) => blockObject.name === props.element._type));
+  legacySchemaType || console.error(`Block object type ${props.element._type} not found in Schema`);
+  const focused = selected && slateEditor.selection !== null && Range.isCollapsed(slateEditor.selection);
+  return /* @__PURE__ */ jsxs("div", { ...props.attributes, className: "pt-block pt-object-block", "data-block-key": props.element._key, "data-block-name": props.element._type, "data-block-type": "object", children: [
+    dragPositionBlock === "start" ? /* @__PURE__ */ jsx(DropIndicator, {}) : null,
+    props.children,
+    /* @__PURE__ */ jsx("div", { ref: blockObjectRef, contentEditable: !1, draggable: !props.readOnly, children: props.renderBlock && legacySchemaType ? props.renderBlock({
+      children: /* @__PURE__ */ jsx(RenderDefaultBlockObject, { blockObject: props.blockObject }),
+      editorElementRef: blockObjectRef,
+      focused,
+      path: [{
+        _key: props.element._key
+      }],
+      schemaType: legacySchemaType,
+      selected,
+      type: legacySchemaType,
+      value: props.blockObject
+    }) : /* @__PURE__ */ jsx(RenderDefaultBlockObject, { blockObject: props.blockObject }) }),
+    dragPositionBlock === "end" ? /* @__PURE__ */ jsx(DropIndicator, {}) : null
+  ] }, props.element._key);
+}
+function RenderInlineObject(props) {
+  const inlineObjectRef = useRef(null), slateEditor = useSlateStatic(), selected = useSelected(), editorActor = useContext(EditorActorContext), legacySchemaType = useSelector(editorActor, (s) => s.context.getLegacySchema().inlineObjects.find((inlineObject) => inlineObject.name === props.element._type));
+  legacySchemaType || console.error(`Inline object type ${props.element._type} not found in Schema`);
+  const focused = selected && slateEditor.selection !== null && Range.isCollapsed(slateEditor.selection), path = DOMEditor.findPath(slateEditor, props.element), [block] = getPointBlock({
+    editor: slateEditor,
+    point: {
+      path,
+      offset: 0
+    }
+  });
+  return block || console.error(`Unable to find parent block of inline object ${props.element._key}`), /* @__PURE__ */ jsxs("span", { ...props.attributes, children: [
+    props.children,
+    /* @__PURE__ */ jsx("span", { draggable: !props.readOnly, className: "pt-inline-object", "data-testid": "pt-inline-object", ref: inlineObjectRef, style: {
+      display: "inline-block"
+    }, "data-child-key": props.inlineObject._key, "data-child-name": props.inlineObject._type, "data-child-type": "object", children: props.renderChild && block && legacySchemaType ? props.renderChild({
+      annotations: [],
+      children: /* @__PURE__ */ jsx(RenderDefaultInlineObject, { inlineObject: props.inlineObject }),
+      editorElementRef: inlineObjectRef,
+      selected,
+      focused,
+      path: [{
+        _key: block._key
+      }, "children", {
+        _key: props.element._key
+      }],
+      schemaType: legacySchemaType,
+      value: props.inlineObject,
+      type: legacySchemaType
+    }) : /* @__PURE__ */ jsx(RenderDefaultInlineObject, { inlineObject: props.inlineObject }) }, props.element._key)
+  ] });
+}
+function RenderTextBlock(props) {
+  const [dragPositionBlock, setDragPositionBlock] = useState(), blockRef = useRef(null), slateEditor = useSlateStatic(), selected = useSelected(), editorActor = useContext(EditorActorContext);
+  useCoreBlockElementBehaviors({
+    key: props.element._key,
+    onSetDragPositionBlock: setDragPositionBlock
+  });
+  const legacySchema = useSelector(editorActor, (s) => s.context.getLegacySchema()), focused = selected && slateEditor.selection !== null && Range.isCollapsed(slateEditor.selection);
+  let children = props.children;
+  const legacyBlockSchemaType = legacySchema.block;
+  if (props.renderStyle && props.textBlock.style) {
+    const legacyStyleSchemaType = props.textBlock.style !== void 0 ? legacySchema.styles.find((style) => style.value === props.textBlock.style) : void 0;
+    legacyStyleSchemaType ? children = props.renderStyle({
+      block: props.textBlock,
+      children,
+      editorElementRef: blockRef,
+      focused,
+      path: [{
+        _key: props.textBlock._key
+      }],
+      schemaType: legacyStyleSchemaType,
+      selected,
+      value: props.textBlock.style
+    }) : console.error(`Unable to find Schema type for text block style ${props.textBlock.style}`);
+  }
+  if (props.renderListItem && props.textBlock.listItem) {
+    const legacyListItemSchemaType = legacySchema.lists.find((list) => list.value === props.textBlock.listItem);
+    legacyListItemSchemaType ? children = props.renderListItem({
+      block: props.textBlock,
+      children,
+      editorElementRef: blockRef,
+      focused,
+      level: props.textBlock.level ?? 1,
+      path: [{
+        _key: props.textBlock._key
+      }],
+      selected,
+      value: props.textBlock.listItem,
+      schemaType: legacyListItemSchemaType
+    }) : console.error(`Unable to find Schema type for text block list item ${props.textBlock.listItem}`);
+  }
+  return /* @__PURE__ */ jsxs("div", { ...props.attributes, className: ["pt-block", "pt-text-block", ...props.textBlock.style ? [`pt-text-block-style-${props.textBlock.style}`] : [], ...props.textBlock.listItem ? ["pt-list-item", `pt-list-item-${props.textBlock.listItem}`, `pt-list-item-level-${props.textBlock.level ?? 1}`] : []].join(" "), spellCheck: props.spellCheck, "data-block-key": props.textBlock._key, "data-block-name": props.textBlock._type, "data-block-type": "text", children: [
+    dragPositionBlock === "start" ? /* @__PURE__ */ jsx(DropIndicator, {}) : null,
+    /* @__PURE__ */ jsx("div", { ref: blockRef, children: props.renderBlock ? props.renderBlock({
+      children,
+      editorElementRef: blockRef,
+      focused,
+      level: props.textBlock.level,
+      listItem: props.textBlock.listItem,
+      path: [{
+        _key: props.textBlock._key
+      }],
+      selected,
+      schemaType: legacyBlockSchemaType,
+      style: props.textBlock.style,
+      type: legacyBlockSchemaType,
+      value: props.textBlock
+    }) : props.children }),
+    dragPositionBlock === "end" ? /* @__PURE__ */ jsx(DropIndicator, {}) : null
+  ] }, props.element._key);
+}
+function RenderElement(props) {
+  const $ = c(45), editorActor = useContext(EditorActorContext), schema = useSelector(editorActor, _temp);
+  if ("__inline" in props.element && props.element.__inline === !0) {
+    let t02;
+    if ($[0] !== props.element || $[1] !== schema) {
+      let t13;
+      $[3] !== props.element ? (t13 = "value" in props.element && typeof props.element.value == "object" ? props.element.value : {}, $[3] = props.element, $[4] = t13) : t13 = $[4], t02 = parseInlineObject({
+        context: {
+          keyGenerator: _temp2,
+          schema
+        },
+        options: {
+          refreshKeys: !1
+        },
+        inlineObject: {
+          _key: props.element._key,
+          _type: props.element._type,
+          ...t13
+        }
+      }), $[0] = props.element, $[1] = schema, $[2] = t02;
+    } else
+      t02 = $[2];
+    const inlineObject = t02;
+    inlineObject || console.error(`Unable to find Inline Object "${props.element._type}" in Schema`);
+    let t12;
+    $[5] !== inlineObject || $[6] !== props.element._key || $[7] !== props.element._type ? (t12 = inlineObject ?? {
+      _key: props.element._key,
+      _type: props.element._type
+    }, $[5] = inlineObject, $[6] = props.element._key, $[7] = props.element._type, $[8] = t12) : t12 = $[8];
+    let t22;
+    return $[9] !== props.attributes || $[10] !== props.children || $[11] !== props.element || $[12] !== props.readOnly || $[13] !== props.renderChild || $[14] !== t12 ? (t22 = /* @__PURE__ */ jsx(RenderInlineObject, { attributes: props.attributes, element: props.element, inlineObject: t12, readOnly: props.readOnly, renderChild: props.renderChild, children: props.children }), $[9] = props.attributes, $[10] = props.children, $[11] = props.element, $[12] = props.readOnly, $[13] = props.renderChild, $[14] = t12, $[15] = t22) : t22 = $[15], t22;
+  }
+  let t0;
+  $[16] !== props.element || $[17] !== schema ? (t0 = parseTextBlock({
+    context: {
+      keyGenerator: _temp3,
+      schema
+    },
+    options: {
+      refreshKeys: !1
+    },
+    block: props.element
+  }), $[16] = props.element, $[17] = schema, $[18] = t0) : t0 = $[18];
+  const textBlock = t0;
+  if (textBlock) {
+    let t12;
+    return $[19] !== props.attributes || $[20] !== props.children || $[21] !== props.element || $[22] !== props.readOnly || $[23] !== props.renderBlock || $[24] !== props.renderListItem || $[25] !== props.renderStyle || $[26] !== props.spellCheck || $[27] !== textBlock ? (t12 = /* @__PURE__ */ jsx(RenderTextBlock, { attributes: props.attributes, element: props.element, readOnly: props.readOnly, renderBlock: props.renderBlock, renderListItem: props.renderListItem, renderStyle: props.renderStyle, spellCheck: props.spellCheck, textBlock, children: props.children }), $[19] = props.attributes, $[20] = props.children, $[21] = props.element, $[22] = props.readOnly, $[23] = props.renderBlock, $[24] = props.renderListItem, $[25] = props.renderStyle, $[26] = props.spellCheck, $[27] = textBlock, $[28] = t12) : t12 = $[28], t12;
+  }
+  let t1;
+  if ($[29] !== props.element || $[30] !== schema) {
+    let t22;
+    $[32] !== props.element ? (t22 = "value" in props.element && typeof props.element.value == "object" ? props.element.value : {}, $[32] = props.element, $[33] = t22) : t22 = $[33], t1 = parseBlockObject({
+      context: {
+        keyGenerator: _temp4,
+        schema
+      },
+      options: {
+        refreshKeys: !1
+      },
+      blockObject: {
+        _key: props.element._key,
+        _type: props.element._type,
+        ...t22
+      }
+    }), $[29] = props.element, $[30] = schema, $[31] = t1;
+  } else
+    t1 = $[31];
+  const blockObject = t1;
+  blockObject || console.error(`Unable to find Block Object "${props.element._type}" in Schema`);
+  let t2;
+  $[34] !== blockObject || $[35] !== props.element._key || $[36] !== props.element._type ? (t2 = blockObject ?? {
+    _key: props.element._key,
+    _type: props.element._type
+  }, $[34] = blockObject, $[35] = props.element._key, $[36] = props.element._type, $[37] = t2) : t2 = $[37];
+  let t3;
+  return $[38] !== props.attributes || $[39] !== props.children || $[40] !== props.element || $[41] !== props.readOnly || $[42] !== props.renderBlock || $[43] !== t2 ? (t3 = /* @__PURE__ */ jsx(RenderBlockObject, { attributes: props.attributes, blockObject: t2, element: props.element, readOnly: props.readOnly, renderBlock: props.renderBlock, children: props.children }), $[38] = props.attributes, $[39] = props.children, $[40] = props.element, $[41] = props.readOnly, $[42] = props.renderBlock, $[43] = t2, $[44] = t3) : t3 = $[44], t3;
+}
+function _temp4() {
+  return "";
+}
+function _temp3() {
+  return "";
+}
+function _temp2() {
+  return "";
+}
+function _temp(s) {
+  return s.context.schema;
+}
 const debug$1 = debugWithName("plugin:withHotKeys");
 function createWithHotkeys(editorActor, portableTextEditor, hotkeysFromOptions) {
   const reservedHotkeys = ["enter", "tab", "shift", "delete", "end"], activeHotkeys = hotkeysFromOptions ?? {};
@@ -1022,7 +1111,7 @@ function createDecorate(rangeDecorationActor) {
       }];
     if (path.length === 0)
       return [];
-    if (!Element$2.isElement(node) || node.children.length === 0)
+    if (!Element$1.isElement(node) || node.children.length === 0)
       return [];
     const blockIndex = path.at(0);
     return blockIndex === void 0 ? [] : rangeDecorationActor.getSnapshot().context.decoratedRanges.filter((decoratedRange) => Range.isCollapsed(decoratedRange) ? node.children.some((_, childIndex) => Path.equals(decoratedRange.anchor.path, [blockIndex, childIndex]) && Path.equals(decoratedRange.focus.path, [blockIndex, childIndex])) : Range.intersection(decoratedRange, {
@@ -1105,7 +1194,7 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
     const withHotKeys = createWithHotkeys(editorActor, portableTextEditor, hotkeys);
     return debug("Editable is in edit mode"), withHotKeys(slateEditor);
   }, [editorActor, hotkeys, portableTextEditor, readOnly, slateEditor]);
-  const renderElement = useCallback((eProps) => /* @__PURE__ */ jsx(Element$1, { ...eProps, readOnly, renderBlock, renderChild, renderListItem, renderStyle, schemaTypes: portableTextEditor.schemaTypes, spellCheck }), [portableTextEditor, spellCheck, readOnly, renderBlock, renderChild, renderListItem, renderStyle]), renderLeaf = useCallback((lProps) => {
+  const renderElement = useCallback((eProps) => /* @__PURE__ */ jsx(RenderElement, { ...eProps, readOnly, renderBlock, renderChild, renderListItem, renderStyle, spellCheck }), [spellCheck, readOnly, renderBlock, renderChild, renderListItem, renderStyle]), renderLeaf = useCallback((lProps) => {
     if (lProps.leaf._type === "span") {
       let rendered = /* @__PURE__ */ jsx(Leaf, { ...lProps, editorActor, schemaTypes: portableTextEditor.schemaTypes, renderAnnotation, renderChild, renderDecorator, readOnly });
       if (renderPlaceholder && lProps.leaf.placeholder && lProps.text.text === "")