@strapi/admin 4.15.5 → 4.16.0

package/dist/_chunks/{index-9304d6de.js → index-9d98e8b2.js}

@@ -31,8 +31,8 @@ const reactIntl = require("react-intl");
 const reactRedux = require("react-redux");
 const reactRouterDom = require("react-router-dom");
 const DragLayer = require("./DragLayer-f07eee6c.js");
-const AuthenticatedApp = require("./AuthenticatedApp-61dfdab8.js");
-const schema = require("./schema-15e33d1c.js");
+const AuthenticatedApp = require("./AuthenticatedApp-12b0b80d.js");
+const schema = require("./schema-e8bfd9c4.js");
 const PropTypes = require("prop-types");
 const reactErrorBoundary = require("react-error-boundary");
 const reactDnd = require("react-dnd");
@@ -53,9 +53,10 @@ const reactQuery = require("react-query");
 const v2 = require("@strapi/design-system/v2");
 const reactDndHtml5Backend = require("react-dnd-html5-backend");
 const styled = require("styled-components");
-const index$2 = require("./index-0ed05075.js");
+const index$2 = require("./index-8b79ee6c.js");
 const size = require("lodash/size");
 const take = require("lodash/take");
+const reactContext = require("@radix-ui/react-context");
 const slate = require("slate");
 const slateHistory = require("slate-history");
 const slateReact = require("slate-react");
