@portabletext/editor 1.48.15 → 1.49.1

package/lib/index.cjs

@@ -330,65 +330,53 @@ function getSelectionDomNodes({
     childNodes: childEntries.map(([childNode]) => slateDom.DOMEditor.toDOMNode(slateEditor, childNode))
   };
 }
-function DefaultBlockObject(props) {
+function DropIndicator() {
+  const $ = reactCompilerRuntime.c(1);
+  let t0;
+  return $[0] === Symbol.for("react.memo_cache_sentinel") ? (t0 = /* @__PURE__ */ jsxRuntime.jsx("div", { contentEditable: !1, className: "pt-drop-indicator", style: {
+    position: "absolute",
+    width: "100%",
+    height: 1,
+    borderBottom: "1px solid currentColor",
+    zIndex: 5
+  }, children: /* @__PURE__ */ jsxRuntime.jsx("span", {}) }), $[0] = t0) : t0 = $[0], t0;
+}
+function RenderDefaultBlockObject(props) {
   const $ = reactCompilerRuntime.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__ */ jsxRuntime.jsxs("div", { style: t0, children: [
+  return $[1] !== props.blockObject._key || $[2] !== props.blockObject._type ? (t1 = /* @__PURE__ */ jsxRuntime.jsxs("div", { style: t0, children: [
     "[",
-    props.value._type,
+    props.blockObject._type,
     ": ",
-    props.value._key,
+    props.blockObject._key,
     "]"
-  ] }), $[1] = props.value._key, $[2] = props.value._type, $[3] = t1) : t1 = $[3], t1;
+  ] }), $[1] = props.blockObject._key, $[2] = props.blockObject._type, $[3] = t1) : t1 = $[3], t1;
 }
-function DefaultInlineObject(props) {
+function RenderDefaultInlineObject(props) {
   const $ = reactCompilerRuntime.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__ */ jsxRuntime.jsxs("span", { style: t0, children: [
+  return $[1] !== props.inlineObject._key || $[2] !== props.inlineObject._type ? (t1 = /* @__PURE__ */ jsxRuntime.jsxs("span", { style: t0, children: [
     "[",
-    props.value._type,
+    props.inlineObject._type,
     ": ",
-    props.value._key,
+    props.inlineObject._key,
     "]"
-  ] }), $[1] = props.value._key, $[2] = props.value._type, $[3] = t1) : t1 = $[3], t1;
+  ] }), $[1] = props.inlineObject._key, $[2] = props.inlineObject._type, $[3] = t1) : t1 = $[3], t1;
 }
