@portabletext/editor 1.46.0 → 1.47.1

package/lib/_chunks-cjs/editor-provider.cjs

@@ -1,5 +1,5 @@
 "use strict";
-var jsxRuntime = require("react/jsx-runtime"), reactCompilerRuntime = require("react-compiler-runtime"), React = require("react"), slateReact = require("slate-react"), react = require("@xstate/react"), debug$g = require("debug"), isEqual = require("lodash/isEqual.js"), slate = require("slate"), xstate = require("xstate"), patches = require("@portabletext/patches"), types = require("@sanity/types"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), uniq = require("lodash/uniq.js"), getRandomValues = require("get-random-values-esm"), parseBlocks = require("./parse-blocks.cjs"), util_sliceBlocks = require("./util.slice-blocks.cjs"), blockTools = require("@portabletext/block-tools"), toHtml = require("@portabletext/to-html"), schema = require("@sanity/schema"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), omit = require("lodash/omit.js"), util_selectionPointToBlockOffset = require("./util.selection-point-to-block-offset.cjs"), selector_isSelectingEntireBlocks = require("./selector.is-selecting-entire-blocks.cjs"), slateDom = require("slate-dom"), startCase = require("lodash.startcase"), behavior_core = require("./behavior.core.cjs"), selector_isOverlappingSelection = require("./selector.is-overlapping-selection.cjs"), rxjs = require("rxjs"), useEffectEvent = require("use-effect-event");
+var jsxRuntime = require("react/jsx-runtime"), reactCompilerRuntime = require("react-compiler-runtime"), React = require("react"), slateReact = require("slate-react"), react = require("@xstate/react"), debug$g = require("debug"), isEqual = require("lodash/isEqual.js"), slate = require("slate"), xstate = require("xstate"), patches = require("@portabletext/patches"), types = require("@sanity/types"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), uniq = require("lodash/uniq.js"), getRandomValues = require("get-random-values-esm"), parseBlocks = require("./parse-blocks.cjs"), util_sliceBlocks = require("./util.slice-blocks.cjs"), blockTools = require("@portabletext/block-tools"), toHtml = require("@portabletext/to-html"), schema = require("@sanity/schema"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), omit = require("lodash/omit.js"), util_selectionPointToBlockOffset = require("./util.selection-point-to-block-offset.cjs"), selector_isSelectingEntireBlocks = require("./selector.is-selecting-entire-blocks.cjs"), slateDom = require("slate-dom"), behavior_core = require("./behavior.core.cjs"), selector_isOverlappingSelection = require("./selector.is-overlapping-selection.cjs"), startCase = require("lodash.startcase"), rxjs = require("rxjs"), useEffectEvent = require("use-effect-event");
 function _interopDefaultCompat(e) {
   return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
@@ -46,7 +46,7 @@ function toSlateValue(value, {
           __inline: !0
         }, keyMap)) : child;
       });
