payload 1.4.2 → 1.5.0

package/dist/admin/components/forms/field-types/RichText/elements/h3/index.js

@@ -1,10 +1,15 @@
-import React from 'react';
-import ElementButton from '../Button';
-import H3Icon from '../../../../../icons/headings/H3';
-const H3 = ({ attributes, children }) => (React.createElement("h3", { ...attributes }, children));
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const Button_1 = __importDefault(require("../Button"));
+const H3_1 = __importDefault(require("../../../../../icons/headings/H3"));
+const H3 = ({ attributes, children }) => (react_1.default.createElement("h3", { ...attributes }, children));
 const h3 = {
-    Button: () => (React.createElement(ElementButton, { format: "h3" },
-        React.createElement(H3Icon, null))),
+    Button: () => (react_1.default.createElement(Button_1.default, { format: "h3" },
+        react_1.default.createElement(H3_1.default, null))),
     Element: H3,
 };
-export default h3;
+exports.default = h3;

package/dist/admin/components/forms/field-types/RichText/elements/h4/index.js

@@ -1,10 +1,15 @@
-import React from 'react';
-import ElementButton from '../Button';
-import H4Icon from '../../../../../icons/headings/H4';
-const H4 = ({ attributes, children }) => (React.createElement("h4", { ...attributes }, children));
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const Button_1 = __importDefault(require("../Button"));
+const H4_1 = __importDefault(require("../../../../../icons/headings/H4"));
+const H4 = ({ attributes, children }) => (react_1.default.createElement("h4", { ...attributes }, children));
 const h4 = {
-    Button: () => (React.createElement(ElementButton, { format: "h4" },
-        React.createElement(H4Icon, null))),
+    Button: () => (react_1.default.createElement(Button_1.default, { format: "h4" },
+        react_1.default.createElement(H4_1.default, null))),
     Element: H4,
 };
-export default h4;
+exports.default = h4;

package/dist/admin/components/forms/field-types/RichText/elements/h5/index.js

@@ -1,10 +1,15 @@
-import React from 'react';
-import ElementButton from '../Button';
-import H5Icon from '../../../../../icons/headings/H5';
-const H5 = ({ attributes, children }) => (React.createElement("h5", { ...attributes }, children));
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const Button_1 = __importDefault(require("../Button"));
+const H5_1 = __importDefault(require("../../../../../icons/headings/H5"));
+const H5 = ({ attributes, children }) => (react_1.default.createElement("h5", { ...attributes }, children));
 const h5 = {
-    Button: () => (React.createElement(ElementButton, { format: "h5" },
-        React.createElement(H5Icon, null))),
+    Button: () => (react_1.default.createElement(Button_1.default, { format: "h5" },
+        react_1.default.createElement(H5_1.default, null))),
     Element: H5,
 };
-export default h5;
+exports.default = h5;

package/dist/admin/components/forms/field-types/RichText/elements/h6/index.js

@@ -1,10 +1,15 @@
-import React from 'react';
-import ElementButton from '../Button';
-import H6Icon from '../../../../../icons/headings/H6';
-const H6 = ({ attributes, children }) => (React.createElement("h6", { ...attributes }, children));
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const Button_1 = __importDefault(require("../Button"));
+const H6_1 = __importDefault(require("../../../../../icons/headings/H6"));
+const H6 = ({ attributes, children }) => (react_1.default.createElement("h6", { ...attributes }, children));
 const h6 = {
-    Button: () => (React.createElement(ElementButton, { format: "h6" },
-        React.createElement(H6Icon, null))),
+    Button: () => (react_1.default.createElement(Button_1.default, { format: "h6" },
+        react_1.default.createElement(H6_1.default, null))),
     Element: H6,
 };
-export default h6;
+exports.default = h6;

package/dist/admin/components/forms/field-types/RichText/elements/indent/index.js