-function DropIndicator() {
-  const $ = reactCompilerRuntime.c(1);
-  let t0;
-  return $[0] === Symbol.for("react.memo_cache_sentinel") ? (t0 = /* @__PURE__ */ jsxRuntime.jsx("div", { contentEditable: !1, className: "pt-drop-indicator", style: {
-    position: "absolute",
-    width: "100%",
-    height: 1,
-    borderBottom: "1px solid currentColor",
-    zIndex: 5
-  }, children: /* @__PURE__ */ jsxRuntime.jsx("span", {}) }), $[0] = t0) : t0 = $[0], t0;
-}
-editorProvider.debugWithName("components:Element");
-const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
-  display: "inline-block"
-}, Element$1 = ({
-  attributes,
-  children,
-  element,
-  schemaTypes,
-  readOnly,
-  renderBlock,
-  renderChild,
-  renderListItem,
-  renderStyle,
-  spellCheck
-}) => {
-  const editorActor = React.useContext(editorProvider.EditorActorContext), slateEditor = slateReact.useSlateStatic(), selected = slateReact.useSelected(), blockRef = React.useRef(null), inlineBlockObjectRef = React.useRef(null), focused = selected && slateEditor.selection && slate.Range.isCollapsed(slateEditor.selection) || !1, [dragPositionBlock, setDragPositionBlock] = React.useState();
-  React.useEffect(() => {
-    const behavior = behaviors_index.defineBehavior({
+function createCoreBlockElementBehaviorsConfig({
+  key,
+  onSetDragPositionBlock
+}) {
+  return [{
+    behavior: behaviors_index.defineBehavior({
       on: "drag.dragover",
       guard: ({
         snapshot,
@@ -400,7 +388,7 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
             selection: event.position.selection
           }
         });
-        if (!dropFocusBlock || dropFocusBlock.node._key !== element._key)
+        if (!dropFocusBlock || dropFocusBlock.node._key !== key)
           return !1;
         const dragOrigin = snapshot.beta.internalDrag?.origin;
         return !dragOrigin || selector_isSelectingEntireBlocks.getSelectedBlocks({
@@ -408,7 +396,7 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
             ...snapshot.context,
             selection: dragOrigin.selection
           }
-        }).some((draggedBlock) => draggedBlock.node._key === element._key) ? !1 : selector_isSelectingEntireBlocks.isSelectingEntireBlocks({
+        }).some((draggedBlock) => draggedBlock.node._key === key) ? !1 : selector_isSelectingEntireBlocks.isSelectingEntireBlocks({
           context: {
             ...snapshot.context,
             selection: dragOrigin.selection
@@ -416,205 +404,286 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
         });
       },
       actions: [({
-        event: event_0
+        event
       }) => [{
         type: "effect",
         effect: () => {
-          setDragPositionBlock(event_0.position.block);
+          onSetDragPositionBlock(event.position.block);
         }
       }]]
-    }), priority = editorProvider.createEditorPriority({
+    }),
+    priority: editorProvider.createEditorPriority({
       reference: {
         priority: editorProvider.corePriority,
         importance: "lower"
       }
-    }), behaviorConfig = {
-      behavior,
-      priority
-    };
-    return editorActor.send({
-      type: "add behavior",
-      behaviorConfig
-    }), () => {
-      editorActor.send({
-        type: "remove behavior",
-        behaviorConfig
-      });
-    };
-  }, [editorActor, element._key]), React.useEffect(() => {
-    const behavior_0 = behaviors_index.defineBehavior({
+    })
+  }, {
+    behavior: behaviors_index.defineBehavior({
       on: "drag.*",
       guard: ({
-        event: event_1
-      }) => event_1.type !== "drag.dragover",
+        event
+      }) => event.type !== "drag.dragover",
       actions: [({
-        event: event_2
+        event
       }) => [{
         type: "effect",
         effect: () => {
-          setDragPositionBlock(void 0);
+          onSetDragPositionBlock(void 0);
         }
-      }, behaviors_index.forward(event_2)]]
-    }), priority_0 = editorProvider.createEditorPriority({
+      }, behaviors_index.forward(event)]]
+    }),
+    priority: editorProvider.createEditorPriority({
       reference: {
         priority: editorProvider.corePriority,
         importance: "lower"
       }
-    }), behaviorConfig_0 = {
-      behavior: behavior_0,
-      priority: priority_0
-    };
-    return editorActor.send({
-      type: "add behavior",
-      behaviorConfig: behaviorConfig_0
-    }), () => {
+    })
+  }];
+}
+function useCoreBlockElementBehaviors(t0) {
+  const $ = reactCompilerRuntime.c(5), {
+    key,
+    onSetDragPositionBlock
+  } = t0, editorActor = React.useContext(editorProvider.EditorActorContext);
+  let t1, t2;
+  $[0] !== editorActor || $[1] !== key || $[2] !== onSetDragPositionBlock ? (t1 = () => {
+    const behaviorConfigs = createCoreBlockElementBehaviorsConfig({
+      key,
+      onSetDragPositionBlock
+    });
+    for (const behaviorConfig of behaviorConfigs)
       editorActor.send({
-        type: "remove behavior",
-        behaviorConfig: behaviorConfig_0
+        type: "add behavior",
+        behaviorConfig
       });
+    return () => {
+      for (const behaviorConfig_0 of behaviorConfigs)
+        editorActor.send({
+          type: "remove behavior",
+          behaviorConfig: behaviorConfig_0
+        });
     };
-  }, [editorActor]);
-  const value = React.useMemo(() => editorProvider.fromSlateValue([element], schemaTypes.block.name, editorProvider.KEY_TO_VALUE_ELEMENT.get(slateEditor))[0], [slateEditor, element, schemaTypes.block.name]);
-  let renderedBlock = children, className;
-  const blockPath = React.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 = slateReact.ReactEditor.findPath(slateEditor, element), [block] = slate.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 (slate.Element.isElement(block)) {
-      const elmPath = [{
-        _key: block._key
-      }, "children", {
-        _key: element._key
-      }];
-      return /* @__PURE__ */ jsxRuntime.jsxs("span", { ...attributes, children: [
-        children,
-        /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(DefaultInlineObject, { value }),
-            editorElementRef: inlineBlockObjectRef,
-            focused,
-            path: elmPath,
-            schemaType,
-            selected,
-            type: schemaType,
-            value
-          }),
-          !renderChild && /* @__PURE__ */ jsxRuntime.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,
+  }, t2 = [editorActor, key, onSetDragPositionBlock], $[0] = editorActor, $[1] = key, $[2] = onSetDragPositionBlock, $[3] = t1, $[4] = t2) : (t1 = $[3], t2 = $[4]), React.useEffect(t1, t2);
+}
+function RenderBlockObject(props) {
+  const [dragPositionBlock, setDragPositionBlock] = React.useState(), blockObjectRef = React.useRef(null), slateEditor = slateReact.useSlateStatic(), selected = slateReact.useSelected(), editorActor = React.useContext(editorProvider.EditorActorContext);
+  useCoreBlockElementBehaviors({
+    key: props.element._key,
+    onSetDragPositionBlock: setDragPositionBlock
+  });
+  const legacySchemaType = react.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 && slate.Range.isCollapsed(slateEditor.selection);
+  return /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(DropIndicator, {}) : null,
+    props.children,
+    /* @__PURE__ */ jsxRuntime.jsx("div", { ref: blockObjectRef, contentEditable: !1, draggable: !props.readOnly, children: props.renderBlock && legacySchemaType ? props.renderBlock({
+      children: /* @__PURE__ */ jsxRuntime.jsx(RenderDefaultBlockObject, { blockObject: props.blockObject }),
+      editorElementRef: blockObjectRef,
       focused,
+      path: [{
+        _key: props.element._key
+      }],
+      schemaType: legacySchemaType,
       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
-      }));
+      type: legacySchemaType,
+      value: props.blockObject
+    }) : /* @__PURE__ */ jsxRuntime.jsx(RenderDefaultBlockObject, { blockObject: props.blockObject }) }),
+    dragPositionBlock === "end" ? /* @__PURE__ */ jsxRuntime.jsx(DropIndicator, {}) : null
+  ] });
+}
+function RenderInlineObject(props) {
+  const inlineObjectRef = React.useRef(null), slateEditor = slateReact.useSlateStatic(), selected = slateReact.useSelected(), editorActor = React.useContext(editorProvider.EditorActorContext), legacySchemaType = react.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 && slate.Range.isCollapsed(slateEditor.selection), path = slateDom.DOMEditor.findPath(slateEditor, props.element), [block] = editorProvider.getPointBlock({
+    editor: slateEditor,
+    point: {
+      path,
+      offset: 0
     }
-    const renderProps = Object.defineProperty({
-      children: renderedBlock,
+  });
+  return block || console.error(`Unable to find parent block of inline object ${props.element._key}`), /* @__PURE__ */ jsxRuntime.jsxs("span", { ...props.attributes, draggable: !props.readOnly, className: "pt-inline-object", "data-child-key": props.inlineObject._key, "data-child-name": props.inlineObject._type, "data-child-type": "object", children: [
+    props.children,
+    /* @__PURE__ */ jsxRuntime.jsx("span", { ref: inlineObjectRef, style: {
+      display: "inline-block"
+    }, children: props.renderChild && block && legacySchemaType ? props.renderChild({
+      annotations: [],
+      children: /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(RenderDefaultInlineObject, { inlineObject: props.inlineObject }) })
+  ] });
+}
+function RenderTextBlock(props) {
+  const [dragPositionBlock, setDragPositionBlock] = React.useState(), blockRef = React.useRef(null), slateEditor = slateReact.useSlateStatic(), selected = slateReact.useSelected(), editorActor = React.useContext(editorProvider.EditorActorContext);
+  useCoreBlockElementBehaviors({
+    key: props.element._key,
+    onSetDragPositionBlock: setDragPositionBlock
+  });
+  const legacySchema = react.useSelector(editorActor, (s) => s.context.getLegacySchema()), focused = selected && slateEditor.selection !== null && slate.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,
-      level,
-      listItem: isListItem ? element.listItem : void 0,
-      path: blockPath,
+      path: [{
+        _key: props.textBlock._key
+      }],
+      schemaType: legacyStyleSchemaType,
       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__ */ jsxRuntime.jsxs("div", { ...attributes, className, spellCheck, children: [
-      dragPositionBlock === "start" ? /* @__PURE__ */ jsxRuntime.jsx(DropIndicator, {}) : null,
-      /* @__PURE__ */ jsxRuntime.jsx("div", { ref: blockRef, children: propsOrDefaultRendered }),
-      dragPositionBlock === "end" ? /* @__PURE__ */ jsxRuntime.jsx(DropIndicator, {}) : null
-    ] }, element._key);
+      value: props.textBlock.style
+    }) : console.error(`Unable to find Schema type for text block style ${props.textBlock.style}`);
   }
-  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 = editorProvider.fromSlateValue([element], schemaTypes.block.name, editorProvider.KEY_TO_VALUE_ELEMENT.get(slateEditor))[0];
-  let renderedBlockFromProps;
-  if (renderBlock) {
-    const _props = Object.defineProperty({
-      children: /* @__PURE__ */ jsxRuntime.jsx(DefaultBlockObject, { value }),
+  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,
-      path: blockPath,
-      schemaType: schemaType_0,
+      level: props.textBlock.level ?? 1,
+      path: [{
+        _key: props.textBlock._key
+      }],
       selected,
-      value: block_0
-    }, "type", {
-      enumerable: !1,
-      get() {
-        return console.warn("Property 'type' is deprecated, use 'schemaType' instead."), schemaType_0;
-      }
-    });
-    renderedBlockFromProps = renderBlock(_props);
+      value: props.textBlock.listItem,
+      schemaType: legacyListItemSchemaType
+    }) : console.error(`Unable to find Schema type for text block list item ${props.textBlock.listItem}`);
   }