-      return !hasMissingStyle && !hasMissingMarkDefs && !hasMissingChildren && !hasInlines && slate.Element.isElement(block) ? block : (hasMissingStyle && (rest.style = schemaTypes.styles[0].value), keepObjectEquality({
+      return !hasMissingStyle && !hasMissingMarkDefs && !hasMissingChildren && !hasInlines && slate.Element.isElement(block) ? block : (hasMissingStyle && (rest.style = schemaTypes.styles[0].name), keepObjectEquality({
         _type,
         _key,
         ...rest,
@@ -115,7 +115,7 @@ function fromSlateValue(value, textBlockType, keyMap = {}) {
   });
 }
 function isEqualToEmptyEditor(children, schemaTypes) {
-  return children === void 0 || children && Array.isArray(children) && children.length === 0 || children && Array.isArray(children) && children.length === 1 && slate.Element.isElement(children[0]) && children[0]._type === schemaTypes.block.name && "style" in children[0] && children[0].style === schemaTypes.styles[0].value && !("listItem" in children[0]) && Array.isArray(children[0].children) && children[0].children.length === 1 && slate.Text.isText(children[0].children[0]) && children[0].children[0]._type === "span" && !children[0].children[0].marks?.join("") && children[0].children[0].text === "";
+  return children === void 0 || children && Array.isArray(children) && children.length === 0 || children && Array.isArray(children) && children.length === 1 && slate.Element.isElement(children[0]) && children[0]._type === schemaTypes.block.name && "style" in children[0] && children[0].style === schemaTypes.styles[0].name && !("listItem" in children[0]) && Array.isArray(children[0].children) && children[0].children.length === 1 && slate.Text.isText(children[0].children[0]) && children[0].children[0]._type === "span" && !children[0].children[0].marks?.join("") && children[0].children[0].text === "";
 }
 const IS_PROCESSING_REMOTE_CHANGES = /* @__PURE__ */ new WeakMap(), KEY_TO_SLATE_ELEMENT = /* @__PURE__ */ new WeakMap(), KEY_TO_VALUE_ELEMENT = /* @__PURE__ */ new WeakMap(), SLATE_TO_PORTABLE_TEXT_RANGE = /* @__PURE__ */ new WeakMap(), mutationMachine = xstate.setup({
   types: {
@@ -476,7 +476,7 @@ function validateValue(value, types$1, keyGenerator) {
             }
           }, !0;
       }
-      const orphanedMarks = allUsedMarks.filter((mark) => !types$1.decorators.map((dec) => dec.value).includes(mark)).filter((mark) => textBlock.markDefs === void 0 || !textBlock.markDefs.find((def) => def._key === mark));
+      const orphanedMarks = allUsedMarks.filter((mark) => !types$1.decorators.map((dec) => dec.name).includes(mark)).filter((mark) => textBlock.markDefs === void 0 || !textBlock.markDefs.find((def) => def._key === mark));
       if (orphanedMarks.length > 0) {
         const spanChildren = textBlock.children.filter((cld) => cld._type === types$1.span.name && Array.isArray(cld.marks) && cld.marks.some((mark) => orphanedMarks.includes(mark)));
         if (spanChildren) {
@@ -1329,11 +1329,10 @@ const debug$f = debugWithName("plugin:withUndoRedo"), SAVING = /* @__PURE__ */ n
 }, getRemotePatches = (editor) => (REMOTE_PATCHES.get(editor) || REMOTE_PATCHES.set(editor, []), REMOTE_PATCHES.get(editor) || []);
 function createWithUndoRedo(options) {
   const {
-    editorActor,
-    blockSchemaType
+    editorActor
   } = options;
   return (editor) => {
-    let previousSnapshot = fromSlateValue(editor.children, blockSchemaType.name);
+    let previousSnapshot = fromSlateValue(editor.children, editorActor.getSnapshot().context.schema.block.name);
     const remotePatches = getRemotePatches(editor);
     let previousBehaviorActionSetId = getCurrentBehaviorActionSetId(editor);
     options.subscriptions.push(() => {
@@ -2059,7 +2058,7 @@ function Synchronizer(props) {
   }, $[6] = slateEditor, $[7] = t0.context.keyGenerator, $[8] = t2, $[9] = t3.context.schema, $[10] = t4) : t4 = $[10];
   const syncActorRef = react.useActorRef(syncMachine, t4);
   let t5;
-  $[11] !== editorActor ? (t5 = editorActor.getSnapshot(), $[11] = editorActor, $[12] = t5) : t5 = $[12];
+  $[11] !== props.editorActor ? (t5 = props.editorActor.getSnapshot(), $[11] = props.editorActor, $[12] = t5) : t5 = $[12];
   let t6;
   $[13] !== slateEditor || $[14] !== t5.context.schema ? (t6 = {
     input: {
@@ -2262,121 +2261,128 @@ const converterJson = {
       mimeType: "application/x-portable-text"
     };
   }
-}, converterTextHtml = {
-  mimeType: "text/html",
-  serialize: ({
-    snapshot,
-    event
-  }) => {
-    const selection = snapshot.beta.internalDrag?.origin.selection ?? snapshot.context.selection;
-    if (!selection)
-      return {
+};
+function createConverterTextHtml(legacySchema) {
+  return {
+    mimeType: "text/html",
+    serialize: ({
+      snapshot,
+      event
+    }) => {
+      const selection = snapshot.beta.internalDrag?.origin.selection ?? snapshot.context.selection;
+      if (!selection)
+        return {
+          type: "serialization.failure",
+          mimeType: "text/html",
+          originEvent: event.originEvent,
+          reason: "No selection"
+        };
+      const blocks = util_sliceBlocks.sliceBlocks({
+        blocks: snapshot.context.value,
+        selection
+      }), html = toHtml.toHTML(blocks, {
+        onMissingComponent: !1,
+        components: {
+          unknownType: ({
+            children
+          }) => children !== void 0 ? `${children}` : ""
+        }
+      });
+      return html === "" ? {
         type: "serialization.failure",
         mimeType: "text/html",
         originEvent: event.originEvent,
-        reason: "No selection"
+        reason: "Serialized HTML is empty"
+      } : {
+        type: "serialization.success",
+        data: html,
+        mimeType: "text/html",
+        originEvent: event.originEvent
       };
-    const blocks = util_sliceBlocks.sliceBlocks({
-      blocks: snapshot.context.value,
-      selection
-    }), html = toHtml.toHTML(blocks, {
-      onMissingComponent: !1,
-      components: {
-        unknownType: ({
-          children
-        }) => children !== void 0 ? `${children}` : ""
-      }
-    });
-    return html === "" ? {
-      type: "serialization.failure",
-      mimeType: "text/html",
-      originEvent: event.originEvent,
-      reason: "Serialized HTML is empty"
-    } : {
-      type: "serialization.success",
-      data: html,
-      mimeType: "text/html",
-      originEvent: event.originEvent
-    };
-  },
-  deserialize: ({
-    snapshot,
-    event
-  }) => {
-    const parsedBlocks = blockTools.htmlToBlocks(event.data, snapshot.context.schema.portableText, {
-      keyGenerator: snapshot.context.keyGenerator,
-      unstable_whitespaceOnPasteMode: snapshot.context.schema.block.options.unstable_whitespaceOnPasteMode
-    }).flatMap((block) => {
-      const parsedBlock = parseBlocks.parseBlock({
-        context: snapshot.context,
-        block,
-        options: {
-          refreshKeys: !1
-        }
+    },
+    deserialize: ({
+      snapshot,
+      event
+    }) => {
+      const parsedBlocks = blockTools.htmlToBlocks(event.data, legacySchema.portableText, {
+        keyGenerator: snapshot.context.keyGenerator,
+        unstable_whitespaceOnPasteMode: legacySchema.block.options.unstable_whitespaceOnPasteMode
+      }).flatMap((block) => {
+        const parsedBlock = parseBlocks.parseBlock({
+          context: snapshot.context,
+          block,
+          options: {
+            refreshKeys: !1
+          }
+        });
+        return parsedBlock ? [parsedBlock] : [];
       });
-      return parsedBlock ? [parsedBlock] : [];
-    });
-    return parsedBlocks.length === 0 ? {
-      type: "deserialization.failure",
-      mimeType: "text/html",
-      reason: "No blocks deserialized"
-    } : {
-      type: "deserialization.success",
-      data: parsedBlocks,
-      mimeType: "text/html"
-    };
-  }
-}, converterTextPlain = {
-  mimeType: "text/plain",
-  serialize: ({
-    snapshot,
-    event
-  }) => {
-    const selection = snapshot.beta.internalDrag?.origin.selection ?? snapshot.context.selection;
-    return selection ? {
-      type: "serialization.success",
-      data: util_sliceBlocks.sliceBlocks({
-        blocks: snapshot.context.value,
-        selection
-      }).map((block) => types.isPortableTextTextBlock(block) ? block.children.map((child) => child._type === snapshot.context.schema.span.name ? child.text : snapshot.beta.hasTag("dragging internally") ? `[${snapshot.context.schema.inlineObjects.find((inlineObjectType) => inlineObjectType.name === child._type)?.title ?? "Object"}]` : "").join("") : snapshot.beta.hasTag("dragging internally") ? `[${snapshot.context.schema.blockObjects.find((blockObjectType) => blockObjectType.name === block._type)?.title ?? "Object"}]` : "").filter((block) => block !== "").join(`
+      return parsedBlocks.length === 0 ? {
+        type: "deserialization.failure",
+        mimeType: "text/html",
+        reason: "No blocks deserialized"
+      } : {
+        type: "deserialization.success",
+        data: parsedBlocks,
+        mimeType: "text/html"
+      };
+    }
+  };
+}
+function createConverterTextPlain(legacySchema) {
+  return {
+    mimeType: "text/plain",
+    serialize: ({
+      snapshot,
+      event
+    }) => {
+      const selection = snapshot.beta.internalDrag?.origin.selection ?? snapshot.context.selection;
+      return selection ? {
+        type: "serialization.success",
+        data: util_sliceBlocks.sliceBlocks({
+          blocks: snapshot.context.value,
+          selection
+        }).map((block) => types.isPortableTextTextBlock(block) ? block.children.map((child) => child._type === snapshot.context.schema.span.name ? child.text : snapshot.beta.hasTag("dragging internally") ? `[${snapshot.context.schema.inlineObjects.find((inlineObjectType) => inlineObjectType.name === child._type)?.title ?? "Object"}]` : "").join("") : snapshot.beta.hasTag("dragging internally") ? `[${snapshot.context.schema.blockObjects.find((blockObjectType) => blockObjectType.name === block._type)?.title ?? "Object"}]` : "").filter((block) => block !== "").join(`
 
 `),
-      mimeType: "text/plain",
-      originEvent: event.originEvent
-    } : {
-      type: "serialization.failure",
-      mimeType: "text/plain",
-      originEvent: event.originEvent,
-      reason: "No selection"
-    };
-  },
-  deserialize: ({
-    snapshot,
-    event
-  }) => {
-    const textToHtml = `<html><body>${escapeHtml(event.data).split(/\n{2,}/).map((line) => line ? `<p>${line.replace(/(?:\r\n|\r|\n)/g, "<br/>")}</p>` : "<p></p>").join("")}</body></html>`, parsedBlocks = blockTools.htmlToBlocks(textToHtml, snapshot.context.schema.portableText, {
-      keyGenerator: snapshot.context.keyGenerator
-    }).flatMap((block) => {
-      const parsedBlock = parseBlocks.parseBlock({
-        context: snapshot.context,
-        block,
-        options: {
-          refreshKeys: !1
-        }
+        mimeType: "text/plain",
+        originEvent: event.originEvent
+      } : {
+        type: "serialization.failure",
+        mimeType: "text/plain",
+        originEvent: event.originEvent,
+        reason: "No selection"
+      };
+    },
+    deserialize: ({
+      snapshot,
+      event
+    }) => {
+      const textToHtml = `<html><body>${escapeHtml(event.data).split(/\n{2,}/).map((line) => line ? `<p>${line.replace(/(?:\r\n|\r|\n)/g, "<br/>")}</p>` : "<p></p>").join("")}</body></html>`, parsedBlocks = blockTools.htmlToBlocks(textToHtml, legacySchema.portableText, {
+        keyGenerator: snapshot.context.keyGenerator
+      }).flatMap((block) => {
+        const parsedBlock = parseBlocks.parseBlock({
+          context: snapshot.context,
+          block,
+          options: {
+            refreshKeys: !1
+          }
+        });
+        return parsedBlock ? [parsedBlock] : [];
       });
-      return parsedBlock ? [parsedBlock] : [];
-    });
-    return parsedBlocks.length === 0 ? {
-      type: "deserialization.failure",
-      mimeType: "text/plain",
-      reason: "No blocks deserialized"
-    } : {
-      type: "deserialization.success",
-      data: parsedBlocks,
-      mimeType: "text/plain"
-    };
-  }
-}, entityMap = {
+      return parsedBlocks.length === 0 ? {
+        type: "deserialization.failure",
+        mimeType: "text/plain",
+        reason: "No blocks deserialized"
+      } : {
+        type: "deserialization.success",
+        data: parsedBlocks,
+        mimeType: "text/plain"
+      };
+    }
+  };
+}
+const entityMap = {
   "&": "&amp;",
   "<": "&lt;",
   ">": "&gt;",
@@ -2389,68 +2395,18 @@ const converterJson = {
 function escapeHtml(str) {
   return String(str).replace(/[&<>"'`=/]/g, (s) => entityMap[s]);
 }
-const coreConverters = [converterJson, converterPortableText, converterTextHtml, converterTextPlain];
+function createCoreConverters(legacySchema) {
+  return [converterJson, converterPortableText, createConverterTextHtml(legacySchema), createConverterTextPlain(legacySchema)];
+}
 function compileType(rawType) {
   return schema.Schema.compile({
     name: "blockTypeSchema",
     types: [rawType]
   }).get(rawType.name);
 }
-function createEditorSchema(portableTextType) {
-  if (!portableTextType)
-    throw new Error("Parameter 'portabletextType' missing (required)");
-  const blockType = portableTextType.of?.find(findBlockType);
-  if (!blockType)
-    throw new Error("Block type is not defined in this schema (required)");
-  const childrenField = blockType.fields?.find((field) => field.name === "children");
-  if (!childrenField)
-    throw new Error("Children field for block type found in schema (required)");
-  const ofType = childrenField.type.of;
-  if (!ofType)
-    throw new Error("Valid types for block children not found in schema (required)");
-  const spanType = ofType.find((memberType) => memberType.name === "span");
-  if (!spanType)
-    throw new Error("Span type not found in schema (required)");
-  const inlineObjectTypes = ofType.filter((memberType) => memberType.name !== "span") || [], blockObjectTypes = portableTextType.of?.filter((field) => field.name !== blockType.name) || [];
-  return {
-    styles: resolveEnabledStyles(blockType),
-    decorators: resolveEnabledDecorators(spanType),
-    lists: resolveEnabledListItems(blockType),
-    block: blockType,
-    span: spanType,
-    portableText: portableTextType,
-    inlineObjects: inlineObjectTypes,
-    blockObjects: blockObjectTypes,
-    annotations: spanType.annotations
-  };
-}
-function resolveEnabledStyles(blockType) {
-  const styleField = blockType.fields?.find((btField) => btField.name === "style");
-  if (!styleField)
-    throw new Error("A field with name 'style' is not defined in the block type (required).");
-  const textStyles = styleField.type.options?.list && styleField.type.options.list?.filter((style) => style.value);
-  if (!textStyles || textStyles.length === 0)
-    throw new Error("The style fields need at least one style defined. I.e: {title: 'Normal', value: 'normal'}.");
-  return textStyles;
-}
-function resolveEnabledDecorators(spanType) {
-  return spanType.decorators;
-}
-function resolveEnabledListItems(blockType) {
-  const listField = blockType.fields?.find((btField) => btField.name === "listItem");
-  if (!listField)
-    throw new Error("A field with name 'listItem' is not defined in the block type (required).");
-  const listItems = listField.type.options?.list && listField.type.options.list.filter((list) => list.value);
-  if (!listItems)
-    throw new Error("The list field need at least to be an empty array");
-  return listItems;
-}
-function findBlockType(type) {
-  return type.type ? findBlockType(type.type) : type.name === "block" ? type : null;
-}
 const debug$c = debugWithName("operationToPatches");
-function createOperationToPatches(types2) {
-  const textBlockName = types2.block.name;
+function createOperationToPatches(editorActor) {
+  const textBlockName = editorActor.getSnapshot().context.schema.block.name;
   function insertTextPatch(editor, operation, beforeValue) {
     debug$c.enabled && debug$c("Operation", JSON.stringify(operation, null, 2));
     const block = editor.isTextBlock(editor.children[operation.path[0]]) && editor.children[operation.path[0]];
@@ -2719,12 +2675,12 @@ function getNextSpan({
   return nextSpan;
 }
 const debug$b = debugWithName("plugin:withPortableTextMarkModel");
-function createWithPortableTextMarkModel(editorActor, types2) {
+function createWithPortableTextMarkModel(editorActor) {
   return function(editor) {
     const {
       apply: apply2,
       normalizeNode
-    } = editor, decorators = types2.decorators.map((t) => t.value);
+    } = editor, decorators = editorActor.getSnapshot().context.schema.decorators.map((t) => t.name);
     return editor.normalizeNode = (nodeEntry) => {
       const [node, path] = nodeEntry;
       if (editor.isTextBlock(node)) {
@@ -2769,7 +2725,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
         return;
       }
       if (editor.isTextSpan(node)) {
-        const blockPath = slate.Path.parent(path), [block] = slate.Editor.node(editor, blockPath), decorators2 = types2.decorators.map((decorator) => decorator.value), annotations = node.marks?.filter((mark) => !decorators2.includes(mark));
+        const blockPath = slate.Path.parent(path), [block] = slate.Editor.node(editor, blockPath), decorators2 = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name), annotations = node.marks?.filter((mark) => !decorators2.includes(mark));
         if (editor.isTextBlock(block) && node.text === "" && annotations && annotations.length > 0) {
           debug$b("Removing annotations from empty span node"), editorActor.send({
             type: "normalizing"
@@ -2784,7 +2740,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
         }
       }
       if (editor.isTextBlock(node)) {
-        const decorators2 = types2.decorators.map((decorator) => decorator.value);
+        const decorators2 = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name);
         for (const [child, childPath] of slate.Node.children(editor, path))
           if (editor.isTextSpan(child)) {
             const marks = child.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !node.markDefs?.find((def) => def._key === mark));
@@ -2805,7 +2761,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
       if (editor.isTextSpan(node)) {
         const blockPath = slate.Path.parent(path), [block] = slate.Editor.node(editor, blockPath);
         if (editor.isTextBlock(block)) {
-          const decorators2 = types2.decorators.map((decorator) => decorator.value), marks = node.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
+          const decorators2 = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name), marks = node.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
           if (orphanedAnnotations.length > 0) {
             debug$b("Removing orphaned annotations from span node"), editorActor.send({
               type: "normalizing"
@@ -3056,7 +3012,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
           }
         }
       }
-      if (op.type === "merge_node" && op.path.length === 1 && "markDefs" in op.properties && op.properties._type === types2.block.name && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0 && op.path[0] - 1 >= 0) {
+      if (op.type === "merge_node" && op.path.length === 1 && "markDefs" in op.properties && op.properties._type === editorActor.getSnapshot().context.schema.block.name && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0 && op.path[0] - 1 >= 0) {
         const [targetBlock, targetPath] = slate.Editor.node(editor, [op.path[0] - 1]);
         if (editor.isTextBlock(targetBlock)) {
           const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [], newMarkDefs = uniq__default.default([...oldDefs, ...op.properties.markDefs]);
@@ -3984,7 +3940,15 @@ function insertBlock({
     }
   }
 }
-const moveBlockActionImplementation = ({
+const moveBackwardActionImplementation = ({
+  action
+}) => {
+  slate.Transforms.move(action.editor, {
+    unit: "character",
+    distance: action.distance,
+    reverse: !0
+  });
+}, moveBlockActionImplementation = ({
   action
 }) => {
   const at = [toSlatePath(action.at, action.editor)[0]], to = [toSlatePath(action.to, action.editor)[0]];
@@ -3993,6 +3957,13 @@ const moveBlockActionImplementation = ({
     to,
     mode: "highest"
   });
+}, moveForwardActionImplementation = ({
+  action
+}) => {
+  slate.Transforms.move(action.editor, {
+    unit: "character",
+    distance: action.distance
+  });
 }, noopActionImplementation = () => {
 }, selectActionImplementation = ({
   action
@@ -4038,7 +4009,7 @@ const moveBlockActionImplementation = ({
           continue;
         const marks = child.marks ?? [];
         for (const mark of marks)
-          schema2.decorators.some((decorator) => decorator.value === mark) || prevNodeSpans.some((prevNodeSpan) => prevNodeSpan.marks?.includes(mark)) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(mark, keyGenerator());
+          schema2.decorators.some((decorator) => decorator.name === mark) || prevNodeSpans.some((prevNodeSpan) => prevNodeSpan.marks?.includes(mark)) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(mark, keyGenerator());
         const newMarks = marks.map((mark) => newMarkDefKeys.get(mark) ?? mark);
         isEqual__default.default(marks, newMarks) || slate.Transforms.setNodes(editor, {
           marks: newMarks
@@ -4082,7 +4053,9 @@ const moveBlockActionImplementation = ({
   "insert.span": insertSpanActionImplementation,
   "insert.text": insertTextActionImplementation,
   effect: effectActionImplementation,
+  "move.backward": moveBackwardActionImplementation,
   "move.block": moveBlockActionImplementation,
+  "move.forward": moveForwardActionImplementation,
   noop: noopActionImplementation,
   select: selectActionImplementation,
   "split.block": splitBlockActionImplementation
@@ -4225,6 +4198,13 @@ function performAction({
       });
       break;
     }
+    case "move.backward": {
+      behaviorActionImplementations["move.backward"]({
+        context,
+        action
+      });
+      break;
+    }
     case "move.block": {
       behaviorActionImplementations["move.block"]({
         context,
@@ -4232,6 +4212,13 @@ function performAction({
       });
       break;
     }
+    case "move.forward": {
+      behaviorActionImplementations["move.forward"]({
+        context,
+        action
+      });
+      break;
+    }
     case "noop":
       break;
     case "split.block": {
@@ -4443,7 +4430,7 @@ function createWithMaxBlocks(editorActor) {
     }, editor;
   };
 }
-function createWithObjectKeys(editorActor, schemaTypes) {
+function createWithObjectKeys(editorActor) {
   return function(editor) {
     const {
       apply: apply2,
@@ -4483,7 +4470,7 @@ function createWithObjectKeys(editorActor, schemaTypes) {
       apply2(operation);
     }, editor.normalizeNode = (entry) => {
       const [node, path] = entry;
-      if (slate.Element.isElement(node) && node._type === schemaTypes.block.name) {
+      if (slate.Element.isElement(node) && node._type === editorActor.getSnapshot().context.schema.block.name) {
         if (!node._key) {
           editorActor.send({
             type: "normalizing"
@@ -4515,7 +4502,7 @@ function createWithObjectKeys(editorActor, schemaTypes) {
   };
 }
 const debug$9 = debugWithName("applyPatches"), debugVerbose = debug$9.enabled && !0;
-function createApplyPatch(schemaTypes) {
+function createApplyPatch(schema2) {
   return (editor, patch) => {
     let changed = !1;
     debugVerbose && (debug$9(`
@@ -4524,7 +4511,7 @@ NEW PATCH =============================================================`), debug
     try {
       switch (patch.type) {
         case "insert":
-          changed = insertPatch(editor, patch, schemaTypes);
+          changed = insertPatch(editor, patch, schema2);
           break;
         case "unset":
           changed = unsetPatch(editor, patch);
@@ -4575,7 +4562,7 @@ function diffMatchPatch(editor, patch) {
     }) : op === DIFF_EQUAL && (offset += text.length);
   return debugState(editor, "after"), !0;
 }
-function insertPatch(editor, patch, schemaTypes) {
+function insertPatch(editor, patch, schema2) {
   const {
     block: targetBlock,
     child: targetChild,
@@ -4591,7 +4578,7 @@ function insertPatch(editor, patch, schemaTypes) {
       items: items2,
       position: position2
     } = patch, blocksToInsert = toSlateValue(items2, {
-      schemaTypes
+      schemaTypes: schema2
     }, KEY_TO_SLATE_ELEMENT.get(editor)), targetBlockIndex = targetBlockPath[0], normalizedIdx2 = position2 === "after" ? targetBlockIndex + 1 : targetBlockIndex;
     return debug$9(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), slate.Transforms.insertNodes(editor, blocksToInsert, {
       at: [normalizedIdx2]
@@ -4607,7 +4594,7 @@ function insertPatch(editor, patch, schemaTypes) {
     ...targetBlock,
     children: items
   }], {
-    schemaTypes
+    schemaTypes: schema2
   }, KEY_TO_SLATE_ELEMENT.get(editor)), targetChildIndex = targetChildPath[1], normalizedIdx = position === "after" ? targetChildIndex + 1 : targetChildIndex, childInsertPath = [targetChildPath[0], normalizedIdx];
   return debug$9(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && slate.Element.isElement(childrenToInsert[0]) && slate.Transforms.insertNodes(editor, childrenToInsert[0].children, {
     at: childInsertPath
@@ -4785,11 +4772,10 @@ const debug$8 = debugWithName("plugin:withPatches");
 function createWithPatches({
   editorActor,
   patchFunctions,
-  schemaTypes,
   subscriptions
 }) {
   let previousChildren;
-  const applyPatch = createApplyPatch(schemaTypes);
+  const applyPatch = createApplyPatch(editorActor.getSnapshot().context.schema);
   return function(editor) {
     IS_PROCESSING_REMOTE_CHANGES.set(editor, !1), PATCHING.set(editor, !0), previousChildren = [...editor.children];
     const {
@@ -4828,9 +4814,9 @@ function createWithPatches({
     }), editor.apply = (operation) => {
       let patches$1 = [];
       previousChildren = editor.children;
-      const editorWasEmpty = isEqualToEmptyEditor(previousChildren, schemaTypes);
+      const editorWasEmpty = isEqualToEmptyEditor(previousChildren, editorActor.getSnapshot().context.schema);
       apply2(operation);
-      const editorIsEmpty = isEqualToEmptyEditor(editor.children, schemaTypes);
+      const editorIsEmpty = isEqualToEmptyEditor(editor.children, editorActor.getSnapshot().context.schema);
       if (!isPatching(editor))
         return editor;
       switch (editorWasEmpty && !editorIsEmpty && operation.type !== "set_selection" && patches$1.push(patches.insert(previousChildren, "before", [0])), operation.type) {
@@ -4861,7 +4847,7 @@ function createWithPatches({
       }
       if (!editorWasEmpty && editorIsEmpty && ["merge_node", "set_node", "remove_text", "remove_node"].includes(operation.type) && (patches$1 = [...patches$1, patches.unset([])], editorActor.send({
         type: "notify.unset",
-        previousValue: fromSlateValue(previousChildren, schemaTypes.block.name, KEY_TO_VALUE_ELEMENT.get(editor))
+        previousValue: fromSlateValue(previousChildren, editorActor.getSnapshot().context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor))
       })), editorWasEmpty && patches$1.length > 0 && (patches$1 = [patches.setIfMissing([], []), ...patches$1]), patches$1.length > 0)
         for (const patch of patches$1)
           editorActor.send({
@@ -4871,7 +4857,7 @@ function createWithPatches({
               origin: "local"
             },
             actionId: getCurrentActionId(editor),
-            value: fromSlateValue(editor.children, schemaTypes.block.name, KEY_TO_VALUE_ELEMENT.get(editor))
+            value: fromSlateValue(editor.children, editorActor.getSnapshot().context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor))
           });
       return editor;
     }, editor;
@@ -4912,8 +4898,8 @@ function createWithPlaceholderBlock(editorActor) {
   };
 }
 const debug$6 = debugWithName("plugin:withPortableTextBlockStyle");
-function createWithPortableTextBlockStyle(editorActor, types2) {
-  const defaultStyle = types2.styles[0].value;
+function createWithPortableTextBlockStyle(editorActor) {
+  const defaultStyle = editorActor.getSnapshot().context.schema.styles[0].name;
   return function(editor) {
     const {
       normalizeNode
@@ -4977,11 +4963,10 @@ function createWithPortableTextSelections(editorActor) {
 }
 const debug$5 = debugWithName("plugin:withSchemaTypes");
 function createWithSchemaTypes({
-  editorActor,
-  schemaTypes
+  editorActor
 }) {
   return function(editor) {
-    editor.isTextBlock = (value) => types.isPortableTextTextBlock(value) && value._type === schemaTypes.block.name, editor.isTextSpan = (value) => types.isPortableTextSpan(value) && value._type === schemaTypes.span.name, editor.isListBlock = (value) => types.isPortableTextListBlock(value) && value._type === schemaTypes.block.name, editor.isVoid = (element) => schemaTypes.block.name !== element._type && (schemaTypes.blockObjects.map((obj) => obj.name).includes(element._type) || schemaTypes.inlineObjects.map((obj) => obj.name).includes(element._type)), editor.isInline = (element) => schemaTypes.inlineObjects.map((obj) => obj.name).includes(element._type) && "__inline" in element && element.__inline === !0;
+    editor.isTextBlock = (value) => types.isPortableTextTextBlock(value) && value._type === editorActor.getSnapshot().context.schema.block.name, editor.isTextSpan = (value) => types.isPortableTextSpan(value) && value._type === editorActor.getSnapshot().context.schema.span.name, editor.isListBlock = (value) => types.isPortableTextListBlock(value) && value._type === editorActor.getSnapshot().context.schema.block.name, editor.isVoid = (element) => editorActor.getSnapshot().context.schema.block.name !== element._type && (editorActor.getSnapshot().context.schema.blockObjects.map((obj) => obj.name).includes(element._type) || editorActor.getSnapshot().context.schema.inlineObjects.map((obj) => obj.name).includes(element._type)), editor.isInline = (element) => editorActor.getSnapshot().context.schema.inlineObjects.map((obj) => obj.name).includes(element._type) && "__inline" in element && element.__inline === !0;
     const {
       normalizeNode
     } = editor;
@@ -4994,7 +4979,7 @@ function createWithSchemaTypes({
           type: "normalizing"
         }), slate.Transforms.setNodes(editor, {
           ...span,
-          _type: schemaTypes.span.name,
+          _type: editorActor.getSnapshot().context.schema.span.name,
           _key: key
         }, {
           at: path
@@ -5022,14 +5007,13 @@ function createWithSchemaTypes({
   };
 }
 function createWithUtils({
-  editorActor,
-  schemaTypes
+  editorActor
 }) {
   return function(editor) {
     return editor.pteCreateTextBlock = (options) => toSlateValue([{
-      _type: schemaTypes.block.name,
+      _type: editorActor.getSnapshot().context.schema.block.name,
       _key: editorActor.getSnapshot().context.keyGenerator(),
-      style: schemaTypes.styles[0].value || "normal",
+      style: editorActor.getSnapshot().context.schema.styles[0].name || "normal",
       ...options.listItem ? {
         listItem: options.listItem
       } : {},
@@ -5041,33 +5025,29 @@ function createWithUtils({
         _type: "span",
         _key: editorActor.getSnapshot().context.keyGenerator(),
         text: "",
-        marks: options.decorators.filter((decorator) => schemaTypes.decorators.find(({
-          value
-        }) => value === decorator))
+        marks: options.decorators.filter((decorator) => editorActor.getSnapshot().context.schema.decorators.find(({
+          name
+        }) => name === decorator))
       }]
     }], {
-      schemaTypes
+      schemaTypes: editorActor.getSnapshot().context.schema
     })[0], editor;
   };
 }
 const withPlugins = (editor, options) => {
   const e = editor, {
     editorActor
-  } = options, schemaTypes = editorActor.getSnapshot().context.schema, operationToPatches = createOperationToPatches(schemaTypes), withObjectKeys = createWithObjectKeys(editorActor, schemaTypes), withSchemaTypes = createWithSchemaTypes({
-    editorActor,
-    schemaTypes
+  } = options, operationToPatches = createOperationToPatches(editorActor), withObjectKeys = createWithObjectKeys(editorActor), withSchemaTypes = createWithSchemaTypes({
+    editorActor
   }), withPatches = createWithPatches({
     editorActor,
     patchFunctions: operationToPatches,
-    schemaTypes,
     subscriptions: options.subscriptions
   }), withMaxBlocks = createWithMaxBlocks(editorActor), withUndoRedo = createWithUndoRedo({
     editorActor,
-    blockSchemaType: schemaTypes.block,
     subscriptions: options.subscriptions
-  }), withPortableTextMarkModel = createWithPortableTextMarkModel(editorActor, schemaTypes), withPortableTextBlockStyle = createWithPortableTextBlockStyle(editorActor, schemaTypes), withPlaceholderBlock = createWithPlaceholderBlock(editorActor), withUtils = createWithUtils({
-    editorActor,
-    schemaTypes
+  }), withPortableTextMarkModel = createWithPortableTextMarkModel(editorActor), withPortableTextBlockStyle = createWithPortableTextBlockStyle(editorActor), withPlaceholderBlock = createWithPlaceholderBlock(editorActor), withUtils = createWithUtils({
+    editorActor
   }), withPortableTextSelections = createWithPortableTextSelections(editorActor);
   return createWithEventListeners(editorActor)(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPortableTextBlockStyle(withPlaceholderBlock(withUtils(withMaxBlocks(withUndoRedo(withPatches(withPortableTextSelections(e)))))))))));
 }, debug$4 = debugWithName("component:PortableTextEditor:SlateContainer"), slateEditors = /* @__PURE__ */ new WeakMap();
@@ -5091,100 +5071,6 @@ function createSlateEditor(config) {
   };
   return slateEditors.set(config.editorActor, slateEditor), slateEditor;
 }
-function defineSchema(definition) {
-  return definition;
-}
-const temporaryImageName = `tmp-${defaultKeyGenerator()}-image`, temporaryUrlName = `tmp-${defaultKeyGenerator()}-url`, temporaryObjectNames = {
-  image: temporaryImageName,
-  url: temporaryUrlName
-}, objectNames = {
-  [temporaryImageName]: "image",
-  [temporaryUrlName]: "url"
-}, defaultObjectTitles = {
-  image: "Image",
-  url: "URL"
-};
-function compileSchemaDefinition(definition) {
-  const blockObjects = definition?.blockObjects?.map((blockObject) => types.defineType({
-    type: "object",
-    // Very naive way to work around `SanitySchema.compile` adding default
-    // fields to objects with certain names.
-    name: temporaryObjectNames[blockObject.name] ?? blockObject.name,
-    title: blockObject.title === void 0 ? (
-      // This avoids the default title which is a title case of the object name
-      defaultObjectTitles[blockObject.name]
-    ) : blockObject.title,
-    fields: blockObject.fields?.map((field) => ({
-      name: field.name,
-      type: field.type
-    })) ?? []
-  })) ?? [], inlineObjects = definition?.inlineObjects?.map((inlineObject) => types.defineType({
-    type: "object",
-    // Very naive way to work around `SanitySchema.compile` adding default
-    // fields to objects with certain names.
-    name: temporaryObjectNames[inlineObject.name] ?? inlineObject.name,
-    title: inlineObject.title === void 0 ? (
-      // This avoids the default title which is a title case of the object name
-      defaultObjectTitles[inlineObject.name]
-    ) : inlineObject.title,
-    fields: inlineObject.fields?.map((field) => ({
-      name: field.name,
-      type: field.type
-    })) ?? []
-  })) ?? [], portableTextSchema = types.defineField({
-    type: "array",
-    name: "portable-text",
-    of: [...blockObjects.map((blockObject) => ({
-      type: blockObject.name
-    })), {
-      type: "block",
-      name: "block",
-      of: inlineObjects.map((inlineObject) => ({
-        type: inlineObject.name
-      })),
-      marks: {
-        decorators: definition?.decorators?.map((decorator) => ({
-          title: decorator.title ?? startCase__default.default(decorator.name),
-          value: decorator.name
-        })) ?? [],
-        annotations: definition?.annotations?.map((annotation) => ({
-          name: annotation.name,
-          type: "object",
-          title: annotation.title,
-          fields: annotation.fields?.map((field) => ({
-            name: field.name,
-            type: field.type
-          })) ?? []
-        })) ?? []
-      },
-      lists: definition?.lists?.map((list) => ({
-        value: list.name,
-        title: list.title ?? startCase__default.default(list.name)
-      })) ?? [],
-      styles: definition?.styles?.map((style) => ({
-        value: style.name,
-        title: style.title ?? startCase__default.default(style.name)
-      })) ?? []
-    }]
-  }), schema$1 = schema.Schema.compile({
-    types: [portableTextSchema, ...blockObjects, ...inlineObjects]
-  }).get("portable-text"), pteSchema = createEditorSchema(schema$1);
-  return {
-    ...pteSchema,
-    blockObjects: pteSchema.blockObjects.map((blockObject) => objectNames[blockObject.name] !== void 0 ? {
-      ...blockObject,
-      name: objectNames[blockObject.name],
-      type: {
-        ...blockObject.type,
-        name: objectNames[blockObject.name]
-      }
-    } : blockObject),
-    inlineObjects: pteSchema.inlineObjects.map((inlineObject) => objectNames[inlineObject.name] !== void 0 ? {
-      ...inlineObject,
-      name: objectNames[inlineObject.name]
-    } : inlineObject)
-  };
-}
 const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
   on: "annotation.toggle",
   guard: ({
@@ -6161,7 +6047,7 @@ function getActiveDecorators({
   schema: schema2,
   slateEditorInstance
 }) {
-  const decorators = schema2.decorators.map((decorator) => decorator.value);
+  const decorators = schema2.decorators.map((decorator) => decorator.name);
   return ({
     ...slate.Editor.marks(slateEditorInstance) ?? {}
   }.marks ?? []).filter((mark) => decorators.includes(mark));
@@ -6586,6 +6472,201 @@ const editorMachine = xstate.setup({
     }
   }
 });
+function createLegacySchema(portableTextType) {
+  if (!portableTextType)
+    throw new Error("Parameter 'portabletextType' missing (required)");
+  const blockType = portableTextType.of?.find(findBlockType);
+  if (!blockType)
+    throw new Error("Block type is not defined in this schema (required)");
+  const childrenField = blockType.fields?.find((field) => field.name === "children");
+  if (!childrenField)
+    throw new Error("Children field for block type found in schema (required)");
+  const ofType = childrenField.type.of;
+  if (!ofType)
+    throw new Error("Valid types for block children not found in schema (required)");
+  const spanType = ofType.find((memberType) => memberType.name === "span");
+  if (!spanType)
+    throw new Error("Span type not found in schema (required)");
+  const inlineObjectTypes = ofType.filter((memberType) => memberType.name !== "span") || [], blockObjectTypes = portableTextType.of?.filter((field) => field.name !== blockType.name) || [];
+  return {
+    styles: resolveEnabledStyles(blockType),
+    decorators: resolveEnabledDecorators(spanType),
+    lists: resolveEnabledListItems(blockType),
+    block: blockType,
+    span: spanType,
+    portableText: portableTextType,
+    inlineObjects: inlineObjectTypes,
+    blockObjects: blockObjectTypes,
+    annotations: spanType.annotations
+  };
+}
+function resolveEnabledStyles(blockType) {
+  const styleField = blockType.fields?.find((btField) => btField.name === "style");
+  if (!styleField)
+    throw new Error("A field with name 'style' is not defined in the block type (required).");
+  const textStyles = styleField.type.options?.list && styleField.type.options.list?.filter((style) => style.value);
+  if (!textStyles || textStyles.length === 0)
+    throw new Error("The style fields need at least one style defined. I.e: {title: 'Normal', value: 'normal'}.");
+  return textStyles;
+}
+function resolveEnabledDecorators(spanType) {
+  return spanType.decorators;
+}
+function resolveEnabledListItems(blockType) {
+  const listField = blockType.fields?.find((btField) => btField.name === "listItem");
+  if (!listField)
+    throw new Error("A field with name 'listItem' is not defined in the block type (required).");
+  const listItems = listField.type.options?.list && listField.type.options.list.filter((list) => list.value);
+  if (!listItems)
+    throw new Error("The list field need at least to be an empty array");
+  return listItems;
+}
+function findBlockType(type) {
+  return type.type ? findBlockType(type.type) : type.name === "block" ? type : null;
+}
+function defineSchema(definition) {
+  return definition;
+}
+const temporaryImageName = `tmp-${defaultKeyGenerator()}-image`, temporaryUrlName = `tmp-${defaultKeyGenerator()}-url`, temporaryObjectNames = {
+  image: temporaryImageName,
+  url: temporaryUrlName
+}, objectNames = {
+  [temporaryImageName]: "image",
+  [temporaryUrlName]: "url"
+}, defaultObjectTitles = {
+  image: "Image",
+  url: "URL"
+};
+function legacySchemaToEditorSchema(schema2) {
+  return {
+    annotations: schema2.annotations.map((annotation) => ({
+      name: annotation.name,
+      fields: annotation.fields.map((field) => ({
+        name: field.name,
+        type: field.type.jsonType
+      })),
+      title: annotation.title
+    })),
+    block: {
+      name: schema2.block.name
+    },
+    blockObjects: schema2.blockObjects.map((blockObject) => ({
+      name: blockObject.name,
+      fields: blockObject.fields.map((field) => ({
+        name: field.name,
+        type: field.type.jsonType
+      })),
+      title: blockObject.title
+    })),
+    decorators: schema2.decorators.map((decorator) => ({
+      name: decorator.value,
+      title: decorator.title,
+      value: decorator.value
+    })),
+    inlineObjects: schema2.inlineObjects.map((inlineObject) => ({
+      name: inlineObject.name,
+      fields: inlineObject.fields.map((field) => ({
+        name: field.name,
+        type: field.type.jsonType
+      })),
+      title: inlineObject.title
+    })),
+    span: {
+      name: schema2.span.name
+    },
+    styles: schema2.styles.map((style) => ({
+      name: style.value,
+      title: style.title,
+      value: style.value
+    })),
+    lists: schema2.lists.map((list) => ({
+      name: list.value,
+      title: list.title,
+      value: list.value
+    }))
+  };
+}
+function compileSchemaDefinitionToLegacySchema(definition) {
+  const blockObjects = definition?.blockObjects?.map((blockObject) => types.defineType({
+    type: "object",
+    // Very naive way to work around `SanitySchema.compile` adding default
+    // fields to objects with certain names.
+    name: temporaryObjectNames[blockObject.name] ?? blockObject.name,
+    title: blockObject.title === void 0 ? (
+      // This avoids the default title which is a title case of the object name
+      defaultObjectTitles[blockObject.name]
+    ) : blockObject.title,
+    fields: blockObject.fields?.map((field) => ({
+      name: field.name,
+      type: field.type
+    })) ?? []
+  })) ?? [], inlineObjects = definition?.inlineObjects?.map((inlineObject) => types.defineType({
+    type: "object",
+    // Very naive way to work around `SanitySchema.compile` adding default
+    // fields to objects with certain names.
+    name: temporaryObjectNames[inlineObject.name] ?? inlineObject.name,
+    title: inlineObject.title === void 0 ? (
+      // This avoids the default title which is a title case of the object name
+      defaultObjectTitles[inlineObject.name]
+    ) : inlineObject.title,
+    fields: inlineObject.fields?.map((field) => ({
+      name: field.name,
+      type: field.type
+    })) ?? []
+  })) ?? [], portableTextSchema = types.defineField({
+    type: "array",
+    name: "portable-text",
+    of: [...blockObjects.map((blockObject) => ({
+      type: blockObject.name
+    })), {
+      type: "block",
+      name: "block",
+      of: inlineObjects.map((inlineObject) => ({
+        type: inlineObject.name
+      })),
+      marks: {
+        decorators: definition?.decorators?.map((decorator) => ({
+          title: decorator.title ?? startCase__default.default(decorator.name),
+          value: decorator.name
+        })) ?? [],
+        annotations: definition?.annotations?.map((annotation) => ({
+          name: annotation.name,
+          type: "object",
+          title: annotation.title,
+          fields: annotation.fields?.map((field) => ({
+            name: field.name,
+            type: field.type
+          })) ?? []
+        })) ?? []
+      },
+      lists: definition?.lists?.map((list) => ({
+        value: list.name,
+        title: list.title ?? startCase__default.default(list.name)
+      })) ?? [],
+      styles: definition?.styles?.map((style) => ({
+        value: style.name,
+        title: style.title ?? startCase__default.default(style.name)
+      })) ?? []
+    }]
+  }), schema$1 = schema.Schema.compile({
+    types: [portableTextSchema, ...blockObjects, ...inlineObjects]
+  }).get("portable-text"), pteSchema = createLegacySchema(schema$1);
+  return {
+    ...pteSchema,
+    blockObjects: pteSchema.blockObjects.map((blockObject) => objectNames[blockObject.name] !== void 0 ? {
+      ...blockObject,
+      name: objectNames[blockObject.name],
+      type: {
+        ...blockObject.type,
+        name: objectNames[blockObject.name]
+      }
+    } : blockObject),
+    inlineObjects: pteSchema.inlineObjects.map((inlineObject) => objectNames[inlineObject.name] !== void 0 ? {
+      ...inlineObject,
+      name: objectNames[inlineObject.name]
+    } : inlineObject)
+  };
+}
 function defaultCompare(a, b) {
   return a === b;
 }
@@ -6994,35 +7075,37 @@ function isAnnotationActive({
   }
 }
 function createInternalEditor(config) {
-  const editorActor = xstate.createActor(editorMachine, {
-    input: editorConfigToMachineInput(config)
+  const legacySchema = config.schemaDefinition ? compileSchemaDefinitionToLegacySchema(config.schemaDefinition) : createLegacySchema(config.schema.hasOwnProperty("jsonType") ? config.schema : compileType(config.schema)), editorSchema = legacySchemaToEditorSchema(legacySchema), editorActor = xstate.createActor(editorMachine, {
+    input: editorConfigToMachineInput({
+      ...config,
+      schema: editorSchema,
+      legacySchema
+    })
   });
-  return editorActor.start(), createInternalEditorFromActor(editorActor);
+  return editorActor.start(), createInternalEditorFromActor(editorActor, legacySchema);
 }
 function useCreateInternalEditor(config) {
-  const $ = reactCompilerRuntime.c(6);
-  let t0;
-  $[0] !== config ? (t0 = editorConfigToMachineInput(config), $[0] = config, $[1] = t0) : t0 = $[1];
-  let t1;
-  $[2] !== t0 ? (t1 = {
-    input: t0
-  }, $[2] = t0, $[3] = t1) : t1 = $[3];
-  const editorActor = react.useActorRef(editorMachine, t1);
-  let t2, t3;
-  return $[4] !== editorActor ? (t3 = createInternalEditorFromActor(editorActor), $[4] = editorActor, $[5] = t3) : t3 = $[5], t2 = t3, t2;
+  const legacySchema = config.schemaDefinition ? compileSchemaDefinitionToLegacySchema(config.schemaDefinition) : createLegacySchema(config.schema.hasOwnProperty("jsonType") ? config.schema : compileType(config.schema)), editorSchema = legacySchemaToEditorSchema(legacySchema), editorActor = react.useActorRef(editorMachine, {
+    input: editorConfigToMachineInput({
+      ...config,
+      schema: editorSchema,
+      legacySchema
+    })
+  });
+  return React.useMemo(() => createInternalEditorFromActor(editorActor, legacySchema), [editorActor, legacySchema]);
 }
 function editorConfigToMachineInput(config) {
   return {
     behaviors: config.behaviors,
-    converters: coreConverters,
+    converters: createCoreConverters(config.legacySchema),
     keyGenerator: config.keyGenerator ?? defaultKeyGenerator,
     maxBlocks: config.maxBlocks,
     readOnly: config.readOnly,
-    schema: config.schemaDefinition ? compileSchemaDefinition(config.schemaDefinition) : createEditorSchema(config.schema.hasOwnProperty("jsonType") ? config.schema : compileType(config.schema)),
+    schema: config.schema,
     initialValue: config.initialValue
   };
 }
-function createInternalEditorFromActor(editorActor) {
+function createInternalEditorFromActor(editorActor, legacySchema) {
   const slateEditor = createSlateEditor({
     editorActor
   }), editable = createEditableAPI(slateEditor.instance, editorActor);
@@ -7097,6 +7180,7 @@ function createInternalEditorFromActor(editorActor) {
     _internal: {
       editable,
       editorActor,
+      legacySchema,
       slateEditor
     }
   };
@@ -7152,12 +7236,12 @@ class PortableTextEditor extends React.Component {
       initialValue: props.value,
       maxBlocks: props.maxBlocks === void 0 ? void 0 : Number.parseInt(props.maxBlocks.toString(), 10),
       readOnly: props.readOnly
-    }), this.schemaTypes = this.editor._internal.editorActor.getSnapshot().context.schema, this.editable = this.editor._internal.editable;
+    }), this.schemaTypes = this.editor._internal.legacySchema, this.editable = this.editor._internal.editable;
   }
   componentDidUpdate(prevProps) {
-    !this.props.editor && !prevProps.editor && this.props.schemaType !== prevProps.schemaType && (this.schemaTypes = createEditorSchema(this.props.schemaType.hasOwnProperty("jsonType") ? this.props.schemaType : compileType(this.props.schemaType)), this.editor._internal.editorActor.send({
+    !this.props.editor && !prevProps.editor && this.props.schemaType !== prevProps.schemaType && (this.schemaTypes = createLegacySchema(this.props.schemaType.hasOwnProperty("jsonType") ? this.props.schemaType : compileType(this.props.schemaType)), this.editor._internal.editorActor.send({
       type: "update schema",
-      schema: this.schemaTypes
+      schema: legacySchemaToEditorSchema(this.schemaTypes)
     })), !this.props.editor && !prevProps.editor && (this.props.readOnly !== prevProps.readOnly && this.editor._internal.editorActor.send({
       type: "update readOnly",
       readOnly: this.props.readOnly ?? !1