@@ -1,47 +1,75 @@
-import React, { useCallback } from 'react';
-import { useSlate, ReactEditor } from 'slate-react';
-import { Editor, Element, Text, Transforms } from 'slate';
-import IndentLeft from '../../../../../icons/IndentLeft';
-import IndentRight from '../../../../../icons/IndentRight';
-import { baseClass } from '../Button';
-import isElementActive from '../isActive';
-import listTypes from '../listTypes';
-import { getCommonBlock } from '../getCommonBlock';
-import { unwrapList } from '../unwrapList';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importStar(require("react"));
+const slate_react_1 = require("slate-react");
+const slate_1 = require("slate");
+const IndentLeft_1 = __importDefault(require("../../../../../icons/IndentLeft"));
+const IndentRight_1 = __importDefault(require("../../../../../icons/IndentRight"));
+const Button_1 = require("../Button");
+const isActive_1 = __importDefault(require("../isActive"));
+const listTypes_1 = __importDefault(require("../listTypes"));
+const getCommonBlock_1 = require("../getCommonBlock");
+const unwrapList_1 = require("../unwrapList");
 const indentType = 'indent';
-const IndentWithPadding = ({ attributes, children }) => (React.createElement("div", { style: { paddingLeft: 25 }, ...attributes }, children));
+const IndentWithPadding = ({ attributes, children }) => (react_1.default.createElement("div", { style: { paddingLeft: 25 }, ...attributes }, children));
 const indent = {
     Button: () => {
-        const editor = useSlate();
-        const handleIndent = useCallback((e, dir) => {
+        const editor = (0, slate_react_1.useSlate)();
+        const handleIndent = (0, react_1.useCallback)((e, dir) => {
             e.preventDefault();
             if (dir === 'left') {
-                if (isElementActive(editor, 'li')) {
-                    const [, listPath] = getCommonBlock(editor, (n) => Element.isElement(n) && listTypes.includes(n.type));
-                    const matchedParentList = Editor.above(editor, {
+                if ((0, isActive_1.default)(editor, 'li')) {
+                    const [, listPath] = (0, getCommonBlock_1.getCommonBlock)(editor, (n) => slate_1.Element.isElement(n) && listTypes_1.default.includes(n.type));
+                    const matchedParentList = slate_1.Editor.above(editor, {
                         at: listPath,
-                        match: (n) => !Editor.isEditor(n) && Editor.isBlock(editor, n),
+                        match: (n) => !slate_1.Editor.isEditor(n) && slate_1.Editor.isBlock(editor, n),
                     });
                     if (matchedParentList) {
                         const [parentListItem, parentListItemPath] = matchedParentList;
                         if (parentListItem.children.length > 1) {
                             // Remove nested list
-                            Transforms.unwrapNodes(editor, {
+                            slate_1.Transforms.unwrapNodes(editor, {
                                 at: parentListItemPath,
                                 match: (node, path) => {
-                                    const matches = !Editor.isEditor(node)
-                                        && Element.isElement(node)
-                                        && listTypes.includes(node.type)
+                                    const matches = !slate_1.Editor.isEditor(node)
+                                        && slate_1.Element.isElement(node)
+                                        && listTypes_1.default.includes(node.type)
                                         && path.length === parentListItemPath.length + 1;
                                     return matches;
                                 },
                             });
                             // Set li type on any children that don't have a type
-                            Transforms.setNodes(editor, { type: 'li' }, {
+                            slate_1.Transforms.setNodes(editor, { type: 'li' }, {
                                 at: parentListItemPath,
                                 match: (node, path) => {
-                                    const matches = !Editor.isEditor(node)
-                                        && Element.isElement(node)
+                                    const matches = !slate_1.Editor.isEditor(node)
+                                        && slate_1.Element.isElement(node)
                                         && node.type !== 'li'
                                         && path.length === parentListItemPath.length + 1;
                                     return matches;
@@ -49,16 +77,16 @@ const indent = {
                             });
                             // Parent list item path has changed at this point
                             // so we need to re-fetch the parent node
-                            const [newParentNode] = Editor.node(editor, parentListItemPath);
+                            const [newParentNode] = slate_1.Editor.node(editor, parentListItemPath);
                             // If the parent node is an li,
                             // lift all li nodes within
-                            if (Element.isElement(newParentNode) && newParentNode.type === 'li') {
+                            if (slate_1.Element.isElement(newParentNode) && newParentNode.type === 'li') {
                                 // Lift the nested lis
-                                Transforms.liftNodes(editor, {
+                                slate_1.Transforms.liftNodes(editor, {
                                     at: parentListItemPath,
                                     match: (node, path) => {
-                                        const matches = !Editor.isEditor(node)
-                                            && Element.isElement(node)
+                                        const matches = !slate_1.Editor.isEditor(node)
+                                            && slate_1.Element.isElement(node)
                                             && path.length === parentListItemPath.length + 1
                                             && node.type === 'li';
                                         return matches;
@@ -67,96 +95,96 @@ const indent = {
                             }
                         }
                         else {
-                            Transforms.unwrapNodes(editor, {
+                            slate_1.Transforms.unwrapNodes(editor, {
                                 at: parentListItemPath,
                                 match: (node, path) => {
-                                    return Element.isElement(node)
+                                    return slate_1.Element.isElement(node)
                                         && node.type === 'li'
                                         && path.length === parentListItemPath.length;
                                 },
                             });
-                            Transforms.unwrapNodes(editor, {
-                                match: (n) => Element.isElement(n) && listTypes.includes(n.type),
+                            slate_1.Transforms.unwrapNodes(editor, {
+                                match: (n) => slate_1.Element.isElement(n) && listTypes_1.default.includes(n.type),
                             });
                         }
                     }
                     else {
-                        unwrapList(editor, listPath);
+                        (0, unwrapList_1.unwrapList)(editor, listPath);
                     }
                 }
                 else {
-                    Transforms.unwrapNodes(editor, {
-                        match: (n) => Element.isElement(n) && n.type === indentType,
+                    slate_1.Transforms.unwrapNodes(editor, {
+                        match: (n) => slate_1.Element.isElement(n) && n.type === indentType,
                         split: true,
                         mode: 'lowest',
                     });
                 }
             }
             if (dir === 'right') {
-                const isCurrentlyOL = isElementActive(editor, 'ol');
-                const isCurrentlyUL = isElementActive(editor, 'ul');
+                const isCurrentlyOL = (0, isActive_1.default)(editor, 'ol');
+                const isCurrentlyUL = (0, isActive_1.default)(editor, 'ul');
                 if (isCurrentlyOL || isCurrentlyUL) {
                     // Get the path of the first selected li -
                     // Multiple lis could be selected
                     // and the selection may start in the middle of the first li
-                    const [[, firstSelectedLIPath]] = Array.from(Editor.nodes(editor, {
+                    const [[, firstSelectedLIPath]] = Array.from(slate_1.Editor.nodes(editor, {
                         mode: 'lowest',
-                        match: (node) => Element.isElement(node) && node.type === 'li',
+                        match: (node) => slate_1.Element.isElement(node) && node.type === 'li',
                     }));
                     // Is the first selected li the first in its list?
                     const hasPrecedingLI = firstSelectedLIPath[firstSelectedLIPath.length - 1] > 0;
                     // If the first selected li is NOT the first in its list,
                     // we need to inject it into the prior li
                     if (hasPrecedingLI) {
-                        const [, precedingLIPath] = Editor.previous(editor, {
+                        const [, precedingLIPath] = slate_1.Editor.previous(editor, {
                             at: firstSelectedLIPath,
                         });
-                        const [precedingLIChildren] = Editor.node(editor, [...precedingLIPath, 0]);
-                        const precedingLIChildrenIsText = Text.isText(precedingLIChildren);
+                        const [precedingLIChildren] = slate_1.Editor.node(editor, [...precedingLIPath, 0]);
+                        const precedingLIChildrenIsText = slate_1.Text.isText(precedingLIChildren);
                         if (precedingLIChildrenIsText) {
                             // Wrap the prior li text content so that it can be nested next to a list
-                            Transforms.wrapNodes(editor, { children: [] }, { at: [...precedingLIPath, 0] });
+                            slate_1.Transforms.wrapNodes(editor, { children: [] }, { at: [...precedingLIPath, 0] });
                         }
                         // Move the selected lis after the prior li contents
-                        Transforms.moveNodes(editor, {
+                        slate_1.Transforms.moveNodes(editor, {
                             to: [...precedingLIPath, 1],
-                            match: (node) => Element.isElement(node) && node.type === 'li',
+                            match: (node) => slate_1.Element.isElement(node) && node.type === 'li',
                             mode: 'lowest',
                         });
                         // Wrap the selected lis in a new list
-                        Transforms.wrapNodes(editor, {
+                        slate_1.Transforms.wrapNodes(editor, {
                             type: isCurrentlyOL ? 'ol' : 'ul', children: [],
                         }, {
-                            match: (node) => Element.isElement(node) && node.type === 'li',
+                            match: (node) => slate_1.Element.isElement(node) && node.type === 'li',
                             mode: 'lowest',
                         });
                     }
                     else {
                         // Otherwise, just wrap the node in a list / li
-                        Transforms.wrapNodes(editor, {
+                        slate_1.Transforms.wrapNodes(editor, {
                             type: isCurrentlyOL ? 'ol' : 'ul', children: [{ type: 'li', children: [] }],
                         }, {
-                            match: (node) => Element.isElement(node) && node.type === 'li',
+                            match: (node) => slate_1.Element.isElement(node) && node.type === 'li',
                             mode: 'lowest',
                         });
                     }
                 }
                 else {
-                    Transforms.wrapNodes(editor, { type: indentType, children: [] });
+                    slate_1.Transforms.wrapNodes(editor, { type: indentType, children: [] });
                 }
             }
-            ReactEditor.focus(editor);
+            slate_react_1.ReactEditor.focus(editor);
         }, [editor]);
-        const canDeIndent = isElementActive(editor, 'li') || isElementActive(editor, indentType);
-        return (React.createElement(React.Fragment, null,
-            React.createElement("button", { type: "button", className: [
-                    baseClass,
-                    !canDeIndent && `${baseClass}--disabled`,
+        const canDeIndent = (0, isActive_1.default)(editor, 'li') || (0, isActive_1.default)(editor, indentType);
+        return (react_1.default.createElement(react_1.default.Fragment, null,
+            react_1.default.createElement("button", { type: "button", className: [
+                    Button_1.baseClass,
+                    !canDeIndent && `${Button_1.baseClass}--disabled`,
                 ].filter(Boolean).join(' '), onClick: canDeIndent ? (e) => handleIndent(e, 'left') : undefined },
-                React.createElement(IndentLeft, null)),
-            React.createElement("button", { type: "button", className: baseClass, onClick: (e) => handleIndent(e, 'right') },
-                React.createElement(IndentRight, null))));
+                react_1.default.createElement(IndentLeft_1.default, null)),
+            react_1.default.createElement("button", { type: "button", className: Button_1.baseClass, onClick: (e) => handleIndent(e, 'right') },
+                react_1.default.createElement(IndentRight_1.default, null))));
     },
     Element: IndentWithPadding,
 };
-export default indent;
+exports.default = indent;

package/dist/admin/components/forms/field-types/RichText/elements/index.js

@@ -1,29 +1,34 @@
-import h1 from './h1';
-import h2 from './h2';
-import h3 from './h3';
-import h4 from './h4';
-import h5 from './h5';
-import h6 from './h6';
-import link from './link';
-import ol from './ol';
-import ul from './ul';
-import li from './li';
-import indent from './indent';
-import relationship from './relationship';
-import upload from './upload';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const h1_1 = __importDefault(require("./h1"));
+const h2_1 = __importDefault(require("./h2"));
+const h3_1 = __importDefault(require("./h3"));
+const h4_1 = __importDefault(require("./h4"));
+const h5_1 = __importDefault(require("./h5"));
+const h6_1 = __importDefault(require("./h6"));
+const link_1 = __importDefault(require("./link"));
+const ol_1 = __importDefault(require("./ol"));
+const ul_1 = __importDefault(require("./ul"));
+const li_1 = __importDefault(require("./li"));
+const indent_1 = __importDefault(require("./indent"));
+const relationship_1 = __importDefault(require("./relationship"));
+const upload_1 = __importDefault(require("./upload"));
 const elements = {
-    h1,
-    h2,
-    h3,
-    h4,
-    h5,
-    h6,
-    link,
-    ol,
-    ul,
-    li,
-    indent,
-    relationship,
-    upload,
+    h1: h1_1.default,
+    h2: h2_1.default,
+    h3: h3_1.default,
+    h4: h4_1.default,
+    h5: h5_1.default,
+    h6: h6_1.default,
+    link: link_1.default,
+    ol: ol_1.default,
+    ul: ul_1.default,
+    li: li_1.default,
+    indent: indent_1.default,
+    relationship: relationship_1.default,
+    upload: upload_1.default,
 };
-export default elements;
+exports.default = elements;

package/dist/admin/components/forms/field-types/RichText/elements/injectVoid.js

@@ -1,24 +1,28 @@
-import { Editor, Transforms } from 'slate';
-import { isLastSelectedElementEmpty } from './isLastSelectedElementEmpty';
-export const injectVoidElement = (editor, element) => {
-    const lastSelectedElementIsEmpty = isLastSelectedElementEmpty(editor);
-    const previous = Editor.previous(editor);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectVoidElement = void 0;
+const slate_1 = require("slate");
+const isLastSelectedElementEmpty_1 = require("./isLastSelectedElementEmpty");
+const injectVoidElement = (editor, element) => {
+    const lastSelectedElementIsEmpty = (0, isLastSelectedElementEmpty_1.isLastSelectedElementEmpty)(editor);
+    const previous = slate_1.Editor.previous(editor);
     if (lastSelectedElementIsEmpty) {
         // If previous node is void
-        if (Editor.isVoid(editor, previous === null || previous === void 0 ? void 0 : previous[0])) {
+        if (slate_1.Editor.isVoid(editor, previous === null || previous === void 0 ? void 0 : previous[0])) {
             // Insert a blank element between void nodes
             // so user can place cursor between void nodes
-            Transforms.insertNodes(editor, { children: [{ text: '' }] });
-            Transforms.setNodes(editor, element);
+            slate_1.Transforms.insertNodes(editor, { children: [{ text: '' }] });
+            slate_1.Transforms.setNodes(editor, element);
             // Otherwise just set the empty node equal to new void
         }
         else {
-            Transforms.setNodes(editor, element);
+            slate_1.Transforms.setNodes(editor, element);
         }
     }
     else {
-        Transforms.insertNodes(editor, element);
+        slate_1.Transforms.insertNodes(editor, element);
     }
     // Add an empty node after the new void
-    Transforms.insertNodes(editor, { children: [{ text: '' }] });
+    slate_1.Transforms.insertNodes(editor, { children: [{ text: '' }] });
 };
+exports.injectVoidElement = injectVoidElement;

package/dist/admin/components/forms/field-types/RichText/elements/isActive.js

@@ -1,11 +1,13 @@
-import { Editor, Element } from 'slate';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const slate_1 = require("slate");
 const isElementActive = (editor, format) => {
     if (!editor.selection)
         return false;
-    const [match] = Array.from(Editor.nodes(editor, {
-        at: Editor.unhangRange(editor, editor.selection),
-        match: (n) => !Editor.isEditor(n) && Element.isElement(n) && n.type === format,
+    const [match] = Array.from(slate_1.Editor.nodes(editor, {
+        at: slate_1.Editor.unhangRange(editor, editor.selection),
+        match: (n) => !slate_1.Editor.isEditor(n) && slate_1.Element.isElement(n) && n.type === format,
     }));
     return !!match;
 };
-export default isElementActive;
+exports.default = isElementActive;

package/dist/admin/components/forms/field-types/RichText/elements/isLastSelectedElementEmpty.js

@@ -1,16 +1,20 @@
-import { Editor, Element } from 'slate';
-import { nodeIsTextNode } from '../types';
-export const isLastSelectedElementEmpty = (editor) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLastSelectedElementEmpty = void 0;
+const slate_1 = require("slate");
+const types_1 = require("../types");
+const isLastSelectedElementEmpty = (editor) => {
     var _a, _b;
     if (!editor.selection)
         return false;
-    const currentlySelectedNodes = Array.from(Editor.nodes(editor, {
-        at: Editor.unhangRange(editor, editor.selection),
-        match: (n) => !Editor.isEditor(n) && Element.isElement(n) && (!n.type || n.type === 'p'),
+    const currentlySelectedNodes = Array.from(slate_1.Editor.nodes(editor, {
+        at: slate_1.Editor.unhangRange(editor, editor.selection),
+        match: (n) => !slate_1.Editor.isEditor(n) && slate_1.Element.isElement(n) && (!n.type || n.type === 'p'),
     }));
     const lastSelectedNode = currentlySelectedNodes === null || currentlySelectedNodes === void 0 ? void 0 : currentlySelectedNodes[(currentlySelectedNodes === null || currentlySelectedNodes === void 0 ? void 0 : currentlySelectedNodes.length) - 1];
-    return lastSelectedNode && Element.isElement(lastSelectedNode[0])
+    return lastSelectedNode && slate_1.Element.isElement(lastSelectedNode[0])
         && (!lastSelectedNode[0].type || lastSelectedNode[0].type === 'p')
-        && nodeIsTextNode((_a = lastSelectedNode[0].children) === null || _a === void 0 ? void 0 : _a[0])
+        && (0, types_1.nodeIsTextNode)((_a = lastSelectedNode[0].children) === null || _a === void 0 ? void 0 : _a[0])
         && ((_b = lastSelectedNode[0].children) === null || _b === void 0 ? void 0 : _b[0].text) === '';
 };
+exports.isLastSelectedElementEmpty = isLastSelectedElementEmpty;

package/dist/admin/components/forms/field-types/RichText/elements/isListActive.js

@@ -1,21 +1,23 @@
-import { Editor, Element } from 'slate';
-import { getCommonBlock } from './getCommonBlock';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const slate_1 = require("slate");
+const getCommonBlock_1 = require("./getCommonBlock");
 const isListActive = (editor, format) => {
     if (!editor.selection)
         return false;
-    const [topmostSelectedNode, topmostSelectedNodePath] = getCommonBlock(editor);
-    if (Editor.isEditor(topmostSelectedNode))
+    const [topmostSelectedNode, topmostSelectedNodePath] = (0, getCommonBlock_1.getCommonBlock)(editor);
+    if (slate_1.Editor.isEditor(topmostSelectedNode))
         return false;
-    const [match] = Array.from(Editor.nodes(editor, {
+    const [match] = Array.from(slate_1.Editor.nodes(editor, {
         at: topmostSelectedNodePath,
         mode: 'lowest',
         match: (node, path) => {
-            return !Editor.isEditor(node)
-                && Element.isElement(node)
+            return !slate_1.Editor.isEditor(node)
+                && slate_1.Element.isElement(node)
                 && node.type === format
                 && path.length >= topmostSelectedNodePath.length - 2;
         },
     }));
     return !!match;
 };
-export default isListActive;
+exports.default = isListActive;

package/dist/admin/components/forms/field-types/RichText/elements/isWithinListItem.js

@@ -1,15 +1,19 @@
-import { Editor, Element } from 'slate';
-export const isWithinListItem = (editor) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWithinListItem = void 0;
+const slate_1 = require("slate");
+const isWithinListItem = (editor) => {
     var _a;
     let parentLI;
     try {
-        parentLI = Editor.parent(editor, editor.selection);
+        parentLI = slate_1.Editor.parent(editor, editor.selection);
     }
     catch (e) {
         // swallow error, Slate
     }
-    if (Element.isElement(parentLI === null || parentLI === void 0 ? void 0 : parentLI[0]) && ((_a = parentLI === null || parentLI === void 0 ? void 0 : parentLI[0]) === null || _a === void 0 ? void 0 : _a.type) === 'li') {
+    if (slate_1.Element.isElement(parentLI === null || parentLI === void 0 ? void 0 : parentLI[0]) && ((_a = parentLI === null || parentLI === void 0 ? void 0 : parentLI[0]) === null || _a === void 0 ? void 0 : _a.type) === 'li') {
         return true;
     }
     return false;
 };
+exports.isWithinListItem = isWithinListItem;

package/dist/admin/components/forms/field-types/RichText/elements/li/index.js

@@ -1,11 +1,16 @@
-import React from 'react';
-import listTypes from '../listTypes';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const listTypes_1 = __importDefault(require("../listTypes"));
 const LI = (props) => {
     var _a, _b;
     const { attributes, element, children } = props;
-    const disableListStyle = element.children.length >= 1 && listTypes.includes((_b = (_a = element.children) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.type);
-    return (React.createElement("li", { style: { listStyle: disableListStyle ? 'none' : undefined }, ...attributes }, children));
+    const disableListStyle = element.children.length >= 1 && listTypes_1.default.includes((_b = (_a = element.children) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.type);
+    return (react_1.default.createElement("li", { style: { listStyle: disableListStyle ? 'none' : undefined }, ...attributes }, children));
 };
-export default {
+exports.default = {
     Element: LI,
 };