-  return /* @__PURE__ */ jsxRuntime.jsxs("div", { ...attributes, className, children: [
+  return /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(DropIndicator, {}) : null,
-    children,
-    /* @__PURE__ */ jsxRuntime.jsx("div", { ref: blockRef, contentEditable: !1, draggable: !readOnly, children: renderedBlockFromProps || /* @__PURE__ */ jsxRuntime.jsx(DefaultBlockObject, { value }) }),
+    /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(DropIndicator, {}) : null
-  ] }, element._key);
-};
-Element$1.displayName = "Element";
-const debug$2 = editorProvider.debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (props) => {
-  const {
-    editorActor,
-    attributes,
-    children,
-    leaf,
-    schemaTypes,
-    renderChild,
-    renderDecorator,
-    renderAnnotation
-  } = props, spanRef = React.useRef(null), portableTextEditor = editorProvider.usePortableTextEditor(), blockSelected = slateReact.useSelected(), [focused, setFocused] = React.useState(!1), [selected, setSelected] = React.useState(!1), block = children.props.parent, path = React.useMemo(() => block ? [{
-    _key: block?._key
+  ] });
+}
+function RenderElement(props) {
+  const $ = reactCompilerRuntime.c(45), editorActor = React.useContext(editorProvider.EditorActorContext), schema = react.useSelector(editorActor, _temp$1);
+  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 = util_sliceBlocks.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__ */ jsxRuntime.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 = util_sliceBlocks.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__ */ jsxRuntime.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 = util_sliceBlocks.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__ */ jsxRuntime.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$1(s) {
+  return s.context.schema;
+}
+function RenderSpan(props) {
+  const slateEditor = slateReact.useSlateStatic(), editorActor = React.useContext(editorProvider.EditorActorContext), legacySchema = react.useSelector(editorActor, (s) => s.context.getLegacySchema()), spanRef = React.useRef(null), portableTextEditor = editorProvider.usePortableTextEditor(), blockSelected = slateReact.useSelected(), [focused, setFocused] = React.useState(!1), [selected, setSelected] = React.useState(!1), parent = props.children.props.parent, block = parent && slateEditor.isTextBlock(parent) ? parent : void 0, path = React.useMemo(() => block ? [{
+    _key: block._key
   }, "children", {
-    _key: leaf._key
-  }] : [], [block, leaf._key]), decoratorValues = React.useMemo(() => schemaTypes.decorators.map((dec) => dec.value), [schemaTypes.decorators]), marks = React.useMemo(() => uniq__default.default((leaf.marks || EMPTY_MARKS).filter((mark) => decoratorValues.includes(mark))), [decoratorValues, leaf.marks]), annotationMarks = Array.isArray(leaf.marks) ? leaf.marks : EMPTY_MARKS, annotations = React.useMemo(() => annotationMarks.map((mark_0) => !decoratorValues.includes(mark_0) && block?.markDefs?.find((def) => def._key === mark_0)).filter(Boolean), [annotationMarks, block, decoratorValues]), shouldTrackSelectionAndFocus = annotations.length > 0 && blockSelected;
+    _key: props.leaf._key
+  }] : void 0, [block, props.leaf._key]), decoratorSchemaTypes = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name), decorators = uniq__default.default((props.leaf.marks ?? []).filter((mark) => decoratorSchemaTypes.includes(mark))), annotationMarkDefs = (props.leaf.marks ?? []).flatMap((mark_0) => {
+    if (decoratorSchemaTypes.includes(mark_0))
+      return [];
+    const markDef_0 = block?.markDefs?.find((markDef) => markDef._key === mark_0);
+    return markDef_0 ? [markDef_0] : [];
+  }), shouldTrackSelectionAndFocus = annotationMarkDefs.length > 0 && blockSelected;
   React.useEffect(() => {
     if (!shouldTrackSelectionAndFocus) {
       setFocused(!1);
@@ -628,7 +697,6 @@ const debug$2 = editorProvider.debugWithName("components:Leaf"), EMPTY_MARKS = [
   const setSelectedFromRange = React.useCallback(() => {
     if (!shouldTrackSelectionAndFocus)
       return;
-    debug$2("Setting selection and focus from range");
     const winSelection = window.getSelection();
     if (!winSelection) {
       setSelected(!1);
@@ -655,75 +723,92 @@ const debug$2 = editorProvider.debugWithName("components:Leaf"), EMPTY_MARKS = [
       onBlur.unsubscribe(), onFocus.unsubscribe(), onSelection.unsubscribe();
     };
   }, [editorActor, path, portableTextEditor, setSelectedFromRange, shouldTrackSelectionAndFocus]), React.useEffect(() => setSelectedFromRange(), [setSelectedFromRange]);
-  const content = React.useMemo(() => {
-    let returnedChildren = children;
-    if (slate.Text.isText(leaf) && leaf._type === schemaTypes.span.name && (marks.forEach((mark_1) => {
-      const schemaType = schemaTypes.decorators.find((dec_0) => dec_0.value === mark_1);
-      if (schemaType && renderDecorator) {
-        const _props = Object.defineProperty({
-          children: returnedChildren,
-          editorElementRef: spanRef,
-          focused,
-          path,
-          selected,
-          schemaType,
-          value: mark_1
-        }, "type", {
-          enumerable: !1,
-          get() {
-            return console.warn("Property 'type' is deprecated, use 'schemaType' instead."), schemaType;
-          }
-        });
-        returnedChildren = renderDecorator(_props);
-      }
-    }), block && annotations.length > 0 && annotations.forEach((annotation) => {
-      const schemaType_0 = schemaTypes.annotations.find((t) => t.name === annotation._type);
-      if (schemaType_0)
-        if (renderAnnotation) {
-          const _props_0 = Object.defineProperty({
-            block,
-            children: returnedChildren,
-            editorElementRef: spanRef,
-            focused,
-            path,
-            selected,
-            schemaType: schemaType_0,
-            value: annotation
-          }, "type", {
-            enumerable: !1,
-            get() {
-              return console.warn("Property 'type' is deprecated, use 'schemaType' instead."), schemaType_0;
-            }
-          });
-          returnedChildren = /* @__PURE__ */ jsxRuntime.jsx("span", { ref: spanRef, children: renderAnnotation(_props_0) });
-        } else
-          returnedChildren = /* @__PURE__ */ jsxRuntime.jsx("span", { ref: spanRef, children: returnedChildren });
-    }), block && renderChild)) {
-      const child = block.children.find((_child) => _child._key === leaf._key);
-      if (child) {
-        const _props_1 = Object.defineProperty({
-          annotations,
-          children: /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: returnedChildren }),
-          editorElementRef: spanRef,
-          focused,
-          path,
-          schemaType: schemaTypes.span,
-          selected,
-          value: child
-        }, "type", {
-          enumerable: !1,
-          get() {
-            return console.warn("Property 'type' is deprecated, use 'schemaType' instead."), schemaTypes.span;
-          }
-        });
-        returnedChildren = renderChild(_props_1);
-      }
-    }
-    return returnedChildren;
-  }, [annotations, block, children, focused, leaf, marks, path, renderAnnotation, renderChild, renderDecorator, schemaTypes.annotations, schemaTypes.decorators, schemaTypes.span, selected]);
-  return React.useMemo(() => /* @__PURE__ */ jsxRuntime.jsx("span", { ...attributes, ref: spanRef, children: content }, leaf._key), [leaf, attributes, content]);
+  let children = props.children;
+  for (const mark_1 of decorators) {
+    const legacyDecoratorSchemaType = legacySchema.decorators.find((dec) => dec.value === mark_1);
+    path && legacyDecoratorSchemaType && props.renderDecorator && (children = props.renderDecorator({
+      children,
+      editorElementRef: spanRef,
+      focused,
+      path,
+      selected,
+      schemaType: legacyDecoratorSchemaType,
+      value: mark_1,
+      type: legacyDecoratorSchemaType
+    }));
+  }
+  for (const annotationMarkDef of annotationMarkDefs) {
+    const legacyAnnotationSchemaType = legacySchema.annotations.find((t) => t.name === annotationMarkDef._type);
+    legacyAnnotationSchemaType && (block && path && props.renderAnnotation ? children = /* @__PURE__ */ jsxRuntime.jsx("span", { ref: spanRef, children: props.renderAnnotation({
+      block,
+      children,
+      editorElementRef: spanRef,
+      focused,
+      path,
+      selected,
+      schemaType: legacyAnnotationSchemaType,
+      value: annotationMarkDef,
+      type: legacyAnnotationSchemaType
+    }) }) : children = /* @__PURE__ */ jsxRuntime.jsx("span", { ref: spanRef, children }));
+  }
+  if (block && path && props.renderChild) {
+    const child = block.children.find((_child) => _child._key === props.leaf._key);
+    child && (children = props.renderChild({
+      annotations: annotationMarkDefs,
+      children,
+      editorElementRef: spanRef,
+      focused,
+      path,
+      schemaType: legacySchema.span,
+      selected,
+      value: child,
+      type: legacySchema.span
+    }));
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("span", { ...props.attributes, ref: spanRef, children });
+}
+const PLACEHOLDER_STYLE = {
+  position: "absolute",
+  userSelect: "none",
+  pointerEvents: "none",
+  left: 0,
+  right: 0
 };
-Leaf.displayName = "Leaf";
+function RenderLeaf(props) {
+  const $ = reactCompilerRuntime.c(12), editorActor = React.useContext(editorProvider.EditorActorContext), schema = react.useSelector(editorActor, _temp);
+  if (props.leaf._type !== schema.span.name)
+    return props.children;
+  let t0;
+  $[0] !== props ? (t0 = /* @__PURE__ */ jsxRuntime.jsx(RenderSpan, { ...props }), $[0] = props, $[1] = t0) : t0 = $[1];
+  let renderedSpan = t0;
+  if (props.renderPlaceholder && props.leaf.placeholder && props.text.text === "") {
+    let t1;
+    $[2] !== props.renderPlaceholder ? (t1 = props.renderPlaceholder(), $[2] = props.renderPlaceholder, $[3] = t1) : t1 = $[3];
+    let t2;
+    $[4] !== t1 ? (t2 = /* @__PURE__ */ jsxRuntime.jsx("span", { style: PLACEHOLDER_STYLE, contentEditable: !1, children: t1 }), $[4] = t1, $[5] = t2) : t2 = $[5];
+    let t3;
+    return $[6] !== renderedSpan || $[7] !== t2 ? (t3 = /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      t2,
+      renderedSpan
+    ] }), $[6] = renderedSpan, $[7] = t2, $[8] = t3) : t3 = $[8], t3;
+  }
+  const rangeDecoration = props.leaf.rangeDecoration;
+  if (rangeDecoration) {
+    let t1;
+    $[9] !== rangeDecoration || $[10] !== renderedSpan ? (t1 = rangeDecoration.component({
+      children: renderedSpan
+    }), $[9] = rangeDecoration, $[10] = renderedSpan, $[11] = t1) : t1 = $[11], renderedSpan = t1;
+  }
+  return renderedSpan;
+}
+function _temp(s) {
+  return s.context.schema;
+}
+function RenderText(props) {
+  const $ = reactCompilerRuntime.c(5);
+  let t0;
+  return $[0] !== props.attributes || $[1] !== props.children || $[2] !== props.text._key || $[3] !== props.text._type ? (t0 = /* @__PURE__ */ jsxRuntime.jsx("span", { ...props.attributes, "data-child-key": props.text._key, "data-child-name": props.text._type, "data-child-type": "span", children: props.children }), $[0] = props.attributes, $[1] = props.children, $[2] = props.text._key, $[3] = props.text._type, $[4] = t0) : t0 = $[4], t0;
+}
 const debug$1 = editorProvider.debugWithName("plugin:withHotKeys");
 function createWithHotkeys(editorActor, portableTextEditor, hotkeysFromOptions) {
   const reservedHotkeys = ["enter", "tab", "shift", "delete", "end"], activeHotkeys = hotkeysFromOptions ?? {};
@@ -1040,13 +1125,7 @@ function createDecorate(rangeDecorationActor) {
     }) || slate.Range.includes(decoratedRange, path));
   };
 }