@@ -3031,14 +3032,18 @@ const insertLink = (editor, { url }) => {
     const linkNodes = Array.from(
       slate.Editor.nodes(editor, {
         at: editor.selection,
-        match: (node) => node.type === "link"
+        match: (node) => !slate.Editor.isEditor(node) && node.type === "link"
       })
     );
     linkNodes.forEach(([, path]) => {
       slate.Transforms.unwrapNodes(editor, { at: path });
     });
     if (slate.Range.isCollapsed(editor.selection)) {
-      const link = { type: "link", url: url ? addProtocol(url) : "", children: [{ text: url }] };
+      const link = {
+        type: "link",
+        url: url ? addProtocol(url) : "",
+        children: [{ type: "text", text: url }]
+      };
       slate.Transforms.insertNodes(editor, link);
     } else {
       slate.Transforms.wrapNodes(
@@ -3049,18 +3054,23 @@ const insertLink = (editor, { url }) => {
     }
   }
 };
-const editLink = (editor, { url, text }) => {
-  if (editor.selection) {
-    const [linkNode, linkPath] = slate.Editor.above(editor, { match: (node) => node.type === "link" });
-    if (linkNode) {
-      slate.Transforms.setNodes(editor, { url: addProtocol(url) }, { at: linkPath });
-      if (text !== "" && text !== slate.Editor.string(editor, linkPath)) {
-        const linkNodeChildrens = Array.from(slate.Node.children(editor, linkPath, { reverse: true }));
-        linkNodeChildrens.forEach(([, childPath]) => {
-          slate.Transforms.removeNodes(editor, { at: childPath });
-        });
-        slate.Transforms.insertNodes(editor, [{ text }], { at: linkPath.concat(0) });
-      }
+const editLink = (editor, link) => {
+  const { url, text } = link;
+  if (!editor.selection) {
+    return;
+  }
+  const linkEntry = slate.Editor.above(editor, {
+    match: (node) => !slate.Editor.isEditor(node) && node.type === "link"
+  });
+  if (linkEntry) {
+    const [, linkPath] = linkEntry;
+    slate.Transforms.setNodes(editor, { url: addProtocol(url) }, { at: linkPath });
+    if (text !== "" && text !== slate.Editor.string(editor, linkPath)) {
+      const linkNodeChildrens = Array.from(slate.Node.children(editor, linkPath, { reverse: true }));
+      linkNodeChildrens.forEach(([, childPath]) => {
+        slate.Transforms.removeNodes(editor, { at: childPath });
+      });
+      slate.Transforms.insertNodes(editor, [{ type: "text", text }], { at: linkPath.concat(0) });
     }
   }
 };
@@ -3134,18 +3144,21 @@ const Unorderedlist = styled__default.default.ul`
   list-style-type: disc;
   ${listStyle}
 `;
+const isText$2 = (node) => {
+  return slate.Node.isNode(node) && !slate.Editor.isEditor(node) && node.type === "text";
+};
+const isListNode$1 = (node) => {
+  return slate.Node.isNode(node) && !slate.Editor.isEditor(node) && node.type === "list";
+};
 const List = ({ attributes, children, element }) => {
-  if (element.format === "ordered")
+  if (!isListNode$1(element)) {
+    return null;
+  }
+  if (element.format === "ordered") {
     return /* @__PURE__ */ jsxRuntime.jsx(Orderedlist, { ...attributes, children });
+  }
   return /* @__PURE__ */ jsxRuntime.jsx(Unorderedlist, { ...attributes, children });
 };
-List.propTypes = {
-  attributes: PropTypes__default.default.object.isRequired,
-  children: PropTypes__default.default.node.isRequired,
-  element: PropTypes__default.default.shape({
-    format: PropTypes__default.default.string.isRequired
-  }).isRequired
-};
 const replaceListWithEmptyBlock = (editor, currentListPath) => {
   slate.Transforms.removeNodes(editor, { at: currentListPath });
   if (currentListPath[0] === 0) {
@@ -3161,9 +3174,11 @@ const replaceListWithEmptyBlock = (editor, currentListPath) => {
   }
 };
 const handleBackspaceKeyOnList = (editor, event) => {
+  if (!editor.selection)
+    return;
   const [currentListItem, currentListItemPath] = slate.Editor.parent(editor, editor.selection.anchor);
   const [currentList, currentListPath] = slate.Editor.parent(editor, currentListItemPath);
-  const isListEmpty = currentList.children.length === 1 && currentListItem.children[0].text === "";
+  const isListEmpty = currentList.children.length === 1 && isText$2(currentListItem.children[0]) && currentListItem.children[0].text === "";
   const isNodeStart = slate.Editor.isStart(editor, editor.selection.anchor, currentListItemPath);
   const isFocusAtTheBeginningOfAChild = editor.selection.focus.offset === 0 && editor.selection.focus.path.at(-1) === 0;
   if (isListEmpty) {
@@ -3171,7 +3186,7 @@ const handleBackspaceKeyOnList = (editor, event) => {
     replaceListWithEmptyBlock(editor, currentListPath);
   } else if (isNodeStart) {
     slate.Transforms.liftNodes(editor, {
-      match: (n) => n.type === "list-item"
+      match: (node) => !slate.Editor.isEditor(node) && node.type === "list-item"
     });
     slate.Transforms.setNodes(
       editor,
@@ -3182,23 +3197,32 @@ const handleBackspaceKeyOnList = (editor, event) => {
     );
   } else if (isFocusAtTheBeginningOfAChild) {
     slate.Transforms.liftNodes(editor, {
-      match: (n) => n.type === "list-item"
+      match: (node) => !slate.Editor.isEditor(node) && node.type === "list-item"
     });
     slate.Transforms.setNodes(editor, { type: "paragraph" });
   }
 };
 const handleEnterKeyOnList = (editor) => {
-  const [currentListItem, currentListItemPath] = slate.Editor.above(editor, {
-    matchNode: (node) => node.type === "list-item"
+  const currentListItemEntry = slate.Editor.above(editor, {
+    match: (node) => !slate.Editor.isEditor(node) && node.type === "list-item"
   });
+  if (!currentListItemEntry || !editor.selection) {
+    return;
+  }
+  const [currentListItem, currentListItemPath] = currentListItemEntry;
   const [currentList, currentListPath] = slate.Editor.parent(editor, currentListItemPath);
-  const isListEmpty = currentList.children.length === 1 && currentListItem.children[0].text === "";
-  const isListItemEmpty = currentListItem.children.length === 1 && currentListItem.children[0].text === "";
+  const isListEmpty = currentList.children.length === 1 && isText$2(currentListItem.children[0]) && currentListItem.children[0].text === "";
+  const isListItemEmpty = currentListItem.children.length === 1 && isText$2(currentListItem.children[0]) && currentListItem.children[0].text === "";
   if (isListEmpty) {
     replaceListWithEmptyBlock(editor, currentListPath);
   } else if (isListItemEmpty) {
     slate.Transforms.removeNodes(editor, { at: currentListItemPath });
-    const listNodeEntry = slate.Editor.above(editor, { match: (n) => n.type === "list" });
+    const listNodeEntry = slate.Editor.above(editor, {
+      match: (node) => !slate.Editor.isEditor(node) && node.type === "list"
+    });
+    if (!listNodeEntry) {
+      return;
+    }
     const createdParagraphPath = slate.Path.next(listNodeEntry[1]);
     slate.Transforms.insertNodes(
       editor,
@@ -3223,27 +3247,19 @@ const Img = styled__default.default.img`
   max-width: 100%;
   object-fit: contain;
 `;
+const isImage = (element) => {
+  return element.type === "image";
+};
 const Image = ({ attributes, children, element }) => {
-  if (!element.image)
+  if (!isImage(element)) {
     return null;
+  }
   const { url, alternativeText, width, height } = element.image;
   return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { ...attributes, children: [
     children,
     /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { background: "neutral100", contentEditable: false, justifyContent: "center", children: /* @__PURE__ */ jsxRuntime.jsx(Img, { src: url, alt: alternativeText, width, height }) })
   ] });
 };
-Image.propTypes = {
-  attributes: PropTypes__default.default.object.isRequired,
-  children: PropTypes__default.default.node.isRequired,
-  element: PropTypes__default.default.shape({
-    image: PropTypes__default.default.shape({
-      url: PropTypes__default.default.string.isRequired,
-      alternativeText: PropTypes__default.default.string,
-      width: PropTypes__default.default.number,
-      height: PropTypes__default.default.number
-    })
-  }).isRequired
-};
 const TooltipCustom = styled__default.default(designSystem.Tooltip)`
   z-index: 6;
 `;
@@ -3252,162 +3268,178 @@ const CustomButton = styled__default.default(designSystem.Button)`
     line-height: normal;
   }
 `;
-const Link = React__namespace.forwardRef(({ element, children, ...attributes }, forwardedRef) => {
-  const { formatMessage } = reactIntl.useIntl();
-  const editor = slateReact.useSlate();
-  const path = slateReact.ReactEditor.findPath(editor, element);
-  const [popoverOpen, setPopoverOpen] = React__namespace.useState(
-    editor.lastInsertedLinkPath ? slate.Path.equals(path, editor.lastInsertedLinkPath) : false
-  );
-  const [isEditing, setIsEditing] = React__namespace.useState(element.url === "");
-  const linkRef = React__namespace.useRef(null);
-  const elementText = element.children.map((child) => child.text).join("");
-  const [linkText, setLinkText] = React__namespace.useState(elementText);
-  const [linkUrl, setLinkUrl] = React__namespace.useState(element.url);
-  const handleOpenEditPopover = (e) => {
-    e.preventDefault();
-    setPopoverOpen(true);
-  };
-  const handleSave = (e) => {
-    e.stopPropagation();
-    if (slate.Range.isCollapsed(editor.selection)) {
-      const [, parentPath] = slate.Editor.parent(editor, editor.selection.focus?.path);
-      slate.Transforms.select(editor, parentPath);
-    }
-    editLink(editor, { url: linkUrl, text: linkText });
-    setIsEditing(false);
-  };
-  const handleCancel = () => {
-    setIsEditing(false);
-    if (element.url === "") {
-      removeLink(editor);
-    }
-  };
-  const handleDismiss = () => {
-    setPopoverOpen(false);
-    if (element.url === "") {
-      removeLink(editor);
-    }
-    slateReact.ReactEditor.focus(editor);
-  };
-  const composedRefs = schema.composeRefs(linkRef, forwardedRef);
-  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-    /* @__PURE__ */ jsxRuntime.jsx(
-      StyledBaseLink,
-      {
-        ...attributes,
-        ref: composedRefs,
-        href: element.url,
-        onClick: handleOpenEditPopover,
-        color: "primary600",
-        children
+const Link = React__namespace.forwardRef(
+  ({ element, children, attributes }, forwardedRef) => {
+    const { formatMessage } = reactIntl.useIntl();
+    const { editor } = useBlocksEditorContext("Link");
+    const path = slateReact.ReactEditor.findPath(editor, element);
+    const [popoverOpen, setPopoverOpen] = React__namespace.useState(
+      editor.lastInsertedLinkPath ? slate.Path.equals(path, editor.lastInsertedLinkPath) : false
+    );
+    const elementAsLink = element;
+    const [isEditing, setIsEditing] = React__namespace.useState(elementAsLink.url === "");
+    const linkRef = React__namespace.useRef(null);
+    const elementText = elementAsLink.children.map((child) => child.text).join("");
+    const [linkText, setLinkText] = React__namespace.useState(elementText);
+    const [linkUrl, setLinkUrl] = React__namespace.useState(elementAsLink.url);
+    const handleOpenEditPopover = (e) => {
+      e.preventDefault();
+      setPopoverOpen(true);
+    };
+    const handleSave = (e) => {
+      e.stopPropagation();
+      if (editor.selection && slate.Range.isCollapsed(editor.selection)) {
+        const [, parentPath] = slate.Editor.parent(editor, editor.selection.focus?.path);
+        slate.Transforms.select(editor, parentPath);
+      }
+      editLink(editor, { url: linkUrl, text: linkText });
+      setIsEditing(false);
+    };
+    const handleCancel = () => {
+      setIsEditing(false);
+      if (elementAsLink.url === "") {
+        removeLink(editor);
       }
-    ),
-    popoverOpen && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Popover, { source: linkRef, onDismiss: handleDismiss, padding: 4, contentEditable: false, children: isEditing ? /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { as: "form", onSubmit: handleSave, direction: "column", gap: 4, children: [
-      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Field, { width: "300px", children: [
-        /* @__PURE__ */ jsxRuntime.jsx(designSystem.FieldLabel, { children: formatMessage({
-          id: "components.Blocks.popover.text",
-          defaultMessage: "Text"
-        }) }),
-        /* @__PURE__ */ jsxRuntime.jsx(
-          designSystem.FieldInput,
-          {
-            name: "text",
-            placeholder: formatMessage({
-              id: "components.Blocks.popover.text.placeholder",
-              defaultMessage: "Enter link text"
-            }),
-            value: linkText,
-            onChange: (e) => setLinkText(e.target.value)
-          }
-        )
-      ] }),
-      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Field, { width: "300px", children: [
-        /* @__PURE__ */ jsxRuntime.jsx(designSystem.FieldLabel, { children: formatMessage({
-          id: "components.Blocks.popover.link",
-          defaultMessage: "Link"
-        }) }),
-        /* @__PURE__ */ jsxRuntime.jsx(
-          designSystem.FieldInput,
-          {
-            name: "url",
-            placeholder: "https://strapi.io",
-            value: linkUrl,
-            onChange: (e) => setLinkUrl(e.target.value)
-          }
-        )
-      ] }),
-      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { justifyContent: "end", width: "100%", gap: 2, children: [
-        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "tertiary", onClick: handleCancel, children: formatMessage({
-          id: "components.Blocks.popover.cancel",
-          defaultMessage: "Cancel"
-        }) }),
-        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { type: "submit", disabled: !linkText || !linkUrl, children: formatMessage({
-          id: "components.Blocks.popover.save",
-          defaultMessage: "Save"
-        }) })
-      ] })
-    ] }) : /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", gap: 4, alignItems: "start", width: "400px", children: [
-      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { children: elementText }),
-      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { children: /* @__PURE__ */ jsxRuntime.jsx(StyledBaseLink, { href: element.url, target: "_blank", color: "primary600", children: element.url }) }),
-      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { justifyContent: "end", width: "100%", gap: 2, children: [
-        /* @__PURE__ */ jsxRuntime.jsx(
-          TooltipCustom,
-          {
-            description: formatMessage({
-              id: "components.Blocks.popover.delete",
-              defaultMessage: "Delete"
-            }),
-            children: /* @__PURE__ */ jsxRuntime.jsx(
-              CustomButton,
-              {
-                size: "S",
-                width: "2rem",
-                variant: "danger-light",
-                onClick: () => removeLink(editor),
-                "aria-label": formatMessage({
-                  id: "components.Blocks.popover.delete",
-                  defaultMessage: "Delete"
-                }),
-                type: "button",
-                justifyContent: "center",
-                children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Icon, { width: 3, height: 3, as: Icons.Trash })
-              }
-            )
-          }
-        ),
-        /* @__PURE__ */ jsxRuntime.jsx(
-          TooltipCustom,
-          {
-            description: formatMessage({
-              id: "components.Blocks.popover.edit",
-              defaultMessage: "Edit"
-            }),
-            children: /* @__PURE__ */ jsxRuntime.jsx(
-              CustomButton,
-              {
-                size: "S",
-                width: "2rem",
-                variant: "tertiary",
-                onClick: () => setIsEditing(true),
-                "aria-label": formatMessage({
-                  id: "components.Blocks.popover.edit",
-                  defaultMessage: "Edit"
-                }),
-                type: "button",
-                justifyContent: "center",
-                children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Icon, { width: 3, height: 3, as: Icons.Pencil })
-              }
-            )
-          }
-        )
-      ] })
-    ] }) })
-  ] });
-});
-Link.propTypes = {
-  element: PropTypes__default.default.object.isRequired,
-  children: PropTypes__default.default.node.isRequired
+    };
+    const handleDismiss = () => {
+      setPopoverOpen(false);
+      if (elementAsLink.url === "") {
+        removeLink(editor);
+      }
+      slateReact.ReactEditor.focus(editor);
+    };
+    const composedRefs = schema.composeRefs(linkRef, forwardedRef);
+    return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        StyledBaseLink,
+        {
+          ...attributes,
+          ref: composedRefs,
+          href: elementAsLink.url,
+          onClick: handleOpenEditPopover,
+          color: "primary600",
+          children
+        }
+      ),
+      popoverOpen && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Popover, { source: linkRef, onDismiss: handleDismiss, padding: 4, contentEditable: false, children: isEditing ? /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { as: "form", onSubmit: handleSave, direction: "column", gap: 4, children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Field, { width: "300px", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.FieldLabel, { children: formatMessage({
+            id: "components.Blocks.popover.text",
+            defaultMessage: "Text"
+          }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            designSystem.FieldInput,
+            {
+              name: "text",
+              placeholder: formatMessage({
+                id: "components.Blocks.popover.text.placeholder",
+                defaultMessage: "Enter link text"
+              }),
+              value: linkText,
+              onChange: (e) => setLinkText(e.target.value)
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Field, { width: "300px", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.FieldLabel, { children: formatMessage({
+            id: "components.Blocks.popover.link",
+            defaultMessage: "Link"
+          }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            designSystem.FieldInput,
+            {
+              name: "url",
+              placeholder: "https://strapi.io",
+              value: linkUrl,
+              onChange: (e) => setLinkUrl(e.target.value)
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { justifyContent: "end", width: "100%", gap: 2, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "tertiary", onClick: handleCancel, children: formatMessage({
+            id: "components.Blocks.popover.cancel",
+            defaultMessage: "Cancel"
+          }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { type: "submit", disabled: !linkText || !linkUrl, children: formatMessage({
+            id: "components.Blocks.popover.save",
+            defaultMessage: "Save"
+          }) })
+        ] })
+      ] }) : /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", gap: 4, alignItems: "start", width: "400px", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { children: elementText }),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { children: /* @__PURE__ */ jsxRuntime.jsx(StyledBaseLink, { href: elementAsLink.url, target: "_blank", color: "primary600", children: elementAsLink.url }) }),
+        /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { justifyContent: "end", width: "100%", gap: 2, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            TooltipCustom,
+            {
+              description: formatMessage({
+                id: "components.Blocks.popover.delete",
+                defaultMessage: "Delete"
+              }),
+              children: /* @__PURE__ */ jsxRuntime.jsx(
+                CustomButton,
+                {
+                  size: "S",
+                  width: "2rem",
+                  variant: "danger-light",
+                  onClick: () => removeLink(editor),
+                  "aria-label": formatMessage({
+                    id: "components.Blocks.popover.delete",
+                    defaultMessage: "Delete"
+                  }),
+                  type: "button",
+                  justifyContent: "center",
+                  children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Icon, { width: 3, height: 3, as: Icons.Trash })
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            TooltipCustom,
+            {
+              description: formatMessage({
+                id: "components.Blocks.popover.edit",
+                defaultMessage: "Edit"
+              }),
+              children: /* @__PURE__ */ jsxRuntime.jsx(
+                CustomButton,
+                {
+                  size: "S",
+                  width: "2rem",
+                  variant: "tertiary",
+                  onClick: () => setIsEditing(true),
+                  "aria-label": formatMessage({
+                    id: "components.Blocks.popover.edit",
+                    defaultMessage: "Edit"
+                  }),
+                  type: "button",
+                  justifyContent: "center",
+                  children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Icon, { width: 3, height: 3, as: Icons.Pencil })
+                }
+              )
+            }
+          )
+        ] })
+      ] }) })
+    ] });
+  }
+);
+const selectorBlockKeys = [
+  "paragraph",
+  "heading-one",
+  "heading-two",
+  "heading-three",
+  "heading-four",
+  "heading-five",
+  "heading-six",
+  "list-ordered",
+  "list-unordered",
+  "image",
+  "quote",
+  "code"
+];
+const isSelectorBlockKey = (key) => {
+  return typeof key === "string" && selectorBlockKeys.includes(key);
 };
 function useBlocksStore() {
   return {
@@ -3424,18 +3456,25 @@ function useBlocksStore() {
       matchNode: (node) => node.type === "paragraph",
       isInBlocksSelector: true,
       handleEnterKey(editor) {
+        if (!editor.selection) {
+          return;
+        }
         const anchorPathInitialPosition = editor.selection.anchor.path;
         slate.Transforms.splitNodes(editor, {
           // Makes sure we always create a new node,
           // even if there's nothing to the right of the cursor in the node.
           always: true
         });
-        const [, parentBlockPath] = slate.Editor.above(editor, {
-          match: (n) => n.type !== "text"
+        const parentBlockEntry = slate.Editor.above(editor, {
+          match: (node) => !slate.Editor.isEditor(node) && node.type !== "text"
         });
+        if (!parentBlockEntry) {
+          return;
+        }
+        const [, parentBlockPath] = parentBlockEntry;
         const isNodeEnd = slate.Editor.isEnd(editor, editor.selection.anchor, parentBlockPath);
         const [fragmentedNode] = slate.Editor.parent(editor, editor.selection.anchor.path);
-        slate.Transforms.removeNodes(editor, editor.selection);
+        slate.Transforms.removeNodes(editor);
         const hasNextNode = editor.children.length - anchorPathInitialPosition[0] > 1;
         slate.Transforms.insertNodes(
           editor,
@@ -3576,7 +3615,7 @@ function useBlocksStore() {
       isInBlocksSelector: false
     },
     link: {
-      renderElement: (props) => /* @__PURE__ */ jsxRuntime.jsx(Link, { element: props.element, ...props.attributes, children: props.children }),
+      renderElement: (props) => /* @__PURE__ */ jsxRuntime.jsx(Link, { element: props.element, attributes: props.attributes, children: props.children }),
       value: {
         type: "link"
       },
@@ -3609,11 +3648,16 @@ function useBlocksStore() {
       matchNode: (node) => node.type === "quote",
       isInBlocksSelector: true,
       handleEnterKey(editor) {
-        const [quoteNode, quoteNodePath] = slate.Editor.above(editor, {
-          match: (n) => n.type === "quote"
+        const quoteNodeEntry = slate.Editor.above(editor, {
+          match: (node) => !slate.Editor.isEditor(node) && node.type === "quote"
         });
+        if (!quoteNodeEntry || !editor.selection) {
+          return;
+        }
+        const [quoteNode, quoteNodePath] = quoteNodeEntry;
         const isNodeEnd = slate.Editor.isEnd(editor, editor.selection.anchor, quoteNodePath);
-        const isEmptyLine = quoteNode.children.at(-1).text.endsWith("\n");
+        const lastTextNode = quoteNode.children.at(-1);
+        const isEmptyLine = isText$2(lastTextNode) && lastTextNode.text.endsWith("\n");
         if (isNodeEnd && isEmptyLine) {
           slate.Transforms.delete(editor, { distance: 1, unit: "character", reverse: true });
           slate.Transforms.insertNodes(editor, {
@@ -3674,7 +3718,7 @@ const InlineCode = styled__default.default.code`
   color: inherit;
 `;
 function useModifiersStore() {
-  const editor = slateReact.useSlate();
+  const { editor } = useBlocksEditorContext("useModifiersStore");
   const modifiers = slate.Editor.marks(editor);
   const baseCheckIsActive = (name) => {
     if (!modifiers)
@@ -3735,16 +3779,22 @@ function useModifiersStore() {
     }
   };
 }
-const getEditorStyle = (theme) => ({
+const getEntries = (object) => Object.entries(object);
+const getKeys = (object) => Object.keys(object);
+const StyledEditable = styled__default.default(slateReact.Editable)`
   // The outline style is set on the wrapper with :focus-within
-  outline: "none",
-  display: "flex",
-  flexDirection: "column",
-  gap: theme.spaces[2],
-  height: "100%"
-});
+  outline: none;
+  display: flex;
+  flex-direction: column;
+  gap: ${({ theme }) => theme.spaces[2]};
+  height: 100%;
+
+  > *:last-child {
+    padding-bottom: ${({ theme }) => theme.spaces[3]};
+  }
+`;
 const baseRenderLeaf = (props, modifiers) => {
-  const wrappedChildren = Object.entries(modifiers).reduce((currentChildren, modifierEntry) => {
+  const wrappedChildren = getEntries(modifiers).reduce((currentChildren, modifierEntry) => {
     const [name, modifier] = modifierEntry;
     if (props.leaf[name]) {
       return modifier.renderLeaf(currentChildren);
@@ -3758,17 +3808,28 @@ const baseRenderElement = (props, blocks) => {
   const block = blockMatch || blocks.paragraph;
   return block.renderElement(props);
 };
-const BlocksInput = ({ disabled, placeholder }) => {
-  const theme = styled.useTheme();
-  const editor = slateReact.useSlate();
-  const blocksRef = React__namespace.useRef();
+const BlocksContent = ({ placeholder }) => {
+  const { editor, disabled } = useBlocksEditorContext("BlocksContent");
+  const blocksRef = React__namespace.useRef(null);
   const modifiers = useModifiersStore();
-  const renderLeaf = React__namespace.useCallback((props) => baseRenderLeaf(props, modifiers), [modifiers]);
+  const renderLeaf = React__namespace.useCallback(
+    (props) => baseRenderLeaf(props, modifiers),
+    [modifiers]
+  );
   const blocks = useBlocksStore();
-  const renderElement = React__namespace.useCallback((props) => baseRenderElement(props, blocks), [blocks]);
+  const renderElement = React__namespace.useCallback(
+    (props) => baseRenderElement(props, blocks),
+    [blocks]
+  );
   const handleEnter = () => {
+    if (!editor.selection) {
+      return;
+    }
     const selectedNode = editor.children[editor.selection.anchor.path[0]];
     const selectedBlock = Object.values(blocks).find((block) => block.matchNode(selectedNode));
+    if (!selectedBlock) {
+      return;
+    }
     if (selectedBlock.handleEnterKey) {
       selectedBlock.handleEnterKey(editor);
     } else {
@@ -3776,8 +3837,14 @@ const BlocksInput = ({ disabled, placeholder }) => {
     }
   };
   const handleBackspaceEvent = (event) => {
+    if (!editor.selection) {
+      return;
+    }
     const selectedNode = editor.children[editor.selection.anchor.path[0]];
     const selectedBlock = Object.values(blocks).find((block) => block.matchNode(selectedNode));
+    if (!selectedBlock) {
+      return;
+    }
     if (selectedBlock.handleBackspaceKey) {
       selectedBlock.handleBackspaceKey(editor, event);
     }
@@ -3805,6 +3872,9 @@ const BlocksInput = ({ disabled, placeholder }) => {
   const handleScrollSelectionIntoView = (_, domRange) => {
     const domRect = domRange.getBoundingClientRect();
     const blocksInput = blocksRef.current;
+    if (!blocksInput) {
+      return;
+    }
     const editorRect = blocksInput.getBoundingClientRect();
     if (domRect.top < editorRect.top || domRect.bottom > editorRect.bottom) {
       blocksInput.scrollBy({
@@ -3825,17 +3895,14 @@ const BlocksInput = ({ disabled, placeholder }) => {
       background: "neutral0",
       color: "neutral800",
       lineHeight: 6,
-      hasRadius: true,
       paddingLeft: 4,
       paddingRight: 4,
-      marginTop: 3,
-      marginBottom: 3,
+      paddingTop: 3,
       children: /* @__PURE__ */ jsxRuntime.jsx(
-        slateReact.Editable,
+        StyledEditable,
         {
           readOnly: disabled,
           placeholder,
-          style: getEditorStyle(theme),
           renderElement,
           renderLeaf,
           onKeyDown: handleKeyDown,
@@ -3845,77 +3912,6 @@ const BlocksInput = ({ disabled, placeholder }) => {
     }
   );
 };
-BlocksInput.defaultProps = {
-  placeholder: null
-};
-BlocksInput.propTypes = {
-  disabled: PropTypes__default.default.bool.isRequired,
-  placeholder: PropTypes__default.default.string
-};
-const withLinks = (editor) => {
-  const { isInline, apply, insertText: insertText2, insertData } = editor;
-  editor.isInline = (element) => {
-    return element.type === "link" ? true : isInline(element);
-  };
-  editor.lastInsertedLinkPath = null;
-  editor.apply = (operation) => {
-    if (operation.type === "insert_node") {
-      if (operation.node.type === "link") {
-        editor.lastInsertedLinkPath = operation.path;
-      }
-    } else if (operation.type === "move_node") {
-      if (slate.Path.hasPrevious(operation.path)) {
-        editor.lastInsertedLinkPath = slate.Path.transform(editor.lastInsertedLinkPath, operation);
-      }
-    }
-    apply(operation);
-  };
-  editor.insertText = (text) => {
-    if (slate.Range.isCollapsed(editor.selection) && text === " ") {
-      const linksInSelection = Array.from(
-        slate.Editor.nodes(editor, { at: editor.selection, match: (node) => node.type === "link" })
-      );
-      const selectionIsInLink = editor.selection && linksInSelection.length > 0;
-      const selectionIsAtEndOfLink = selectionIsInLink && slate.Point.equals(editor.selection.anchor, slate.Editor.end(editor, linksInSelection[0][1]));
-      if (selectionIsAtEndOfLink) {
-        slate.Transforms.insertNodes(
-          editor,
-          { text: " ", type: "text" },
-          { at: slate.Path.next(linksInSelection[0][1]), select: true }
-        );
-        return;
-      }
-    }
-    insertText2(text);
-  };
-  editor.insertData = (data) => {
-    const pastedText = data.getData("text/plain");
-    if (pastedText) {
-      try {
-        new URL(pastedText);
-        insertLink(editor, { url: pastedText });
-        return;
-      } catch (error) {
-      }
-    }
-    insertData(data);
-  };
-  return editor;
-};
-const withStrapiSchema = (editor) => {
-  const { normalizeNode } = editor;
-  editor.normalizeNode = (entry) => {
-    const [node, path] = entry;
-    if (!slate.Element.isElement(node)) {
-      if (node.type !== "text") {
-        slate.Transforms.setNodes(editor, { type: "text" }, { at: path });
-        return;
-      }
-    }
-    normalizeNode(entry);
-  };
-  return editor;
-};
 const ToolbarWrapper = styled__default.default(designSystem.Flex)`
   &[aria-disabled='true'] {
     cursor: not-allowed;
@@ -3926,7 +3922,7 @@ const Separator = styled__default.default(Toolbar__namespace.Separator)`
   width: 1px;
   height: ${helperPlugin.pxToRem(24)};
 `;
-const FlexButton = styled__default.default(designSystem.Flex).attrs({ as: "button" })`
+const FlexButton = styled__default.default(designSystem.Flex)`
   // Inherit the not-allowed cursor from ToolbarWrapper when disabled
   &[aria-disabled] {
     cursor: inherit;
@@ -3966,8 +3962,15 @@ const SelectWrapper = styled__default.default(designSystem.Box)`
     }
   }
 `;
-const ToolbarButton = ({ icon, name, label, isActive, disabled, handleClick }) => {
-  const editor = slateReact.useSlate();
+const ToolbarButton = ({
+  icon,
+  name,
+  label,
+  isActive,
+  disabled,
+  handleClick
+}) => {
+  const { editor } = useBlocksEditorContext("ToolbarButton");
   const { formatMessage } = reactIntl.useIntl();
   const labelMessage = formatMessage(label);
   const enabledColor = isActive ? "primary600" : "neutral600";
@@ -3987,6 +3990,7 @@ const ToolbarButton = ({ icon, name, label, isActive, disabled, handleClick }) =
       children: /* @__PURE__ */ jsxRuntime.jsx(
         FlexButton,
         {
+          as: "button",
           disabled,
           background: isActive ? "primary100" : "",
           alignItems: "center",
@@ -4005,38 +4009,26 @@ const ToolbarButton = ({ icon, name, label, isActive, disabled, handleClick }) =
     }
   ) });
 };
-ToolbarButton.propTypes = {
-  icon: PropTypes__default.default.elementType.isRequired,
-  name: PropTypes__default.default.string.isRequired,
-  label: PropTypes__default.default.shape({
-    id: PropTypes__default.default.string.isRequired,
-    defaultMessage: PropTypes__default.default.string.isRequired
-  }).isRequired,
-  isActive: PropTypes__default.default.bool.isRequired,
-  disabled: PropTypes__default.default.bool.isRequired,
-  handleClick: PropTypes__default.default.func.isRequired
-};
 const toggleBlock = (editor, value) => {
-  const { type, level, format } = value;
+  if (!value.type) {
+    throw new Error("The block type is required");
+  }
   const blockProperties = {
-    type,
-    level: level || null,
-    format: format || null
+    type: value.type,
+    level: value.level || null,
+    format: value.format || null
   };
   if (editor.selection) {
     slate.Transforms.unwrapNodes(editor, {
-      match: (node) => node.type === "list",
+      match: (node) => !slate.Editor.isEditor(node) && node.type === "list",
       split: true
     });
     slate.Transforms.setNodes(editor, blockProperties);
   } else {
     const [, lastNodePath] = slate.Editor.last(editor, []);
-    const [parentNode] = slate.Editor.parent(editor, lastNodePath, {
-      // Makes sure we get a block node, not an inline node
-      match: (node) => node.type !== "text"
-    });
+    const [parentNode] = slate.Editor.parent(editor, lastNodePath);
     slate.Transforms.removeNodes(editor, {
-      void: true,
+      voids: true,
       hanging: true,
       at: {
         anchor: { path: lastNodePath, offset: 0 },
@@ -4075,43 +4067,52 @@ const IMAGE_SCHEMA_FIELDS = [
   "createdAt",
   "updatedAt"
 ];
-const pick = (object, imageSchemaFields) => {
-  return Object.keys(object).reduce((acc, key) => {
-    if (imageSchemaFields.includes(key)) {
-      acc[key] = object[key];
-    }
-    return acc;
-  }, {});
+const pick = (object, keys) => {
+  const entries = keys.map((key) => [key, object[key]]);
+  return Object.fromEntries(entries);
 };
 const ImageDialog = ({ handleClose }) => {
-  const editor = slateReact.useSlate();
+  const { editor } = useBlocksEditorContext("ImageDialog");
   const { components } = helperPlugin.useLibrary();
+  if (!components)
+    return null;
   const MediaLibraryDialog = components["media-library"];
   const insertImages = (images) => {
     slate.Transforms.unwrapNodes(editor, {
-      match: (node) => node.type === "list",
+      match: (node) => !slate.Editor.isEditor(node) && node.type === "list",
       split: true
     });
-    const [, pathToInsert] = slate.Editor.above(editor, {
+    const nodeEntryBeingReplaced = slate.Editor.above(editor, {
       match(node) {
+        if (slate.Editor.isEditor(node))
+          return false;
         const isInlineNode = ["text", "link"].includes(node.type);
         return !isInlineNode;
       }
     });
+    if (!nodeEntryBeingReplaced)
+      return;
+    const [, pathToInsert] = nodeEntryBeingReplaced;
     slate.Transforms.removeNodes(editor);
     const nodesToInsert = images.map((image) => {
-      return { type: "image", image, children: [{ type: "text", text: "" }] };
+      const imageNode = {
+        type: "image",
+        image,
+        children: [{ type: "text", text: "" }]
+      };
+      return imageNode;
     });
     slate.Transforms.insertNodes(editor, nodesToInsert, { at: pathToInsert });
   };
   const handleSelectAssets = (images) => {
     const formattedImages = images.map((image) => {
       const expectedImage = pick(image, IMAGE_SCHEMA_FIELDS);
-      return {
+      const nodeImage = {
         ...expectedImage,
         alternativeText: expectedImage.alternativeText || expectedImage.name,
         url: helperPlugin.prefixFileUrlWithBackendUrl(image.url)
       };
+      return nodeImage;
     });
     insertImages(formattedImages);
     if (isLastBlockType(editor, "image")) {
@@ -4128,16 +4129,13 @@ const ImageDialog = ({ handleClose }) => {
     }
   );
 };
-ImageDialog.propTypes = {
-  handleClose: PropTypes__default.default.func.isRequired
-};
 const isLastBlockType = (editor, type) => {
   const { selection } = editor;
   if (!selection)
     return false;
   const [currentBlock] = slate.Editor.nodes(editor, {
     at: selection,
-    match: (n) => n.type === type
+    match: (node) => !slate.Editor.isEditor(node) && node.type === type
   });
   if (currentBlock) {
     const [, currentNodePath] = currentBlock;
@@ -4156,20 +4154,26 @@ const insertEmptyBlockAtLast = (editor) => {
     { at: [editor.children.length] }
   );
 };
-const BlocksDropdown = ({ disabled }) => {
-  const editor = slateReact.useSlate();
+const BlocksDropdown = () => {
+  const { editor, disabled } = useBlocksEditorContext("BlocksDropdown");
   const { formatMessage } = reactIntl.useIntl();
   const [isMediaLibraryVisible, setIsMediaLibraryVisible] = React__namespace.useState(false);
   const blocks = useBlocksStore();
-  const blockKeysToInclude = Object.entries(blocks).reduce((currentKeys, entry) => {
+  const blockKeysToInclude = getEntries(blocks).reduce((currentKeys, entry) => {
     const [key, block] = entry;
     return block.isInBlocksSelector ? [...currentKeys, key] : currentKeys;
   }, []);
-  const [blockSelected, setBlockSelected] = React__namespace.useState(Object.keys(blocks)[0]);
+  const [blockSelected, setBlockSelected] = React__namespace.useState("paragraph");
   const selectOption = (optionKey) => {
+    if (!isSelectorBlockKey(optionKey)) {
+      return;
+    }
     if (["list-ordered", "list-unordered"].includes(optionKey)) {
-      const listFormat = blocks[optionKey].value.format;
-      const isActive = isListActive(editor, blocks[optionKey].matchNode);
+      const listFormat = blocks[optionKey].value?.format;
+      const isActive = isListActive(
+        editor,
+        (node) => !slate.Editor.isEditor(node) && !isText$1(node) && blocks[optionKey].matchNode(node)
+      );
       toggleList(editor, isActive, listFormat);
     } else if (optionKey !== "image") {
       toggleBlock(editor, blocks[optionKey].value);
@@ -4189,8 +4193,8 @@ const BlocksDropdown = ({ disabled }) => {
         edge: "start",
         depth: 2
       });
-      const anchorBlockKey = Object.keys(blocks).find(
-        (blockKey) => blocks[blockKey].matchNode(anchorNode)
+      const anchorBlockKey = getKeys(blocks).find(
+        (blockKey) => !slate.Editor.isEditor(anchorNode) && blocks[blockKey].matchNode(anchorNode)
       );
       if (anchorBlockKey && anchorBlockKey !== blockSelected) {
         setBlockSelected(anchorBlockKey);
@@ -4203,7 +4207,7 @@ const BlocksDropdown = ({ disabled }) => {
       {
         startIcon: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Icon, { as: blocks[blockSelected].icon }),
         onChange: selectOption,
-        placeholder: blocks[blockSelected].label,
+        placeholder: formatMessage(blocks[blockSelected].label),
         value: blockSelected,
         onCloseAutoFocus: preventSelectFocus,
         "aria-label": formatMessage({
@@ -4226,9 +4230,6 @@ const BlocksDropdown = ({ disabled }) => {
     isMediaLibraryVisible && /* @__PURE__ */ jsxRuntime.jsx(ImageDialog, { handleClose: () => setIsMediaLibraryVisible(false) })
   ] });
 };
-BlocksDropdown.propTypes = {
-  disabled: PropTypes__default.default.bool.isRequired
-};
 const BlockOption = ({ value, icon, label, blockSelected }) => {
   const { formatMessage } = reactIntl.useIntl();
   const isSelected = value === blockSelected;
@@ -4241,17 +4242,11 @@ const BlockOption = ({ value, icon, label, blockSelected }) => {
     }
   );
 };
-BlockOption.propTypes = {
-  icon: PropTypes__default.default.elementType.isRequired,
-  value: PropTypes__default.default.string.isRequired,
-  label: PropTypes__default.default.shape({
-    id: PropTypes__default.default.string.isRequired,
-    defaultMessage: PropTypes__default.default.string.isRequired
-  }).isRequired,
-  blockSelected: PropTypes__default.default.string.isRequired
+const isText$1 = (node) => {
+  return slate.Node.isNode(node) && !slate.Editor.isEditor(node) && node.type === "text";
 };
 const isListNode = (node) => {
-  return !slate.Editor.isEditor(node) && slate.Element.isElement(node) && node.type === "list";
+  return slate.Node.isNode(node) && !slate.Editor.isEditor(node) && node.type === "list";
 };
 const isListActive = (editor, matchNode) => {
   const { selection } = editor;
@@ -4280,12 +4275,9 @@ const toggleList = (editor, isActive, format) => {
     }
   } else {
     const [, lastNodePath] = slate.Editor.last(editor, []);
-    const [parentNode] = slate.Editor.parent(editor, lastNodePath, {
-      // Makes sure we get a block node, not an inline node
-      match: (node) => node.type !== "text"
-    });
+    const [parentNode] = slate.Editor.parent(editor, lastNodePath);
     slate.Transforms.removeNodes(editor, {
-      void: true,
+      voids: true,
       hanging: true,
       at: {
         anchor: { path: lastNodePath, offset: 0 },
@@ -4309,15 +4301,14 @@ const toggleList = (editor, isActive, format) => {
     }
   }
 };
-const ListButton = ({ block, disabled }) => {
-  const editor = slateReact.useSlate();
-  const {
-    icon,
-    matchNode,
-    value: { format },
-    label
-  } = block;
-  const isActive = isListActive(editor, matchNode);
+const ListButton = ({ block }) => {
+  const { editor, disabled } = useBlocksEditorContext("ListButton");
+  const { icon, matchNode, value, label } = block;
+  const { format } = value;
+  const isActive = isListActive(
+    editor,
+    (node) => !slate.Editor.isEditor(node) && node.type !== "text" && matchNode(node)
+  );
   return /* @__PURE__ */ jsxRuntime.jsx(
     ToolbarButton,
     {
@@ -4330,22 +4321,8 @@ const ListButton = ({ block, disabled }) => {
     }
   );
 };
-ListButton.propTypes = {
-  block: PropTypes__default.default.shape({
-    icon: PropTypes__default.default.elementType.isRequired,
-    matchNode: PropTypes__default.default.func.isRequired,
-    value: PropTypes__default.default.shape({
-      format: PropTypes__default.default.string.isRequired
-    }).isRequired,
-    label: PropTypes__default.default.shape({
-      id: PropTypes__default.default.string.isRequired,
-      defaultMessage: PropTypes__default.default.string.isRequired
-    }).isRequired
-  }).isRequired,
-  disabled: PropTypes__default.default.bool.isRequired
-};
 const LinkButton = ({ disabled }) => {
-  const editor = slateReact.useSlate();
+  const { editor } = useBlocksEditorContext("LinkButton");
   const isLinkActive = () => {
     const { selection } = editor;
     if (!selection)
@@ -4367,12 +4344,15 @@ const LinkButton = ({ disabled }) => {
     }
     const anchorNodeEntry = slate.Editor.above(editor, {
       at: editor.selection.anchor,
-      match: (node) => node.type !== "text"
+      match: (node) => !slate.Editor.isEditor(node) && node.type !== "text"
     });
     const focusNodeEntry = slate.Editor.above(editor, {
       at: editor.selection.focus,
-      match: (node) => node.type !== "text"
+      match: (node) => !slate.Editor.isEditor(node) && node.type !== "text"
     });
+    if (!anchorNodeEntry || !focusNodeEntry) {
+      return false;
+    }
     return anchorNodeEntry[0] !== focusNodeEntry[0];
   };
   const addLink = () => {
@@ -4393,13 +4373,10 @@ const LinkButton = ({ disabled }) => {
     }
   );
 };
-LinkButton.propTypes = {
-  disabled: PropTypes__default.default.bool.isRequired
-};
-const BlocksToolbar = ({ disabled }) => {
+const BlocksToolbar = () => {
   const modifiers = useModifiersStore();
   const blocks = useBlocksStore();
-  const editor = slateReact.useSlate();
+  const { editor, disabled } = useBlocksEditorContext("BlocksToolbar");
   const checkButtonDisabled = () => {
     if (disabled) {
       return true;
@@ -4415,7 +4392,7 @@ const BlocksToolbar = ({ disabled }) => {
   };
   const isButtonDisabled = checkButtonDisabled();
   return /* @__PURE__ */ jsxRuntime.jsx(Toolbar__namespace.Root, { "aria-disabled": disabled, asChild: true, children: /* @__PURE__ */ jsxRuntime.jsxs(ToolbarWrapper, { gap: 2, padding: 2, children: [
-    /* @__PURE__ */ jsxRuntime.jsx(BlocksDropdown, { disabled }),
+    /* @__PURE__ */ jsxRuntime.jsx(BlocksDropdown, {}),
     /* @__PURE__ */ jsxRuntime.jsx(Separator, {}),
     /* @__PURE__ */ jsxRuntime.jsx(Toolbar__namespace.ToggleGroup, { type: "multiple", asChild: true, children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 1, children: [
       Object.entries(modifiers).map(([name, modifier]) => /* @__PURE__ */ jsxRuntime.jsx(
@@ -4434,32 +4411,91 @@ const BlocksToolbar = ({ disabled }) => {
     ] }) }),
     /* @__PURE__ */ jsxRuntime.jsx(Separator, {}),
     /* @__PURE__ */ jsxRuntime.jsx(Toolbar__namespace.ToggleGroup, { type: "single", asChild: true, children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 1, children: [
-      /* @__PURE__ */ jsxRuntime.jsx(ListButton, { block: blocks["list-unordered"], disabled }),
-      /* @__PURE__ */ jsxRuntime.jsx(ListButton, { block: blocks["list-ordered"], disabled })
+      /* @__PURE__ */ jsxRuntime.jsx(ListButton, { block: blocks["list-unordered"] }),
+      /* @__PURE__ */ jsxRuntime.jsx(ListButton, { block: blocks["list-ordered"] })
     ] }) })
   ] }) });
 };
-BlocksToolbar.propTypes = {
-  disabled: PropTypes__default.default.bool.isRequired
+const withLinks = (editor) => {
+  const { isInline, apply, insertText: insertText2, insertData } = editor;
+  editor.isInline = (element) => {
+    return element.type === "link" ? true : isInline(element);
+  };
+  editor.lastInsertedLinkPath = null;
+  editor.apply = (operation) => {
+    if (operation.type === "insert_node") {
+      if (!slate.Editor.isEditor(operation.node) && operation.node.type === "link") {
+        editor.lastInsertedLinkPath = operation.path;
+      }
+    } else if (operation.type === "move_node") {
+      if (slate.Path.hasPrevious(operation.path) && editor.lastInsertedLinkPath) {
+        editor.lastInsertedLinkPath = slate.Path.transform(editor.lastInsertedLinkPath, operation);
+      }
+    }
+    apply(operation);
+  };
+  editor.insertText = (text) => {
+    if (editor.selection && slate.Range.isCollapsed(editor.selection) && text === " ") {
+      const linksInSelection = Array.from(
+        slate.Editor.nodes(editor, {
+          at: editor.selection,
+          match: (node) => !slate.Editor.isEditor(node) && node.type === "link"
+        })
+      );
+      const selectionIsInLink = editor.selection && linksInSelection.length > 0;
+      const selectionIsAtEndOfLink = selectionIsInLink && slate.Point.equals(editor.selection.anchor, slate.Editor.end(editor, linksInSelection[0][1]));
+      if (selectionIsAtEndOfLink) {
+        slate.Transforms.insertNodes(
+          editor,
+          { text: " ", type: "text" },
+          { at: slate.Path.next(linksInSelection[0][1]), select: true }
+        );
+        return;
+      }
+    }
+    insertText2(text);
+  };
+  editor.insertData = (data) => {
+    const pastedText = data.getData("text/plain");
+    if (pastedText) {
+      try {
+        new URL(pastedText);
+        insertLink(editor, { url: pastedText });
+        return;
+      } catch (error) {
+      }
+    }
+    insertData(data);
+  };
+  return editor;
+};
+const isText = (node) => {
+  return slate.Node.isNode(node) && !slate.Editor.isEditor(node) && node.type === "text";
 };
-const TypographyAsterisk$1 = styled__default.default(designSystem.Typography)`
-  line-height: 0;
-`;
-const LabelAction$2 = styled__default.default(designSystem.Box)`
-  svg path {
-    fill: ${({ theme }) => theme.colors.neutral500};
-  }
-`;
-const EditorDivider = styled__default.default(designSystem.Divider)`
-  background: ${({ theme }) => theme.colors.neutral200};
-`;
-const withImages = (editor) => {
-  const { isVoid } = editor;
-  editor.isVoid = (element) => {
-    return element.type === "image" ? true : isVoid(element);
+const withStrapiSchema = (editor) => {
+  const { normalizeNode } = editor;
+  editor.normalizeNode = (entry) => {
+    const [node, path] = entry;
+    if (!slate.Element.isElement(node) && !isText(node)) {
+      slate.Transforms.setNodes(editor, { type: "text" }, { at: path });
+      return;
+    }
+    normalizeNode(entry);
   };
   return editor;
 };
+const [BlocksEditorProvider, usePartialBlocksEditorContext] = reactContext.createContext("BlocksEditor");
+function useBlocksEditorContext(consumerName) {
+  const context = usePartialBlocksEditorContext(consumerName);
+  const editor = slateReact.useSlate();
+  return {
+    ...context,
+    editor
+  };
+}
+const EditorDivider = styled__default.default(designSystem.Divider)`
+  background: ${({ theme }) => theme.colors.neutral200};
+`;
 function useResetKey(value) {
   const slateUpdatesCount = React__namespace.useRef(0);
   const valueUpdatesCount = React__namespace.useRef(0);
@@ -4473,20 +4509,23 @@ function useResetKey(value) {
   }, [value]);
   return { key, incrementSlateUpdatesCount: () => slateUpdatesCount.current += 1 };
 }
+const withImages = (editor) => {
+  const { isVoid } = editor;
+  editor.isVoid = (element) => {
+    return element.type === "image" ? true : isVoid(element);
+  };
+  return editor;
+};
 const pipe = (...fns) => (value) => fns.reduce((prev, fn) => fn(prev), value);
 const BlocksEditor = React__namespace.forwardRef(
-  ({ intlLabel, labelAction, name, disabled, required, error, value, onChange, placeholder, hint }, ref) => {
+  ({ disabled = false, name, placeholder, onChange, value, error }, forwardedRef) => {
     const { formatMessage } = reactIntl.useIntl();
     const [editor] = React__namespace.useState(
       () => pipe(slateHistory.withHistory, withImages, withStrapiSchema, slateReact.withReact, withLinks)(slate.createEditor())
     );
-    const label = intlLabel.id ? formatMessage(
-      { id: intlLabel.id, defaultMessage: intlLabel.defaultMessage },
-      { ...intlLabel.values }
-    ) : name;
-    const formattedPlaceholder = placeholder ? formatMessage({ id: placeholder.id, defaultMessage: placeholder.defaultMessage }) : null;
+    const formattedPlaceholder = placeholder && formatMessage({ id: placeholder.id, defaultMessage: placeholder.defaultMessage });
     React__namespace.useImperativeHandle(
-      ref,
+      forwardedRef,
       () => ({
         focus() {
           slateReact.ReactEditor.focus(editor);
@@ -4500,67 +4539,64 @@ const BlocksEditor = React__namespace.forwardRef(
       if (isAstChange) {
         incrementSlateUpdatesCount();
         onChange({
+          // Casting is needed because Slate's onChange type doesn't take into consideration
+          // that we set Editor['children'] to Attribute.BlocksValue in custom.d.ts
           target: { name, value: state, type: "blocks" }
         });
       }
     };
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      slateReact.Slate,
+      {
+        editor,
+        initialValue: value || [{ type: "paragraph", children: [{ type: "text", text: "" }] }],
+        onChange: handleSlateChange,
+        children: /* @__PURE__ */ jsxRuntime.jsx(BlocksEditorProvider, { disabled, children: /* @__PURE__ */ jsxRuntime.jsxs(
+          designSystem.InputWrapper,
+          {
+            direction: "column",
+            alignItems: "flex-start",
+            height: "512px",
+            disabled,
+            hasError: Boolean(error),
+            style: { overflow: "hidden" },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(BlocksToolbar, {}),
+              /* @__PURE__ */ jsxRuntime.jsx(EditorDivider, { width: "100%" }),
+              /* @__PURE__ */ jsxRuntime.jsx(BlocksContent, { placeholder: formattedPlaceholder })
+            ]
+          }
+        ) })
+      },
+      key
+    );
+  }
+);
+const LabelAction$2 = styled__default.default(designSystem.Box)`
+  svg path {
+    fill: ${({ theme }) => theme.colors.neutral500};
+  }
+`;
+const BlocksInput = React__namespace.forwardRef(
+  ({ intlLabel, labelAction, name, required = false, error = "", hint = null, ...editorProps }, forwardedRef) => {
+    const { formatMessage } = reactIntl.useIntl();
+    const label = intlLabel.id ? formatMessage(intlLabel) : name;
     return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
       /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", alignItems: "stretch", gap: 1, children: [
         /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 1, children: [
           /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { variant: "pi", fontWeight: "bold", textColor: "neutral800", children: [
             label,
-            required && /* @__PURE__ */ jsxRuntime.jsx(TypographyAsterisk$1, { textColor: "danger600", children: "*" })
+            required && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: "danger600", lineHeight: "0px", children: "*" })
           ] }),
           labelAction && /* @__PURE__ */ jsxRuntime.jsx(LabelAction$2, { paddingLeft: 1, children: labelAction })
         ] }),
-        /* @__PURE__ */ jsxRuntime.jsx(
-          slateReact.Slate,
-          {
-            editor,
-            initialValue: value || [{ type: "paragraph", children: [{ type: "text", text: "" }] }],
-            onChange: handleSlateChange,
-            children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.InputWrapper, { direction: "column", alignItems: "flex-start", height: "512px", children: [
-              /* @__PURE__ */ jsxRuntime.jsx(BlocksToolbar, { disabled }),
-              /* @__PURE__ */ jsxRuntime.jsx(EditorDivider, { width: "100%" }),
-              /* @__PURE__ */ jsxRuntime.jsx(BlocksInput, { disabled, placeholder: formattedPlaceholder })
-            ] })
-          },
-          key
-        ),
+        /* @__PURE__ */ jsxRuntime.jsx(BlocksEditor, { name, error, ref: forwardedRef, ...editorProps }),
         /* @__PURE__ */ jsxRuntime.jsx(Hint, { hint, name, error })
       ] }),
       error && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 1, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "danger600", "data-strapi-field-error": true, children: error }) })
     ] });
   }
 );
-BlocksEditor.defaultProps = {
-  labelAction: null,
-  disabled: false,
-  required: false,
-  error: "",
-  value: null,
-  placeholder: null,
-  hint: null
-};
-BlocksEditor.propTypes = {
-  intlLabel: PropTypes__default.default.shape({
-    id: PropTypes__default.default.string.isRequired,
-    defaultMessage: PropTypes__default.default.string.isRequired,
-    values: PropTypes__default.default.object
-  }).isRequired,
-  labelAction: PropTypes__default.default.element,
-  name: PropTypes__default.default.string.isRequired,
-  required: PropTypes__default.default.bool,
-  disabled: PropTypes__default.default.bool,
-  error: PropTypes__default.default.string,
-  onChange: PropTypes__default.default.func.isRequired,
-  value: PropTypes__default.default.array,
-  placeholder: PropTypes__default.default.shape({
-    id: PropTypes__default.default.string.isRequired,
-    defaultMessage: PropTypes__default.default.string.isRequired
-  }),
-  hint: PropTypes__default.default.oneOfType([PropTypes__default.default.string, PropTypes__default.default.array])
-};
 const FieldActionWrapper = styled__default.default(designSystem.FieldAction)`
   svg {
     height: 1rem;
@@ -5067,7 +5103,7 @@ const useRelation = (cacheKey, { relation, search }) => {
     setSearchParams({
       ...options2,
       _q: term,
-      _filter: "$startsWithi"
+      _filter: "$containsi"
     });
   };
   return { relations: relationsRes, search: searchRes, searchFor };
@@ -5427,7 +5463,7 @@ const RelationInput = ({
   }, [paginatedRelations, relations, numberOfRelationsToDisplay, totalNumberOfRelations]);
   const handleMenuOpen = (isOpen) => {
     if (isOpen) {
-      onSearch();
+      onSearch(textValue);
     }
   };
   const handleUpdatePositionOfRelation = (newIndex, currentIndex) => {
@@ -5468,7 +5504,7 @@ const RelationInput = ({
             designSystem.Combobox,
             {
               ref: fieldRef,
-              autocomplete: "list",
+              autocomplete: "none",
               error,
               name,
               hint: description,
@@ -7827,7 +7863,7 @@ function Inputs({
     uid: InputUID,
     media: fields.media,
     wysiwyg: Wysiwyg,
-    blocks: BlocksEditor,
+    blocks: BlocksInput,
     ...fields,
     ...customFieldInputs
   };
@@ -11200,7 +11236,7 @@ const EditView = ({ allowedActions, isSingleType, goBack, slug, id, origin, user
   const toggleNotification = helperPlugin.useNotification();
   const Information2 = index$2.useEnterprise(
     InformationBoxCE,
-    async () => (await Promise.resolve().then(() => require("./index-787a0db6.js"))).InformationBoxEE
+    async () => (await Promise.resolve().then(() => require("./index-8759f1d9.js"))).InformationBoxEE
   );
   useOnce(() => {
     if (location?.state && "error" in location.state) {
@@ -14046,7 +14082,7 @@ function ListView({ canCreate, canDelete, canRead, canPublish, layout, slug }) {
   const hasReviewWorkflows = options2?.reviewWorkflows ?? false;
   const reviewWorkflowColumns = index$2.useEnterprise(
     REVIEW_WORKFLOW_COLUMNS_CE,
-    async () => (await Promise.resolve().then(() => require("./constants-ec71917d.js"))).REVIEW_WORKFLOW_COLUMNS_EE,
+    async () => (await Promise.resolve().then(() => require("./constants-dd4a9742.js"))).REVIEW_WORKFLOW_COLUMNS_EE,
     {
       enabled: !!options2?.reviewWorkflows
     }
@@ -14054,7 +14090,7 @@ function ListView({ canCreate, canDelete, canRead, canPublish, layout, slug }) {
   const ReviewWorkflowsColumns = index$2.useEnterprise(
     REVIEW_WORKFLOW_COLUMNS_CELL_CE,
     async () => {
-      const { ReviewWorkflowsStageEE, ReviewWorkflowsAssigneeEE } = await Promise.resolve().then(() => require("./index-d5f569ab.js"));
+      const { ReviewWorkflowsStageEE, ReviewWorkflowsAssigneeEE } = await Promise.resolve().then(() => require("./index-cf24d5a0.js"));
       return { ReviewWorkflowsStageEE, ReviewWorkflowsAssigneeEE };
     },
     {
@@ -14063,7 +14099,7 @@ function ListView({ canCreate, canDelete, canRead, canPublish, layout, slug }) {
   );
   const reviewWorkflowFilter = index$2.useEnterprise(
     REVIEW_WORKFLOW_FILTER_CE,
-    async () => (await Promise.resolve().then(() => require("./constants-008a1527.js"))).REVIEW_WORKFLOW_FILTERS,
+    async () => (await Promise.resolve().then(() => require("./constants-5fd54815.js"))).REVIEW_WORKFLOW_FILTERS,
     {
       combine(ceFilters, eeFilters) {
         return [
@@ -15362,4 +15398,4 @@ const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
 exports.Information = Information;
 exports.getDisplayName = getDisplayName;
 exports.index = index$1;
-//# sourceMappingURL=index-9304d6de.js.map
+//# sourceMappingURL=index-9d98e8b2.js.map