@portabletext/editor 1.16.4 → 1.17.1

package/lib/index.js

@@ -1,14 +1,3 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty, __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp.call(b, prop) && __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b))
-      __propIsEnum.call(b, prop) && __defNormalProp(a, prop, b[prop]);
-  return a;
-};
 import { Schema } from "@sanity/schema";
 import { defineType, defineField, isKeySegment, isPortableTextTextBlock, isPortableTextSpan as isPortableTextSpan$1, isPortableTextListBlock } from "@sanity/types";
 import startCase from "lodash.startcase";
@@ -37,13 +26,12 @@ import { blockOffsetToSpanSelectionPoint, coreBehaviors, isHotkey } from "./_chu
 import getRandomValues from "get-random-values-esm";
 import { htmlToBlocks, normalizeBlock } from "@sanity/block-tools";
 function createEditorSchema(portableTextType) {
-  var _a, _b, _c;
   if (!portableTextType)
     throw new Error("Parameter 'portabletextType' missing (required)");
-  const blockType = (_a = portableTextType.of) == null ? void 0 : _a.find(findBlockType);
+  const blockType = portableTextType.of?.find(findBlockType);
   if (!blockType)
     throw new Error("Block type is not defined in this schema (required)");
-  const childrenField = (_b = blockType.fields) == null ? void 0 : _b.find((field) => field.name === "children");
+  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;
@@ -52,7 +40,7 @@ function createEditorSchema(portableTextType) {
   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 = ((_c = portableTextType.of) == null ? void 0 : _c.filter((field) => field.name !== blockType.name)) || [];
+  const inlineObjectTypes = ofType.filter((memberType) => memberType.name !== "span") || [], blockObjectTypes = portableTextType.of?.filter((field) => field.name !== blockType.name) || [];
   return {
     styles: resolveEnabledStyles(blockType),
     decorators: resolveEnabledDecorators(spanType),
@@ -66,11 +54,10 @@ function createEditorSchema(portableTextType) {
   };
 }
 function resolveEnabledStyles(blockType) {
-  var _a, _b, _c;
-  const styleField = (_a = blockType.fields) == null ? void 0 : _a.find((btField) => btField.name === "style");
+  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 = ((_b = styleField.type.options) == null ? void 0 : _b.list) && ((_c = styleField.type.options.list) == null ? void 0 : _c.filter((style) => style.value));
+  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;
@@ -79,11 +66,10 @@ function resolveEnabledDecorators(spanType) {
   return spanType.decorators;
 }
 function resolveEnabledListItems(blockType) {
-  var _a, _b;
-  const listField = (_a = blockType.fields) == null ? void 0 : _a.find((btField) => btField.name === "listItem");
+  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 = ((_b = listField.type.options) == null ? void 0 : _b.list) && listField.type.options.list.filter((list) => list.value);
+  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;
@@ -91,20 +77,11 @@ function resolveEnabledListItems(blockType) {
 function findBlockType(type) {
   return type.type ? findBlockType(type.type) : type.name === "block" ? type : null;
 }
-var __defProp$q = Object.defineProperty, __defProps$j = Object.defineProperties, __getOwnPropDescs$j = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$q = Object.getOwnPropertySymbols, __hasOwnProp$q = Object.prototype.hasOwnProperty, __propIsEnum$q = Object.prototype.propertyIsEnumerable, __defNormalProp$q = (obj, key, value) => key in obj ? __defProp$q(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$q = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$q.call(b, prop) && __defNormalProp$q(a, prop, b[prop]);
-  if (__getOwnPropSymbols$q)
-    for (var prop of __getOwnPropSymbols$q(b))
-      __propIsEnum$q.call(b, prop) && __defNormalProp$q(a, prop, b[prop]);
-  return a;
-}, __spreadProps$j = (a, b) => __defProps$j(a, __getOwnPropDescs$j(b));
 function defineSchema(definition) {
   return definition;
 }
 function compileSchemaDefinition(definition) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
-  const blockObjects = (_b = (_a = definition == null ? void 0 : definition.blockObjects) == null ? void 0 : _a.map((blockObject) => defineType({
+  const blockObjects = definition?.blockObjects?.map((blockObject) => defineType({
     type: "object",
     // Very naive way to work around `SanitySchema.compile` adding default
     // fields to objects with the name `image`
@@ -112,13 +89,13 @@ function compileSchemaDefinition(definition) {
     title: blockObject.title,
     icon: blockObject.icon,
     fields: []
-  }))) != null ? _b : [], inlineObjects = (_d = (_c = definition == null ? void 0 : definition.inlineObjects) == null ? void 0 : _c.map((inlineObject) => defineType({
+  })) ?? [], inlineObjects = definition?.inlineObjects?.map((inlineObject) => defineType({
     type: "object",
     name: inlineObject.name,
     title: inlineObject.title,
     icon: inlineObject.icon,
     fields: []
-  }))) != null ? _d : [], portableTextSchema = defineField({
+  })) ?? [], portableTextSchema = defineField({
     type: "array",
     name: "portable-text",
     of: [...blockObjects.map((blockObject) => ({
@@ -130,49 +107,43 @@ function compileSchemaDefinition(definition) {
         type: inlineObject.name
       })),
       marks: {
-        decorators: (_f = (_e = definition == null ? void 0 : definition.decorators) == null ? void 0 : _e.map((decorator) => {
-          var _a2;
-          return {
-            title: (_a2 = decorator.title) != null ? _a2 : startCase(decorator.name),
-            value: decorator.name,
-            icon: decorator.icon
-          };
-        })) != null ? _f : [],
-        annotations: (_h = (_g = definition == null ? void 0 : definition.annotations) == null ? void 0 : _g.map((annotation) => ({
+        decorators: definition?.decorators?.map((decorator) => ({
+          title: decorator.title ?? startCase(decorator.name),
+          value: decorator.name,
+          icon: decorator.icon
+        })) ?? [],
+        annotations: definition?.annotations?.map((annotation) => ({
           name: annotation.name,
           type: "object",
           title: annotation.title,
           icon: annotation.icon
-        }))) != null ? _h : []
+        })) ?? []
       },
-      lists: (_j = (_i = definition == null ? void 0 : definition.lists) == null ? void 0 : _i.map((list) => {
-        var _a2;
-        return {
-          value: list.name,
-          title: (_a2 = list.title) != null ? _a2 : startCase(list.name),
-          icon: list.icon
-        };
-      })) != null ? _j : [],
-      styles: (_l = (_k = definition == null ? void 0 : definition.styles) == null ? void 0 : _k.map((style) => {
-        var _a2;
-        return {
-          value: style.name,
-          title: (_a2 = style.title) != null ? _a2 : startCase(style.name),
-          icon: style.icon
-        };
-      })) != null ? _l : []
+      lists: definition?.lists?.map((list) => ({
+        value: list.name,
+        title: list.title ?? startCase(list.name),
+        icon: list.icon
+      })) ?? [],
+      styles: definition?.styles?.map((style) => ({
+        value: style.name,
+        title: style.title ?? startCase(style.name),
+        icon: style.icon
+      })) ?? []
     }]
   }), schema = Schema.compile({
     types: [portableTextSchema, ...blockObjects, ...inlineObjects]
   }).get("portable-text"), pteSchema = createEditorSchema(schema);
-  return __spreadProps$j(__spreadValues$q({}, pteSchema), {
-    blockObjects: pteSchema.blockObjects.map((blockObject) => blockObject.name === "tmp-image" ? __spreadProps$j(__spreadValues$q({}, blockObject), {
+  return {
+    ...pteSchema,
+    blockObjects: pteSchema.blockObjects.map((blockObject) => blockObject.name === "tmp-image" ? {
+      ...blockObject,
       name: "image",
-      type: __spreadProps$j(__spreadValues$q({}, blockObject.type), {
+      type: {
+        ...blockObject.type,
         name: "image"
-      })
-    }) : blockObject)
-  });
+      }
+    } : blockObject)
+  };
 }
 const rootName = "sanity-pte:";
 debug$l(rootName);
@@ -307,22 +278,6 @@ function normalizeSelection(selection, value) {
     backward: selection.backward
   } : null;
 }
-var __defProp$p = Object.defineProperty, __defProps$i = Object.defineProperties, __getOwnPropDescs$i = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$p = Object.getOwnPropertySymbols, __hasOwnProp$p = Object.prototype.hasOwnProperty, __propIsEnum$p = Object.prototype.propertyIsEnumerable, __defNormalProp$p = (obj, key, value) => key in obj ? __defProp$p(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$p = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$p.call(b, prop) && __defNormalProp$p(a, prop, b[prop]);
-  if (__getOwnPropSymbols$p)
-    for (var prop of __getOwnPropSymbols$p(b))
-      __propIsEnum$p.call(b, prop) && __defNormalProp$p(a, prop, b[prop]);
-  return a;
-}, __spreadProps$i = (a, b) => __defProps$i(a, __getOwnPropDescs$i(b)), __objRest$3 = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    __hasOwnProp$p.call(source, prop) && exclude.indexOf(prop) < 0 && (target[prop] = source[prop]);
-  if (source != null && __getOwnPropSymbols$p)
-    for (var prop of __getOwnPropSymbols$p(source))
-      exclude.indexOf(prop) < 0 && __propIsEnum$p.call(source, prop) && (target[prop] = source[prop]);
-  return target;
-};
 const VOID_CHILD_KEY = "void-child";
 function keepObjectEquality(object, keyMap) {
   const value = keyMap[object._key];
@@ -332,13 +287,11 @@ function toSlateValue(value, {
   schemaTypes
 }, keyMap = {}) {
   return value && Array.isArray(value) ? value.map((block) => {
-    const _a = block, {
+    const {
       _type,
-      _key
-    } = _a, rest = __objRest$3(_a, [
-      "_type",
-      "_key"
-    ]), voidChildren = [{
+      _key,
+      ...rest
+    } = block, voidChildren = [{
       _key: VOID_CHILD_KEY,
       _type: "span",
       text: "",
@@ -348,13 +301,11 @@ function toSlateValue(value, {
       const textBlock = block;
       let hasInlines = !1;
       const hasMissingStyle = typeof textBlock.style > "u", hasMissingMarkDefs = typeof textBlock.markDefs > "u", hasMissingChildren = typeof textBlock.children > "u", children = (textBlock.children || []).map((child) => {
-        const _a2 = child, {
+        const {
           _type: cType,
-          _key: cKey
-        } = _a2, cRest = __objRest$3(_a2, [
-          "_type",
-          "_key"
-        ]);
+          _key: cKey,
+          ...cRest
+        } = child;
         return cType !== "span" ? (hasInlines = !0, keepObjectEquality({
           _type: cType,
           _key: cKey,
@@ -363,12 +314,12 @@ function toSlateValue(value, {
           __inline: !0
         }, keyMap)) : child;
       });
-      return !hasMissingStyle && !hasMissingMarkDefs && !hasMissingChildren && !hasInlines && Element$1.isElement(block) ? block : (hasMissingStyle && (rest.style = schemaTypes.styles[0].value), keepObjectEquality(__spreadProps$i(__spreadValues$p({
+      return !hasMissingStyle && !hasMissingMarkDefs && !hasMissingChildren && !hasInlines && Element$1.isElement(block) ? block : (hasMissingStyle && (rest.style = schemaTypes.styles[0].value), keepObjectEquality({
         _type,
-        _key
-      }, rest), {
+        _key,
+        ...rest,
         children
-      }), keyMap));
+      }, keyMap));
     }
     return keepObjectEquality({
       _type,
@@ -394,42 +345,40 @@ function fromSlateValue(value, textBlockType, keyMap = {}) {
         } = child;
         if ("value" in child && _cType !== "span") {
           hasInlines = !0;
-          const _a = child, {
+          const {
             value: v,
             _key: k,
             _type: t,
             __inline: _i,
-            children: _c
-          } = _a, rest = __objRest$3(_a, [
-            "value",
-            "_key",
-            "_type",
-            "__inline",
-            "children"
-          ]);
-          return keepObjectEquality(__spreadProps$i(__spreadValues$p(__spreadValues$p({}, rest), v), {
+            children: _c,
+            ...rest
+          } = child;
+          return keepObjectEquality({
+            ...rest,
+            ...v,
             _key: k,
             _type: t
-          }), keyMap);
+          }, keyMap);
         }
         return child;
       });
-      return hasInlines ? keepObjectEquality(__spreadProps$i(__spreadValues$p({}, block), {
+      return hasInlines ? keepObjectEquality({
+        ...block,
         children,
         _key,
         _type
-      }), keyMap) : block;
+      }, keyMap) : block;
     }
     const blockValue = "value" in block && block.value;
-    return keepObjectEquality(__spreadValues$p({
+    return keepObjectEquality({
       _key,
-      _type
-    }, typeof blockValue == "object" ? blockValue : {}), keyMap);
+      _type,
+      ...typeof blockValue == "object" ? blockValue : {}
+    }, keyMap);
   });
 }
 function isEqualToEmptyEditor(children, schemaTypes) {
-  var _a;
-  return children === void 0 || children && Array.isArray(children) && children.length === 0 || children && Array.isArray(children) && children.length === 1 && Element$1.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 && Text.isText(children[0].children[0]) && children[0].children[0]._type === "span" && !((_a = children[0].children[0].marks) != null && _a.join("")) && children[0].children[0].text === "";
+  return children === void 0 || children && Array.isArray(children) && children.length === 0 || children && Array.isArray(children) && children.length === 1 && Element$1.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 && 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(), IS_DRAGGING = /* @__PURE__ */ new WeakMap(), IS_DRAGGING_BLOCK_ELEMENT = /* @__PURE__ */ new WeakMap(), IS_DRAGGING_ELEMENT_TARGET = /* @__PURE__ */ new WeakMap(), IS_DRAGGING_BLOCK_TARGET_POSITION = /* @__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(), DefaultObject = (props) => {
   const $ = c(4);
@@ -729,14 +678,6 @@ const debug$k = debugWithName("components:DraggableBlock"), DraggableBlock = (t0
   ] }), $[41] = children, $[42] = handleDrag, $[43] = handleDragEnd, $[44] = handleDragOver, $[45] = handleDragStart, $[46] = handleDrop, $[47] = isVoid, $[48] = t17, $[49] = t18, $[50] = t19) : t19 = $[50], t19;
 };
 DraggableBlock.displayName = "DraggableBlock";
-var __defProp$o = Object.defineProperty, __defProps$h = Object.defineProperties, __getOwnPropDescs$h = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$o = Object.getOwnPropertySymbols, __hasOwnProp$o = Object.prototype.hasOwnProperty, __propIsEnum$o = Object.prototype.propertyIsEnumerable, __defNormalProp$o = (obj, key, value) => key in obj ? __defProp$o(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$o = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$o.call(b, prop) && __defNormalProp$o(a, prop, b[prop]);
-  if (__getOwnPropSymbols$o)
-    for (var prop of __getOwnPropSymbols$o(b))
-      __propIsEnum$o.call(b, prop) && __defNormalProp$o(a, prop, b[prop]);
-  return a;
-}, __spreadProps$h = (a, b) => __defProps$h(a, __getOwnPropDescs$h(b));
 debugWithName("components:Element");
 const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
   display: "inline-block"
@@ -773,7 +714,7 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
       }, "children", {
         _key: element._key
       }];
-      return /* @__PURE__ */ jsxs("span", __spreadProps$h(__spreadValues$o({}, attributes), { children: [
+      return /* @__PURE__ */ jsxs("span", { ...attributes, children: [
         children,
         /* @__PURE__ */ jsxs("span", { draggable: !readOnly, className: "pt-inline-object", "data-testid": "pt-inline-object", ref: inlineBlockObjectRef, style: inlineBlockStyle, contentEditable: !1, children: [
           renderChild && renderChild({
@@ -790,7 +731,7 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
           }),
           !renderChild && /* @__PURE__ */ jsx(DefaultObject, { value })
         ] }, element._key)
-      ] }));
+      ] });
     }
     throw new Error("Block not found!");
   }
@@ -841,7 +782,7 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
         return console.warn("Property 'type' is deprecated, use 'schemaType' instead."), schemaTypes.block;
       }
     }), propsOrDefaultRendered = renderBlock ? renderBlock(renderProps) : children;
-    return /* @__PURE__ */ jsx("div", __spreadProps$h(__spreadValues$o({}, attributes), { className, spellCheck, children: /* @__PURE__ */ jsx(DraggableBlock, { element, readOnly, blockRef, children: /* @__PURE__ */ jsx("div", { ref: blockRef, children: propsOrDefaultRendered }) }) }), element._key);
+    return /* @__PURE__ */ jsx("div", { ...attributes, className, spellCheck, children: /* @__PURE__ */ jsx(DraggableBlock, { element, readOnly, blockRef, children: /* @__PURE__ */ jsx("div", { ref: blockRef, children: propsOrDefaultRendered }) }) }, element._key);
   }
   const schemaType_0 = schemaTypes.blockObjects.find((_type_0) => _type_0.name === element._type);
   if (!schemaType_0)
@@ -866,13 +807,13 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
     });
     renderedBlockFromProps = renderBlock(_props);
   }
-  return /* @__PURE__ */ jsxs("div", __spreadProps$h(__spreadValues$o({}, attributes), { className, children: [
+  return /* @__PURE__ */ jsxs("div", { ...attributes, className, children: [
     children,
     /* @__PURE__ */ jsxs(DraggableBlock, { element, readOnly, blockRef, children: [
       renderedBlockFromProps && /* @__PURE__ */ jsx("div", { ref: blockRef, contentEditable: !1, children: renderedBlockFromProps }),
       !renderedBlockFromProps && /* @__PURE__ */ jsx(DefaultBlockObject, { selected, children: /* @__PURE__ */ jsx(DefaultObject, { value }) })
     ] })
-  ] }), element._key);
+  ] }, element._key);
 };
 Element.displayName = "Element";
 const PortableTextEditorContext = createContext(null), usePortableTextEditor = () => {
@@ -971,14 +912,6 @@ const FLUSH_PATCHES_THROTTLED_MS = process.env.NODE_ENV === "test" ? 500 : 1e3,
     }
   }
 });