-const debug = editorProvider.debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
-  position: "absolute",
-  userSelect: "none",
-  pointerEvents: "none",
-  left: 0,
-  right: 0
-}, PortableTextEditable = React.forwardRef(function(props, forwardedRef) {
+const debug = editorProvider.debugWithName("component:Editable"), PortableTextEditable = React.forwardRef(function(props, forwardedRef) {
   const {
     hotkeys,
     onBlur,
@@ -1108,21 +1187,7 @@ const debug = editorProvider.debugWithName("component:Editable"), PLACEHOLDER_ST
     const withHotKeys = createWithHotkeys(editorActor, portableTextEditor, hotkeys);
     return debug("Editable is in edit mode"), withHotKeys(slateEditor);
   }, [editorActor, hotkeys, portableTextEditor, readOnly, slateEditor]);
-  const renderElement = React.useCallback((eProps) => /* @__PURE__ */ jsxRuntime.jsx(Element$1, { ...eProps, readOnly, renderBlock, renderChild, renderListItem, renderStyle, schemaTypes: portableTextEditor.schemaTypes, spellCheck }), [portableTextEditor, spellCheck, readOnly, renderBlock, renderChild, renderListItem, renderStyle]), renderLeaf = React.useCallback((lProps) => {
-    if (lProps.leaf._type === "span") {
-      let rendered = /* @__PURE__ */ jsxRuntime.jsx(Leaf, { ...lProps, editorActor, schemaTypes: portableTextEditor.schemaTypes, renderAnnotation, renderChild, renderDecorator, readOnly });
-      if (renderPlaceholder && lProps.leaf.placeholder && lProps.text.text === "")
-        return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-          /* @__PURE__ */ jsxRuntime.jsx("span", { style: PLACEHOLDER_STYLE, contentEditable: !1, children: renderPlaceholder() }),
-          rendered
-        ] });
-      const decoration = lProps.leaf.rangeDecoration;
-      return decoration && (rendered = decoration.component({
-        children: rendered
-      })), rendered;
-    }
-    return lProps.children;
-  }, [editorActor, portableTextEditor, readOnly, renderAnnotation, renderChild, renderDecorator, renderPlaceholder]), restoreSelectionFromProps = React.useCallback(() => {
+  const renderElement = React.useCallback((eProps) => /* @__PURE__ */ jsxRuntime.jsx(RenderElement, { ...eProps, readOnly, renderBlock, renderChild, renderListItem, renderStyle, spellCheck }), [spellCheck, readOnly, renderBlock, renderChild, renderListItem, renderStyle]), renderLeaf = React.useCallback((leafProps) => /* @__PURE__ */ jsxRuntime.jsx(RenderLeaf, { ...leafProps, readOnly, renderAnnotation, renderChild, renderDecorator, renderPlaceholder }), [readOnly, renderAnnotation, renderChild, renderDecorator, renderPlaceholder]), renderText = React.useCallback((props_0) => /* @__PURE__ */ jsxRuntime.jsx(RenderText, { ...props_0 }), []), restoreSelectionFromProps = React.useCallback(() => {
     if (propsSelection) {
       debug(`Selection from props ${JSON.stringify(propsSelection)}`);
       const normalizedSelection = normalizeSelection(propsSelection, editorProvider.fromSlateValue(slateEditor.children, editorActor.getSnapshot().context.schema.block.name));
@@ -1633,6 +1698,7 @@ const debug = editorProvider.debugWithName("component:Editable"), PLACEHOLDER_ST
       renderPlaceholder: void 0,
       renderElement,
       renderLeaf,
+      renderText,
       scrollSelectionIntoView: scrollSelectionIntoViewToSlate
     }
   ) : null;