-var __defProp$n = Object.defineProperty, __defProps$g = Object.defineProperties, __getOwnPropDescs$g = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$n = Object.getOwnPropertySymbols, __hasOwnProp$n = Object.prototype.hasOwnProperty, __propIsEnum$n = Object.prototype.propertyIsEnumerable, __defNormalProp$n = (obj, key, value) => key in obj ? __defProp$n(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$n = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$n.call(b, prop) && __defNormalProp$n(a, prop, b[prop]);
-  if (__getOwnPropSymbols$n)
-    for (var prop of __getOwnPropSymbols$n(b))
-      __propIsEnum$n.call(b, prop) && __defNormalProp$n(a, prop, b[prop]);
-  return a;
-}, __spreadProps$g = (a, b) => __defProps$g(a, __getOwnPropDescs$g(b));
 function validateValue(value, types, keyGenerator) {
   let resolution = null, valid = !0;
   const validChildTypes = [types.span.name, ...types.inlineObjects.map((t) => t.name)], validBlockTypes = [types.block.name, ...types.blockObjects.map((t) => t.name)];
@@ -1016,9 +949,10 @@ function validateValue(value, types, keyGenerator) {
       }, !0;
     if (!blk._key || typeof blk._key != "string")
       return resolution = {
-        patches: [set(__spreadProps$g(__spreadValues$n({}, blk), {
+        patches: [set({
+          ...blk,
           _key: keyGenerator()
-        }), [index])],
+        }, [index])],
         description: `Block at index ${index} is missing required _key.`,
         action: "Set the block with a random _key value",
         item: blk,
@@ -1034,9 +968,10 @@ function validateValue(value, types, keyGenerator) {
       if (blk._type === "block") {
         const currentBlockTypeName = types.block.name;
         return resolution = {
-          patches: [set(__spreadProps$g(__spreadValues$n({}, blk), {
+          patches: [set({
+            ...blk,
             _type: currentBlockTypeName
-          }), [{
+          }, [{
             _key: blk._key
           }])],
           description: `Block with _key '${blk._key}' has invalid type name '${blk._type}'. According to the schema, the block type name is '${currentBlockTypeName}'`,
@@ -1052,12 +987,14 @@ function validateValue(value, types, keyGenerator) {
           }
         }, !0;
       }
-      return !blk._type && isPortableTextTextBlock(__spreadProps$g(__spreadValues$n({}, blk), {
+      return !blk._type && isPortableTextTextBlock({
+        ...blk,
         _type: types.block.name
-      })) ? (resolution = {
-        patches: [set(__spreadProps$g(__spreadValues$n({}, blk), {
+      }) ? (resolution = {
+        patches: [set({
+          ...blk,
           _type: types.block.name
-        }), [{
+        }, [{
           _key: blk._key
         }])],
         description: `Block with _key '${blk._key}' is missing a type name. According to the schema, the block type name is '${types.block.name}'`,
@@ -1217,9 +1154,10 @@ function validateValue(value, types, keyGenerator) {
             }
           }, !0;
         if (!child._key || typeof child._key != "string") {
-          const newChild = __spreadProps$g(__spreadValues$n({}, child), {
+          const newChild = {
+            ...child,
             _key: keyGenerator()
-          });
+          };
           return resolution = {
             autoResolve: !0,
             patches: [set(newChild, [{
@@ -1239,9 +1177,10 @@ function validateValue(value, types, keyGenerator) {
           }, !0;
         }
         return child._type ? validChildTypes.includes(child._type) ? child._type === types.span.name && typeof child.text != "string" ? (resolution = {
-          patches: [set(__spreadProps$g(__spreadValues$n({}, child), {
+          patches: [set({
+            ...child,
             text: ""
-          }), [{
+          }, [{
             _key: blk._key
           }, "children", {
             _key: child._key
@@ -1317,14 +1256,6 @@ function withoutPatching(editor, fn) {
 function isPatching(editor) {
   return PATCHING.get(editor);
 }
-function isHighSurrogate(char) {
-  const charCode = char.charCodeAt(0);
-  return charCode >= 55296 && charCode <= 56319;
-}
-function isLowSurrogate(char) {
-  const charCode = char.charCodeAt(0);
-  return charCode >= 56320 && charCode <= 57343;
-}
 function cloneDiff(diff2) {
   const [type, patch] = diff2;
   return [type, patch];
@@ -1332,123 +1263,41 @@ function cloneDiff(diff2) {
 function getCommonOverlap(textA, textB) {
   let text1 = textA, text2 = textB;
   const text1Length = text1.length, text2Length = text2.length;
-  if (text1Length === 0 || text2Length === 0)
-    return 0;
+  if (text1Length === 0 || text2Length === 0) return 0;
   text1Length > text2Length ? text1 = text1.substring(text1Length - text2Length) : text1Length < text2Length && (text2 = text2.substring(0, text1Length));
   const textLength = Math.min(text1Length, text2Length);
-  if (text1 === text2)
-    return textLength;
+  if (text1 === text2) return textLength;
   let best = 0, length = 1;
   for (let found = 0; found !== -1; ) {
     const pattern = text1.substring(textLength - length);
-    if (found = text2.indexOf(pattern), found === -1)
-      return best;
+    if (found = text2.indexOf(pattern), found === -1) return best;
     length += found, (found === 0 || text1.substring(textLength - length) === text2.substring(0, length)) && (best = length, length++);
   }
   return best;
 }
 function getCommonPrefix(text1, text2) {
-  if (!text1 || !text2 || text1[0] !== text2[0])
-    return 0;
+  if (!text1 || !text2 || text1[0] !== text2[0]) return 0;
   let pointerMin = 0, pointerMax = Math.min(text1.length, text2.length), pointerMid = pointerMax, pointerStart = 0;
-  for (; pointerMin < pointerMid; )
-    text1.substring(pointerStart, pointerMid) === text2.substring(pointerStart, pointerMid) ? (pointerMin = pointerMid, pointerStart = pointerMin) : pointerMax = pointerMid, pointerMid = Math.floor((pointerMax - pointerMin) / 2 + pointerMin);
+  for (; pointerMin < pointerMid; ) text1.substring(pointerStart, pointerMid) === text2.substring(pointerStart, pointerMid) ? (pointerMin = pointerMid, pointerStart = pointerMin) : pointerMax = pointerMid, pointerMid = Math.floor((pointerMax - pointerMin) / 2 + pointerMin);
   return pointerMid;
 }
 function getCommonSuffix(text1, text2) {
-  if (!text1 || !text2 || text1[text1.length - 1] !== text2[text2.length - 1])
-    return 0;
+  if (!text1 || !text2 || text1[text1.length - 1] !== text2[text2.length - 1]) return 0;
   let pointerMin = 0, pointerMax = Math.min(text1.length, text2.length), pointerMid = pointerMax, pointerEnd = 0;
-  for (; pointerMin < pointerMid; )
-    text1.substring(text1.length - pointerMid, text1.length - pointerEnd) === text2.substring(text2.length - pointerMid, text2.length - pointerEnd) ? (pointerMin = pointerMid, pointerEnd = pointerMin) : pointerMax = pointerMid, pointerMid = Math.floor((pointerMax - pointerMin) / 2 + pointerMin);
+  for (; pointerMin < pointerMid; ) text1.substring(text1.length - pointerMid, text1.length - pointerEnd) === text2.substring(text2.length - pointerMid, text2.length - pointerEnd) ? (pointerMin = pointerMid, pointerEnd = pointerMin) : pointerMax = pointerMid, pointerMid = Math.floor((pointerMax - pointerMin) / 2 + pointerMin);
   return pointerMid;
 }
-function cleanupSemantic(rawDiffs) {
-  let diffs = rawDiffs.map((diff2) => cloneDiff(diff2)), hasChanges = !1;
-  const equalities = [];
-  let equalitiesLength = 0, lastEquality = null, pointer = 0, lengthInsertions1 = 0, lengthDeletions1 = 0, lengthInsertions2 = 0, lengthDeletions2 = 0;
-  for (; pointer < diffs.length; )
-    diffs[pointer][0] === DIFF_EQUAL ? (equalities[equalitiesLength++] = pointer, lengthInsertions1 = lengthInsertions2, lengthDeletions1 = lengthDeletions2, lengthInsertions2 = 0, lengthDeletions2 = 0, lastEquality = diffs[pointer][1]) : (diffs[pointer][0] === DIFF_INSERT ? lengthInsertions2 += diffs[pointer][1].length : lengthDeletions2 += diffs[pointer][1].length, lastEquality && lastEquality.length <= Math.max(lengthInsertions1, lengthDeletions1) && lastEquality.length <= Math.max(lengthInsertions2, lengthDeletions2) && (diffs.splice(equalities[equalitiesLength - 1], 0, [DIFF_DELETE, lastEquality]), diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT, equalitiesLength--, equalitiesLength--, pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1, lengthInsertions1 = 0, lengthDeletions1 = 0, lengthInsertions2 = 0, lengthDeletions2 = 0, lastEquality = null, hasChanges = !0)), pointer++;
-  for (hasChanges && (diffs = cleanupMerge(diffs)), diffs = cleanupSemanticLossless(diffs), pointer = 1; pointer < diffs.length; ) {
-    if (diffs[pointer - 1][0] === DIFF_DELETE && diffs[pointer][0] === DIFF_INSERT) {
-      const deletion = diffs[pointer - 1][1], insertion = diffs[pointer][1], overlapLength1 = getCommonOverlap(deletion, insertion), overlapLength2 = getCommonOverlap(insertion, deletion);
-      overlapLength1 >= overlapLength2 ? (overlapLength1 >= deletion.length / 2 || overlapLength1 >= insertion.length / 2) && (diffs.splice(pointer, 0, [DIFF_EQUAL, insertion.substring(0, overlapLength1)]), diffs[pointer - 1][1] = deletion.substring(0, deletion.length - overlapLength1), diffs[pointer + 1][1] = insertion.substring(overlapLength1), pointer++) : (overlapLength2 >= deletion.length / 2 || overlapLength2 >= insertion.length / 2) && (diffs.splice(pointer, 0, [DIFF_EQUAL, deletion.substring(0, overlapLength2)]), diffs[pointer - 1][0] = DIFF_INSERT, diffs[pointer - 1][1] = insertion.substring(0, insertion.length - overlapLength2), diffs[pointer + 1][0] = DIFF_DELETE, diffs[pointer + 1][1] = deletion.substring(overlapLength2), pointer++), pointer++;
-    }
-    pointer++;
-  }
-  return diffs;
-}
-const nonAlphaNumericRegex = /[^a-zA-Z0-9]/, whitespaceRegex = /\s/, linebreakRegex = /[\r\n]/, blanklineEndRegex = /\n\r?\n$/, blanklineStartRegex = /^\r?\n\r?\n/;
-function cleanupSemanticLossless(rawDiffs) {
-  const diffs = rawDiffs.map((diff2) => cloneDiff(diff2));
-  function diffCleanupSemanticScore(one, two) {
-    if (!one || !two)
-      return 6;
-    const char1 = one.charAt(one.length - 1), char2 = two.charAt(0), nonAlphaNumeric1 = char1.match(nonAlphaNumericRegex), nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex), whitespace1 = nonAlphaNumeric1 && char1.match(whitespaceRegex), whitespace2 = nonAlphaNumeric2 && char2.match(whitespaceRegex), lineBreak1 = whitespace1 && char1.match(linebreakRegex), lineBreak2 = whitespace2 && char2.match(linebreakRegex), blankLine1 = lineBreak1 && one.match(blanklineEndRegex), blankLine2 = lineBreak2 && two.match(blanklineStartRegex);
-    return blankLine1 || blankLine2 ? 5 : lineBreak1 || lineBreak2 ? 4 : nonAlphaNumeric1 && !whitespace1 && whitespace2 ? 3 : whitespace1 || whitespace2 ? 2 : nonAlphaNumeric1 || nonAlphaNumeric2 ? 1 : 0;
-  }
-  let pointer = 1;
-  for (; pointer < diffs.length - 1; ) {
-    if (diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {
-      let equality1 = diffs[pointer - 1][1], edit = diffs[pointer][1], equality2 = diffs[pointer + 1][1];
-      const commonOffset = getCommonSuffix(equality1, edit);
-      if (commonOffset) {
-        const commonString = edit.substring(edit.length - commonOffset);
-        equality1 = equality1.substring(0, equality1.length - commonOffset), edit = commonString + edit.substring(0, edit.length - commonOffset), equality2 = commonString + equality2;
-      }
-      let bestEquality1 = equality1, bestEdit = edit, bestEquality2 = equality2, bestScore = diffCleanupSemanticScore(equality1, edit) + diffCleanupSemanticScore(edit, equality2);
-      for (; edit.charAt(0) === equality2.charAt(0); ) {
-        equality1 += edit.charAt(0), edit = edit.substring(1) + equality2.charAt(0), equality2 = equality2.substring(1);
-        const score = diffCleanupSemanticScore(equality1, edit) + diffCleanupSemanticScore(edit, equality2);
-        score >= bestScore && (bestScore = score, bestEquality1 = equality1, bestEdit = edit, bestEquality2 = equality2);
-      }
-      diffs[pointer - 1][1] !== bestEquality1 && (bestEquality1 ? diffs[pointer - 1][1] = bestEquality1 : (diffs.splice(pointer - 1, 1), pointer--), diffs[pointer][1] = bestEdit, bestEquality2 ? diffs[pointer + 1][1] = bestEquality2 : (diffs.splice(pointer + 1, 1), pointer--));
-    }
-    pointer++;
-  }
-  return diffs;
-}
-function cleanupMerge(rawDiffs) {
-  let diffs = rawDiffs.map((diff2) => cloneDiff(diff2));
-  diffs.push([DIFF_EQUAL, ""]);
-  let pointer = 0, countDelete = 0, countInsert = 0, textDelete = "", textInsert = "", commonlength;
-  for (; pointer < diffs.length; )
-    switch (diffs[pointer][0]) {
-      case DIFF_INSERT:
-        countInsert++, textInsert += diffs[pointer][1], pointer++;
-        break;
-      case DIFF_DELETE:
-        countDelete++, textDelete += diffs[pointer][1], pointer++;
-        break;
-      case DIFF_EQUAL:
-        countDelete + countInsert > 1 ? (countDelete !== 0 && countInsert !== 0 && (commonlength = getCommonPrefix(textInsert, textDelete), commonlength !== 0 && (pointer - countDelete - countInsert > 0 && diffs[pointer - countDelete - countInsert - 1][0] === DIFF_EQUAL ? diffs[pointer - countDelete - countInsert - 1][1] += textInsert.substring(0, commonlength) : (diffs.splice(0, 0, [DIFF_EQUAL, textInsert.substring(0, commonlength)]), pointer++), textInsert = textInsert.substring(commonlength), textDelete = textDelete.substring(commonlength)), commonlength = getCommonSuffix(textInsert, textDelete), commonlength !== 0 && (diffs[pointer][1] = textInsert.substring(textInsert.length - commonlength) + diffs[pointer][1], textInsert = textInsert.substring(0, textInsert.length - commonlength), textDelete = textDelete.substring(0, textDelete.length - commonlength))), pointer -= countDelete + countInsert, diffs.splice(pointer, countDelete + countInsert), textDelete.length && (diffs.splice(pointer, 0, [DIFF_DELETE, textDelete]), pointer++), textInsert.length && (diffs.splice(pointer, 0, [DIFF_INSERT, textInsert]), pointer++), pointer++) : pointer !== 0 && diffs[pointer - 1][0] === DIFF_EQUAL ? (diffs[pointer - 1][1] += diffs[pointer][1], diffs.splice(pointer, 1)) : pointer++, countInsert = 0, countDelete = 0, textDelete = "", textInsert = "";
-        break;
-      default:
-        throw new Error("Unknown diff operation");
-    }
-  diffs[diffs.length - 1][1] === "" && diffs.pop();
-  let hasChanges = !1;
-  for (pointer = 1; pointer < diffs.length - 1; )
-    diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL && (diffs[pointer][1].substring(diffs[pointer][1].length - diffs[pointer - 1][1].length) === diffs[pointer - 1][1] ? (diffs[pointer][1] = diffs[pointer - 1][1] + diffs[pointer][1].substring(0, diffs[pointer][1].length - diffs[pointer - 1][1].length), diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1], diffs.splice(pointer - 1, 1), hasChanges = !0) : diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) === diffs[pointer + 1][1] && (diffs[pointer - 1][1] += diffs[pointer + 1][1], diffs[pointer][1] = diffs[pointer][1].substring(diffs[pointer + 1][1].length) + diffs[pointer + 1][1], diffs.splice(pointer + 1, 1), hasChanges = !0)), pointer++;
-  return hasChanges && (diffs = cleanupMerge(diffs)), diffs;
-}
-function trueCount() {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++)
-    args[_key] = arguments[_key];
-  return args.reduce((n, bool) => n + (bool ? 1 : 0), 0);
+function isHighSurrogate(char) {
+  const charCode = char.charCodeAt(0);
+  return charCode >= 55296 && charCode <= 56319;
 }
-function cleanupEfficiency(rawDiffs) {
-  let editCost = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 4, diffs = rawDiffs.map((diff2) => cloneDiff(diff2)), hasChanges = !1;
-  const equalities = [];
-  let equalitiesLength = 0, lastEquality = null, pointer = 0, preIns = !1, preDel = !1, postIns = !1, postDel = !1;
-  for (; pointer < diffs.length; )
-    diffs[pointer][0] === DIFF_EQUAL ? (diffs[pointer][1].length < editCost && (postIns || postDel) ? (equalities[equalitiesLength++] = pointer, preIns = postIns, preDel = postDel, lastEquality = diffs[pointer][1]) : (equalitiesLength = 0, lastEquality = null), postIns = !1, postDel = !1) : (diffs[pointer][0] === DIFF_DELETE ? postDel = !0 : postIns = !0, lastEquality && (preIns && preDel && postIns && postDel || lastEquality.length < editCost / 2 && trueCount(preIns, preDel, postIns, postDel) === 3) && (diffs.splice(equalities[equalitiesLength - 1], 0, [DIFF_DELETE, lastEquality]), diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT, equalitiesLength--, lastEquality = null, preIns && preDel ? (postIns = !0, postDel = !0, equalitiesLength = 0) : (equalitiesLength--, pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1, postIns = !1, postDel = !1), hasChanges = !0)), pointer++;
-  return hasChanges && (diffs = cleanupMerge(diffs)), diffs;
+function isLowSurrogate(char) {
+  const charCode = char.charCodeAt(0);
+  return charCode >= 56320 && charCode <= 57343;
 }
 function bisect(text1, text2, deadline) {
   const text1Length = text1.length, text2Length = text2.length, maxD = Math.ceil((text1Length + text2Length) / 2), vOffset = maxD, vLength = 2 * maxD, v1 = new Array(vLength), v2 = new Array(vLength);
-  for (let x = 0; x < vLength; x++)
-    v1[x] = -1, v2[x] = -1;
+  for (let x = 0; x < vLength; x++) v1[x] = -1, v2[x] = -1;
   v1[vOffset + 1] = 0, v2[vOffset + 1] = 0;
   const delta = text1Length - text2Length, front = delta % 2 !== 0;
   let k1start = 0, k1end = 0, k2start = 0, k2end = 0;
@@ -1458,18 +1307,14 @@ function bisect(text1, text2, deadline) {
       let x1;
       k1 === -d || k1 !== d && v1[k1Offset - 1] < v1[k1Offset + 1] ? x1 = v1[k1Offset + 1] : x1 = v1[k1Offset - 1] + 1;
       let y1 = x1 - k1;
-      for (; x1 < text1Length && y1 < text2Length && text1.charAt(x1) === text2.charAt(y1); )
-        x1++, y1++;
-      if (v1[k1Offset] = x1, x1 > text1Length)
-        k1end += 2;
-      else if (y1 > text2Length)
-        k1start += 2;
+      for (; x1 < text1Length && y1 < text2Length && text1.charAt(x1) === text2.charAt(y1); ) x1++, y1++;
+      if (v1[k1Offset] = x1, x1 > text1Length) k1end += 2;
+      else if (y1 > text2Length) k1start += 2;
       else if (front) {
         const k2Offset = vOffset + delta - k1;
         if (k2Offset >= 0 && k2Offset < vLength && v2[k2Offset] !== -1) {
           const x2 = text1Length - v2[k2Offset];
-          if (x1 >= x2)
-            return bisectSplit(text1, text2, x1, y1, deadline);
+          if (x1 >= x2) return bisectSplit(text1, text2, x1, y1, deadline);
         }
       }
     }
@@ -1478,18 +1323,14 @@ function bisect(text1, text2, deadline) {
       let x2;
       k2 === -d || k2 !== d && v2[k2Offset - 1] < v2[k2Offset + 1] ? x2 = v2[k2Offset + 1] : x2 = v2[k2Offset - 1] + 1;
       let y2 = x2 - k2;
-      for (; x2 < text1Length && y2 < text2Length && text1.charAt(text1Length - x2 - 1) === text2.charAt(text2Length - y2 - 1); )
-        x2++, y2++;
-      if (v2[k2Offset] = x2, x2 > text1Length)
-        k2end += 2;
-      else if (y2 > text2Length)
-        k2start += 2;
+      for (; x2 < text1Length && y2 < text2Length && text1.charAt(text1Length - x2 - 1) === text2.charAt(text2Length - y2 - 1); ) x2++, y2++;
+      if (v2[k2Offset] = x2, x2 > text1Length) k2end += 2;
+      else if (y2 > text2Length) k2start += 2;
       else if (!front) {
         const k1Offset = vOffset + delta - k2;
         if (k1Offset >= 0 && k1Offset < vLength && v1[k1Offset] !== -1) {
           const x1 = v1[k1Offset], y1 = vOffset + x1 - k1Offset;
-          if (x2 = text1Length - x2, x1 >= x2)
-            return bisectSplit(text1, text2, x1, y1, deadline);
+          if (x2 = text1Length - x2, x1 >= x2) return bisectSplit(text1, text2, x1, y1, deadline);
         }
       }
     }
@@ -1506,23 +1347,18 @@ function bisectSplit(text1, text2, x, y, deadline) {
   });
   return diffs.concat(diffsb);
 }
-function findHalfMatch(text1, text2) {
-  if ((arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1) <= 0)
-    return null;
+function findHalfMatch(text1, text2, timeout = 1) {
+  if (timeout <= 0) return null;
   const longText = text1.length > text2.length ? text1 : text2, shortText = text1.length > text2.length ? text2 : text1;
-  if (longText.length < 4 || shortText.length * 2 < longText.length)
-    return null;
+  if (longText.length < 4 || shortText.length * 2 < longText.length) return null;
   const halfMatch1 = halfMatchI(longText, shortText, Math.ceil(longText.length / 4)), halfMatch2 = halfMatchI(longText, shortText, Math.ceil(longText.length / 2));
   let halfMatch;
-  if (halfMatch1 && halfMatch2)
-    halfMatch = halfMatch1[4].length > halfMatch2[4].length ? halfMatch1 : halfMatch2;
+  if (halfMatch1 && halfMatch2) halfMatch = halfMatch1[4].length > halfMatch2[4].length ? halfMatch1 : halfMatch2;
   else {
-    if (!halfMatch1 && !halfMatch2)
-      return null;
+    if (!halfMatch1 && !halfMatch2) return null;
     halfMatch2 ? halfMatch1 || (halfMatch = halfMatch2) : halfMatch = halfMatch1;
   }
-  if (!halfMatch)
-    throw new Error("Unable to find a half match.");
+  if (!halfMatch) throw new Error("Unable to find a half match.");
   let text1A, text1B, text2A, text2B;
   text1.length > text2.length ? (text1A = halfMatch[0], text1B = halfMatch[1], text2A = halfMatch[2], text2B = halfMatch[3]) : (text2A = halfMatch[0], text2B = halfMatch[1], text1A = halfMatch[2], text1B = halfMatch[3]);
   const midCommon = halfMatch[4];
@@ -1540,8 +1376,7 @@ function halfMatchI(longText, shortText, i) {
 function charsToLines(diffs, lineArray) {
   for (let x = 0; x < diffs.length; x++) {
     const chars = diffs[x][1], text = [];
-    for (let y = 0; y < chars.length; y++)
-      text[y] = lineArray[chars.charCodeAt(y)];
+    for (let y = 0; y < chars.length; y++) text[y] = lineArray[chars.charCodeAt(y)];
     diffs[x][1] = text.join("");
   }
 }
@@ -1594,8 +1429,7 @@ function doLineModeDiff(textA, textB, opts) {
             checkLines: !1,
             deadline: opts.deadline
           });
-          for (let j = aa.length - 1; j >= 0; j--)
-            diffs.splice(pointer, 0, aa[j]);
+          for (let j = aa.length - 1; j >= 0; j--) diffs.splice(pointer, 0, aa[j]);
           pointer += aa.length;
         }
         countInsert = 0, countDelete = 0, textDelete = "", textInsert = "";
@@ -1609,15 +1443,11 @@ function doLineModeDiff(textA, textB, opts) {
 }
 function computeDiff(text1, text2, opts) {
   let diffs;
-  if (!text1)
-    return [[DIFF_INSERT, text2]];
-  if (!text2)
-    return [[DIFF_DELETE, text1]];
+  if (!text1) return [[DIFF_INSERT, text2]];
+  if (!text2) return [[DIFF_DELETE, text1]];
   const longtext = text1.length > text2.length ? text1 : text2, shorttext = text1.length > text2.length ? text2 : text1, i = longtext.indexOf(shorttext);
-  if (i !== -1)
-    return diffs = [[DIFF_INSERT, longtext.substring(0, i)], [DIFF_EQUAL, shorttext], [DIFF_INSERT, longtext.substring(i + shorttext.length)]], text1.length > text2.length && (diffs[0][0] = DIFF_DELETE, diffs[2][0] = DIFF_DELETE), diffs;
-  if (shorttext.length === 1)
-    return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];
+  if (i !== -1) return diffs = [[DIFF_INSERT, longtext.substring(0, i)], [DIFF_EQUAL, shorttext], [DIFF_INSERT, longtext.substring(i + shorttext.length)]], text1.length > text2.length && (diffs[0][0] = DIFF_DELETE, diffs[2][0] = DIFF_DELETE), diffs;
+  if (shorttext.length === 1) return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];
   const halfMatch = findHalfMatch(text1, text2);
   if (halfMatch) {
     const text1A = halfMatch[0], text1B = halfMatch[1], text2A = halfMatch[2], text2B = halfMatch[3], midCommon = halfMatch[4], diffsA = doDiff(text1A, text2A, opts), diffsB = doDiff(text1B, text2B, opts);
@@ -1625,17 +1455,25 @@ function computeDiff(text1, text2, opts) {
   }
   return opts.checkLines && text1.length > 100 && text2.length > 100 ? doLineModeDiff(text1, text2, opts) : bisect(text1, text2, opts.deadline);
 }
+var __defProp$2 = Object.defineProperty, __getOwnPropSymbols$2 = Object.getOwnPropertySymbols, __hasOwnProp$2 = Object.prototype.hasOwnProperty, __propIsEnum$2 = Object.prototype.propertyIsEnumerable, __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value
+}) : obj[key] = value, __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {})) __hasOwnProp$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2) for (var prop of __getOwnPropSymbols$2(b)) __propIsEnum$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
+  return a;
+};
 const DIFF_DELETE = -1, DIFF_INSERT = 1, DIFF_EQUAL = 0;
 function diff(textA, textB, opts) {
-  if (textA === null || textB === null)
-    throw new Error("Null input. (diff)");
+  if (textA === null || textB === null) throw new Error("Null input. (diff)");
   const diffs = doDiff(textA, textB, createInternalOpts(opts || {}));
   return adjustDiffForSurrogatePairs(diffs), diffs;
 }
 function doDiff(textA, textB, options) {
   let text1 = textA, text2 = textB;
-  if (text1 === text2)
-    return text1 ? [[DIFF_EQUAL, text1]] : [];
+  if (text1 === text2) return text1 ? [[DIFF_EQUAL, text1]] : [];
   let commonlength = getCommonPrefix(text1, text2);
   const commonprefix = text1.substring(0, commonlength);
   text1 = text1.substring(commonlength), text2 = text2.substring(commonlength), commonlength = getCommonSuffix(text1, text2);
@@ -1649,7 +1487,7 @@ function createDeadLine(timeout) {
   return typeof timeout < "u" && (t = timeout <= 0 ? Number.MAX_VALUE : timeout), Date.now() + t * 1e3;
 }
 function createInternalOpts(opts) {
-  return __spreadValues({
+  return __spreadValues$2({
     checkLines: !0,
     deadline: createDeadLine(opts.timeout || 1)
   }, opts);
@@ -1700,9 +1538,93 @@ function adjustDiffForSurrogatePairs(diffs) {
     const firstChar = diffText[0], lastChar = diffText[diffText.length - 1];
     isHighSurrogate(lastChar) && diffType === DIFF_EQUAL && deisolateChar(diffs, i, 1), isLowSurrogate(firstChar) && diffType === DIFF_EQUAL && deisolateChar(diffs, i, -1);
   }
-  for (let i = 0; i < diffs.length; i++)
-    diffs[i][1].length === 0 && diffs.splice(i, 1);
+  for (let i = 0; i < diffs.length; i++) diffs[i][1].length === 0 && diffs.splice(i, 1);
+}
+function cleanupSemantic(rawDiffs) {
+  let diffs = rawDiffs.map((diff2) => cloneDiff(diff2)), hasChanges = !1;
+  const equalities = [];
+  let equalitiesLength = 0, lastEquality = null, pointer = 0, lengthInsertions1 = 0, lengthDeletions1 = 0, lengthInsertions2 = 0, lengthDeletions2 = 0;
+  for (; pointer < diffs.length; ) diffs[pointer][0] === DIFF_EQUAL ? (equalities[equalitiesLength++] = pointer, lengthInsertions1 = lengthInsertions2, lengthDeletions1 = lengthDeletions2, lengthInsertions2 = 0, lengthDeletions2 = 0, lastEquality = diffs[pointer][1]) : (diffs[pointer][0] === DIFF_INSERT ? lengthInsertions2 += diffs[pointer][1].length : lengthDeletions2 += diffs[pointer][1].length, lastEquality && lastEquality.length <= Math.max(lengthInsertions1, lengthDeletions1) && lastEquality.length <= Math.max(lengthInsertions2, lengthDeletions2) && (diffs.splice(equalities[equalitiesLength - 1], 0, [DIFF_DELETE, lastEquality]), diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT, equalitiesLength--, equalitiesLength--, pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1, lengthInsertions1 = 0, lengthDeletions1 = 0, lengthInsertions2 = 0, lengthDeletions2 = 0, lastEquality = null, hasChanges = !0)), pointer++;
+  for (hasChanges && (diffs = cleanupMerge(diffs)), diffs = cleanupSemanticLossless(diffs), pointer = 1; pointer < diffs.length; ) {
+    if (diffs[pointer - 1][0] === DIFF_DELETE && diffs[pointer][0] === DIFF_INSERT) {
+      const deletion = diffs[pointer - 1][1], insertion = diffs[pointer][1], overlapLength1 = getCommonOverlap(deletion, insertion), overlapLength2 = getCommonOverlap(insertion, deletion);
+      overlapLength1 >= overlapLength2 ? (overlapLength1 >= deletion.length / 2 || overlapLength1 >= insertion.length / 2) && (diffs.splice(pointer, 0, [DIFF_EQUAL, insertion.substring(0, overlapLength1)]), diffs[pointer - 1][1] = deletion.substring(0, deletion.length - overlapLength1), diffs[pointer + 1][1] = insertion.substring(overlapLength1), pointer++) : (overlapLength2 >= deletion.length / 2 || overlapLength2 >= insertion.length / 2) && (diffs.splice(pointer, 0, [DIFF_EQUAL, deletion.substring(0, overlapLength2)]), diffs[pointer - 1][0] = DIFF_INSERT, diffs[pointer - 1][1] = insertion.substring(0, insertion.length - overlapLength2), diffs[pointer + 1][0] = DIFF_DELETE, diffs[pointer + 1][1] = deletion.substring(overlapLength2), pointer++), pointer++;
+    }
+    pointer++;
+  }
+  return diffs;
 }
+const nonAlphaNumericRegex = /[^a-zA-Z0-9]/, whitespaceRegex = /\s/, linebreakRegex = /[\r\n]/, blanklineEndRegex = /\n\r?\n$/, blanklineStartRegex = /^\r?\n\r?\n/;
+function cleanupSemanticLossless(rawDiffs) {
+  const diffs = rawDiffs.map((diff2) => cloneDiff(diff2));
+  function diffCleanupSemanticScore(one, two) {
+    if (!one || !two) return 6;
+    const char1 = one.charAt(one.length - 1), char2 = two.charAt(0), nonAlphaNumeric1 = char1.match(nonAlphaNumericRegex), nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex), whitespace1 = nonAlphaNumeric1 && char1.match(whitespaceRegex), whitespace2 = nonAlphaNumeric2 && char2.match(whitespaceRegex), lineBreak1 = whitespace1 && char1.match(linebreakRegex), lineBreak2 = whitespace2 && char2.match(linebreakRegex), blankLine1 = lineBreak1 && one.match(blanklineEndRegex), blankLine2 = lineBreak2 && two.match(blanklineStartRegex);
+    return blankLine1 || blankLine2 ? 5 : lineBreak1 || lineBreak2 ? 4 : nonAlphaNumeric1 && !whitespace1 && whitespace2 ? 3 : whitespace1 || whitespace2 ? 2 : nonAlphaNumeric1 || nonAlphaNumeric2 ? 1 : 0;
+  }
+  let pointer = 1;
+  for (; pointer < diffs.length - 1; ) {
+    if (diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {
+      let equality1 = diffs[pointer - 1][1], edit = diffs[pointer][1], equality2 = diffs[pointer + 1][1];
+      const commonOffset = getCommonSuffix(equality1, edit);
+      if (commonOffset) {
+        const commonString = edit.substring(edit.length - commonOffset);
+        equality1 = equality1.substring(0, equality1.length - commonOffset), edit = commonString + edit.substring(0, edit.length - commonOffset), equality2 = commonString + equality2;
+      }
+      let bestEquality1 = equality1, bestEdit = edit, bestEquality2 = equality2, bestScore = diffCleanupSemanticScore(equality1, edit) + diffCleanupSemanticScore(edit, equality2);
+      for (; edit.charAt(0) === equality2.charAt(0); ) {
+        equality1 += edit.charAt(0), edit = edit.substring(1) + equality2.charAt(0), equality2 = equality2.substring(1);
+        const score = diffCleanupSemanticScore(equality1, edit) + diffCleanupSemanticScore(edit, equality2);
+        score >= bestScore && (bestScore = score, bestEquality1 = equality1, bestEdit = edit, bestEquality2 = equality2);
+      }
+      diffs[pointer - 1][1] !== bestEquality1 && (bestEquality1 ? diffs[pointer - 1][1] = bestEquality1 : (diffs.splice(pointer - 1, 1), pointer--), diffs[pointer][1] = bestEdit, bestEquality2 ? diffs[pointer + 1][1] = bestEquality2 : (diffs.splice(pointer + 1, 1), pointer--));
+    }
+    pointer++;
+  }
+  return diffs;
+}
+function cleanupMerge(rawDiffs) {
+  let diffs = rawDiffs.map((diff2) => cloneDiff(diff2));
+  diffs.push([DIFF_EQUAL, ""]);
+  let pointer = 0, countDelete = 0, countInsert = 0, textDelete = "", textInsert = "", commonlength;
+  for (; pointer < diffs.length; ) switch (diffs[pointer][0]) {
+    case DIFF_INSERT:
+      countInsert++, textInsert += diffs[pointer][1], pointer++;
+      break;
+    case DIFF_DELETE:
+      countDelete++, textDelete += diffs[pointer][1], pointer++;
+      break;
+    case DIFF_EQUAL:
+      countDelete + countInsert > 1 ? (countDelete !== 0 && countInsert !== 0 && (commonlength = getCommonPrefix(textInsert, textDelete), commonlength !== 0 && (pointer - countDelete - countInsert > 0 && diffs[pointer - countDelete - countInsert - 1][0] === DIFF_EQUAL ? diffs[pointer - countDelete - countInsert - 1][1] += textInsert.substring(0, commonlength) : (diffs.splice(0, 0, [DIFF_EQUAL, textInsert.substring(0, commonlength)]), pointer++), textInsert = textInsert.substring(commonlength), textDelete = textDelete.substring(commonlength)), commonlength = getCommonSuffix(textInsert, textDelete), commonlength !== 0 && (diffs[pointer][1] = textInsert.substring(textInsert.length - commonlength) + diffs[pointer][1], textInsert = textInsert.substring(0, textInsert.length - commonlength), textDelete = textDelete.substring(0, textDelete.length - commonlength))), pointer -= countDelete + countInsert, diffs.splice(pointer, countDelete + countInsert), textDelete.length && (diffs.splice(pointer, 0, [DIFF_DELETE, textDelete]), pointer++), textInsert.length && (diffs.splice(pointer, 0, [DIFF_INSERT, textInsert]), pointer++), pointer++) : pointer !== 0 && diffs[pointer - 1][0] === DIFF_EQUAL ? (diffs[pointer - 1][1] += diffs[pointer][1], diffs.splice(pointer, 1)) : pointer++, countInsert = 0, countDelete = 0, textDelete = "", textInsert = "";
+      break;
+    default:
+      throw new Error("Unknown diff operation");
+  }
+  diffs[diffs.length - 1][1] === "" && diffs.pop();
+  let hasChanges = !1;
+  for (pointer = 1; pointer < diffs.length - 1; ) diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL && (diffs[pointer][1].substring(diffs[pointer][1].length - diffs[pointer - 1][1].length) === diffs[pointer - 1][1] ? (diffs[pointer][1] = diffs[pointer - 1][1] + diffs[pointer][1].substring(0, diffs[pointer][1].length - diffs[pointer - 1][1].length), diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1], diffs.splice(pointer - 1, 1), hasChanges = !0) : diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) === diffs[pointer + 1][1] && (diffs[pointer - 1][1] += diffs[pointer + 1][1], diffs[pointer][1] = diffs[pointer][1].substring(diffs[pointer + 1][1].length) + diffs[pointer + 1][1], diffs.splice(pointer + 1, 1), hasChanges = !0)), pointer++;
+  return hasChanges && (diffs = cleanupMerge(diffs)), diffs;
+}
+function trueCount(...args) {
+  return args.reduce((n, bool) => n + (bool ? 1 : 0), 0);
+}
+function cleanupEfficiency(rawDiffs, editCost = 4) {
+  let diffs = rawDiffs.map((diff2) => cloneDiff(diff2)), hasChanges = !1;
+  const equalities = [];
+  let equalitiesLength = 0, lastEquality = null, pointer = 0, preIns = !1, preDel = !1, postIns = !1, postDel = !1;
+  for (; pointer < diffs.length; ) diffs[pointer][0] === DIFF_EQUAL ? (diffs[pointer][1].length < editCost && (postIns || postDel) ? (equalities[equalitiesLength++] = pointer, preIns = postIns, preDel = postDel, lastEquality = diffs[pointer][1]) : (equalitiesLength = 0, lastEquality = null), postIns = !1, postDel = !1) : (diffs[pointer][0] === DIFF_DELETE ? postDel = !0 : postIns = !0, lastEquality && (preIns && preDel && postIns && postDel || lastEquality.length < editCost / 2 && trueCount(preIns, preDel, postIns, postDel) === 3) && (diffs.splice(equalities[equalitiesLength - 1], 0, [DIFF_DELETE, lastEquality]), diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT, equalitiesLength--, lastEquality = null, preIns && preDel ? (postIns = !0, postDel = !0, equalitiesLength = 0) : (equalitiesLength--, pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1, postIns = !1, postDel = !1), hasChanges = !0)), pointer++;
+  return hasChanges && (diffs = cleanupMerge(diffs)), diffs;
+}
+var __defProp$1 = Object.defineProperty, __getOwnPropSymbols$1 = Object.getOwnPropertySymbols, __hasOwnProp$1 = Object.prototype.hasOwnProperty, __propIsEnum$1 = Object.prototype.propertyIsEnumerable, __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value
+}) : obj[key] = value, __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {})) __hasOwnProp$1.call(b, prop) && __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1) for (var prop of __getOwnPropSymbols$1(b)) __propIsEnum$1.call(b, prop) && __defNormalProp$1(a, prop, b[prop]);
+  return a;
+};
 const DEFAULT_OPTIONS = {
   /**
    * At what point is no match declared (0.0 = perfection, 1.0 = very loose).
@@ -1716,13 +1638,11 @@ const DEFAULT_OPTIONS = {
   distance: 1e3
 };
 function applyDefaults(options) {
-  return __spreadValues(__spreadValues({}, DEFAULT_OPTIONS), options);
+  return __spreadValues$1(__spreadValues$1({}, DEFAULT_OPTIONS), options);
 }
 const MAX_BITS$1 = 32;
-function bitap(text, pattern, loc) {
-  let opts = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
-  if (pattern.length > MAX_BITS$1)
-    throw new Error("Pattern too long for this browser.");
+function bitap(text, pattern, loc, opts = {}) {
+  if (pattern.length > MAX_BITS$1) throw new Error("Pattern too long for this browser.");
   const options = applyDefaults(opts), s = getAlphabetFromPattern(pattern);
   function getBitapScore(e, x) {
     const accuracy = e / pattern.length, proximity = Math.abs(loc - x);
@@ -1734,8 +1654,7 @@ function bitap(text, pattern, loc) {
   bestLoc = -1;
   let binMin, binMid, binMax = pattern.length + text.length, lastRd = [];
   for (let d = 0; d < pattern.length; d++) {
-    for (binMin = 0, binMid = binMax; binMin < binMid; )
-      getBitapScore(d, loc + binMid) <= scoreThreshold ? binMin = binMid : binMax = binMid, binMid = Math.floor((binMax - binMin) / 2 + binMin);
+    for (binMin = 0, binMid = binMax; binMin < binMid; ) getBitapScore(d, loc + binMid) <= scoreThreshold ? binMin = binMid : binMax = binMid, binMid = Math.floor((binMax - binMin) / 2 + binMin);
     binMax = binMid;
     let start = Math.max(1, loc - binMid + 1);
     const finish = Math.min(loc + binMid, text.length) + pattern.length, rd = new Array(finish + 2);
@@ -1744,106 +1663,40 @@ function bitap(text, pattern, loc) {
       const charMatch = s[text.charAt(j - 1)];
       if (d === 0 ? rd[j] = (rd[j + 1] << 1 | 1) & charMatch : rd[j] = (rd[j + 1] << 1 | 1) & charMatch | ((lastRd[j + 1] | lastRd[j]) << 1 | 1) | lastRd[j + 1], rd[j] & matchmask) {
         const score = getBitapScore(d, j - 1);
-        if (score <= scoreThreshold)
-          if (scoreThreshold = score, bestLoc = j - 1, bestLoc > loc)
-            start = Math.max(1, 2 * loc - bestLoc);
-          else
-            break;
+        if (score <= scoreThreshold) if (scoreThreshold = score, bestLoc = j - 1, bestLoc > loc) start = Math.max(1, 2 * loc - bestLoc);
+        else break;
       }
     }
-    if (getBitapScore(d + 1, loc) > scoreThreshold)
-      break;
+    if (getBitapScore(d + 1, loc) > scoreThreshold) break;
     lastRd = rd;
   }
   return bestLoc;
 }
 function getAlphabetFromPattern(pattern) {
   const s = {};
-  for (let i = 0; i < pattern.length; i++)
-    s[pattern.charAt(i)] = 0;
-  for (let i = 0; i < pattern.length; i++)
-    s[pattern.charAt(i)] |= 1 << pattern.length - i - 1;
+  for (let i = 0; i < pattern.length; i++) s[pattern.charAt(i)] = 0;
+  for (let i = 0; i < pattern.length; i++) s[pattern.charAt(i)] |= 1 << pattern.length - i - 1;
   return s;
 }
 function match(text, pattern, searchLocation) {
-  if (text === null || pattern === null || searchLocation === null)
-    throw new Error("Null input. (match())");
+  if (text === null || pattern === null || searchLocation === null) throw new Error("Null input. (match())");
   const loc = Math.max(0, Math.min(searchLocation, text.length));
-  if (text === pattern)
-    return 0;
+  if (text === pattern) return 0;
   if (text.length) {
-    if (text.substring(loc, loc + pattern.length) === pattern)
-      return loc;
+    if (text.substring(loc, loc + pattern.length) === pattern) return loc;
   } else return -1;
   return bitap(text, pattern, loc);
 }
-function createPatchObject(start1, start2) {
-  return {
-    diffs: [],
-    start1,
-    start2,
-    utf8Start1: start1,
-    utf8Start2: start2,
-    length1: 0,
-    length2: 0,
-    utf8Length1: 0,
-    utf8Length2: 0
-  };
-}
 function diffText1(diffs) {
   const text = [];
-  for (let x = 0; x < diffs.length; x++)
-    diffs[x][0] !== DIFF_INSERT && (text[x] = diffs[x][1]);
+  for (let x = 0; x < diffs.length; x++) diffs[x][0] !== DIFF_INSERT && (text[x] = diffs[x][1]);
   return text.join("");
 }
 function diffText2(diffs) {
   const text = [];
-  for (let x = 0; x < diffs.length; x++)
-    diffs[x][0] !== DIFF_DELETE && (text[x] = diffs[x][1]);
+  for (let x = 0; x < diffs.length; x++) diffs[x][0] !== DIFF_DELETE && (text[x] = diffs[x][1]);
   return text.join("");
 }
-function countUtf8Bytes(str) {
-  let bytes = 0;
-  for (let i = 0; i < str.length; i++) {
-    const codePoint = str.codePointAt(i);
-    if (typeof codePoint > "u")
-      throw new Error("Failed to get codepoint");
-    bytes += utf8len(codePoint);
-  }
-  return bytes;
-}
-function adjustIndiciesToUcs2(patches, base) {
-  let options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, byteOffset = 0, idx = 0;
-  function advanceTo(target) {
-    for (; byteOffset < target; ) {
-      const codePoint = base.codePointAt(idx);
-      if (typeof codePoint > "u")
-        return idx;
-      byteOffset += utf8len(codePoint), codePoint > 65535 ? idx += 2 : idx += 1;
-    }
-    if (!options.allowExceedingIndices && byteOffset !== target)
-      throw new Error("Failed to determine byte offset");
-    return idx;
-  }
-  const adjusted = [];
-  for (const patch of patches)
-    adjusted.push({
-      diffs: patch.diffs.map((diff2) => cloneDiff(diff2)),
-      start1: advanceTo(patch.start1),
-      start2: advanceTo(patch.start2),
-      utf8Start1: patch.utf8Start1,
-      utf8Start2: patch.utf8Start2,
-      length1: patch.length1,
-      length2: patch.length2,
-      utf8Length1: patch.utf8Length1,
-      utf8Length2: patch.utf8Length2
-    });
-  return adjusted;
-}
-function utf8len(codePoint) {
-  return codePoint <= 127 ? 1 : codePoint <= 2047 ? 2 : codePoint <= 65535 ? 3 : 4;
-}
-const MAX_BITS = 32, DEFAULT_MARGIN = 4;
 function levenshtein(diffs) {
   let leven = 0, insertions = 0, deletions = 0;
   for (let x = 0; x < diffs.length; x++) {
@@ -1866,38 +1719,82 @@ function levenshtein(diffs) {
 }
 function xIndex(diffs, loc) {
   let chars1 = 0, chars2 = 0, lastChars1 = 0, lastChars2 = 0, x;
-  for (x = 0; x < diffs.length && (diffs[x][0] !== DIFF_INSERT && (chars1 += diffs[x][1].length), diffs[x][0] !== DIFF_DELETE && (chars2 += diffs[x][1].length), !(chars1 > loc)); x++)
-    lastChars1 = chars1, lastChars2 = chars2;
+  for (x = 0; x < diffs.length && (diffs[x][0] !== DIFF_INSERT && (chars1 += diffs[x][1].length), diffs[x][0] !== DIFF_DELETE && (chars2 += diffs[x][1].length), !(chars1 > loc)); x++) lastChars1 = chars1, lastChars2 = chars2;
   return diffs.length !== x && diffs[x][0] === DIFF_DELETE ? lastChars2 : lastChars2 + (loc - lastChars1);
 }
-function addPadding(patches) {
-  const paddingLength = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_MARGIN;
+function countUtf8Bytes(str) {
+  let bytes = 0;
+  for (let i = 0; i < str.length; i++) {
+    const codePoint = str.codePointAt(i);
+    if (typeof codePoint > "u") throw new Error("Failed to get codepoint");
+    bytes += utf8len(codePoint);
+  }
+  return bytes;
+}
+function adjustIndiciesToUcs2(patches, base, options = {}) {
+  let byteOffset = 0, idx = 0;
+  function advanceTo(target) {
+    for (; byteOffset < target; ) {
+      const codePoint = base.codePointAt(idx);
+      if (typeof codePoint > "u") return idx;
+      byteOffset += utf8len(codePoint), codePoint > 65535 ? idx += 2 : idx += 1;
+    }
+    if (!options.allowExceedingIndices && byteOffset !== target) throw new Error("Failed to determine byte offset");
+    return idx;
+  }
+  const adjusted = [];
+  for (const patch of patches) adjusted.push({
+    diffs: patch.diffs.map((diff2) => cloneDiff(diff2)),
+    start1: advanceTo(patch.start1),
+    start2: advanceTo(patch.start2),
+    utf8Start1: patch.utf8Start1,
+    utf8Start2: patch.utf8Start2,
+    length1: patch.length1,
+    length2: patch.length2,
+    utf8Length1: patch.utf8Length1,
+    utf8Length2: patch.utf8Length2
+  });
+  return adjusted;
+}
+function utf8len(codePoint) {
+  return codePoint <= 127 ? 1 : codePoint <= 2047 ? 2 : codePoint <= 65535 ? 3 : 4;
+}
+const MAX_BITS = 32, DEFAULT_MARGIN = 4;
+function addPadding(patches, margin = DEFAULT_MARGIN) {
+  const paddingLength = margin;
   let nullPadding = "";
-  for (let x = 1; x <= paddingLength; x++)
-    nullPadding += String.fromCharCode(x);
-  for (const p of patches)
-    p.start1 += paddingLength, p.start2 += paddingLength, p.utf8Start1 += paddingLength, p.utf8Start2 += paddingLength;
+  for (let x = 1; x <= paddingLength; x++) nullPadding += String.fromCharCode(x);
+  for (const p of patches) p.start1 += paddingLength, p.start2 += paddingLength, p.utf8Start1 += paddingLength, p.utf8Start2 += paddingLength;
   let patch = patches[0], diffs = patch.diffs;
-  if (diffs.length === 0 || diffs[0][0] !== DIFF_EQUAL)
-    diffs.unshift([DIFF_EQUAL, nullPadding]), patch.start1 -= paddingLength, patch.start2 -= paddingLength, patch.utf8Start1 -= paddingLength, patch.utf8Start2 -= paddingLength, patch.length1 += paddingLength, patch.length2 += paddingLength, patch.utf8Length1 += paddingLength, patch.utf8Length2 += paddingLength;
+  if (diffs.length === 0 || diffs[0][0] !== DIFF_EQUAL) diffs.unshift([DIFF_EQUAL, nullPadding]), patch.start1 -= paddingLength, patch.start2 -= paddingLength, patch.utf8Start1 -= paddingLength, patch.utf8Start2 -= paddingLength, patch.length1 += paddingLength, patch.length2 += paddingLength, patch.utf8Length1 += paddingLength, patch.utf8Length2 += paddingLength;
   else if (paddingLength > diffs[0][1].length) {
     const firstDiffLength = diffs[0][1].length, extraLength = paddingLength - firstDiffLength;
     diffs[0][1] = nullPadding.substring(firstDiffLength) + diffs[0][1], patch.start1 -= extraLength, patch.start2 -= extraLength, patch.utf8Start1 -= extraLength, patch.utf8Start2 -= extraLength, patch.length1 += extraLength, patch.length2 += extraLength, patch.utf8Length1 += extraLength, patch.utf8Length2 += extraLength;
   }
-  if (patch = patches[patches.length - 1], diffs = patch.diffs, diffs.length === 0 || diffs[diffs.length - 1][0] !== DIFF_EQUAL)
-    diffs.push([DIFF_EQUAL, nullPadding]), patch.length1 += paddingLength, patch.length2 += paddingLength, patch.utf8Length1 += paddingLength, patch.utf8Length2 += paddingLength;
+  if (patch = patches[patches.length - 1], diffs = patch.diffs, diffs.length === 0 || diffs[diffs.length - 1][0] !== DIFF_EQUAL) diffs.push([DIFF_EQUAL, nullPadding]), patch.length1 += paddingLength, patch.length2 += paddingLength, patch.utf8Length1 += paddingLength, patch.utf8Length2 += paddingLength;
   else if (paddingLength > diffs[diffs.length - 1][1].length) {
     const extraLength = paddingLength - diffs[diffs.length - 1][1].length;
     diffs[diffs.length - 1][1] += nullPadding.substring(0, extraLength), patch.length1 += extraLength, patch.length2 += extraLength, patch.utf8Length1 += extraLength, patch.utf8Length2 += extraLength;
   }
   return nullPadding;
 }
-function splitMax(patches) {
-  let margin = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_MARGIN;
+function createPatchObject(start1, start2) {
+  return {
+    diffs: [],
+    start1,
+    start2,
+    utf8Start1: start1,
+    utf8Start2: start2,
+    length1: 0,
+    length2: 0,
+    utf8Length1: 0,
+    utf8Length2: 0
+  };
+}
+function splitMax(patches, margin = DEFAULT_MARGIN) {
   const patchSize = MAX_BITS;
   for (let x = 0; x < patches.length; x++) {
-    if (patches[x].length1 <= patchSize)
-      continue;
+    if (patches[x].length1 <= patchSize) continue;
     const bigpatch = patches[x];
     patches.splice(x--, 1);
     let start1 = bigpatch.start1, start2 = bigpatch.start2, preContext = "";
@@ -1923,13 +1820,10 @@ function splitMax(patches) {
     }
   }
 }
-function apply(patches, originalText) {
-  let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-  if (typeof patches == "string")
-    throw new Error("Patches must be an array - pass the patch to `parsePatch()` first");
+function apply(patches, originalText, opts = {}) {
+  if (typeof patches == "string") throw new Error("Patches must be an array - pass the patch to `parsePatch()` first");
   let text = originalText;
-  if (patches.length === 0)
-    return [text, []];
+  if (patches.length === 0) return [text, []];
   const parsed = adjustIndiciesToUcs2(patches, text, {
     allowExceedingIndices: opts.allowExceedingIndices
   }), margin = opts.margin || DEFAULT_MARGIN, deleteThreshold = opts.deleteThreshold || 0.4, nullPadding = addPadding(parsed, margin);
@@ -1939,19 +1833,16 @@ function apply(patches, originalText) {
   for (let x = 0; x < parsed.length; x++) {
     const expectedLoc = parsed[x].start2 + delta, text1 = diffText1(parsed[x].diffs);
     let startLoc, endLoc = -1;
-    if (text1.length > MAX_BITS ? (startLoc = match(text, text1.substring(0, MAX_BITS), expectedLoc), startLoc !== -1 && (endLoc = match(text, text1.substring(text1.length - MAX_BITS), expectedLoc + text1.length - MAX_BITS), (endLoc === -1 || startLoc >= endLoc) && (startLoc = -1))) : startLoc = match(text, text1, expectedLoc), startLoc === -1)
-      results[x] = !1, delta -= parsed[x].length2 - parsed[x].length1;
+    if (text1.length > MAX_BITS ? (startLoc = match(text, text1.substring(0, MAX_BITS), expectedLoc), startLoc !== -1 && (endLoc = match(text, text1.substring(text1.length - MAX_BITS), expectedLoc + text1.length - MAX_BITS), (endLoc === -1 || startLoc >= endLoc) && (startLoc = -1))) : startLoc = match(text, text1, expectedLoc), startLoc === -1) results[x] = !1, delta -= parsed[x].length2 - parsed[x].length1;
     else {
       results[x] = !0, delta = startLoc - expectedLoc;
       let text2;
-      if (endLoc === -1 ? text2 = text.substring(startLoc, startLoc + text1.length) : text2 = text.substring(startLoc, endLoc + MAX_BITS), text1 === text2)
-        text = text.substring(0, startLoc) + diffText2(parsed[x].diffs) + text.substring(startLoc + text1.length);
+      if (endLoc === -1 ? text2 = text.substring(startLoc, startLoc + text1.length) : text2 = text.substring(startLoc, endLoc + MAX_BITS), text1 === text2) text = text.substring(0, startLoc) + diffText2(parsed[x].diffs) + text.substring(startLoc + text1.length);
       else {
         let diffs = diff(text1, text2, {
           checkLines: !1
         });
-        if (text1.length > MAX_BITS && levenshtein(diffs) / text1.length > deleteThreshold)
-          results[x] = !1;
+        if (text1.length > MAX_BITS && levenshtein(diffs) / text1.length > deleteThreshold) results[x] = !1;
         else {
           diffs = cleanupSemanticLossless(diffs);
           let index1 = 0, index2 = 0;
@@ -1967,20 +1858,17 @@ function apply(patches, originalText) {
 }
 const patchHeader = /^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$/;
 function parse(textline) {
-  if (!textline)
-    return [];
+  if (!textline) return [];
   const patches = [], lines = textline.split(`
 `);
   let textPointer = 0;
   for (; textPointer < lines.length; ) {
     const m = lines[textPointer].match(patchHeader);
-    if (!m)
-      throw new Error("Invalid patch string: ".concat(lines[textPointer]));
+    if (!m) throw new Error(`Invalid patch string: ${lines[textPointer]}`);
     const patch = createPatchObject(toInt(m[1]), toInt(m[3]));
     for (patches.push(patch), m[2] === "" ? (patch.start1--, patch.utf8Start1--, patch.length1 = 1, patch.utf8Length1 = 1) : m[2] === "0" ? (patch.length1 = 0, patch.utf8Length1 = 0) : (patch.start1--, patch.utf8Start1--, patch.utf8Length1 = toInt(m[2]), patch.length1 = patch.utf8Length1), m[4] === "" ? (patch.start2--, patch.utf8Start2--, patch.length2 = 1, patch.utf8Length2 = 1) : m[4] === "0" ? (patch.length2 = 0, patch.utf8Length2 = 0) : (patch.start2--, patch.utf8Start2--, patch.utf8Length2 = toInt(m[4]), patch.length2 = patch.utf8Length2), textPointer++; textPointer < lines.length; ) {
       const currentLine = lines[textPointer], sign = currentLine.charAt(0);
-      if (sign === "@")
-        break;
+      if (sign === "@") break;
       if (sign === "") {
         textPointer++;
         continue;
@@ -1988,18 +1876,14 @@ function parse(textline) {
       let line;
       try {
         line = decodeURI(currentLine.slice(1));
-      } catch (ex) {
-        throw new Error("Illegal escape in parse: ".concat(currentLine));
+      } catch {
+        throw new Error(`Illegal escape in parse: ${currentLine}`);
       }
       const utf8Diff = countUtf8Bytes(line) - line.length;
-      if (sign === "-")
-        patch.diffs.push([DIFF_DELETE, line]), patch.length1 -= utf8Diff;
-      else if (sign === "+")
-        patch.diffs.push([DIFF_INSERT, line]), patch.length2 -= utf8Diff;
-      else if (sign === " ")
-        patch.diffs.push([DIFF_EQUAL, line]), patch.length1 -= utf8Diff, patch.length2 -= utf8Diff;
-      else
-        throw new Error('Invalid patch mode "'.concat(sign, '" in: ').concat(line));
+      if (sign === "-") patch.diffs.push([DIFF_DELETE, line]), patch.length1 -= utf8Diff;
+      else if (sign === "+") patch.diffs.push([DIFF_INSERT, line]), patch.length2 -= utf8Diff;
+      else if (sign === " ") patch.diffs.push([DIFF_EQUAL, line]), patch.length1 -= utf8Diff, patch.length2 -= utf8Diff;
+      else throw new Error(`Invalid patch mode "${sign}" in: ${line}`);
       textPointer++;
     }
   }
@@ -2014,8 +1898,7 @@ function withUndoing(editor, fn) {
   IS_UDOING.set(editor, !0), fn(), IS_UDOING.set(editor, prev);
 }
 function isUndoing(editor) {
-  var _a;
-  return (_a = IS_UDOING.get(editor)) != null ? _a : !1;
+  return IS_UDOING.get(editor) ?? !1;
 }
 function setIsUndoing(editor, isUndoing2) {
   IS_UDOING.set(editor, isUndoing2);
@@ -2025,20 +1908,11 @@ function withRedoing(editor, fn) {
   IS_REDOING.set(editor, !0), fn(), IS_REDOING.set(editor, prev);
 }
 function isRedoing(editor) {
-  var _a;
-  return (_a = IS_REDOING.get(editor)) != null ? _a : !1;
+  return IS_REDOING.get(editor) ?? !1;
 }
 function setIsRedoing(editor, isRedoing2) {
   IS_REDOING.set(editor, isRedoing2);
 }
-var __defProp$m = Object.defineProperty, __getOwnPropSymbols$m = Object.getOwnPropertySymbols, __hasOwnProp$m = Object.prototype.hasOwnProperty, __propIsEnum$m = Object.prototype.propertyIsEnumerable, __defNormalProp$m = (obj, key, value) => key in obj ? __defProp$m(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$m = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$m.call(b, prop) && __defNormalProp$m(a, prop, b[prop]);
-  if (__getOwnPropSymbols$m)
-    for (var prop of __getOwnPropSymbols$m(b))
-      __propIsEnum$m.call(b, prop) && __defNormalProp$m(a, prop, b[prop]);
-  return a;
-};
 const debug$j = debugWithName("plugin:withUndoRedo"), debugVerbose$3 = debug$j.enabled && !1, SAVING = /* @__PURE__ */ new WeakMap(), REMOTE_PATCHES = /* @__PURE__ */ new WeakMap(), UNDO_STEP_LIMIT = 1e3, isSaving = (editor) => {
   const state = SAVING.get(editor);
   return state === void 0 ? !0 : state;
@@ -2201,7 +2075,9 @@ function createWithUndoRedo(options) {
 }
 function transformOperation(editor, patch, operation, snapshot, previousSnapshot) {
   debugVerbose$3 && (debug$j(`Adjusting '${operation.type}' operation paths for '${patch.type}' patch`), debug$j(`Operation ${JSON.stringify(operation)}`), debug$j(`Patch ${JSON.stringify(patch)}`));
-  const transformedOperation = __spreadValues$m({}, operation);
+  const transformedOperation = {
+    ...operation
+  };
   if (patch.type === "insert" && patch.path.length === 1) {
     const insertBlockIndex = (snapshot || []).findIndex((blk) => isEqual({
       _key: blk._key
@@ -2221,7 +2097,6 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
     return !operationTargetBlock || !isEqual({
       _key: operationTargetBlock._key
     }, patch.path[0]) ? [transformedOperation] : (parse(patch.value).forEach((diffPatch) => {
-      var _a, _b, _c, _d;
       let adjustOffsetBy = 0, changedOffset = diffPatch.utf8Start1;
       const {
         diffs
@@ -2230,7 +2105,15 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
         const [diffType, text] = diff2;
         diffType === DIFF_INSERT ? (adjustOffsetBy += text.length, changedOffset += text.length) : diffType === DIFF_DELETE ? (adjustOffsetBy -= text.length, changedOffset -= text.length) : diffType === DIFF_EQUAL && (diffs.slice(index).every(([dType]) => dType === DIFF_EQUAL) || (changedOffset += text.length));
       }), transformedOperation.type === "insert_text" && changedOffset < transformedOperation.offset && (transformedOperation.offset += adjustOffsetBy), transformedOperation.type === "remove_text" && changedOffset <= transformedOperation.offset - transformedOperation.text.length && (transformedOperation.offset += adjustOffsetBy), transformedOperation.type === "set_selection") {
-        const currentFocus = (_a = transformedOperation.properties) != null && _a.focus ? __spreadValues$m({}, transformedOperation.properties.focus) : void 0, currentAnchor = (_b = transformedOperation == null ? void 0 : transformedOperation.properties) != null && _b.anchor ? __spreadValues$m({}, transformedOperation.properties.anchor) : void 0, newFocus = (_c = transformedOperation == null ? void 0 : transformedOperation.newProperties) != null && _c.focus ? __spreadValues$m({}, transformedOperation.newProperties.focus) : void 0, newAnchor = (_d = transformedOperation == null ? void 0 : transformedOperation.newProperties) != null && _d.anchor ? __spreadValues$m({}, transformedOperation.newProperties.anchor) : void 0;
+        const currentFocus = transformedOperation.properties?.focus ? {
+          ...transformedOperation.properties.focus
+        } : void 0, currentAnchor = transformedOperation?.properties?.anchor ? {
+          ...transformedOperation.properties.anchor
+        } : void 0, newFocus = transformedOperation?.newProperties?.focus ? {
+          ...transformedOperation.newProperties.focus
+        } : void 0, newAnchor = transformedOperation?.newProperties?.anchor ? {
+          ...transformedOperation.newProperties.anchor
+        } : void 0;
         (currentFocus && currentAnchor || newFocus && newAnchor) && ([currentFocus, currentAnchor, newFocus, newAnchor].forEach((point) => {
           point && changedOffset < point.offset && (point.offset += adjustOffsetBy);
         }), currentFocus && currentAnchor && (transformedOperation.properties = {
@@ -2246,14 +2129,23 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
   return [transformedOperation];
 }
 function adjustBlockPath(operation, level, blockIndex) {
-  var _a, _b, _c, _d;
-  const transformedOperation = __spreadValues$m({}, operation);
+  const transformedOperation = {
+    ...operation
+  };
   if (blockIndex >= 0 && transformedOperation.type !== "set_selection" && Array.isArray(transformedOperation.path) && transformedOperation.path[0] >= blockIndex + level && transformedOperation.path[0] + level > -1) {
     const newPath = [transformedOperation.path[0] + level, ...transformedOperation.path.slice(1)];
     transformedOperation.path = newPath;
   }
   if (transformedOperation.type === "set_selection") {
-    const currentFocus = (_a = transformedOperation.properties) != null && _a.focus ? __spreadValues$m({}, transformedOperation.properties.focus) : void 0, currentAnchor = (_b = transformedOperation == null ? void 0 : transformedOperation.properties) != null && _b.anchor ? __spreadValues$m({}, transformedOperation.properties.anchor) : void 0, newFocus = (_c = transformedOperation == null ? void 0 : transformedOperation.newProperties) != null && _c.focus ? __spreadValues$m({}, transformedOperation.newProperties.focus) : void 0, newAnchor = (_d = transformedOperation == null ? void 0 : transformedOperation.newProperties) != null && _d.anchor ? __spreadValues$m({}, transformedOperation.newProperties.anchor) : void 0;
+    const currentFocus = transformedOperation.properties?.focus ? {
+      ...transformedOperation.properties.focus
+    } : void 0, currentAnchor = transformedOperation?.properties?.anchor ? {
+      ...transformedOperation.properties.anchor
+    } : void 0, newFocus = transformedOperation?.newProperties?.focus ? {
+      ...transformedOperation.newProperties.focus
+    } : void 0, newAnchor = transformedOperation?.newProperties?.anchor ? {
+      ...transformedOperation.newProperties.anchor
+    } : void 0;
     (currentFocus && currentAnchor || newFocus && newAnchor) && ([currentFocus, currentAnchor, newFocus, newAnchor].forEach((point) => {
       point && point.path[0] >= blockIndex + level && point.path[0] + level > -1 && (point.path = [point.path[0] + level, ...point.path.slice(1)]);
     }), currentFocus && currentAnchor && (transformedOperation.properties = {
@@ -2274,27 +2166,18 @@ function withoutSaving(editor, fn) {
 function createSelectOperation(editor) {
   return {
     type: "set_selection",
-    properties: __spreadValues$m({}, editor.selection),
-    newProperties: __spreadValues$m({}, editor.selection)
+    properties: {
+      ...editor.selection
+    },
+    newProperties: {
+      ...editor.selection
+    }
   };
 }
 function findOperationTargetBlock(editor, operation) {
   let block;
   return operation.type === "set_selection" && editor.selection ? block = editor.children[editor.selection.focus.path[0]] : "path" in operation && (block = editor.children[operation.path[0]]), block;
 }
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name), __await = function(promise, isYieldStar) {
-  this[0] = promise, this[1] = isYieldStar;
-}, __asyncGenerator = (__this, __arguments, generator) => {
-  var resume = (k, v, yes, no) => {
-    try {
-      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
-      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
-    } catch (e) {
-      no(e);
-    }
-  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
-  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
-}, __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
 const syncValueCallback = ({
   sendBack,
   input
@@ -2345,10 +2228,7 @@ const syncValueCallback = ({
     }) => context.initialValueSynced,
     "is busy": ({
       context
-    }) => {
-      var _a;
-      return !context.readOnly && (context.isProcessingLocalChanges || ((_a = isChangingRemotely(context.slateEditor)) != null ? _a : !1));
-    },
+    }) => !context.readOnly && (context.isProcessingLocalChanges || (isChangingRemotely(context.slateEditor) ?? !1)),
     "value changed while syncing": ({
       context,
       event
@@ -2533,33 +2413,22 @@ async function updateValue({
                 });
               isChanged = !0;
             }
-            try {
-              for (var iter = __forAwait(getBlocks({
-                slateValue: slateValueFromProps,
-                streamBlocks
-              })), more, temp, error; more = !(temp = await iter.next()).done; more = !1) {
-                const [currentBlock, currentBlockIndex] = temp.value, {
-                  blockChanged,
-                  blockValid
-                } = syncBlock({
-                  context,
-                  sendBack,
-                  block: currentBlock,
-                  index: currentBlockIndex,
-                  slateEditor,
-                  value
-                });
-                isChanged = blockChanged || isChanged, isValid = isValid && blockValid;
-              }
-            } catch (temp2) {
-              error = [temp2];
-            } finally {
-              try {
-                more && (temp = iter.return) && await temp.call(iter);
-              } finally {
-                if (error)
-                  throw error[0];
-              }
+            for await (const [currentBlock, currentBlockIndex] of getBlocks({
+              slateValue: slateValueFromProps,
+              streamBlocks
+            })) {
+              const {
+                blockChanged,
+                blockValid
+              } = syncBlock({
+                context,
+                sendBack,
+                block: currentBlock,
+                index: currentBlockIndex,
+                slateEditor,
+                value
+              });
+              isChanged = blockChanged || isChanged, isValid = isValid && blockValid;
             }
             resolve();
           });
@@ -2609,28 +2478,13 @@ async function updateValue({
     value
   });
 }
-function getBlocks(_0) {
-  return __asyncGenerator(this, arguments, function* ({
-    slateValue,
-    streamBlocks
-  }) {
-    let index = 0;
-    try {
-      for (var iter = __forAwait(slateValue), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = !1) {
-        const block = temp.value;
-        streamBlocks && (yield new __await(new Promise((resolve) => setTimeout(resolve, 0)))), yield [block, index], index++;
-      }
-    } catch (temp2) {
-      error = [temp2];
-    } finally {
-      try {
-        more && (temp = iter.return) && (yield new __await(temp.call(iter)));
-      } finally {
-        if (error)
-          throw error[0];
-      }
-    }
-  });
+async function* getBlocks({
+  slateValue,
+  streamBlocks
+}) {
+  let index = 0;
+  for await (const block of slateValue)
+    streamBlocks && await new Promise((resolve) => setTimeout(resolve, 0)), yield [block, index], index++;
 }
 function syncBlock({
   context,
@@ -2645,15 +2499,14 @@ function syncBlock({
   return Editor.withoutNormalizing(slateEditor, () => {
     withRemoteChanges(slateEditor, () => {
       withoutPatching(slateEditor, () => {
-        var _a, _b, _c, _d, _e;
         if (hasChanges && blockValid) {
           const validationValue = [value[currentBlockIndex]], validation = validateValue(validationValue, context.schema, context.keyGenerator);
-          !validation.valid && (_a = validation.resolution) != null && _a.autoResolve && ((_b = validation.resolution) == null ? void 0 : _b.patches.length) > 0 && !context.readOnly && context.previousValue && context.previousValue !== value && (console.warn(`${validation.resolution.action} for block with _key '${validationValue[0]._key}'. ${(_c = validation.resolution) == null ? void 0 : _c.description}`), validation.resolution.patches.forEach((patch) => {
+          !validation.valid && validation.resolution?.autoResolve && validation.resolution?.patches.length > 0 && !context.readOnly && context.previousValue && context.previousValue !== value && (console.warn(`${validation.resolution.action} for block with _key '${validationValue[0]._key}'. ${validation.resolution?.description}`), validation.resolution.patches.forEach((patch) => {
             sendBack({
               type: "patch",
               patch
             });
-          })), validation.valid || (_d = validation.resolution) != null && _d.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$i.enabled && debug$i("Updating block", oldBlock, currentBlock), _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex)) : (debug$i.enabled && debug$i("Replacing block", oldBlock, currentBlock), _replaceBlock(slateEditor, currentBlock, currentBlockIndex)), blockChanged = !0) : (sendBack({
+          })), validation.valid || validation.resolution?.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$i.enabled && debug$i("Updating block", oldBlock, currentBlock), _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex)) : (debug$i.enabled && debug$i("Replacing block", oldBlock, currentBlock), _replaceBlock(slateEditor, currentBlock, currentBlockIndex)), blockChanged = !0) : (sendBack({
             type: "invalid value",
             resolution: validation.resolution,
             value
@@ -2661,7 +2514,7 @@ function syncBlock({
         }
         if (!oldBlock && blockValid) {
           const validationValue = [value[currentBlockIndex]], validation = validateValue(validationValue, context.schema, context.keyGenerator);
-          debug$i.enabled && debug$i("Validating and inserting new block in the end of the value", currentBlock), validation.valid || (_e = validation.resolution) != null && _e.autoResolve ? Transforms.insertNodes(slateEditor, currentBlock, {
+          debug$i.enabled && debug$i("Validating and inserting new block in the end of the value", currentBlock), validation.valid || validation.resolution?.autoResolve ? Transforms.insertNodes(slateEditor, currentBlock, {
             at: [currentBlockIndex]
           }) : (debug$i("Invalid", validation), sendBack({
             type: "invalid value",
@@ -2695,9 +2548,9 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
         at: [currentBlockIndex, childIndex]
       }));
     }), currentBlock.children.forEach((currentBlockChild, currentBlockChildIndex) => {
-      const oldBlockChild = oldBlock.children[currentBlockChildIndex], isChildChanged = !isEqual(currentBlockChild, oldBlockChild), isTextChanged = !isEqual(currentBlockChild.text, oldBlockChild == null ? void 0 : oldBlockChild.text), path = [currentBlockIndex, currentBlockChildIndex];
+      const oldBlockChild = oldBlock.children[currentBlockChildIndex], isChildChanged = !isEqual(currentBlockChild, oldBlockChild), isTextChanged = !isEqual(currentBlockChild.text, oldBlockChild?.text), path = [currentBlockIndex, currentBlockChildIndex];
       if (isChildChanged)
-        if (currentBlockChild._key === (oldBlockChild == null ? void 0 : oldBlockChild._key)) {
+        if (currentBlockChild._key === oldBlockChild?._key) {
           debug$i("Updating changed child", currentBlockChild, oldBlockChild), Transforms.setNodes(slateEditor, currentBlockChild, {
             at: path
           });
@@ -2824,14 +2677,6 @@ function _temp(s) {
   return s.context.value;
 }
 Synchronizer.displayName = "Synchronizer";
-var __defProp$l = Object.defineProperty, __defProps$f = Object.defineProperties, __getOwnPropDescs$f = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$l = Object.getOwnPropertySymbols, __hasOwnProp$l = Object.prototype.hasOwnProperty, __propIsEnum$l = Object.prototype.propertyIsEnumerable, __defNormalProp$l = (obj, key, value) => key in obj ? __defProp$l(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$l = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$l.call(b, prop) && __defNormalProp$l(a, prop, b[prop]);
-  if (__getOwnPropSymbols$l)
-    for (var prop of __getOwnPropSymbols$l(b))
-      __propIsEnum$l.call(b, prop) && __defNormalProp$l(a, prop, b[prop]);
-  return a;
-}, __spreadProps$f = (a, b) => __defProps$f(a, __getOwnPropDescs$f(b));
 const debug$g = debugWithName("operationToPatches");
 function createOperationToPatches(types) {
   const textBlockName = types.block.name;
@@ -2871,7 +2716,10 @@ function createOperationToPatches(types) {
       const block = editor.children[operation.path[0]];
       if (typeof block._key != "string")
         throw new Error("Expected block to have a _key");
-      const setNode = omitBy(__spreadValues$l(__spreadValues$l({}, editor.children[operation.path[0]]), operation.newProperties), isUndefined);
+      const setNode = omitBy({
+        ...editor.children[operation.path[0]],
+        ...operation.newProperties
+      }, isUndefined);
       return [set(fromSlateValue([setNode], textBlockName)[0], [{
         _key: block._key
       }])];
@@ -2906,12 +2754,14 @@ function createOperationToPatches(types) {
   function insertNodePatch(editor, operation, beforeValue) {
     const block = beforeValue[operation.path[0]], isTextBlock = editor.isTextBlock(block);
     if (operation.path.length === 1) {
-      const position = operation.path[0] === 0 ? "before" : "after", beforeBlock = beforeValue[operation.path[0] - 1], targetKey = operation.path[0] === 0 ? block == null ? void 0 : block._key : beforeBlock == null ? void 0 : beforeBlock._key;
+      const position = operation.path[0] === 0 ? "before" : "after", beforeBlock = beforeValue[operation.path[0] - 1], targetKey = operation.path[0] === 0 ? block?._key : beforeBlock?._key;
       return targetKey ? [insert([fromSlateValue([operation.node], textBlockName)[0]], position, [{
         _key: targetKey
       }])] : [setIfMissing(beforeValue, []), insert([fromSlateValue([operation.node], textBlockName)[0]], "before", [operation.path[0]])];
     } else if (isTextBlock && operation.path.length === 2 && editor.children[operation.path[0]]) {
-      const position = block.children.length === 0 || !block.children[operation.path[1] - 1] ? "before" : "after", node = __spreadValues$l({}, operation.node);
+      const position = block.children.length === 0 || !block.children[operation.path[1] - 1] ? "before" : "after", node = {
+        ...operation.node
+      };
       !node._type && Text.isText(node) && (node._type = "span", node.marks = []);
       const child = fromSlateValue([{
         _key: "bogus",
@@ -2950,9 +2800,10 @@ function createOperationToPatches(types) {
     if (operation.path.length === 2) {
       const splitSpan = splitBlock.children[operation.path[1]];
       if (editor.isTextSpan(splitSpan)) {
-        const targetSpans = fromSlateValue([__spreadProps$f(__spreadValues$l({}, splitBlock), {
+        const targetSpans = fromSlateValue([{
+          ...splitBlock,
           children: splitBlock.children.slice(operation.path[1] + 1, operation.path[1] + 2)
-        })], textBlockName)[0].children;
+        }], textBlockName)[0].children;
         patches.push(insert(targetSpans, "after", [{
           _key: splitBlock._key
         }, "children", {
@@ -2988,7 +2839,7 @@ function createOperationToPatches(types) {
   function mergeNodePatch(editor, operation, beforeValue) {
     const patches = [], block = beforeValue[operation.path[0]], updatedBlock = editor.children[operation.path[0]];
     if (operation.path.length === 1)
-      if (block != null && block._key) {
+      if (block?._key) {
         const newBlock = fromSlateValue([editor.children[operation.path[0] - 1]], textBlockName)[0];
         patches.push(set(newBlock, [{
           _key: newBlock._key
@@ -3260,7 +3111,6 @@ function createWithMaxBlocks(editorActor) {
       apply: apply2
     } = editor;
     return editor.apply = (operation) => {
-      var _a;
       if (editorActor.getSnapshot().matches({
         "edit mode": "read only"
       })) {
@@ -3275,19 +3125,11 @@ function createWithMaxBlocks(editorActor) {
         apply2(operation);
         return;
       }
-      const rows = (_a = editorActor.getSnapshot().context.maxBlocks) != null ? _a : -1;
+      const rows = editorActor.getSnapshot().context.maxBlocks ?? -1;
       rows > 0 && editor.children.length >= rows && (operation.type === "insert_node" || operation.type === "split_node") && operation.path.length === 1 || apply2(operation);
     }, editor;
   };
 }
-var __defProp$k = Object.defineProperty, __defProps$e = Object.defineProperties, __getOwnPropDescs$e = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$k = Object.getOwnPropertySymbols, __hasOwnProp$k = Object.prototype.hasOwnProperty, __propIsEnum$k = Object.prototype.propertyIsEnumerable, __defNormalProp$k = (obj, key, value) => key in obj ? __defProp$k(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$k = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$k.call(b, prop) && __defNormalProp$k(a, prop, b[prop]);
-  if (__getOwnPropSymbols$k)
-    for (var prop of __getOwnPropSymbols$k(b))
-      __propIsEnum$k.call(b, prop) && __defNormalProp$k(a, prop, b[prop]);
-  return a;
-}, __spreadProps$e = (a, b) => __defProps$e(a, __getOwnPropDescs$e(b));
 function createWithObjectKeys(editorActor, schemaTypes) {
   return function(editor) {
     const {
@@ -3304,19 +3146,23 @@ function createWithObjectKeys(editorActor, schemaTypes) {
         return;
       }
       if (operation.type === "split_node") {
-        apply2(__spreadProps$e(__spreadValues$k({}, operation), {
-          properties: __spreadProps$e(__spreadValues$k({}, operation.properties), {
+        apply2({
+          ...operation,
+          properties: {
+            ...operation.properties,
             _key: editorActor.getSnapshot().context.keyGenerator()
-          })
-        }));
+          }
+        });
         return;
       }
       if (operation.type === "insert_node" && !Editor.isEditor(operation.node)) {
-        apply2(__spreadProps$e(__spreadValues$k({}, operation), {
-          node: __spreadProps$e(__spreadValues$k({}, operation.node), {
+        apply2({
+          ...operation,
+          node: {
+            ...operation.node,
             _key: editorActor.getSnapshot().context.keyGenerator()
-          })
-        }));
+          }
+        });
         return;
       }
       apply2(operation);
@@ -3353,22 +3199,6 @@ function createWithObjectKeys(editorActor, schemaTypes) {
     }, editor;
   };
 }
-var __defProp$j = Object.defineProperty, __defProps$d = Object.defineProperties, __getOwnPropDescs$d = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$j = Object.getOwnPropertySymbols, __hasOwnProp$j = Object.prototype.hasOwnProperty, __propIsEnum$j = Object.prototype.propertyIsEnumerable, __defNormalProp$j = (obj, key, value) => key in obj ? __defProp$j(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$j = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$j.call(b, prop) && __defNormalProp$j(a, prop, b[prop]);
-  if (__getOwnPropSymbols$j)
-    for (var prop of __getOwnPropSymbols$j(b))
-      __propIsEnum$j.call(b, prop) && __defNormalProp$j(a, prop, b[prop]);
-  return a;
-}, __spreadProps$d = (a, b) => __defProps$d(a, __getOwnPropDescs$d(b)), __objRest$2 = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    __hasOwnProp$j.call(source, prop) && exclude.indexOf(prop) < 0 && (target[prop] = source[prop]);
-  if (source != null && __getOwnPropSymbols$j)
-    for (var prop of __getOwnPropSymbols$j(source))
-      exclude.indexOf(prop) < 0 && __propIsEnum$j.call(source, prop) && (target[prop] = source[prop]);
-  return target;
-};
 const debug$f = debugWithName("applyPatches"), debugVerbose$2 = debug$f.enabled && !0;
 function createApplyPatch(schemaTypes) {
   return (editor, patch) => {
@@ -3458,9 +3288,10 @@ function insertPatch(editor, patch, schemaTypes) {
   } = patch;
   if (!targetChild || !targetChildPath)
     return debug$f("Child not found"), !1;
-  const childrenToInsert = targetBlock && toSlateValue([__spreadProps$d(__spreadValues$j({}, targetBlock), {
+  const childrenToInsert = targetBlock && toSlateValue([{
+    ...targetBlock,
     children: items
-  })], {
+  }], {
     schemaTypes
   }, KEY_TO_SLATE_ELEMENT.get(editor)), targetChildIndex = targetChildPath[1], normalizedIdx = position === "after" ? targetChildIndex + 1 : targetChildIndex, childInsertPath = [targetChildPath[0], normalizedIdx];
   return debug$f(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && Element$1.isElement(childrenToInsert[0]) && Transforms.insertNodes(editor, childrenToInsert[0].children, {
@@ -3505,19 +3336,21 @@ function setPatch(editor, patch) {
     return !0;
   } else if (Element$1.isElement(block) && patch.path.length === 1 && blockPath) {
     debug$f("Setting block property");
-    const _a = value, {
-      children
-    } = _a, nextRest = __objRest$2(_a, [
-      "children"
-    ]), _b = block || {
+    const {
+      children,
+      ...nextRest
+    } = value, {
+      children: prevChildren,
+      ...prevRest
+    } = block || {
       children: void 0
-    }, prevRest = __objRest$2(_b, [
-      "children"
-    ]);
+    };
     editor.apply({
       type: "set_node",
       path: blockPath,
-      properties: __spreadValues$j({}, prevRest),
+      properties: {
+        ...prevRest
+      },
       newProperties: nextRest
     }), debug$f("Setting children"), block.children.forEach((c2, cIndex) => {
       editor.apply({
@@ -3534,9 +3367,10 @@ function setPatch(editor, patch) {
     });
   } else if (block && "value" in block) {
     const newVal = applyAll([block.value], [patch])[0];
-    return Transforms.setNodes(editor, __spreadProps$d(__spreadValues$j({}, block), {
+    return Transforms.setNodes(editor, {
+      ...block,
       value: newVal
-    }), {
+    }, {
       at: blockPath
     }), !0;
   }
@@ -3619,7 +3453,7 @@ function findBlockAndChildFromPath(editor, path) {
     block,
     child,
     blockPath,
-    childPath: blockPath == null ? void 0 : blockPath.concat(childIndex)
+    childPath: blockPath?.concat(childIndex)
   } : {
     block,
     blockPath,
@@ -3627,14 +3461,6 @@ function findBlockAndChildFromPath(editor, path) {
     childPath: void 0
   };
 }
-var __defProp$i = Object.defineProperty, __defProps$c = Object.defineProperties, __getOwnPropDescs$c = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$i = Object.getOwnPropertySymbols, __hasOwnProp$i = Object.prototype.hasOwnProperty, __propIsEnum$i = Object.prototype.propertyIsEnumerable, __defNormalProp$i = (obj, key, value) => key in obj ? __defProp$i(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$i = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$i.call(b, prop) && __defNormalProp$i(a, prop, b[prop]);
-  if (__getOwnPropSymbols$i)
-    for (var prop of __getOwnPropSymbols$i(b))
-      __propIsEnum$i.call(b, prop) && __defNormalProp$i(a, prop, b[prop]);
-  return a;
-}, __spreadProps$c = (a, b) => __defProps$c(a, __getOwnPropDescs$c(b));
 const debug$e = debugWithName("plugin:withPatches");
 function createWithPatches({
   editorActor,
@@ -3719,9 +3545,10 @@ function createWithPatches({
       })), editorWasEmpty && patches.length > 0 && (patches = [setIfMissing([], []), ...patches]), patches.length > 0 && patches.forEach((patch) => {
         editorActor.send({
           type: "patch",
-          patch: __spreadProps$c(__spreadValues$i({}, patch), {
+          patch: {
+            ...patch,
             origin: "local"
-          })
+          }
         });
       }), editor;
     }, editor;
@@ -3834,14 +3661,6 @@ function getNextSpan({
     }
   return nextSpan;
 }
-var __defProp$h = Object.defineProperty, __defProps$b = Object.defineProperties, __getOwnPropDescs$b = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$h = Object.getOwnPropertySymbols, __hasOwnProp$h = Object.prototype.hasOwnProperty, __propIsEnum$h = Object.prototype.propertyIsEnumerable, __defNormalProp$h = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$h = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$h.call(b, prop) && __defNormalProp$h(a, prop, b[prop]);
-  if (__getOwnPropSymbols$h)
-    for (var prop of __getOwnPropSymbols$h(b))
-      __propIsEnum$h.call(b, prop) && __defNormalProp$h(a, prop, b[prop]);
-  return a;
-}, __spreadProps$b = (a, b) => __defProps$b(a, __getOwnPropDescs$b(b));
 const debug$b = debugWithName("plugin:withPortableTextMarkModel");
 function createWithPortableTextMarkModel(editorActor, types) {
   return function(editor) {
@@ -3850,19 +3669,12 @@ function createWithPortableTextMarkModel(editorActor, types) {
       normalizeNode
     } = editor, decorators = types.decorators.map((t) => t.value);
     return editor.normalizeNode = (nodeEntry) => {
-      var _a, _b, _c, _d, _e, _f, _g;
       const [node, path] = nodeEntry;
       if (editor.isTextBlock(node)) {
         const children = Node.children(editor, path);
         for (const [child, childPath] of children) {
           const nextNode = node.children[childPath[1] + 1];
-          if (editor.isTextSpan(child) && editor.isTextSpan(nextNode) && (_a = child.marks) != null && _a.every((mark) => {
-            var _a2;
-            return (_a2 = nextNode.marks) == null ? void 0 : _a2.includes(mark);
-          }) && (_b = nextNode.marks) != null && _b.every((mark) => {
-            var _a2;
-            return (_a2 = child.marks) == null ? void 0 : _a2.includes(mark);
-          })) {
+          if (editor.isTextSpan(child) && editor.isTextSpan(nextNode) && child.marks?.every((mark) => nextNode.marks?.includes(mark)) && nextNode.marks?.every((mark) => child.marks?.includes(mark))) {
             debug$b("Merging spans", JSON.stringify(child, null, 2), JSON.stringify(nextNode, null, 2)), editorActor.send({
               type: "normalizing"
             }), Transforms.mergeNodes(editor, {
@@ -3900,12 +3712,12 @@ function createWithPortableTextMarkModel(editorActor, types) {
         return;
       }
       if (editor.isTextSpan(node)) {
-        const blockPath = Path.parent(path), [block] = Editor.node(editor, blockPath), decorators2 = types.decorators.map((decorator) => decorator.value), annotations = (_c = node.marks) == null ? void 0 : _c.filter((mark) => !decorators2.includes(mark));
+        const blockPath = Path.parent(path), [block] = Editor.node(editor, blockPath), decorators2 = types.decorators.map((decorator) => decorator.value), 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"
           }), Transforms.setNodes(editor, {
-            marks: (_d = node.marks) == null ? void 0 : _d.filter((mark) => decorators2.includes(mark))
+            marks: node.marks?.filter((mark) => decorators2.includes(mark))
           }, {
             at: path
           }), editorActor.send({
@@ -3918,10 +3730,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         const decorators2 = types.decorators.map((decorator) => decorator.value);
         for (const [child, childPath] of Node.children(editor, path))
           if (editor.isTextSpan(child)) {
-            const marks = (_e = child.marks) != null ? _e : [], orphanedAnnotations = marks.filter((mark) => {
-              var _a2;
-              return !decorators2.includes(mark) && !((_a2 = node.markDefs) != null && _a2.find((def) => def._key === mark));
-            });
+            const marks = child.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !node.markDefs?.find((def) => def._key === mark));
             if (orphanedAnnotations.length > 0) {
               debug$b("Removing orphaned annotations from span node"), editorActor.send({
                 type: "normalizing"
@@ -3939,10 +3748,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
       if (editor.isTextSpan(node)) {
         const blockPath = Path.parent(path), [block] = Editor.node(editor, blockPath);
         if (editor.isTextBlock(block)) {
-          const decorators2 = types.decorators.map((decorator) => decorator.value), marks = (_f = node.marks) != null ? _f : [], orphanedAnnotations = marks.filter((mark) => {
-            var _a2;
-            return !decorators2.includes(mark) && !((_a2 = block.markDefs) != null && _a2.find((def) => def._key === mark));
-          });
+          const decorators2 = types.decorators.map((decorator) => decorator.value), 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"
@@ -3958,7 +3764,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         }
       }
       if (editor.isTextBlock(node)) {
-        const markDefs = (_g = node.markDefs) != null ? _g : [], markDefKeys = /* @__PURE__ */ new Set(), newMarkDefs = [];
+        const markDefs = node.markDefs ?? [], markDefKeys = /* @__PURE__ */ new Set(), newMarkDefs = [];
         for (const markDef of markDefs)
           markDefKeys.has(markDef._key) || (markDefKeys.add(markDef._key), newMarkDefs.push(markDef));
         if (markDefs.length !== newMarkDefs.length) {
@@ -3991,7 +3797,6 @@ function createWithPortableTextMarkModel(editorActor, types) {
       }
       normalizeNode(nodeEntry);
     }, editor.apply = (op) => {
-      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F;
       if (isChangingRemotely(editor)) {
         apply2(op);
         return;
@@ -4009,17 +3814,17 @@ function createWithPortableTextMarkModel(editorActor, types) {
           focus: op.newProperties.focus
         });
         if (previousSelectionIsCollapsed && newSelectionIsCollapsed) {
-          const focusSpan = (_a = Array.from(Editor.nodes(editor, {
+          const focusSpan = Array.from(Editor.nodes(editor, {
             mode: "lowest",
             at: op.properties.focus,
             match: (n) => editor.isTextSpan(n),
             voids: !1
-          }))[0]) == null ? void 0 : _a[0], newFocusSpan = (_b = Array.from(Editor.nodes(editor, {
+          }))[0]?.[0], newFocusSpan = Array.from(Editor.nodes(editor, {
             mode: "lowest",
             at: op.newProperties.focus,
             match: (n) => editor.isTextSpan(n),
             voids: !1
-          }))[0]) == null ? void 0 : _b[0], movedToNextSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] + 1 && focusSpan.text.length === op.properties.focus.offset && op.newProperties.focus.offset === 0, movedToPreviousSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] - 1 && op.properties.focus.offset === 0 && newFocusSpan.text.length === op.newProperties.focus.offset;
+          }))[0]?.[0], movedToNextSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] + 1 && focusSpan.text.length === op.properties.focus.offset && op.newProperties.focus.offset === 0, movedToPreviousSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] - 1 && op.properties.focus.offset === 0 && newFocusSpan.text.length === op.newProperties.focus.offset;
           if (movedToNextSpan || movedToPreviousSpan)
             return;
         }
@@ -4035,29 +3840,32 @@ function createWithPortableTextMarkModel(editorActor, types) {
             editor,
             blockPath,
             spanPath: op.path
-          }), previousSpanAnnotations = previousSpan ? (_c = previousSpan.marks) == null ? void 0 : _c.filter((mark) => !decorators.includes(mark)) : [], nextSpan = getNextSpan({
+          }), previousSpanAnnotations = previousSpan ? previousSpan.marks?.filter((mark) => !decorators.includes(mark)) : [], nextSpan = getNextSpan({
             editor,
             blockPath,
             spanPath: [op.path[0], op.path[1] - 1]
-          }), nextSpanAnnotations = nextSpan ? (_d = nextSpan.marks) == null ? void 0 : _d.filter((mark) => !decorators.includes(mark)) : [], annotationsEnding = (_e = previousSpanAnnotations == null ? void 0 : previousSpanAnnotations.filter((annotation) => !(nextSpanAnnotations != null && nextSpanAnnotations.includes(annotation)))) != null ? _e : [], atTheEndOfAnnotation = annotationsEnding.length > 0;
-          if (atTheEndOfAnnotation && isPortableTextSpan(op.node) && (_f = op.node.marks) != null && _f.some((mark) => annotationsEnding.includes(mark))) {
-            Transforms.insertNodes(editor, __spreadProps$b(__spreadValues$h({}, op.node), {
-              marks: (_h = (_g = op.node.marks) == null ? void 0 : _g.filter((mark) => !annotationsEnding.includes(mark))) != null ? _h : []
-            }));
+          }), nextSpanAnnotations = nextSpan ? nextSpan.marks?.filter((mark) => !decorators.includes(mark)) : [], annotationsEnding = previousSpanAnnotations?.filter((annotation) => !nextSpanAnnotations?.includes(annotation)) ?? [], atTheEndOfAnnotation = annotationsEnding.length > 0;
+          if (atTheEndOfAnnotation && isPortableTextSpan(op.node) && op.node.marks?.some((mark) => annotationsEnding.includes(mark))) {
+            Transforms.insertNodes(editor, {
+              ...op.node,
+              marks: op.node.marks?.filter((mark) => !annotationsEnding.includes(mark)) ?? []
+            });
             return;
           }
-          const annotationsStarting = (_i = nextSpanAnnotations == null ? void 0 : nextSpanAnnotations.filter((annotation) => !(previousSpanAnnotations != null && previousSpanAnnotations.includes(annotation)))) != null ? _i : [], atTheStartOfAnnotation = annotationsStarting.length > 0;
-          if (atTheStartOfAnnotation && isPortableTextSpan(op.node) && (_j = op.node.marks) != null && _j.some((mark) => annotationsStarting.includes(mark))) {
-            Transforms.insertNodes(editor, __spreadProps$b(__spreadValues$h({}, op.node), {
-              marks: (_l = (_k = op.node.marks) == null ? void 0 : _k.filter((mark) => !annotationsStarting.includes(mark))) != null ? _l : []
-            }));
+          const annotationsStarting = nextSpanAnnotations?.filter((annotation) => !previousSpanAnnotations?.includes(annotation)) ?? [], atTheStartOfAnnotation = annotationsStarting.length > 0;
+          if (atTheStartOfAnnotation && isPortableTextSpan(op.node) && op.node.marks?.some((mark) => annotationsStarting.includes(mark))) {
+            Transforms.insertNodes(editor, {
+              ...op.node,
+              marks: op.node.marks?.filter((mark) => !annotationsStarting.includes(mark)) ?? []
+            });
             return;
           }
-          const nextSpanDecorators = (_n = (_m = nextSpan == null ? void 0 : nextSpan.marks) == null ? void 0 : _m.filter((mark) => decorators.includes(mark))) != null ? _n : [];
-          if (nextSpanDecorators.length > 0 && atTheEndOfAnnotation && !atTheStartOfAnnotation && isPortableTextSpan(op.node) && ((_o = op.node.marks) == null ? void 0 : _o.length) === 0) {
-            Transforms.insertNodes(editor, __spreadProps$b(__spreadValues$h({}, op.node), {
+          const nextSpanDecorators = nextSpan?.marks?.filter((mark) => decorators.includes(mark)) ?? [];
+          if (nextSpanDecorators.length > 0 && atTheEndOfAnnotation && !atTheStartOfAnnotation && isPortableTextSpan(op.node) && op.node.marks?.length === 0) {
+            Transforms.insertNodes(editor, {
+              ...op.node,
               marks: nextSpanDecorators
-            }));
+            });
             return;
           }
         }
@@ -4069,12 +3877,12 @@ function createWithPortableTextMarkModel(editorActor, types) {
         if (selection && collapsedSelection) {
           const [_block, blockPath] = Editor.node(editor, selection, {
             depth: 1
-          }), [span, spanPath] = (_p = Array.from(Editor.nodes(editor, {
+          }), [span, spanPath] = Array.from(Editor.nodes(editor, {
             mode: "lowest",
             at: selection.focus,
             match: (n) => editor.isTextSpan(n),
             voids: !1
-          }))[0]) != null ? _p : [void 0, void 0], marks = (_q = span.marks) != null ? _q : [], marksWithoutAnnotations = marks.filter((mark) => decorators.includes(mark)), spanHasAnnotations = marks.length > marksWithoutAnnotations.length, spanIsEmpty = span.text.length === 0, atTheBeginningOfSpan = selection.anchor.offset === 0, atTheEndOfSpan = selection.anchor.offset === span.text.length, previousSpan = getPreviousSpan({
+          }))[0] ?? [void 0, void 0], marks = span.marks ?? [], marksWithoutAnnotations = marks.filter((mark) => decorators.includes(mark)), spanHasAnnotations = marks.length > marksWithoutAnnotations.length, spanIsEmpty = span.text.length === 0, atTheBeginningOfSpan = selection.anchor.offset === 0, atTheEndOfSpan = selection.anchor.offset === span.text.length, previousSpan = getPreviousSpan({
             editor,
             blockPath,
             spanPath
@@ -4082,7 +3890,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
             editor,
             blockPath,
             spanPath
-          }), nextSpanAnnotations = (_s = (_r = nextSpan == null ? void 0 : nextSpan.marks) == null ? void 0 : _r.filter((mark) => !decorators.includes(mark))) != null ? _s : [], spanAnnotations = marks.filter((mark) => !decorators.includes(mark)), previousSpanHasAnnotations = previousSpan ? (_t = previousSpan.marks) == null ? void 0 : _t.some((mark) => !decorators.includes(mark)) : !1, previousSpanHasSameAnnotations = previousSpan ? (_u = previousSpan.marks) == null ? void 0 : _u.filter((mark) => !decorators.includes(mark)).every((mark) => marks.includes(mark)) : !1, previousSpanHasSameAnnotation = previousSpan ? (_v = previousSpan.marks) == null ? void 0 : _v.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1, previousSpanHasSameMarks = previousSpan ? (_w = previousSpan.marks) == null ? void 0 : _w.every((mark) => marks.includes(mark)) : !1, nextSpanSharesSomeAnnotations = spanAnnotations.some((mark) => nextSpanAnnotations == null ? void 0 : nextSpanAnnotations.includes(mark));
+          }), nextSpanAnnotations = nextSpan?.marks?.filter((mark) => !decorators.includes(mark)) ?? [], spanAnnotations = marks.filter((mark) => !decorators.includes(mark)), previousSpanHasAnnotations = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark)) : !1, previousSpanHasSameAnnotations = previousSpan ? previousSpan.marks?.filter((mark) => !decorators.includes(mark)).every((mark) => marks.includes(mark)) : !1, previousSpanHasSameAnnotation = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1, previousSpanHasSameMarks = previousSpan ? previousSpan.marks?.every((mark) => marks.includes(mark)) : !1, nextSpanSharesSomeAnnotations = spanAnnotations.some((mark) => nextSpanAnnotations?.includes(mark));
           if (spanHasAnnotations && !spanIsEmpty) {
             if (atTheBeginningOfSpan) {
               if (previousSpanHasSameMarks) {
@@ -4090,7 +3898,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
                   _type: "span",
                   _key: editorActor.getSnapshot().context.keyGenerator(),
                   text: op.text,
-                  marks: (_x = previousSpan == null ? void 0 : previousSpan.marks) != null ? _x : []
+                  marks: previousSpan?.marks ?? []
                 });
                 return;
               } else if (previousSpanHasSameAnnotations) {
@@ -4098,7 +3906,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
                   _type: "span",
                   _key: editorActor.getSnapshot().context.keyGenerator(),
                   text: op.text,
-                  marks: (_y = previousSpan == null ? void 0 : previousSpan.marks) != null ? _y : []
+                  marks: previousSpan?.marks ?? []
                 });
                 return;
               } else if (previousSpanHasSameAnnotation) {
@@ -4120,7 +3928,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
                   _type: "span",
                   _key: editorActor.getSnapshot().context.keyGenerator(),
                   text: op.text,
-                  marks: (_z = nextSpan == null ? void 0 : nextSpan.marks) != null ? _z : []
+                  marks: nextSpan?.marks ?? []
                 });
                 return;
               }
@@ -4140,7 +3948,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
               _type: "span",
               _key: editorActor.getSnapshot().context.keyGenerator(),
               text: op.text,
-              marks: previousSpanHasAnnotations ? [] : ((_A = previousSpan.marks) != null ? _A : []).filter((mark) => decorators.includes(mark))
+              marks: previousSpanHasAnnotations ? [] : (previousSpan.marks ?? []).filter((mark) => decorators.includes(mark))
             });
             return;
           }
@@ -4153,7 +3961,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         if (selection && Range.isExpanded(selection)) {
           const [block, blockPath] = Editor.node(editor, selection, {
             depth: 1
-          }), [span, spanPath] = (_B = Array.from(Editor.nodes(editor, {
+          }), [span, spanPath] = Array.from(Editor.nodes(editor, {
             mode: "lowest",
             at: {
               path: op.path,
@@ -4161,9 +3969,9 @@ function createWithPortableTextMarkModel(editorActor, types) {
             },
             match: (n) => editor.isTextSpan(n),
             voids: !1
-          }))[0]) != null ? _B : [void 0, void 0];
+          }))[0] ?? [void 0, void 0];
           if (span && block && isPortableTextBlock(block)) {
-            const markDefs = (_C = block.markDefs) != null ? _C : [], marks = (_D = span.marks) != null ? _D : [], spanHasAnnotations = marks.some((mark) => markDefs.find((markDef) => markDef._key === mark)), deletingFromTheEnd = op.offset + op.text.length === span.text.length, deletingAllText = op.offset === 0 && deletingFromTheEnd, previousSpan = getPreviousSpan({
+            const markDefs = block.markDefs ?? [], marks = span.marks ?? [], spanHasAnnotations = marks.some((mark) => markDefs.find((markDef) => markDef._key === mark)), deletingFromTheEnd = op.offset + op.text.length === span.text.length, deletingAllText = op.offset === 0 && deletingFromTheEnd, previousSpan = getPreviousSpan({
               editor,
               blockPath,
               spanPath
@@ -4171,9 +3979,11 @@ function createWithPortableTextMarkModel(editorActor, types) {
               editor,
               blockPath,
               spanPath
-            }), previousSpanHasSameAnnotation = previousSpan ? (_E = previousSpan.marks) == null ? void 0 : _E.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1, nextSpanHasSameAnnotation = nextSpan ? (_F = nextSpan.marks) == null ? void 0 : _F.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1;
+            }), previousSpanHasSameAnnotation = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1, nextSpanHasSameAnnotation = nextSpan ? nextSpan.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1;
             if (spanHasAnnotations && deletingAllText && !previousSpanHasSameAnnotation && !nextSpanHasSameAnnotation) {
-              const marksWithoutAnnotationMarks = (__spreadValues$h({}, Editor.marks(editor) || {}).marks || []).filter((mark) => decorators.includes(mark));
+              const marksWithoutAnnotationMarks = ({
+                ...Editor.marks(editor) || {}
+              }.marks || []).filter((mark) => decorators.includes(mark));
               Editor.withoutNormalizing(editor, () => {
                 apply2(op), Transforms.setNodes(editor, {
                   marks: marksWithoutAnnotationMarks
@@ -4206,7 +4016,6 @@ function createWithPortableTextMarkModel(editorActor, types) {
 const addDecoratorActionImplementation = ({
   action
 }) => {
-  var _a;
   const editor = action.editor, mark = action.decorator;
   if (editor.selection) {
     if (Range.isExpanded(editor.selection)) {
@@ -4219,10 +4028,7 @@ const addDecoratorActionImplementation = ({
         at: editor.selection,
         match: Text.isText
       })] : [];
-      splitTextNodes.length > 1 && splitTextNodes.every((node) => {
-        var _a2;
-        return (_a2 = node[0].marks) == null ? void 0 : _a2.includes(mark);
-      }) ? editor.removeMark(mark) : splitTextNodes.forEach(([node, path]) => {
+      splitTextNodes.length > 1 && splitTextNodes.every((node) => node[0].marks?.includes(mark)) ? editor.removeMark(mark) : splitTextNodes.forEach(([node, path]) => {
         const marks = [...(Array.isArray(node.marks) ? node.marks : []).filter((eMark) => eMark !== mark), mark];
         Transforms.setNodes(editor, {
           marks
@@ -4238,7 +4044,7 @@ const addDecoratorActionImplementation = ({
         depth: 1
       }), lonelyEmptySpan = editor.isTextBlock(block) && block.children.length === 1 && editor.isTextSpan(block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
       if (lonelyEmptySpan) {
-        const existingMarks = (_a = lonelyEmptySpan.marks) != null ? _a : [], existingMarksWithoutDecorator = existingMarks.filter((existingMark) => existingMark !== mark);
+        const existingMarks = lonelyEmptySpan.marks ?? [], existingMarksWithoutDecorator = existingMarks.filter((existingMark) => existingMark !== mark);
         Transforms.setNodes(editor, {
           marks: existingMarks.length === existingMarksWithoutDecorator.length ? [...existingMarks, mark] : existingMarksWithoutDecorator
         }, {
@@ -4246,9 +4052,12 @@ const addDecoratorActionImplementation = ({
           match: (node) => editor.isTextSpan(node)
         });
       } else {
-        const existingMarks = __spreadValues$h({}, Editor.marks(editor) || {}).marks || [], marks = __spreadProps$b(__spreadValues$h({}, Editor.marks(editor) || {}), {
+        const existingMarks = {
+          ...Editor.marks(editor) || {}
+        }.marks || [], marks = {
+          ...Editor.marks(editor) || {},
           marks: [...existingMarks, mark]
-        });
+        };
         editor.marks = marks;
       }
     }
@@ -4257,7 +4066,6 @@ const addDecoratorActionImplementation = ({
 }, removeDecoratorActionImplementation = ({
   action
 }) => {
-  var _a;
   const editor = action.editor, mark = action.decorator, {
     selection
   } = editor;
@@ -4284,7 +4092,7 @@ const addDecoratorActionImplementation = ({
         depth: 1
       }), lonelyEmptySpan = editor.isTextBlock(block) && block.children.length === 1 && editor.isTextSpan(block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
       if (lonelyEmptySpan) {
-        const existingMarksWithoutDecorator = ((_a = lonelyEmptySpan.marks) != null ? _a : []).filter((existingMark) => existingMark !== mark);
+        const existingMarksWithoutDecorator = (lonelyEmptySpan.marks ?? []).filter((existingMark) => existingMark !== mark);
         Transforms.setNodes(editor, {
           marks: existingMarksWithoutDecorator
         }, {
@@ -4292,9 +4100,12 @@ const addDecoratorActionImplementation = ({
           match: (node) => editor.isTextSpan(node)
         });
       } else {
-        const existingMarks = __spreadValues$h({}, Editor.marks(editor) || {}).marks || [], marks = __spreadProps$b(__spreadValues$h({}, Editor.marks(editor) || {}), {
+        const existingMarks = {
+          ...Editor.marks(editor) || {}
+        }.marks || [], marks = {
+          ...Editor.marks(editor) || {},
           marks: existingMarks.filter((eMark) => eMark !== mark)
-        });
+        };
         editor.marks = {
           marks: marks.marks,
           _type: "span"
@@ -4313,10 +4124,11 @@ function isDecoratorActive({
     at: editor.selection
   }));
   return selectedTextNodes.length === 0 ? !1 : Range.isExpanded(editor.selection) ? selectedTextNodes.every((n) => {
-    var _a;
     const [node] = n;
-    return (_a = node.marks) == null ? void 0 : _a.includes(decorator);
-  }) : (__spreadValues$h({}, Editor.marks(editor) || {}).marks || []).includes(decorator);
+    return node.marks?.includes(decorator);
+  }) : ({
+    ...Editor.marks(editor) || {}
+  }.marks || []).includes(decorator);
 }
 const toggleDecoratorActionImplementation = ({
   context,
@@ -4376,14 +4188,6 @@ function createWithPortableTextSelections(editorActor, types) {
     }, editor;
   };
 }
-var __defProp$g = Object.defineProperty, __defProps$a = Object.defineProperties, __getOwnPropDescs$a = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$g = Object.getOwnPropertySymbols, __hasOwnProp$g = Object.prototype.hasOwnProperty, __propIsEnum$g = Object.prototype.propertyIsEnumerable, __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$g = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$g.call(b, prop) && __defNormalProp$g(a, prop, b[prop]);
-  if (__getOwnPropSymbols$g)
-    for (var prop of __getOwnPropSymbols$g(b))
-      __propIsEnum$g.call(b, prop) && __defNormalProp$g(a, prop, b[prop]);
-  return a;
-}, __spreadProps$a = (a, b) => __defProps$a(a, __getOwnPropDescs$a(b));
 const debug$9 = debugWithName("plugin:withSchemaTypes");
 function createWithSchemaTypes({
   editorActor,
@@ -4401,10 +4205,11 @@ function createWithSchemaTypes({
         const span = node, key = span._key || editorActor.getSnapshot().context.keyGenerator();
         editorActor.send({
           type: "normalizing"
-        }), Transforms.setNodes(editor, __spreadProps$a(__spreadValues$g({}, span), {
+        }), Transforms.setNodes(editor, {
+          ...span,
           _type: schemaTypes.span.name,
           _key: key
-        }), {
+        }, {
           at: path
         }), editorActor.send({
           type: "done normalizing"
@@ -4429,14 +4234,6 @@ function createWithSchemaTypes({
     }, editor;
   };
 }
-var __defProp$f = Object.defineProperty, __defProps$9 = Object.defineProperties, __getOwnPropDescs$9 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$f = Object.getOwnPropertySymbols, __hasOwnProp$f = Object.prototype.hasOwnProperty, __propIsEnum$f = Object.prototype.propertyIsEnumerable, __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$f = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$f.call(b, prop) && __defNormalProp$f(a, prop, b[prop]);
-  if (__getOwnPropSymbols$f)
-    for (var prop of __getOwnPropSymbols$f(b))
-      __propIsEnum$f.call(b, prop) && __defNormalProp$f(a, prop, b[prop]);
-  return a;
-}, __spreadProps$9 = (a, b) => __defProps$9(a, __getOwnPropDescs$9(b));
 const debug$8 = debugWithName("plugin:withUtils");
 function createWithUtils({
   editorActor,
@@ -4460,26 +4257,29 @@ function createWithUtils({
         } = selection, focusOffset = focus.offset, charsBefore = textNode.text.slice(0, focusOffset), charsAfter = textNode.text.slice(focusOffset, -1), isEmpty = (str) => str.match(/\s/g), whiteSpaceBeforeIndex = charsBefore.split("").reverse().findIndex((str) => isEmpty(str)), newStartOffset = whiteSpaceBeforeIndex > -1 ? charsBefore.length - whiteSpaceBeforeIndex : 0, whiteSpaceAfterIndex = charsAfter.split("").findIndex((obj) => isEmpty(obj)), newEndOffset = charsBefore.length + (whiteSpaceAfterIndex > -1 ? whiteSpaceAfterIndex : charsAfter.length + 1);
         if (!(newStartOffset === newEndOffset || Number.isNaN(newStartOffset) || Number.isNaN(newEndOffset))) {
           debug$8("pteExpandToWord: Expanding to focused word"), Transforms.setSelection(editor, {
-            anchor: __spreadProps$9(__spreadValues$f({}, selection.anchor), {
+            anchor: {
+              ...selection.anchor,
               offset: newStartOffset
-            }),
-            focus: __spreadProps$9(__spreadValues$f({}, selection.focus), {
+            },
+            focus: {
+              ...selection.focus,
               offset: newEndOffset
-            })
+            }
           });
           return;
         }
         debug$8("pteExpandToWord: Can't expand to word here");
       }
-    }, editor.pteCreateTextBlock = (options) => toSlateValue([__spreadProps$9(__spreadValues$f(__spreadValues$f({
+    }, editor.pteCreateTextBlock = (options) => toSlateValue([{
       _type: schemaTypes.block.name,
       _key: editorActor.getSnapshot().context.keyGenerator(),
-      style: schemaTypes.styles[0].value || "normal"
-    }, options.listItem ? {
-      listItem: options.listItem
-    } : {}), options.level ? {
-      level: options.level
-    } : {}), {
+      style: schemaTypes.styles[0].value || "normal",
+      ...options.listItem ? {
+        listItem: options.listItem
+      } : {},
+      ...options.level ? {
+        level: options.level
+      } : {},
       markDefs: [],
       children: [{
         _type: "span",
@@ -4489,7 +4289,7 @@ function createWithUtils({
           value
         }) => value === decorator))
       }]
-    })], {
+    }], {
       schemaTypes
     })[0], editor;
   };
@@ -4535,14 +4335,6 @@ function createSlateEditor(config) {
   };
   return slateEditors.set(config.editorActor, slateEditor), slateEditor;
 }
-var __defProp$e = Object.defineProperty, __defProps$8 = Object.defineProperties, __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$e = Object.getOwnPropertySymbols, __hasOwnProp$e = Object.prototype.hasOwnProperty, __propIsEnum$e = Object.prototype.propertyIsEnumerable, __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$e = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$e.call(b, prop) && __defNormalProp$e(a, prop, b[prop]);
-  if (__getOwnPropSymbols$e)
-    for (var prop of __getOwnPropSymbols$e(b))
-      __propIsEnum$e.call(b, prop) && __defNormalProp$e(a, prop, b[prop]);
-  return a;
-}, __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
 const toggleListItemActionImplementation = ({
   context,
   action
@@ -4552,14 +4344,16 @@ const toggleListItemActionImplementation = ({
     listItem: action.listItem
   }) ? removeListItemActionImplementation({
     context,
-    action: __spreadProps$8(__spreadValues$e({}, action), {
+    action: {
+      ...action,
       type: "list item.remove"
-    })
+    }
   }) : addListItemActionImplementation({
     context,
-    action: __spreadProps$8(__spreadValues$e({}, action), {
+    action: {
+      ...action,
       type: "list item.add"
-    })
+    }
   });
 }, removeListItemActionImplementation = ({
   context,
@@ -4605,14 +4399,6 @@ function isListItemActive({
   })];
   return selectedBlocks.length > 0 ? selectedBlocks.every(([node]) => editor.isListBlock(node) && node.listItem === listItem) : !1;
 }
-var __defProp$d = Object.defineProperty, __defProps$7 = Object.defineProperties, __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$d = Object.getOwnPropertySymbols, __hasOwnProp$d = Object.prototype.hasOwnProperty, __propIsEnum$d = Object.prototype.propertyIsEnumerable, __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$d = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$d.call(b, prop) && __defNormalProp$d(a, prop, b[prop]);
-  if (__getOwnPropSymbols$d)
-    for (var prop of __getOwnPropSymbols$d(b))
-      __propIsEnum$d.call(b, prop) && __defNormalProp$d(a, prop, b[prop]);
-  return a;
-}, __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
 const toggleStyleActionImplementation = ({
   context,
   action
@@ -4622,14 +4408,16 @@ const toggleStyleActionImplementation = ({
     style: action.style
   }) ? removeStyleActionImplementation({
     context,
-    action: __spreadProps$7(__spreadValues$d({}, action), {
+    action: {
+      ...action,
       type: "style.remove"
-    })
+    }
   }) : addStyleActionImplementation({
     context,
-    action: __spreadProps$7(__spreadValues$d({}, action), {
+    action: {
+      ...action,
       type: "style.add"
-    })
+    }
   });
 }, removeStyleActionImplementation = ({
   context,
@@ -4676,14 +4464,6 @@ function isStyleActive({
   })];
   return selectedBlocks.length > 0 ? selectedBlocks.every(([node]) => node.style === style) : !1;
 }
-var __defProp$c = Object.defineProperty, __getOwnPropSymbols$c = Object.getOwnPropertySymbols, __hasOwnProp$c = Object.prototype.hasOwnProperty, __propIsEnum$c = Object.prototype.propertyIsEnumerable, __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$c = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$c.call(b, prop) && __defNormalProp$c(a, prop, b[prop]);
-  if (__getOwnPropSymbols$c)
-    for (var prop of __getOwnPropSymbols$c(b))
-      __propIsEnum$c.call(b, prop) && __defNormalProp$c(a, prop, b[prop]);
-  return a;
-};
 const debug$6 = debugWithName("API:editable");
 function createEditableAPI(editor, editorActor) {
   const types = editorActor.getSnapshot().context.schema;
@@ -4746,7 +4526,9 @@ function createEditableAPI(editor, editorActor) {
         return console.warn(err), !1;
       }
     },
-    marks: () => __spreadValues$c({}, Editor.marks(editor) || {}).marks || [],
+    marks: () => ({
+      ...Editor.marks(editor) || {}
+    }).marks || [],
     undo: () => editor.undo(),
     redo: () => editor.redo(),
     select: (selection) => {
@@ -4768,7 +4550,6 @@ function createEditableAPI(editor, editorActor) {
       }
     },
     insertChild: (type, value) => {
-      var _a, _b, _c;
       if (type.name !== types.span.name)
         return editorActor.send({
           type: "behavior event",
@@ -4780,7 +4561,7 @@ function createEditableAPI(editor, editorActor) {
             }
           },
           editor
-        }), (_b = (_a = toPortableTextRange(fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types)) == null ? void 0 : _a.focus.path) != null ? _b : [];
+        }), toPortableTextRange(fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types)?.focus.path ?? [];
       if (!editor.selection)
         throw new Error("The editor has no selection");
       const [focusBlock] = Array.from(Editor.nodes(editor, {
@@ -4794,10 +4575,11 @@ function createEditableAPI(editor, editorActor) {
       const child = toSlateValue([{
         _key: editorActor.getSnapshot().context.keyGenerator(),
         _type: types.block.name,
-        children: [__spreadValues$c({
+        children: [{
           _key: editorActor.getSnapshot().context.keyGenerator(),
-          _type: type.name
-        }, value || {})]
+          _type: type.name,
+          ...value || {}
+        }]
       }], {
         schemaTypes: editorActor.getSnapshot().context.schema
       })[0].children[0], focusChildPath = editor.selection.focus.path.slice(0, 2), isSpanNode = child._type === types.span.name, focusNode = Node.get(editor, focusChildPath);
@@ -4807,30 +4589,27 @@ function createEditableAPI(editor, editorActor) {
       })), Transforms.insertNodes(editor, child, {
         select: !0,
         at: editor.selection
-      }), editor.onChange(), ((_c = toPortableTextRange(fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types)) == null ? void 0 : _c.focus.path) || [];
+      }), editor.onChange(), toPortableTextRange(fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types)?.focus.path || [];
     },
-    insertBlock: (type, value) => {
-      var _a, _b;
-      return editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "insert.block object",
-          blockObject: {
-            name: type.name,
-            value
-          },
-          placement: "auto"
+    insertBlock: (type, value) => (editorActor.send({
+      type: "behavior event",
+      behaviorEvent: {
+        type: "insert.block object",
+        blockObject: {
+          name: type.name,
+          value
         },
-        editor
-      }), (_b = (_a = toPortableTextRange(fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types)) == null ? void 0 : _a.focus.path) != null ? _b : [];
-    },
+        placement: "auto"
+      },
+      editor
+    }), toPortableTextRange(fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types)?.focus.path ?? []),
     hasBlockStyle: (style) => {
       try {
         return isStyleActive({
           editor,
           style
         });
-      } catch (e) {
+      } catch {
         return !1;
       }
     },
@@ -4840,7 +4619,7 @@ function createEditableAPI(editor, editorActor) {
           editor,
           listItem
         });
-      } catch (e) {
+      } catch {
         return !1;
       }
     },
@@ -4885,12 +4664,11 @@ function createEditableAPI(editor, editorActor) {
           match: (n) => n._key === element._key
         }) || [])[0] || [void 0];
         node = ReactEditor.toDOMNode(editor, item);
-      } catch (e) {
+      } catch {
       }
       return node;
     },
     activeAnnotations: () => {
-      var _a;
       if (!editor.selection || editor.selection.focus.path.length < 2)
         return [];
       try {
@@ -4902,12 +4680,12 @@ function createEditableAPI(editor, editorActor) {
           const [block] = Editor.node(editor, path, {
             depth: 1
           });
-          editor.isTextBlock(block) && ((_a = block.markDefs) == null || _a.forEach((def) => {
+          editor.isTextBlock(block) && block.markDefs?.forEach((def) => {
             Text.isText(span) && span.marks && Array.isArray(span.marks) && span.marks.includes(def._key) && activeAnnotations.push(def);
-          }));
+          });
         }
         return activeAnnotations;
-      } catch (e) {
+      } catch {
         return [];
       }
     },
@@ -4929,7 +4707,7 @@ function createEditableAPI(editor, editorActor) {
             type: "annotation.add",
             annotation: {
               name: type.name,
-              value: value != null ? value : {}
+              value: value ?? {}
             },
             editor
           }
@@ -4942,7 +4720,7 @@ function createEditableAPI(editor, editorActor) {
         if (!(range && range.anchor.path.length > 0 && range.focus.path.length > 0))
           throw new Error("Invalid range");
         if (range) {
-          if (!(options != null && options.mode) || (options == null ? void 0 : options.mode) === "selected") {
+          if (!options?.mode || options?.mode === "selected") {
             debug$6("Deleting content in selection"), Transforms.delete(editor, {
               at: range,
               hanging: !0,
@@ -4950,11 +4728,11 @@ function createEditableAPI(editor, editorActor) {
             }), editor.onChange();
             return;
           }
-          (options == null ? void 0 : options.mode) === "blocks" && (debug$6("Deleting blocks touched by selection"), Transforms.removeNodes(editor, {
+          options?.mode === "blocks" && (debug$6("Deleting blocks touched by selection"), Transforms.removeNodes(editor, {
             at: range,
             voids: !0,
             match: (node) => editor.isTextBlock(node) || !editor.isTextBlock(node) && Element$1.isElement(node)
-          })), (options == null ? void 0 : options.mode) === "children" && (debug$6("Deleting children touched by selection"), Transforms.removeNodes(editor, {
+          })), options?.mode === "children" && (debug$6("Deleting children touched by selection"), Transforms.removeNodes(editor, {
             at: range,
             voids: !0,
             match: (node) => node._type === types.span.name || // Text children
@@ -5011,26 +4789,15 @@ function isAnnotationActive({
       at: editor.selection,
       match: (node) => Text.isText(node)
     })];
-    if (spans.length === 0 || spans.some(([span]) => {
-      var _a;
-      return !isPortableTextSpan$1(span) || !span.marks || ((_a = span.marks) == null ? void 0 : _a.length) === 0;
-    })) return !1;
+    if (spans.length === 0 || spans.some(([span]) => !isPortableTextSpan$1(span) || !span.marks || span.marks?.length === 0)) return !1;
     const selectionMarkDefs = spans.reduce((accMarkDefs, [, path]) => {
       const [block] = Editor.node(editor, path, {
         depth: 1
       });
       return editor.isTextBlock(block) && block.markDefs ? [...accMarkDefs, ...block.markDefs] : accMarkDefs;
     }, []);
-    return spans.every(([span]) => {
-      var _a;
-      if (!isPortableTextSpan$1(span)) return !1;
-      const spanMarkDefs = (_a = span.marks) == null ? void 0 : _a.map((markKey) => {
-        var _a2;
-        return (_a2 = selectionMarkDefs.find((def) => (def == null ? void 0 : def._key) === markKey)) == null ? void 0 : _a2._type;
-      });
-      return spanMarkDefs == null ? void 0 : spanMarkDefs.includes(annotation.name);
-    });
-  } catch (e) {
+    return spans.every(([span]) => isPortableTextSpan$1(span) ? span.marks?.map((markKey) => selectionMarkDefs.find((def) => def?._key === markKey)?._type)?.includes(annotation.name) : !1);
+  } catch {
     return !1;
   }
 }
@@ -5038,7 +4805,6 @@ const addAnnotationActionImplementation = ({
   context,
   action
 }) => {
-  var _a, _b;
   const editor = action.editor, {
     selection: originalSelection
   } = editor;
@@ -5056,12 +4822,13 @@ const addAnnotationActionImplementation = ({
     for (const [block, blockPath] of selectedBlocks) {
       if (block.children.length === 0 || block.children.length === 1 && block.children[0].text === "")
         continue;
-      const annotationKey = context.keyGenerator(), markDefs = (_a = block.markDefs) != null ? _a : [];
+      const annotationKey = context.keyGenerator(), markDefs = block.markDefs ?? [];
       markDefs.find((markDef) => markDef._type === action.annotation.name && markDef._key === annotationKey) === void 0 && (Transforms.setNodes(editor, {
-        markDefs: [...markDefs, __spreadValues$c({
+        markDefs: [...markDefs, {
           _type: action.annotation.name,
-          _key: annotationKey
-        }, action.annotation.value)]
+          _key: annotationKey,
+          ...action.annotation.value
+        }]
       }, {
         at: blockPath
       }), markDefPath = [{
@@ -5076,7 +4843,7 @@ const addAnnotationActionImplementation = ({
       for (const [span, path] of children) {
         if (!editor.isTextSpan(span) || !Range.includes(editor.selection, path))
           continue;
-        const marks = (_b = span.marks) != null ? _b : [], existingSameTypeAnnotations = marks.filter((mark) => markDefs.some((markDef) => markDef._key === mark && markDef._type === action.annotation.name));
+        const marks = span.marks ?? [], existingSameTypeAnnotations = marks.filter((mark) => markDefs.some((markDef) => markDef._key === mark && markDef._type === action.annotation.name));
         Transforms.setNodes(editor, {
           marks: [...marks.filter((mark) => !existingSameTypeAnnotations.includes(mark)), annotationKey]
         }, {
@@ -5098,7 +4865,6 @@ const addAnnotationActionImplementation = ({
 }, removeAnnotationActionImplementation = ({
   action
 }) => {
-  var _a, _b, _c, _d, _e, _f, _g;
   const editor = action.editor;
   if (debug$6("Removing annotation", action.annotation.name), !!editor.selection)
     if (Range.isCollapsed(editor.selection)) {
@@ -5107,12 +4873,12 @@ const addAnnotationActionImplementation = ({
       });
       if (!editor.isTextBlock(block))
         return;
-      const potentialAnnotations = ((_a = block.markDefs) != null ? _a : []).filter((markDef) => markDef._type === action.annotation.name), [selectedChild, selectedChildPath] = Editor.node(editor, editor.selection, {
+      const potentialAnnotations = (block.markDefs ?? []).filter((markDef) => markDef._type === action.annotation.name), [selectedChild, selectedChildPath] = Editor.node(editor, editor.selection, {
         depth: 2
       });
       if (!editor.isTextSpan(selectedChild))
         return;
-      const annotationToRemove = (_b = selectedChild.marks) == null ? void 0 : _b.find((mark) => potentialAnnotations.some((markDef) => markDef._key === mark));
+      const annotationToRemove = selectedChild.marks?.find((mark) => potentialAnnotations.some((markDef) => markDef._key === mark));
       if (!annotationToRemove)
         return;
       const previousSpansWithSameAnnotation = [];
@@ -5120,20 +4886,20 @@ const addAnnotationActionImplementation = ({
         reverse: !0
       }))
         if (editor.isTextSpan(child) && Path.isBefore(childPath, selectedChildPath))
-          if ((_c = child.marks) != null && _c.includes(annotationToRemove))
+          if (child.marks?.includes(annotationToRemove))
             previousSpansWithSameAnnotation.push([child, childPath]);
           else
             break;
       const nextSpansWithSameAnnotation = [];
       for (const [child, childPath] of Node.children(editor, blockPath))
         if (editor.isTextSpan(child) && Path.isAfter(childPath, selectedChildPath))
-          if ((_d = child.marks) != null && _d.includes(annotationToRemove))
+          if (child.marks?.includes(annotationToRemove))
             nextSpansWithSameAnnotation.push([child, childPath]);
           else
             break;
       for (const [child, childPath] of [...previousSpansWithSameAnnotation, [selectedChild, selectedChildPath], ...nextSpansWithSameAnnotation])
         Transforms.setNodes(editor, {
-          marks: (_e = child.marks) == null ? void 0 : _e.filter((mark) => mark !== annotationToRemove)
+          marks: child.marks?.filter((mark) => mark !== annotationToRemove)
         }, {
           at: childPath
         });
@@ -5152,10 +4918,7 @@ const addAnnotationActionImplementation = ({
         for (const [child, childPath] of children) {
           if (!editor.isTextSpan(child) || !Range.includes(editor.selection, childPath))
             continue;
-          const markDefs = (_f = block.markDefs) != null ? _f : [], marks = (_g = child.marks) != null ? _g : [], marksWithoutAnnotation = marks.filter((mark) => {
-            const markDef = markDefs.find((markDef2) => markDef2._key === mark);
-            return (markDef == null ? void 0 : markDef._type) !== action.annotation.name;
-          });
+          const markDefs = block.markDefs ?? [], marks = child.marks ?? [], marksWithoutAnnotation = marks.filter((mark) => markDefs.find((markDef2) => markDef2._key === mark)?._type !== action.annotation.name);
           marksWithoutAnnotation.length !== marks.length && Transforms.setNodes(editor, {
             marks: marksWithoutAnnotation
           }, {
@@ -5198,12 +4961,11 @@ function insertBlock({
   editor,
   schema
 }) {
-  var _a;
   if (editor.selection) {
-    const [focusBlock, focusBlockPath] = (_a = Array.from(Editor.nodes(editor, {
+    const [focusBlock, focusBlockPath] = Array.from(Editor.nodes(editor, {
       at: editor.selection.focus.path.slice(0, 1),
       match: (n) => !Editor.isEditor(n)
-    }))[0]) != null ? _a : [void 0, void 0];
+    }))[0] ?? [void 0, void 0];
     if (placement === "after") {
       const nextPath = [focusBlockPath[0] + 1];
       Transforms.insertNodes(editor, block, {
@@ -5235,22 +4997,15 @@ function insertBlock({
     });
   }
 }
-var __defProp$b = Object.defineProperty, __getOwnPropSymbols$b = Object.getOwnPropertySymbols, __hasOwnProp$b = Object.prototype.hasOwnProperty, __propIsEnum$b = Object.prototype.propertyIsEnumerable, __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$b = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$b.call(b, prop) && __defNormalProp$b(a, prop, b[prop]);
-  if (__getOwnPropSymbols$b)
-    for (var prop of __getOwnPropSymbols$b(b))
-      __propIsEnum$b.call(b, prop) && __defNormalProp$b(a, prop, b[prop]);
-  return a;
-};
 const insertBlockObjectActionImplementation = ({
   context,
   action
 }) => {
-  const block = toSlateValue([__spreadValues$b({
+  const block = toSlateValue([{
     _key: context.keyGenerator(),
-    _type: action.blockObject.name
-  }, action.blockObject.value ? action.blockObject.value : {})], {
+    _type: action.blockObject.name,
+    ...action.blockObject.value ? action.blockObject.value : {}
+  }], {
     schemaTypes: context.schema
   })[0];
   insertBlock({
@@ -5259,29 +5014,19 @@ const insertBlockObjectActionImplementation = ({
     editor: action.editor,
     schema: context.schema
   });
-};
-var __defProp$a = Object.defineProperty, __defProps$6 = Object.defineProperties, __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$a = Object.getOwnPropertySymbols, __hasOwnProp$a = Object.prototype.hasOwnProperty, __propIsEnum$a = Object.prototype.propertyIsEnumerable, __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$a = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$a.call(b, prop) && __defNormalProp$a(a, prop, b[prop]);
-  if (__getOwnPropSymbols$a)
-    for (var prop of __getOwnPropSymbols$a(b))
-      __propIsEnum$a.call(b, prop) && __defNormalProp$a(a, prop, b[prop]);
-  return a;
-}, __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
-const insertBreakActionImplementation = ({
+}, insertBreakActionImplementation = ({
   context,
   action
 }) => {
-  var _a, _b, _c, _d, _e;
   const keyGenerator = context.keyGenerator, schema = context.schema, editor = action.editor;
   if (!editor.selection)
     return;
-  const [focusSpan] = (_a = Array.from(Editor.nodes(editor, {
+  const [focusSpan] = Array.from(Editor.nodes(editor, {
     mode: "lowest",
     at: editor.selection.focus,
     match: (n) => editor.isTextSpan(n),
     voids: !1
-  }))[0]) != null ? _a : [void 0], focusDecorators = (_c = (_b = focusSpan == null ? void 0 : focusSpan.marks) == null ? void 0 : _b.filter((mark) => schema.decorators.some((decorator) => decorator.value === mark))) != null ? _c : [], focusAnnotations = (_e = (_d = focusSpan == null ? void 0 : focusSpan.marks) == null ? void 0 : _d.filter((mark) => !schema.decorators.some((decorator) => decorator.value === mark))) != null ? _e : [], anchorBlockPath = editor.selection.anchor.path.slice(0, 1), focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = Node.descendant(editor, focusBlockPath);
+  }))[0] ?? [void 0], focusDecorators = focusSpan?.marks?.filter((mark) => schema.decorators.some((decorator) => decorator.value === mark)) ?? [], focusAnnotations = focusSpan?.marks?.filter((mark) => !schema.decorators.some((decorator) => decorator.value === mark)) ?? [], anchorBlockPath = editor.selection.anchor.path.slice(0, 1), focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = Node.descendant(editor, focusBlockPath);
   if (editor.isTextBlock(focusBlock)) {
     const [start, end] = Range.edges(editor.selection), lastFocusBlockChild = focusBlock.children[focusBlock.children.length - 1], atTheEndOfBlock = isEqual(start, {
       path: [...focusBlockPath, focusBlock.children.length - 1],
@@ -5320,7 +5065,6 @@ const insertBreakActionImplementation = ({
     const selectionAcrossBlocks = anchorBlockPath[0] !== focusBlockPath[0];
     if (!atTheStartOfBlock && !atTheEndOfBlock && !selectionAcrossBlocks) {
       Editor.withoutNormalizing(editor, () => {
-        var _a2;
         if (!editor.selection)
           return;
         Transforms.splitNodes(editor, {
@@ -5343,28 +5087,20 @@ const insertBreakActionImplementation = ({
           for (const [child, childPath] of children) {
             if (!editor.isTextSpan(child))
               continue;
-            const marks = (_a2 = child.marks) != null ? _a2 : [];
+            const marks = child.marks ?? [];
             for (const mark of marks)
-              schema.decorators.some((decorator) => decorator.value === mark) || prevNodeSpans.some((prevNodeSpan) => {
-                var _a3;
-                return (_a3 = prevNodeSpan.marks) == null ? void 0 : _a3.includes(mark);
-              }) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(mark, keyGenerator());
-            const newMarks = marks.map((mark) => {
-              var _a3;
-              return (_a3 = newMarkDefKeys.get(mark)) != null ? _a3 : mark;
-            });
+              schema.decorators.some((decorator) => decorator.value === 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(marks, newMarks) || Transforms.setNodes(editor, {
               marks: newMarks
             }, {
               at: childPath
             });
           }
-          const newMarkDefs = nextNode.markDefs.map((markDef) => {
-            var _a3;
-            return __spreadProps$6(__spreadValues$a({}, markDef), {
-              _key: (_a3 = newMarkDefKeys.get(markDef._key)) != null ? _a3 : markDef._key
-            });
-          });
+          const newMarkDefs = nextNode.markDefs.map((markDef) => ({
+            ...markDef,
+            _key: newMarkDefKeys.get(markDef._key) ?? markDef._key
+          }));
           isEqual(nextNode.markDefs, newMarkDefs) || Transforms.setNodes(editor, {
             markDefs: newMarkDefs
           }, {
@@ -5385,24 +5121,15 @@ const insertBreakActionImplementation = ({
 }) => {
   insertBreakActionImplementation({
     context,
-    action: __spreadProps$6(__spreadValues$a({}, action), {
+    action: {
+      ...action,
       type: "insert.break"
-    })
+    }
   });
-};
-var __defProp$9 = Object.defineProperty, __getOwnPropSymbols$9 = Object.getOwnPropertySymbols, __hasOwnProp$9 = Object.prototype.hasOwnProperty, __propIsEnum$9 = Object.prototype.propertyIsEnumerable, __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$9 = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$9.call(b, prop) && __defNormalProp$9(a, prop, b[prop]);
-  if (__getOwnPropSymbols$9)
-    for (var prop of __getOwnPropSymbols$9(b))
-      __propIsEnum$9.call(b, prop) && __defNormalProp$9(a, prop, b[prop]);
-  return a;
-};
-const insertInlineObjectActionImplementation = ({
+}, insertInlineObjectActionImplementation = ({
   context,
   action
 }) => {
-  var _a, _b;
   if (!context.schema.inlineObjects.some((inlineObject) => inlineObject.name === action.inlineObject.name)) {
     console.error("Unable to insert unknown inline object");
     return;
@@ -5411,77 +5138,60 @@ const insertInlineObjectActionImplementation = ({
     console.error("Unable to insert inline object without selection");
     return;
   }
-  const [focusTextBlock] = (_a = Array.from(Editor.nodes(action.editor, {
+  const [focusTextBlock] = Array.from(Editor.nodes(action.editor, {
     at: action.editor.selection.focus.path,
     match: (node) => action.editor.isTextBlock(node)
-  })).at(0)) != null ? _a : [void 0, void 0];
+  })).at(0) ?? [void 0, void 0];
   if (!focusTextBlock) {
     console.error("Unable to perform action without focus text block");
     return;
   }
-  const block = toSlateValue([{
+  const child = toSlateValue([{
     _type: context.schema.block.name,
     _key: context.keyGenerator(),
-    children: [__spreadValues$9({
+    children: [{
       _type: action.inlineObject.name,
-      _key: context.keyGenerator()
-    }, (_b = action.inlineObject.value) != null ? _b : {})]
+      _key: context.keyGenerator(),
+      ...action.inlineObject.value ?? {}
+    }]
   }], {
     schemaTypes: context.schema
-  }).at(0), child = block == null ? void 0 : block.children.at(0);
+  }).at(0)?.children.at(0);
   if (!child) {
     console.error("Unable to insert inline object");
     return;
   }
   Transforms.insertNodes(action.editor, child);
-};
-var __defProp$8 = Object.defineProperty, __getOwnPropSymbols$8 = Object.getOwnPropertySymbols, __hasOwnProp$8 = Object.prototype.hasOwnProperty, __propIsEnum$8 = Object.prototype.propertyIsEnumerable, __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$8 = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$8.call(b, prop) && __defNormalProp$8(a, prop, b[prop]);
-  if (__getOwnPropSymbols$8)
-    for (var prop of __getOwnPropSymbols$8(b))
-      __propIsEnum$8.call(b, prop) && __defNormalProp$8(a, prop, b[prop]);
-  return a;
-};
-const insertSpanActionImplementation = ({
+}, insertSpanActionImplementation = ({
   context,
   action
 }) => {
-  var _a, _b, _c, _d;
   if (!action.editor.selection) {
     console.error("Unable to perform action without selection", action);
     return;
   }
-  const [focusBlock, focusBlockPath] = (_a = Array.from(Editor.nodes(action.editor, {
+  const [focusBlock, focusBlockPath] = Array.from(Editor.nodes(action.editor, {
     at: action.editor.selection.focus.path,
     match: (node) => action.editor.isTextBlock(node)
-  }))[0]) != null ? _a : [void 0, void 0];
+  }))[0] ?? [void 0, void 0];
   if (!focusBlock || !focusBlockPath) {
     console.error("Unable to perform action without focus block", action);
     return;
   }
-  const markDefs = (_b = focusBlock.markDefs) != null ? _b : [], annotations = action.annotations ? action.annotations.map((annotation) => __spreadValues$8({
+  const markDefs = focusBlock.markDefs ?? [], annotations = action.annotations ? action.annotations.map((annotation) => ({
     _type: annotation.name,
-    _key: context.keyGenerator()
-  }, annotation.value)) : void 0;
+    _key: context.keyGenerator(),
+    ...annotation.value
+  })) : void 0;
   annotations && annotations.length > 0 && Transforms.setNodes(action.editor, {
     markDefs: [...markDefs, ...annotations]
   }), Transforms.insertNodes(action.editor, {
     _type: "span",
     _key: context.keyGenerator(),
     text: action.text,
-    marks: [...(_c = annotations == null ? void 0 : annotations.map((annotation) => annotation._key)) != null ? _c : [], ...(_d = action.decorators) != null ? _d : []]
+    marks: [...annotations?.map((annotation) => annotation._key) ?? [], ...action.decorators ?? []]
   });
-};
-var __defProp$7 = Object.defineProperty, __getOwnPropSymbols$7 = Object.getOwnPropertySymbols, __hasOwnProp$7 = Object.prototype.hasOwnProperty, __propIsEnum$7 = Object.prototype.propertyIsEnumerable, __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$7 = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$7.call(b, prop) && __defNormalProp$7(a, prop, b[prop]);
-  if (__getOwnPropSymbols$7)
-    for (var prop of __getOwnPropSymbols$7(b))
-      __propIsEnum$7.call(b, prop) && __defNormalProp$7(a, prop, b[prop]);
-  return a;
-};
-const textBlockSetActionImplementation = ({
+}, textBlockSetActionImplementation = ({
   action
 }) => {
   const at = toSlateRange({
@@ -5494,13 +5204,17 @@ const textBlockSetActionImplementation = ({
       offset: 0
     }
   }, action.editor);
-  Transforms.setNodes(action.editor, __spreadValues$7(__spreadValues$7(__spreadValues$7({}, action.style ? {
-    style: action.style
-  } : {}), action.listItem ? {
-    listItem: action.listItem
-  } : {}), action.level ? {
-    level: action.level
-  } : {}), {
+  Transforms.setNodes(action.editor, {
+    ...action.style ? {
+      style: action.style
+    } : {},
+    ...action.listItem ? {
+      listItem: action.listItem
+    } : {},
+    ...action.level ? {
+      level: action.level
+    } : {}
+  }, {
     at
   });
 }, textBlockUnsetActionImplementation = ({
@@ -5519,16 +5233,7 @@ const textBlockSetActionImplementation = ({
   Transforms.unsetNodes(action.editor, action.props, {
     at
   });
-};
-var __defProp$6 = Object.defineProperty, __defProps$5 = Object.defineProperties, __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$6 = Object.getOwnPropertySymbols, __hasOwnProp$6 = Object.prototype.hasOwnProperty, __propIsEnum$6 = Object.prototype.propertyIsEnumerable, __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$6 = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$6.call(b, prop) && __defNormalProp$6(a, prop, b[prop]);
-  if (__getOwnPropSymbols$6)
-    for (var prop of __getOwnPropSymbols$6(b))
-      __propIsEnum$6.call(b, prop) && __defNormalProp$6(a, prop, b[prop]);
-  return a;
-}, __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
-const behaviorActionImplementations = {
+}, behaviorActionImplementations = {
   "annotation.add": addAnnotationActionImplementation,
   "annotation.remove": removeAnnotationActionImplementation,
   "annotation.toggle": toggleAnnotationActionImplementation,
@@ -5617,15 +5322,15 @@ const behaviorActionImplementations = {
     context,
     action
   }) => {
-    var _a, _b, _c, _d;
     const block = toSlateValue([{
       _key: context.keyGenerator(),
       _type: context.schema.block.name,
-      style: (_a = context.schema.styles[0].value) != null ? _a : "normal",
+      style: context.schema.styles[0].value ?? "normal",
       markDefs: [],
-      children: (_d = (_c = (_b = action.textBlock) == null ? void 0 : _b.children) == null ? void 0 : _c.map((child) => __spreadProps$5(__spreadValues$6({}, child), {
+      children: action.textBlock?.children?.map((child) => ({
+        ...child,
         _key: context.keyGenerator()
-      }))) != null ? _d : [{
+      })) ?? [{
         _type: context.schema.span.name,
         _key: context.keyGenerator(),
         text: ""
@@ -5718,7 +5423,11 @@ const behaviorActionImplementations = {
     action
   }) => {
     const selection = action.editor.selection;
-    selection && (Transforms.select(action.editor, __spreadValues$6({}, selection)), action.editor.selection = __spreadValues$6({}, selection));
+    selection && (Transforms.select(action.editor, {
+      ...selection
+    }), action.editor.selection = {
+      ...selection
+    });
   },
   "style.toggle": toggleStyleActionImplementation,
   "style.add": addStyleActionImplementation,
@@ -5990,30 +5699,15 @@ function performDefaultAction({
       });
   }
 }
-var __defProp$5 = Object.defineProperty, __getOwnPropSymbols$5 = Object.getOwnPropertySymbols, __hasOwnProp$5 = Object.prototype.hasOwnProperty, __propIsEnum$5 = Object.prototype.propertyIsEnumerable, __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$5 = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$5.call(b, prop) && __defNormalProp$5(a, prop, b[prop]);
-  if (__getOwnPropSymbols$5)
-    for (var prop of __getOwnPropSymbols$5(b))
-      __propIsEnum$5.call(b, prop) && __defNormalProp$5(a, prop, b[prop]);
-  return a;
-};
 function getActiveDecorators({
   schema,
   slateEditorInstance
 }) {
-  var _a, _b;
   const decorators = schema.decorators.map((decorator) => decorator.value);
-  return ((_b = __spreadValues$5({}, (_a = Editor.marks(slateEditorInstance)) != null ? _a : {}).marks) != null ? _b : []).filter((mark) => decorators.includes(mark));
-}
-var __defProp$4 = Object.defineProperty, __defProps$4 = Object.defineProperties, __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$4 = Object.getOwnPropertySymbols, __hasOwnProp$4 = Object.prototype.hasOwnProperty, __propIsEnum$4 = Object.prototype.propertyIsEnumerable, __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$4 = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$4.call(b, prop) && __defNormalProp$4(a, prop, b[prop]);
-  if (__getOwnPropSymbols$4)
-    for (var prop of __getOwnPropSymbols$4(b))
-      __propIsEnum$4.call(b, prop) && __defNormalProp$4(a, prop, b[prop]);
-  return a;
-}, __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
+  return ({
+    ...Editor.marks(slateEditorInstance) ?? {}
+  }.marks ?? []).filter((mark) => decorators.includes(mark));
+}
 const editorMachine = setup({
   types: {
     context: {},
@@ -6068,11 +5762,11 @@ const editorMachine = setup({
       event,
       enqueue
     }) => {
-      var _a;
       assertEvent(event, ["behavior event"]);
-      const defaultAction = event.behaviorEvent.type === "copy" || event.behaviorEvent.type === "key.down" || event.behaviorEvent.type === "key.up" || event.behaviorEvent.type === "paste" ? void 0 : __spreadProps$4(__spreadValues$4({}, event.behaviorEvent), {
+      const defaultAction = event.behaviorEvent.type === "copy" || event.behaviorEvent.type === "key.down" || event.behaviorEvent.type === "key.up" || event.behaviorEvent.type === "paste" ? void 0 : {
+        ...event.behaviorEvent,
         editor: event.editor
-      }), eventBehaviors = context.behaviors.filter((behavior) => behavior.on === event.behaviorEvent.type);
+      }, eventBehaviors = context.behaviors.filter((behavior) => behavior.on === event.behaviorEvent.type);
       if (eventBehaviors.length === 0) {
         if (!defaultAction)
           return;
@@ -6112,7 +5806,7 @@ const editorMachine = setup({
             actionIntends
           });
         if (behaviorOverwritten) {
-          (_a = event.nativeEvent) == null || _a.preventDefault();
+          event.nativeEvent?.preventDefault();
           break;
         }
       }
@@ -6131,19 +5825,16 @@ const editorMachine = setup({
   id: "editor",
   context: ({
     input
-  }) => {
-    var _a, _b;
-    return {
-      behaviors: (_a = input.behaviors) != null ? _a : coreBehaviors,
-      keyGenerator: input.keyGenerator,
-      pendingEvents: [],
-      schema: input.schema,
-      selection: null,
-      initialReadOnly: (_b = input.readOnly) != null ? _b : !1,
-      maxBlocks: input.maxBlocks,
-      value: input.value
-    };
-  },
+  }) => ({
+    behaviors: input.behaviors ?? coreBehaviors,
+    keyGenerator: input.keyGenerator,
+    pendingEvents: [],
+    schema: input.schema,
+    selection: null,
+    initialReadOnly: input.readOnly ?? !1,
+    maxBlocks: input.maxBlocks,
+    value: input.value
+  }),
   on: {
     unset: {
       actions: emit(({
@@ -6226,9 +5917,10 @@ const editorMachine = setup({
       }) => {
         Editor.withoutNormalizing(event.editor, () => {
           for (const actionIntend of event.actionIntends) {
-            const action = __spreadProps$4(__spreadValues$4({}, actionIntend), {
+            const action = {
+              ...actionIntend,
               editor: event.editor
-            });
+            };
             performAction({
               context,
               action
@@ -6443,10 +6135,9 @@ function useCreateEditor(config) {
   return $[4] !== editorActor ? (t3 = createEditorFromActor(editorActor), $[4] = editorActor, $[5] = t3) : t3 = $[5], t2 = t3, t2;
 }
 function editorConfigToMachineInput(config) {
-  var _a;
   return {
     behaviors: config.behaviors,
-    keyGenerator: (_a = config.keyGenerator) != null ? _a : defaultKeyGenerator,
+    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)),
@@ -6496,16 +6187,13 @@ function PortableTextEditorSelectionProvider(props) {
   let t2;
   return $[3] !== props.children || $[4] !== selection ? (t2 = /* @__PURE__ */ jsx(PortableTextEditorSelectionContext.Provider, { value: selection, children: props.children }), $[3] = props.children, $[4] = selection, $[5] = t2) : t2 = $[5], t2;
 }
-var __defProp$3 = Object.defineProperty, __defProps$3 = Object.defineProperties, __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$3 = Object.getOwnPropertySymbols, __hasOwnProp$3 = Object.prototype.hasOwnProperty, __propIsEnum$3 = Object.prototype.propertyIsEnumerable, __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$3 = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$3.call(b, prop) && __defNormalProp$3(a, prop, b[prop]);
-  if (__getOwnPropSymbols$3)
-    for (var prop of __getOwnPropSymbols$3(b))
-      __propIsEnum$3.call(b, prop) && __defNormalProp$3(a, prop, b[prop]);
-  return a;
-}, __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b)), __publicField = (obj, key, value) => __defNormalProp$3(obj, typeof key != "symbol" ? key + "" : key, value);
 const debug$4 = debugWithName("component:PortableTextEditor");
 class PortableTextEditor extends Component {
+  static displayName = "PortableTextEditor";
+  /**
+   * An observable of all the editor changes.
+   */
+  change$ = new Subject();
   /**
    * A lookup table for all the relevant schema types for this portable text type.
    */
@@ -6516,11 +6204,8 @@ class PortableTextEditor extends Component {
    * The editor API (currently implemented with Slate).
    */
   constructor(props) {
-    var _a;
-    super(props), __publicField(this, "change$", new Subject()), __publicField(this, "setEditable", (editable) => {
-      this.editor._internal.editable = __spreadValues$3(__spreadValues$3({}, this.editor._internal.editable), editable);
-    }), props.editor ? this.editor = props.editor : this.editor = createEditor({
-      keyGenerator: (_a = props.keyGenerator) != null ? _a : defaultKeyGenerator,
+    super(props), props.editor ? this.editor = props.editor : this.editor = createEditor({
+      keyGenerator: props.keyGenerator ?? defaultKeyGenerator,
       schema: props.schemaType,
       initialValue: props.value,
       maxBlocks: props.maxBlocks === void 0 ? void 0 : Number.parseInt(props.maxBlocks.toString(), 10),
@@ -6528,13 +6213,12 @@ class PortableTextEditor extends Component {
     }), this.schemaTypes = this.editor._internal.editorActor.getSnapshot().context.schema, this.editable = this.editor._internal.editable;
   }
   componentDidUpdate(prevProps) {
-    var _a;
     !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({
       type: "update schema",
       schema: this.schemaTypes
     })), !this.props.editor && !prevProps.editor && (this.props.readOnly !== prevProps.readOnly && this.editor._internal.editorActor.send({
       type: "update readOnly",
-      readOnly: (_a = this.props.readOnly) != null ? _a : !1
+      readOnly: this.props.readOnly ?? !1
     }), this.props.maxBlocks !== prevProps.maxBlocks && this.editor._internal.editorActor.send({
       type: "update maxBlocks",
       maxBlocks: this.props.maxBlocks === void 0 ? void 0 : Number.parseInt(this.props.maxBlocks.toString(), 10)
@@ -6543,9 +6227,14 @@ class PortableTextEditor extends Component {
       value: this.props.value
     }), this.props.editorRef !== prevProps.editorRef && this.props.editorRef && (this.props.editorRef.current = this));
   }
+  setEditable = (editable) => {
+    this.editor._internal.editable = {
+      ...this.editor._internal.editable,
+      ...editable
+    };
+  };
   render() {
-    var _a;
-    const legacyPatches = this.props.editor ? void 0 : (_a = this.props.incomingPatches$) != null ? _a : this.props.patches$;
+    const legacyPatches = this.props.editor ? void 0 : this.props.incomingPatches$ ?? this.props.patches$;
     return /* @__PURE__ */ jsxs(Fragment, { children: [
       legacyPatches ? /* @__PURE__ */ jsx(RoutePatchesObservableToEditorActor, { editorActor: this.editor._internal.editorActor, patches$: legacyPatches }) : null,
       /* @__PURE__ */ jsx(RouteEventsToChanges, { editorActor: this.editor._internal.editorActor, onChange: (change) => {
@@ -6555,105 +6244,65 @@ class PortableTextEditor extends Component {
       /* @__PURE__ */ jsx(EditorActorContext.Provider, { value: this.editor._internal.editorActor, children: /* @__PURE__ */ jsx(Slate, { editor: this.editor._internal.slateEditor.instance, initialValue: this.editor._internal.slateEditor.initialValue, children: /* @__PURE__ */ jsx(PortableTextEditorContext.Provider, { value: this, children: /* @__PURE__ */ jsx(PortableTextEditorSelectionProvider, { editorActor: this.editor._internal.editorActor, children: this.props.children }) }) }) })
     ] });
   }
+  // Static API methods
+  static activeAnnotations = (editor) => editor && editor.editable ? editor.editable.activeAnnotations() : [];
+  static isAnnotationActive = (editor, annotationType) => editor && editor.editable ? editor.editable.isAnnotationActive(annotationType) : !1;
+  static addAnnotation = (editor, type, value) => editor.editable?.addAnnotation(type, value);
+  static blur = (editor) => {
+    debug$4("Host blurred"), editor.editable?.blur();
+  };
+  static delete = (editor, selection, options) => editor.editable?.delete(selection, options);
+  static findDOMNode = (editor, element) => editor.editable?.findDOMNode(element);
+  static findByPath = (editor, path) => editor.editable?.findByPath(path) || [];
+  static focus = (editor) => {
+    debug$4("Host requesting focus"), editor.editable?.focus();
+  };
+  static focusBlock = (editor) => editor.editable?.focusBlock();
+  static focusChild = (editor) => editor.editable?.focusChild();
+  static getSelection = (editor) => editor.editable ? editor.editable.getSelection() : null;
+  static getValue = (editor) => editor.editable?.getValue();
+  static hasBlockStyle = (editor, blockStyle) => editor.editable?.hasBlockStyle(blockStyle);
+  static hasListStyle = (editor, listStyle) => editor.editable?.hasListStyle(listStyle);
+  static isCollapsedSelection = (editor) => editor.editable?.isCollapsedSelection();
+  static isExpandedSelection = (editor) => editor.editable?.isExpandedSelection();
+  static isMarkActive = (editor, mark) => editor.editable?.isMarkActive(mark);
+  static insertChild = (editor, type, value) => (debug$4("Host inserting child"), editor.editable?.insertChild(type, value));
+  static insertBlock = (editor, type, value) => editor.editable?.insertBlock(type, value);
+  static insertBreak = (editor) => editor.editable?.insertBreak();
+  static isVoid = (editor, element) => editor.editable?.isVoid(element);
+  static isObjectPath = (_editor, path) => {
+    if (!path || !Array.isArray(path)) return !1;
+    const isChildObjectEditPath = path.length > 3 && path[1] === "children";
+    return path.length > 1 && path[1] !== "children" || isChildObjectEditPath;
+  };
+  static marks = (editor) => editor.editable?.marks();
+  static select = (editor, selection) => {
+    debug$4("Host setting selection", selection), editor.editable?.select(selection);
+  };
+  static removeAnnotation = (editor, type) => editor.editable?.removeAnnotation(type);
+  static toggleBlockStyle = (editor, blockStyle) => (debug$4("Host is toggling block style"), editor.editable?.toggleBlockStyle(blockStyle));
+  static toggleList = (editor, listStyle) => editor.editable?.toggleList(listStyle);
+  static toggleMark = (editor, mark) => {
+    debug$4("Host toggling mark", mark), editor.editable?.toggleMark(mark);
+  };
+  static getFragment = (editor) => (debug$4("Host getting fragment"), editor.editable?.getFragment());
+  static undo = (editor) => {
+    debug$4("Host undoing"), editor.editable?.undo();
+  };
+  static redo = (editor) => {
+    debug$4("Host redoing"), editor.editable?.redo();
+  };
+  static isSelectionsOverlapping = (editor, selectionA, selectionB) => editor.editable?.isSelectionsOverlapping(selectionA, selectionB);
 }
-__publicField(PortableTextEditor, "displayName", "PortableTextEditor"), // Static API methods
-__publicField(PortableTextEditor, "activeAnnotations", (editor) => editor && editor.editable ? editor.editable.activeAnnotations() : []), __publicField(PortableTextEditor, "isAnnotationActive", (editor, annotationType) => editor && editor.editable ? editor.editable.isAnnotationActive(annotationType) : !1), __publicField(PortableTextEditor, "addAnnotation", (editor, type, value) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.addAnnotation(type, value);
-}), __publicField(PortableTextEditor, "blur", (editor) => {
-  var _a;
-  debug$4("Host blurred"), (_a = editor.editable) == null || _a.blur();
-}), __publicField(PortableTextEditor, "delete", (editor, selection, options) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.delete(selection, options);
-}), __publicField(PortableTextEditor, "findDOMNode", (editor, element) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.findDOMNode(element);
-}), __publicField(PortableTextEditor, "findByPath", (editor, path) => {
-  var _a;
-  return ((_a = editor.editable) == null ? void 0 : _a.findByPath(path)) || [];
-}), __publicField(PortableTextEditor, "focus", (editor) => {
-  var _a;
-  debug$4("Host requesting focus"), (_a = editor.editable) == null || _a.focus();
-}), __publicField(PortableTextEditor, "focusBlock", (editor) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.focusBlock();
-}), __publicField(PortableTextEditor, "focusChild", (editor) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.focusChild();
-}), __publicField(PortableTextEditor, "getSelection", (editor) => editor.editable ? editor.editable.getSelection() : null), __publicField(PortableTextEditor, "getValue", (editor) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.getValue();
-}), __publicField(PortableTextEditor, "hasBlockStyle", (editor, blockStyle) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.hasBlockStyle(blockStyle);
-}), __publicField(PortableTextEditor, "hasListStyle", (editor, listStyle) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.hasListStyle(listStyle);
-}), __publicField(PortableTextEditor, "isCollapsedSelection", (editor) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.isCollapsedSelection();
-}), __publicField(PortableTextEditor, "isExpandedSelection", (editor) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.isExpandedSelection();
-}), __publicField(PortableTextEditor, "isMarkActive", (editor, mark) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.isMarkActive(mark);
-}), __publicField(PortableTextEditor, "insertChild", (editor, type, value) => {
-  var _a;
-  return debug$4("Host inserting child"), (_a = editor.editable) == null ? void 0 : _a.insertChild(type, value);
-}), __publicField(PortableTextEditor, "insertBlock", (editor, type, value) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.insertBlock(type, value);
-}), __publicField(PortableTextEditor, "insertBreak", (editor) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.insertBreak();
-}), __publicField(PortableTextEditor, "isVoid", (editor, element) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.isVoid(element);
-}), __publicField(PortableTextEditor, "isObjectPath", (_editor, path) => {
-  if (!path || !Array.isArray(path)) return !1;
-  const isChildObjectEditPath = path.length > 3 && path[1] === "children";
-  return path.length > 1 && path[1] !== "children" || isChildObjectEditPath;
-}), __publicField(PortableTextEditor, "marks", (editor) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.marks();
-}), __publicField(PortableTextEditor, "select", (editor, selection) => {
-  var _a;
-  debug$4("Host setting selection", selection), (_a = editor.editable) == null || _a.select(selection);
-}), __publicField(PortableTextEditor, "removeAnnotation", (editor, type) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.removeAnnotation(type);
-}), __publicField(PortableTextEditor, "toggleBlockStyle", (editor, blockStyle) => {
-  var _a;
-  return debug$4("Host is toggling block style"), (_a = editor.editable) == null ? void 0 : _a.toggleBlockStyle(blockStyle);
-}), __publicField(PortableTextEditor, "toggleList", (editor, listStyle) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.toggleList(listStyle);
-}), __publicField(PortableTextEditor, "toggleMark", (editor, mark) => {
-  var _a;
-  debug$4("Host toggling mark", mark), (_a = editor.editable) == null || _a.toggleMark(mark);
-}), __publicField(PortableTextEditor, "getFragment", (editor) => {
-  var _a;
-  return debug$4("Host getting fragment"), (_a = editor.editable) == null ? void 0 : _a.getFragment();
-}), __publicField(PortableTextEditor, "undo", (editor) => {
-  var _a;
-  debug$4("Host undoing"), (_a = editor.editable) == null || _a.undo();
-}), __publicField(PortableTextEditor, "redo", (editor) => {
-  var _a;
-  debug$4("Host redoing"), (_a = editor.editable) == null || _a.redo();
-}), __publicField(PortableTextEditor, "isSelectionsOverlapping", (editor, selectionA, selectionB) => {
-  var _a;
-  return (_a = editor.editable) == null ? void 0 : _a.isSelectionsOverlapping(selectionA, selectionB);
-});
 function RoutePatchesObservableToEditorActor(props) {
   const $ = c(4);
   let t0, t1;
   return $[0] !== props.editorActor || $[1] !== props.patches$ ? (t0 = () => {
     const subscription = props.patches$.subscribe((payload) => {
-      props.editorActor.send(__spreadValues$3({
-        type: "patches"
-      }, payload));
+      props.editorActor.send({
+        type: "patches",
+        ...payload
+      });
     });
     return () => {
       subscription.unsubscribe();
@@ -6718,9 +6367,10 @@ function RouteEventsToChanges(props) {
           break bb5;
         }
         case "error": {
-          handleChange(__spreadProps$3(__spreadValues$3({}, event), {
+          handleChange({
+            ...event,
             level: "warning"
-          }));
+          });
           break bb5;
         }
         case "annotation.add":
@@ -6748,14 +6398,6 @@ function RouteEventsToChanges(props) {
     };
   }, t2 = [props.editorActor, handleChange], $[2] = handleChange, $[3] = props.editorActor, $[4] = t1, $[5] = t2) : (t1 = $[4], t2 = $[5]), useEffect(t1, t2), null;
 }
-var __defProp$2 = Object.defineProperty, __defProps$2 = Object.defineProperties, __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$2 = Object.getOwnPropertySymbols, __hasOwnProp$2 = Object.prototype.hasOwnProperty, __propIsEnum$2 = Object.prototype.propertyIsEnumerable, __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$2 = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
-  if (__getOwnPropSymbols$2)
-    for (var prop of __getOwnPropSymbols$2(b))
-      __propIsEnum$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
-  return a;
-}, __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
 const debug$3 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (props) => {
   const {
     editorActor,
@@ -6767,13 +6409,10 @@ const debug$3 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     renderDecorator,
     renderAnnotation
   } = props, spanRef = useRef(null), portableTextEditor = usePortableTextEditor(), blockSelected = useSelected(), [focused, setFocused] = useState(!1), [selected, setSelected] = useState(!1), block = children.props.parent, path = useMemo(() => block ? [{
-    _key: block == null ? void 0 : block._key
+    _key: block?._key
   }, "children", {
     _key: leaf._key
-  }] : [], [block, leaf._key]), decoratorValues = useMemo(() => schemaTypes.decorators.map((dec) => dec.value), [schemaTypes.decorators]), marks = useMemo(() => uniq((leaf.marks || EMPTY_MARKS).filter((mark) => decoratorValues.includes(mark))), [decoratorValues, leaf.marks]), annotationMarks = Array.isArray(leaf.marks) ? leaf.marks : EMPTY_MARKS, annotations = useMemo(() => annotationMarks.map((mark_0) => {
-    var _a;
-    return !decoratorValues.includes(mark_0) && ((_a = block == null ? void 0 : block.markDefs) == null ? void 0 : _a.find((def) => def._key === mark_0));
-  }).filter(Boolean), [annotationMarks, block, decoratorValues]), shouldTrackSelectionAndFocus = annotations.length > 0 && blockSelected;
+  }] : [], [block, leaf._key]), decoratorValues = useMemo(() => schemaTypes.decorators.map((dec) => dec.value), [schemaTypes.decorators]), marks = useMemo(() => uniq((leaf.marks || EMPTY_MARKS).filter((mark) => decoratorValues.includes(mark))), [decoratorValues, leaf.marks]), annotationMarks = Array.isArray(leaf.marks) ? leaf.marks : EMPTY_MARKS, annotations = 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;
   useEffect(() => {
     if (!shouldTrackSelectionAndFocus) {
       setFocused(!1);
@@ -6880,7 +6519,7 @@ const debug$3 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     }
     return returnedChildren;
   }, [annotations, block, children, focused, leaf, marks, path, renderAnnotation, renderChild, renderDecorator, schemaTypes.annotations, schemaTypes.decorators, schemaTypes.span, selected]);
-  return useMemo(() => /* @__PURE__ */ jsx("span", __spreadProps$2(__spreadValues$2({}, attributes), { ref: spanRef, children: content }), leaf._key), [leaf, attributes, content]);
+  return useMemo(() => /* @__PURE__ */ jsx("span", { ...attributes, ref: spanRef, children: content }, leaf._key), [leaf, attributes, content]);
 };
 Leaf.displayName = "Leaf";
 const debug$2 = debugWithName("plugin:withHotKeys"), DEFAULT_HOTKEYS = {
@@ -6933,32 +6572,10 @@ function createWithHotkeys(editorActor, portableTextEditor, hotkeysFromOptions)
     }, editor;
   };
 }
-var __defProp$1 = Object.defineProperty, __defProps$1 = Object.defineProperties, __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$1 = Object.getOwnPropertySymbols, __hasOwnProp$1 = Object.prototype.hasOwnProperty, __propIsEnum$1 = Object.prototype.propertyIsEnumerable, __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$1 = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$1.call(b, prop) && __defNormalProp$1(a, prop, b[prop]);
-  if (__getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(b))
-      __propIsEnum$1.call(b, prop) && __defNormalProp$1(a, prop, b[prop]);
-  return a;
-}, __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b)), __objRest$1 = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    __hasOwnProp$1.call(source, prop) && exclude.indexOf(prop) < 0 && (target[prop] = source[prop]);
-  if (source != null && __getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(source))
-      exclude.indexOf(prop) < 0 && __propIsEnum$1.call(source, prop) && (target[prop] = source[prop]);
-  return target;
-};
 const debug$1 = debugWithName("plugin:withInsertData");
 function createWithInsertData(editorActor, schemaTypes) {
   return function(editor) {
-    const blockTypeName = schemaTypes.block.name, spanTypeName = schemaTypes.span.name, whitespaceOnPasteMode = schemaTypes.block.options.unstable_whitespaceOnPasteMode, toPlainText = (blocks) => blocks.map((block) => {
-      var _a;
-      return editor.isTextBlock(block) ? block.children.map((child) => {
-        var _a2;
-        return child._type === spanTypeName ? child.text : `[${((_a2 = schemaTypes.inlineObjects.find((t) => t.name === child._type)) == null ? void 0 : _a2.title) || "Object"}]`;
-      }).join("") : `[${((_a = schemaTypes.blockObjects.find((t) => t.name === block._type)) == null ? void 0 : _a.title) || "Object"}]`;
-    }).join(`
+    const blockTypeName = schemaTypes.block.name, spanTypeName = schemaTypes.span.name, whitespaceOnPasteMode = schemaTypes.block.options.unstable_whitespaceOnPasteMode, toPlainText = (blocks) => blocks.map((block) => editor.isTextBlock(block) ? block.children.map((child) => child._type === spanTypeName ? child.text : `[${schemaTypes.inlineObjects.find((t) => t.name === child._type)?.title || "Object"}]`).join("") : `[${schemaTypes.blockObjects.find((t) => t.name === block._type)?.title || "Object"}]`).join(`
 
 `);
     return editor.setFragmentData = (data, originEvent) => {
@@ -6996,7 +6613,6 @@ function createWithInsertData(editorActor, schemaTypes) {
       const fragment = editor.getFragment(), portableText = fromSlateValue(fragment, blockTypeName), asJSON = JSON.stringify(portableText), asPlainText = toPlainText(portableText);
       data.clearData(), data.setData("text/plain", asPlainText), data.setData("text/html", asHTML), data.setData("application/json", asJSON), data.setData("application/x-portable-text", asJSON), debug$1("text", asPlainText), data.setData("application/x-portable-text-event-origin", originEvent || "external"), debug$1("Set fragment data", asJSON, asHTML);
     }, editor.insertPortableTextData = (data) => {
-      var _a, _b;
       if (!editor.selection)
         return !1;
       const pText = data.getData("application/x-portable-text"), origin = data.getData("application/x-portable-text-event-origin");
@@ -7006,8 +6622,8 @@ function createWithInsertData(editorActor, schemaTypes) {
           const slateValue = _regenerateKeys(editor, toSlateValue(parsed, {
             schemaTypes
           }), editorActor.getSnapshot().context.keyGenerator, spanTypeName, schemaTypes), validation = validateValue(parsed, schemaTypes, editorActor.getSnapshot().context.keyGenerator);
-          if (!validation.valid && !((_a = validation.resolution) != null && _a.autoResolve)) {
-            const errorDescription = `${(_b = validation.resolution) == null ? void 0 : _b.description}`;
+          if (!validation.valid && !validation.resolution?.autoResolve) {
+            const errorDescription = `${validation.resolution?.description}`;
             return editorActor.send({
               type: "error",
               name: "pasteError",
@@ -7020,7 +6636,6 @@ function createWithInsertData(editorActor, schemaTypes) {
       }
       return !1;
     }, editor.insertTextOrHTMLData = (data) => {
-      var _a;
       if (!editor.selection)
         return debug$1("No selection, not inserting"), !1;
       const html = data.getData("text/html"), text = data.getData("text/plain");
@@ -7047,7 +6662,7 @@ function createWithInsertData(editorActor, schemaTypes) {
         const validation = validateValue(portableText, schemaTypes, editorActor.getSnapshot().context.keyGenerator);
         if (!validation.valid) {
           const errorDescription = `Could not validate the resulting portable text to insert.
-${(_a = validation.resolution) == null ? void 0 : _a.description}
+${validation.resolution?.description}
 Try to insert as plain text (shift-paste) instead.`;
           return editorActor.send({
             type: "error",
@@ -7086,37 +6701,46 @@ function escapeHtml(str) {
 }
 function _regenerateKeys(editor, fragment, keyGenerator, spanTypeName, editorTypes) {
   return fragment.map((node) => {
-    const newNode = __spreadValues$1({}, node);
+    const newNode = {
+      ...node
+    };
     if (editor.isTextBlock(newNode)) {
       const annotations = editorTypes.annotations.map((t) => t.name);
       if (annotations.length === 0) {
-        const _a = newNode, NewNodeNoDefs = __objRest$1(_a, [
-          "markDefs"
-        ]);
-        return __spreadProps$1(__spreadValues$1({}, NewNodeNoDefs), {
+        const {
+          markDefs,
+          ...NewNodeNoDefs
+        } = newNode;
+        return {
+          ...NewNodeNoDefs,
           _key: keyGenerator()
-        });
+        };
       }
       if ((newNode.markDefs || []).some((def) => !annotations.includes(def._type))) {
         const allowedAnnotations = (newNode.markDefs || []).filter((def) => annotations.includes(def._type));
-        return __spreadProps$1(__spreadValues$1({}, newNode), {
+        return {
+          ...newNode,
           markDefs: allowedAnnotations,
           _key: keyGenerator()
-        });
+        };
       }
       newNode.markDefs = (newNode.markDefs || []).map((def) => {
         const oldKey = def._key, newKey = keyGenerator();
-        return newNode.children = newNode.children.map((child) => child._type === spanTypeName && editor.isTextSpan(child) ? __spreadProps$1(__spreadValues$1({}, child), {
+        return newNode.children = newNode.children.map((child) => child._type === spanTypeName && editor.isTextSpan(child) ? {
+          ...child,
           marks: child.marks && child.marks.includes(oldKey) ? [...child.marks].filter((mark) => mark !== oldKey).concat(newKey) : child.marks
-        }) : child), __spreadProps$1(__spreadValues$1({}, def), {
+        } : child), {
+          ...def,
           _key: newKey
-        });
+        };
       });
     }
-    const nodeWithNewKeys = __spreadProps$1(__spreadValues$1({}, newNode), {
+    const nodeWithNewKeys = {
+      ...newNode,
       _key: keyGenerator()
-    });
-    return editor.isTextBlock(nodeWithNewKeys) && (nodeWithNewKeys.children = nodeWithNewKeys.children.map((child) => __spreadProps$1(__spreadValues$1({}, child), {
+    };
+    return editor.isTextBlock(nodeWithNewKeys) && (nodeWithNewKeys.children = nodeWithNewKeys.children.map((child) => ({
+      ...child,
       _key: keyGenerator()
     }))), nodeWithNewKeys;
   });
@@ -7161,22 +6785,6 @@ function withSyncRangeDecorations({
     slateEditor.apply = originalApply;
   };
 }
-var __defProp2 = Object.defineProperty, __defProps = Object.defineProperties, __getOwnPropDescs = Object.getOwnPropertyDescriptors, __getOwnPropSymbols2 = Object.getOwnPropertySymbols, __hasOwnProp2 = Object.prototype.hasOwnProperty, __propIsEnum2 = Object.prototype.propertyIsEnumerable, __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues2 = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp2.call(b, prop) && __defNormalProp2(a, prop, b[prop]);
-  if (__getOwnPropSymbols2)
-    for (var prop of __getOwnPropSymbols2(b))
-      __propIsEnum2.call(b, prop) && __defNormalProp2(a, prop, b[prop]);
-  return a;
-}, __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)), __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    __hasOwnProp2.call(source, prop) && exclude.indexOf(prop) < 0 && (target[prop] = source[prop]);
-  if (source != null && __getOwnPropSymbols2)
-    for (var prop of __getOwnPropSymbols2(source))
-      exclude.indexOf(prop) < 0 && __propIsEnum2.call(source, prop) && (target[prop] = source[prop]);
-  return target;
-};
 const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
   position: "absolute",
   userSelect: "none",
@@ -7184,7 +6792,7 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
   left: 0,
   right: 0
 }, PortableTextEditable = forwardRef(function(props, forwardedRef) {
-  const _a = props, {
+  const {
     hotkeys,
     onBlur,
     onFocus,
@@ -7202,27 +6810,9 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
     renderStyle,
     selection: propsSelection,
     scrollSelectionIntoView,
-    spellCheck
-  } = _a, restProps = __objRest(_a, [
-    "hotkeys",
-    "onBlur",
-    "onFocus",
-    "onBeforeInput",
-    "onPaste",
-    "onCopy",
-    "onClick",
-    "rangeDecorations",
-    "renderAnnotation",
-    "renderBlock",
-    "renderChild",
-    "renderDecorator",
-    "renderListItem",
-    "renderPlaceholder",
-    "renderStyle",
-    "selection",
-    "scrollSelectionIntoView",
-    "spellCheck"
-  ]), portableTextEditor = usePortableTextEditor(), ref = useRef(null), [editableElement, setEditableElement] = useState(null), [hasInvalidValue, setHasInvalidValue] = useState(!1), [rangeDecorationState, setRangeDecorationsState] = useState([]);
+    spellCheck,
+    ...restProps
+  } = props, portableTextEditor = usePortableTextEditor(), ref = useRef(null), [editableElement, setEditableElement] = useState(null), [hasInvalidValue, setHasInvalidValue] = useState(!1), [rangeDecorationState, setRangeDecorationsState] = useState([]);
   useImperativeHandle(forwardedRef, () => ref.current);
   const rangeDecorationsRef = useRef(rangeDecorations), editorActor = useContext(EditorActorContext), readOnly = useSelector(editorActor, (s) => s.matches({
     "edit mode": "read only"
@@ -7234,9 +6824,9 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
     const withHotKeys = createWithHotkeys(editorActor, portableTextEditor, hotkeys);
     return debug("Editable is in edit mode"), withInsertData(withHotKeys(slateEditor));
   }, [editorActor, hotkeys, portableTextEditor, readOnly, schemaTypes, slateEditor]);
-  const renderElement = useCallback((eProps) => /* @__PURE__ */ jsx(Element, __spreadProps(__spreadValues2({}, eProps), { readOnly, renderBlock, renderChild, renderListItem, renderStyle, schemaTypes, spellCheck })), [schemaTypes, spellCheck, readOnly, renderBlock, renderChild, renderListItem, renderStyle]), renderLeaf = useCallback((lProps) => {
+  const renderElement = useCallback((eProps) => /* @__PURE__ */ jsx(Element, { ...eProps, readOnly, renderBlock, renderChild, renderListItem, renderStyle, schemaTypes, spellCheck }), [schemaTypes, spellCheck, readOnly, renderBlock, renderChild, renderListItem, renderStyle]), renderLeaf = useCallback((lProps) => {
     if (lProps.leaf._type === "span") {
-      let rendered = /* @__PURE__ */ jsx(Leaf, __spreadProps(__spreadValues2({}, lProps), { editorActor, schemaTypes, renderAnnotation, renderChild, renderDecorator, readOnly }));
+      let rendered = /* @__PURE__ */ jsx(Leaf, { ...lProps, editorActor, schemaTypes, renderAnnotation, renderChild, renderDecorator, readOnly });
       if (renderPlaceholder && lProps.leaf.placeholder && lProps.text.text === "")
         return /* @__PURE__ */ jsxs(Fragment, { children: [
           /* @__PURE__ */ jsx("span", { style: PLACEHOLDER_STYLE, contentEditable: !1, children: renderPlaceholder() }),
@@ -7283,9 +6873,10 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
             origin: "local"
           });
         }
-        newRange !== null && newSlateRanges.push(__spreadProps(__spreadValues2({}, newRange || slateRange_0), {
+        newRange !== null && newSlateRanges.push({
+          ...newRange || slateRange_0,
           rangeDecoration: rangeDecorationItem
-        }));
+        });
       }), newSlateRanges.length > 0) {
         setRangeDecorationsState(newSlateRanges);
         return;
@@ -7331,7 +6922,7 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
       nativeEvent: event
     });
   }, [onCopy, editorActor, slateEditor]), handlePaste = useCallback((event_0) => {
-    const value_0 = PortableTextEditor.getValue(portableTextEditor), ptRange = toPortableTextRange(value_0, slateEditor.selection, schemaTypes), path = (ptRange == null ? void 0 : ptRange.focus.path) || [], onPasteResult = onPaste == null ? void 0 : onPaste({
+    const value_0 = PortableTextEditor.getValue(portableTextEditor), path = toPortableTextRange(value_0, slateEditor.selection, schemaTypes)?.focus.path || [], onPasteResult = onPaste?.({
       event: event_0,
       value: value_0,
       path,
@@ -7396,8 +6987,8 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
     const existingDOMRange = domSelection.getRangeAt(0);
     try {
       const newDOMRange = ReactEditor.toDOMRange(slateEditor, slateEditor.selection);
-      (newDOMRange.startOffset !== existingDOMRange.startOffset || newDOMRange.endOffset !== existingDOMRange.endOffset) && (debug("DOM range out of sync, validating selection"), domSelection == null || domSelection.removeAllRanges(), domSelection.addRange(newDOMRange));
-    } catch (e) {
+      (newDOMRange.startOffset !== existingDOMRange.startOffset || newDOMRange.endOffset !== existingDOMRange.endOffset) && (debug("DOM range out of sync, validating selection"), domSelection?.removeAllRanges(), domSelection.addRange(newDOMRange));
+    } catch {
       debug("Could not resolve selection, selecting top document"), Transforms.deselect(slateEditor), slateEditor.children.length > 0 && Transforms.select(slateEditor, [0, 0]), slateEditor.onChange();
     }
   }, [ref, slateEditor]);
@@ -7485,7 +7076,8 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
     ref.current = ReactEditor.toDOMNode(slateEditor, slateEditor), setEditableElement(ref.current);
   }, [slateEditor, ref]), portableTextEditor ? hasInvalidValue ? null : /* @__PURE__ */ jsx(
     Editable,
-    __spreadProps(__spreadValues2({}, restProps), {
+    {
+      ...restProps,
       autoFocus: !1,
       className: restProps.className || "pt-editable",
       decorate,
@@ -7502,7 +7094,7 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
       renderElement,
       renderLeaf,
       scrollSelectionIntoView: scrollSelectionIntoViewToSlate
-    })
+    }
   ) : null;
 });
 PortableTextEditable.displayName = "ForwardRef(PortableTextEditable)";