@payloadcms/richtext-slate 1.0.0-beta.0

package/dist/field/elements/h5/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _H5 = /*#__PURE__*/ _interop_require_default(require("../../icons/headings/H5"));
+const _Button = /*#__PURE__*/ _interop_require_default(require("../Button"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const H5 = ({ attributes, children })=>/*#__PURE__*/ _react.default.createElement("h5", attributes, children);
+const h5 = {
+    Button: ()=>/*#__PURE__*/ _react.default.createElement(_Button.default, {
+            format: "h5"
+        }, /*#__PURE__*/ _react.default.createElement(_H5.default, null)),
+    Element: H5
+};
+const _default = h5;
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9maWVsZC9lbGVtZW50cy9oNS9pbmRleC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0J1xuXG5pbXBvcnQgSDVJY29uIGZyb20gJy4uLy4uL2ljb25zL2hlYWRpbmdzL0g1J1xuaW1wb3J0IEVsZW1lbnRCdXR0b24gZnJvbSAnLi4vQnV0dG9uJ1xuXG5jb25zdCBINSA9ICh7IGF0dHJpYnV0ZXMsIGNoaWxkcmVuIH0pID0+IDxoNSB7Li4uYXR0cmlidXRlc30+e2NoaWxkcmVufTwvaDU+XG5cbmNvbnN0IGg1ID0ge1xuICBCdXR0b246ICgpID0+IChcbiAgICA8RWxlbWVudEJ1dHRvbiBmb3JtYXQ9XCJoNVwiPlxuICAgICAgPEg1SWNvbiAvPlxuICAgIDwvRWxlbWVudEJ1dHRvbj5cbiAgKSxcbiAgRWxlbWVudDogSDUsXG59XG5cbmV4cG9ydCBkZWZhdWx0IGg1XG4iXSwibmFtZXMiOlsiSDUiLCJhdHRyaWJ1dGVzIiwiY2hpbGRyZW4iLCJoNSIsIkJ1dHRvbiIsIkVsZW1lbnRCdXR0b24iLCJmb3JtYXQiLCJINUljb24iLCJFbGVtZW50Il0sIm1hcHBpbmdzIjoiOzs7OytCQWdCQTs7O2VBQUE7Ozs4REFoQmtCOzJEQUVDOytEQUNPOzs7Ozs7QUFFMUIsTUFBTUEsS0FBSyxDQUFDLEVBQUVDLFVBQVUsRUFBRUMsUUFBUSxFQUFFLGlCQUFLLDZCQUFDQyxNQUFPRixZQUFhQztBQUU5RCxNQUFNQyxLQUFLO0lBQ1RDLFFBQVEsa0JBQ04sNkJBQUNDLGVBQWE7WUFBQ0MsUUFBTzt5QkFDcEIsNkJBQUNDLFdBQU07SUFHWEMsU0FBU1I7QUFDWDtNQUVBLFdBQWVHIn0=

package/dist/field/elements/h6/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+declare const h6: {
+    Button: () => React.JSX.Element;
+    Element: ({ attributes, children }: {
+        attributes: any;
+        children: any;
+    }) => React.JSX.Element;
+};
+export default h6;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/elements/h6/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/field/elements/h6/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAOzB,QAAA,MAAM,EAAE;;;;;;CAOP,CAAA;AAED,eAAe,EAAE,CAAA"}

package/dist/field/elements/h6/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _H6 = /*#__PURE__*/ _interop_require_default(require("../../icons/headings/H6"));
+const _Button = /*#__PURE__*/ _interop_require_default(require("../Button"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const H6 = ({ attributes, children })=>/*#__PURE__*/ _react.default.createElement("h6", attributes, children);
+const h6 = {
+    Button: ()=>/*#__PURE__*/ _react.default.createElement(_Button.default, {
+            format: "h6"
+        }, /*#__PURE__*/ _react.default.createElement(_H6.default, null)),
+    Element: H6
+};
+const _default = h6;
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9maWVsZC9lbGVtZW50cy9oNi9pbmRleC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0J1xuXG5pbXBvcnQgSDZJY29uIGZyb20gJy4uLy4uL2ljb25zL2hlYWRpbmdzL0g2J1xuaW1wb3J0IEVsZW1lbnRCdXR0b24gZnJvbSAnLi4vQnV0dG9uJ1xuXG5jb25zdCBINiA9ICh7IGF0dHJpYnV0ZXMsIGNoaWxkcmVuIH0pID0+IDxoNiB7Li4uYXR0cmlidXRlc30+e2NoaWxkcmVufTwvaDY+XG5cbmNvbnN0IGg2ID0ge1xuICBCdXR0b246ICgpID0+IChcbiAgICA8RWxlbWVudEJ1dHRvbiBmb3JtYXQ9XCJoNlwiPlxuICAgICAgPEg2SWNvbiAvPlxuICAgIDwvRWxlbWVudEJ1dHRvbj5cbiAgKSxcbiAgRWxlbWVudDogSDYsXG59XG5cbmV4cG9ydCBkZWZhdWx0IGg2XG4iXSwibmFtZXMiOlsiSDYiLCJhdHRyaWJ1dGVzIiwiY2hpbGRyZW4iLCJoNiIsIkJ1dHRvbiIsIkVsZW1lbnRCdXR0b24iLCJmb3JtYXQiLCJINkljb24iLCJFbGVtZW50Il0sIm1hcHBpbmdzIjoiOzs7OytCQWdCQTs7O2VBQUE7Ozs4REFoQmtCOzJEQUVDOytEQUNPOzs7Ozs7QUFFMUIsTUFBTUEsS0FBSyxDQUFDLEVBQUVDLFVBQVUsRUFBRUMsUUFBUSxFQUFFLGlCQUFLLDZCQUFDQyxNQUFPRixZQUFhQztBQUU5RCxNQUFNQyxLQUFLO0lBQ1RDLFFBQVEsa0JBQ04sNkJBQUNDLGVBQWE7WUFBQ0MsUUFBTzt5QkFDcEIsNkJBQUNDLFdBQU07SUFHWEMsU0FBU1I7QUFDWDtNQUVBLFdBQWVHIn0=

package/dist/field/elements/indent/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+declare const indent: {
+    Button: () => React.JSX.Element;
+    Element: ({ attributes, children }: {
+        attributes: any;
+        children: any;
+    }) => React.JSX.Element;
+};
+export default indent;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/elements/indent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/field/elements/indent/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsB,MAAM,OAAO,CAAA;AAuB1C,QAAA,MAAM,MAAM;;;;;;CAwMX,CAAA;AAED,eAAe,MAAM,CAAA"}

package/dist/field/elements/indent/index.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _slate = require("slate");
+const _slatereact = require("slate-react");
+const _IndentLeft = /*#__PURE__*/ _interop_require_default(require("../../icons/IndentLeft"));
+const _IndentRight = /*#__PURE__*/ _interop_require_default(require("../../icons/IndentRight"));
+const _Button = require("../Button");
+const _getCommonBlock = require("../getCommonBlock");
+const _isActive = /*#__PURE__*/ _interop_require_default(require("../isActive"));
+const _isBlockElement = require("../isBlockElement");
+const _listTypes = /*#__PURE__*/ _interop_require_default(require("../listTypes"));
+const _unwrapList = require("../unwrapList");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const indentType = 'indent';
+const IndentWithPadding = ({ attributes, children })=>/*#__PURE__*/ _react.default.createElement("div", {
+        style: {
+            paddingLeft: 25
+        },
+        ...attributes
+    }, children);
+const indent = {
+    Button: ()=>{
+        const editor = (0, _slatereact.useSlate)();
+        const handleIndent = (0, _react.useCallback)((e, dir)=>{
+            e.preventDefault();
+            if (dir === 'left') {
+                if ((0, _isActive.default)(editor, 'li')) {
+                    const [, listPath] = (0, _getCommonBlock.getCommonBlock)(editor, (n)=>_slate.Element.isElement(n) && _listTypes.default.includes(n.type));
+                    const matchedParentList = _slate.Editor.above(editor, {
+                        at: listPath,
+                        match: (n)=>!_slate.Editor.isEditor(n) && (0, _isBlockElement.isBlockElement)(editor, n)
+                    });
+                    if (matchedParentList) {
+                        const [parentListItem, parentListItemPath] = matchedParentList;
+                        if (parentListItem.children.length > 1) {
+                            // Remove nested list
+                            _slate.Transforms.unwrapNodes(editor, {
+                                at: parentListItemPath,
+                                match: (node, path)=>{
+                                    const matches = !_slate.Editor.isEditor(node) && _slate.Element.isElement(node) && _listTypes.default.includes(node.type) && path.length === parentListItemPath.length + 1;
+                                    return matches;
+                                }
+                            });
+                            // Set li type on any children that don't have a type
+                            _slate.Transforms.setNodes(editor, {
+                                type: 'li'
+                            }, {
+                                at: parentListItemPath,
+                                match: (node, path)=>{
+                                    const matches = !_slate.Editor.isEditor(node) && _slate.Element.isElement(node) && node.type !== 'li' && path.length === parentListItemPath.length + 1;
+                                    return matches;
+                                }
+                            });
+                            // Parent list item path has changed at this point
+                            // so we need to re-fetch the parent node
+                            const [newParentNode] = _slate.Editor.node(editor, parentListItemPath);
+                            // If the parent node is an li,
+                            // lift all li nodes within
+                            if (_slate.Element.isElement(newParentNode) && newParentNode.type === 'li') {
+                                // Lift the nested lis
+                                _slate.Transforms.liftNodes(editor, {
+                                    at: parentListItemPath,
+                                    match: (node, path)=>{
+                                        const matches = !_slate.Editor.isEditor(node) && _slate.Element.isElement(node) && path.length === parentListItemPath.length + 1 && node.type === 'li';
+                                        return matches;
+                                    }
+                                });
+                            }
+                        } else {
+                            _slate.Transforms.unwrapNodes(editor, {
+                                at: parentListItemPath,
+                                match: (node, path)=>{
+                                    return _slate.Element.isElement(node) && node.type === 'li' && path.length === parentListItemPath.length;
+                                }
+                            });
+                            _slate.Transforms.unwrapNodes(editor, {
+                                match: (n)=>_slate.Element.isElement(n) && _listTypes.default.includes(n.type)
+                            });
+                        }
+                    } else {
+                        (0, _unwrapList.unwrapList)(editor, listPath);
+                    }
+                } else {
+                    _slate.Transforms.unwrapNodes(editor, {
+                        match: (n)=>_slate.Element.isElement(n) && n.type === indentType,
+                        mode: 'lowest',
+                        split: true
+                    });
+                }
+            }
+            if (dir === 'right') {
+                const isCurrentlyOL = (0, _isActive.default)(editor, 'ol');
+                const isCurrentlyUL = (0, _isActive.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(_slate.Editor.nodes(editor, {
+                        match: (node)=>_slate.Element.isElement(node) && node.type === 'li',
+                        mode: 'lowest'
+                    }));
+                    // 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] = _slate.Editor.previous(editor, {
+                            at: firstSelectedLIPath
+                        });
+                        const [precedingLIChildren] = _slate.Editor.node(editor, [
+                            ...precedingLIPath,
+                            0
+                        ]);
+                        const precedingLIChildrenIsText = _slate.Text.isText(precedingLIChildren);
+                        if (precedingLIChildrenIsText) {
+                            // Wrap the prior li text content so that it can be nested next to a list
+                            _slate.Transforms.wrapNodes(editor, {
+                                children: []
+                            }, {
+                                at: [
+                                    ...precedingLIPath,
+                                    0
+                                ]
+                            });
+                        }
+                        // Move the selected lis after the prior li contents
+                        _slate.Transforms.moveNodes(editor, {
+                            match: (node)=>_slate.Element.isElement(node) && node.type === 'li',
+                            mode: 'lowest',
+                            to: [
+                                ...precedingLIPath,
+                                1
+                            ]
+                        });
+                        // Wrap the selected lis in a new list
+                        _slate.Transforms.wrapNodes(editor, {
+                            children: [],
+                            type: isCurrentlyOL ? 'ol' : 'ul'
+                        }, {
+                            match: (node)=>_slate.Element.isElement(node) && node.type === 'li',
+                            mode: 'lowest'
+                        });
+                    } else {
+                        // Otherwise, just wrap the node in a list / li
+                        _slate.Transforms.wrapNodes(editor, {
+                            children: [
+                                {
+                                    children: [],
+                                    type: 'li'
+                                }
+                            ],
+                            type: isCurrentlyOL ? 'ol' : 'ul'
+                        }, {
+                            match: (node)=>_slate.Element.isElement(node) && node.type === 'li',
+                            mode: 'lowest'
+                        });
+                    }
+                } else {
+                    _slate.Transforms.wrapNodes(editor, {
+                        children: [],
+                        type: indentType
+                    });
+                }
+            }
+            _slatereact.ReactEditor.focus(editor);
+        }, [
+            editor
+        ]);
+        const canDeIndent = (0, _isActive.default)(editor, 'li') || (0, _isActive.default)(editor, indentType);
+        return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/ _react.default.createElement("button", {
+            className: [
+                _Button.baseClass,
+                !canDeIndent && `${_Button.baseClass}--disabled`
+            ].filter(Boolean).join(' '),
+            onClick: canDeIndent ? (e)=>handleIndent(e, 'left') : undefined,
+            type: "button"
+        }, /*#__PURE__*/ _react.default.createElement(_IndentLeft.default, null)), /*#__PURE__*/ _react.default.createElement("button", {
+            className: _Button.baseClass,
+            onClick: (e)=>handleIndent(e, 'right'),
+            type: "button"
+        }, /*#__PURE__*/ _react.default.createElement(_IndentRight.default, null)));
+    },
+    Element: IndentWithPadding
+};
+const _default = indent;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/field/elements/indent/index.tsx"],"sourcesContent":["import React, { useCallback } from 'react'\nimport { Editor, Element, Text, Transforms } from 'slate'\nimport { ReactEditor, useSlate } from 'slate-react'\n\nimport type { ElementNode } from '../../../types'\n\nimport IndentLeft from '../../icons/IndentLeft'\nimport IndentRight from '../../icons/IndentRight'\nimport { baseClass } from '../Button'\nimport { getCommonBlock } from '../getCommonBlock'\nimport isElementActive from '../isActive'\nimport { isBlockElement } from '../isBlockElement'\nimport listTypes from '../listTypes'\nimport { unwrapList } from '../unwrapList'\n\nconst indentType = 'indent'\n\nconst IndentWithPadding = ({ attributes, children }) => (\n  <div style={{ paddingLeft: 25 }} {...attributes}>\n    {children}\n  </div>\n)\n\nconst indent = {\n  Button: () => {\n    const editor = useSlate()\n    const handleIndent = useCallback(\n      (e, dir) => {\n        e.preventDefault()\n\n        if (dir === 'left') {\n          if (isElementActive(editor, 'li')) {\n            const [, listPath] = getCommonBlock(\n              editor,\n              (n) => Element.isElement(n) && listTypes.includes(n.type),\n            )\n\n            const matchedParentList = Editor.above(editor, {\n              at: listPath,\n              match: (n: ElementNode) => !Editor.isEditor(n) && isBlockElement(editor, n),\n            })\n\n            if (matchedParentList) {\n              const [parentListItem, parentListItemPath] = matchedParentList\n\n              if (parentListItem.children.length > 1) {\n                // Remove nested list\n                Transforms.unwrapNodes(editor, {\n                  at: parentListItemPath,\n                  match: (node, path) => {\n                    const matches =\n                      !Editor.isEditor(node) &&\n                      Element.isElement(node) &&\n                      listTypes.includes(node.type) &&\n                      path.length === parentListItemPath.length + 1\n\n                    return matches\n                  },\n                })\n\n                // Set li type on any children that don't have a type\n                Transforms.setNodes(\n                  editor,\n                  { type: 'li' },\n                  {\n                    at: parentListItemPath,\n                    match: (node, path) => {\n                      const matches =\n                        !Editor.isEditor(node) &&\n                        Element.isElement(node) &&\n                        node.type !== 'li' &&\n                        path.length === parentListItemPath.length + 1\n\n                      return matches\n                    },\n                  },\n                )\n\n                // Parent list item path has changed at this point\n                // so we need to re-fetch the parent node\n                const [newParentNode] = Editor.node(editor, parentListItemPath)\n\n                // If the parent node is an li,\n                // lift all li nodes within\n                if (Element.isElement(newParentNode) && newParentNode.type === 'li') {\n                  // Lift the nested lis\n                  Transforms.liftNodes(editor, {\n                    at: parentListItemPath,\n                    match: (node, path) => {\n                      const matches =\n                        !Editor.isEditor(node) &&\n                        Element.isElement(node) &&\n                        path.length === parentListItemPath.length + 1 &&\n                        node.type === 'li'\n\n                      return matches\n                    },\n                  })\n                }\n              } else {\n                Transforms.unwrapNodes(editor, {\n                  at: parentListItemPath,\n                  match: (node, path) => {\n                    return (\n                      Element.isElement(node) &&\n                      node.type === 'li' &&\n                      path.length === parentListItemPath.length\n                    )\n                  },\n                })\n\n                Transforms.unwrapNodes(editor, {\n                  match: (n) => Element.isElement(n) && listTypes.includes(n.type),\n                })\n              }\n            } else {\n              unwrapList(editor, listPath)\n            }\n          } else {\n            Transforms.unwrapNodes(editor, {\n              match: (n) => Element.isElement(n) && n.type === indentType,\n              mode: 'lowest',\n              split: true,\n            })\n          }\n        }\n\n        if (dir === 'right') {\n          const isCurrentlyOL = isElementActive(editor, 'ol')\n          const isCurrentlyUL = isElementActive(editor, 'ul')\n\n          if (isCurrentlyOL || isCurrentlyUL) {\n            // Get the path of the first selected li -\n            // Multiple lis could be selected\n            // and the selection may start in the middle of the first li\n            const [[, firstSelectedLIPath]] = Array.from(\n              Editor.nodes(editor, {\n                match: (node) => Element.isElement(node) && node.type === 'li',\n                mode: 'lowest',\n              }),\n            )\n\n            // Is the first selected li the first in its list?\n            const hasPrecedingLI = firstSelectedLIPath[firstSelectedLIPath.length - 1] > 0\n\n            // If the first selected li is NOT the first in its list,\n            // we need to inject it into the prior li\n            if (hasPrecedingLI) {\n              const [, precedingLIPath] = Editor.previous(editor, {\n                at: firstSelectedLIPath,\n              })\n\n              const [precedingLIChildren] = Editor.node(editor, [...precedingLIPath, 0])\n              const precedingLIChildrenIsText = Text.isText(precedingLIChildren)\n\n              if (precedingLIChildrenIsText) {\n                // Wrap the prior li text content so that it can be nested next to a list\n                Transforms.wrapNodes(editor, { children: [] }, { at: [...precedingLIPath, 0] })\n              }\n\n              // Move the selected lis after the prior li contents\n              Transforms.moveNodes(editor, {\n                match: (node) => Element.isElement(node) && node.type === 'li',\n                mode: 'lowest',\n                to: [...precedingLIPath, 1],\n              })\n\n              // Wrap the selected lis in a new list\n              Transforms.wrapNodes(\n                editor,\n                {\n                  children: [],\n                  type: isCurrentlyOL ? 'ol' : 'ul',\n                },\n                {\n                  match: (node) => Element.isElement(node) && node.type === 'li',\n                  mode: 'lowest',\n                },\n              )\n            } else {\n              // Otherwise, just wrap the node in a list / li\n              Transforms.wrapNodes(\n                editor,\n                {\n                  children: [{ children: [], type: 'li' }],\n                  type: isCurrentlyOL ? 'ol' : 'ul',\n                },\n                {\n                  match: (node) => Element.isElement(node) && node.type === 'li',\n                  mode: 'lowest',\n                },\n              )\n            }\n          } else {\n            Transforms.wrapNodes(editor, { children: [], type: indentType })\n          }\n        }\n\n        ReactEditor.focus(editor)\n      },\n      [editor],\n    )\n\n    const canDeIndent = isElementActive(editor, 'li') || isElementActive(editor, indentType)\n\n    return (\n      <React.Fragment>\n        <button\n          className={[baseClass, !canDeIndent && `${baseClass}--disabled`]\n            .filter(Boolean)\n            .join(' ')}\n          onClick={canDeIndent ? (e) => handleIndent(e, 'left') : undefined}\n          type=\"button\"\n        >\n          <IndentLeft />\n        </button>\n        <button className={baseClass} onClick={(e) => handleIndent(e, 'right')} type=\"button\">\n          <IndentRight />\n        </button>\n      </React.Fragment>\n    )\n  },\n  Element: IndentWithPadding,\n}\n\nexport default indent\n"],"names":["indentType","IndentWithPadding","attributes","children","div","style","paddingLeft","indent","Button","editor","useSlate","handleIndent","useCallback","e","dir","preventDefault","isElementActive","listPath","getCommonBlock","n","Element","isElement","listTypes","includes","type","matchedParentList","Editor","above","at","match","isEditor","isBlockElement","parentListItem","parentListItemPath","length","Transforms","unwrapNodes","node","path","matches","setNodes","newParentNode","liftNodes","unwrapList","mode","split","isCurrentlyOL","isCurrentlyUL","firstSelectedLIPath","Array","from","nodes","hasPrecedingLI","precedingLIPath","previous","precedingLIChildren","precedingLIChildrenIsText","Text","isText","wrapNodes","moveNodes","to","ReactEditor","focus","canDeIndent","React","Fragment","button","className","baseClass","filter","Boolean","join","onClick","undefined","IndentLeft","IndentRight"],"mappings":"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"}

package/dist/field/elements/index.d.ts

@@ -0,0 +1,117 @@
+/// <reference types="react" />
+declare const elements: {
+    blockquote: {
+        Button: () => import("react").JSX.Element;
+        Element: ({ attributes, children }: {
+            attributes: any;
+            children: any;
+        }) => import("react").JSX.Element;
+    };
+    h1: {
+        Button: () => import("react").JSX.Element;
+        Element: ({ attributes, children }: {
+            attributes: any;
+            children: any;
+        }) => import("react").JSX.Element;
+    };
+    h2: {
+        Button: () => import("react").JSX.Element;
+        Element: ({ attributes, children }: {
+            attributes: any;
+            children: any;
+        }) => import("react").JSX.Element;
+    };
+    h3: {
+        Button: () => import("react").JSX.Element;
+        Element: ({ attributes, children }: {
+            attributes: any;
+            children: any;
+        }) => import("react").JSX.Element;
+    };
+    h4: {
+        Button: () => import("react").JSX.Element;
+        Element: ({ attributes, children }: {
+            attributes: any;
+            children: any;
+        }) => import("react").JSX.Element;
+    };
+    h5: {
+        Button: () => import("react").JSX.Element;
+        Element: ({ attributes, children }: {
+            attributes: any;
+            children: any;
+        }) => import("react").JSX.Element;
+    };
+    h6: {
+        Button: () => import("react").JSX.Element;
+        Element: ({ attributes, children }: {
+            attributes: any;
+            children: any;
+        }) => import("react").JSX.Element;
+    };
+    indent: {
+        Button: () => import("react").JSX.Element;
+        Element: ({ attributes, children }: {
+            attributes: any;
+            children: any;
+        }) => import("react").JSX.Element;
+    };
+    li: {
+        Element: (props: any) => import("react").JSX.Element;
+    };
+    link: {
+        Button: import("react").FC<{
+            fieldProps: import("../../types").FieldProps;
+            path: string;
+        }>;
+        Element: import("react").FC<{
+            attributes: import("react").HTMLAttributes<HTMLDivElement>;
+            children: import("react").ReactNode;
+            editorRef: import("react").RefObject<HTMLDivElement>;
+            element: any;
+            fieldProps: import("../../types").FieldProps;
+        }>;
+        plugins: ((incomingEditor: import("slate").BaseEditor & import("slate-react").ReactEditor & import("slate-history").HistoryEditor) => import("slate").BaseEditor & import("slate-react").ReactEditor & import("slate-history").HistoryEditor)[];
+    };
+    ol: {
+        Button: () => import("react").JSX.Element;
+        Element: ({ attributes, children }: {
+            attributes: any;
+            children: any;
+        }) => import("react").JSX.Element;
+    };
+    relationship: {
+        Button: (props: {
+            enabledCollectionSlugs: string[];
+            path: string;
+        }) => import("react").ReactNode;
+        Element: (props: {
+            attributes: import("react").HTMLAttributes<HTMLDivElement>;
+            children: import("react").ReactNode;
+            element: any;
+            fieldProps: import("../../types").FieldProps;
+        }) => import("react").ReactNode;
+        plugins: ((incomingEditor: any) => any)[];
+    };
+    textAlign: {
+        name: string;
+        Button: () => import("react").JSX.Element;
+    };
+    ul: {
+        Button: () => import("react").JSX.Element;
+        Element: ({ attributes, children }: {
+            attributes: any;
+            children: any;
+        }) => import("react").JSX.Element;
+    };
+    upload: {
+        Button: (props: {
+            enabledCollectionSlugs: string[];
+            path: string;
+        }) => import("react").ReactNode;
+        Element: (props: import("./upload/Element").ElementProps) => import("react").ReactNode;
+        plugins: ((incomingEditor: any) => any)[];
+    };
+};
+export default elements;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/elements/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/field/elements/index.tsx"],"names":[],"mappings":";AAgBA,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBb,CAAA;AAED,eAAe,QAAQ,CAAA"}

package/dist/field/elements/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _blockquote = /*#__PURE__*/ _interop_require_default(require("./blockquote"));
+const _h1 = /*#__PURE__*/ _interop_require_default(require("./h1"));
+const _h2 = /*#__PURE__*/ _interop_require_default(require("./h2"));
+const _h3 = /*#__PURE__*/ _interop_require_default(require("./h3"));
+const _h4 = /*#__PURE__*/ _interop_require_default(require("./h4"));
+const _h5 = /*#__PURE__*/ _interop_require_default(require("./h5"));
+const _h6 = /*#__PURE__*/ _interop_require_default(require("./h6"));
+const _indent = /*#__PURE__*/ _interop_require_default(require("./indent"));
+const _li = /*#__PURE__*/ _interop_require_default(require("./li"));
+const _link = /*#__PURE__*/ _interop_require_default(require("./link"));
+const _ol = /*#__PURE__*/ _interop_require_default(require("./ol"));
+const _relationship = /*#__PURE__*/ _interop_require_default(require("./relationship"));
+const _textAlign = /*#__PURE__*/ _interop_require_default(require("./textAlign"));
+const _ul = /*#__PURE__*/ _interop_require_default(require("./ul"));
+const _upload = /*#__PURE__*/ _interop_require_default(require("./upload"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const elements = {
+    blockquote: _blockquote.default,
+    h1: _h1.default,
+    h2: _h2.default,
+    h3: _h3.default,
+    h4: _h4.default,
+    h5: _h5.default,
+    h6: _h6.default,
+    indent: _indent.default,
+    li: _li.default,
+    link: _link.default,
+    ol: _ol.default,
+    relationship: _relationship.default,
+    textAlign: _textAlign.default,
+    ul: _ul.default,
+    upload: _upload.default
+};
+const _default = elements;
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9maWVsZC9lbGVtZW50cy9pbmRleC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGJsb2NrcXVvdGUgZnJvbSAnLi9ibG9ja3F1b3RlJ1xuaW1wb3J0IGgxIGZyb20gJy4vaDEnXG5pbXBvcnQgaDIgZnJvbSAnLi9oMidcbmltcG9ydCBoMyBmcm9tICcuL2gzJ1xuaW1wb3J0IGg0IGZyb20gJy4vaDQnXG5pbXBvcnQgaDUgZnJvbSAnLi9oNSdcbmltcG9ydCBoNiBmcm9tICcuL2g2J1xuaW1wb3J0IGluZGVudCBmcm9tICcuL2luZGVudCdcbmltcG9ydCBsaSBmcm9tICcuL2xpJ1xuaW1wb3J0IGxpbmsgZnJvbSAnLi9saW5rJ1xuaW1wb3J0IG9sIGZyb20gJy4vb2wnXG5pbXBvcnQgcmVsYXRpb25zaGlwIGZyb20gJy4vcmVsYXRpb25zaGlwJ1xuaW1wb3J0IHRleHRBbGlnbiBmcm9tICcuL3RleHRBbGlnbidcbmltcG9ydCB1bCBmcm9tICcuL3VsJ1xuaW1wb3J0IHVwbG9hZCBmcm9tICcuL3VwbG9hZCdcblxuY29uc3QgZWxlbWVudHMgPSB7XG4gIGJsb2NrcXVvdGUsXG4gIGgxLFxuICBoMixcbiAgaDMsXG4gIGg0LFxuICBoNSxcbiAgaDYsXG4gIGluZGVudCxcbiAgbGksXG4gIGxpbmssXG4gIG9sLFxuICByZWxhdGlvbnNoaXAsXG4gIHRleHRBbGlnbixcbiAgdWwsXG4gIHVwbG9hZCxcbn1cblxuZXhwb3J0IGRlZmF1bHQgZWxlbWVudHNcbiJdLCJuYW1lcyI6WyJlbGVtZW50cyIsImJsb2NrcXVvdGUiLCJoMSIsImgyIiwiaDMiLCJoNCIsImg1IiwiaDYiLCJpbmRlbnQiLCJsaSIsImxpbmsiLCJvbCIsInJlbGF0aW9uc2hpcCIsInRleHRBbGlnbiIsInVsIiwidXBsb2FkIl0sIm1hcHBpbmdzIjoiOzs7OytCQWtDQTs7O2VBQUE7OzttRUFsQ3VCOzJEQUNSOzJEQUNBOzJEQUNBOzJEQUNBOzJEQUNBOzJEQUNBOytEQUNJOzJEQUNKOzZEQUNFOzJEQUNGO3FFQUNVO2tFQUNIOzJEQUNQOytEQUNJOzs7Ozs7QUFFbkIsTUFBTUEsV0FBVztJQUNmQyxZQUFBQSxtQkFBVTtJQUNWQyxJQUFBQSxXQUFFO0lBQ0ZDLElBQUFBLFdBQUU7SUFDRkMsSUFBQUEsV0FBRTtJQUNGQyxJQUFBQSxXQUFFO0lBQ0ZDLElBQUFBLFdBQUU7SUFDRkMsSUFBQUEsV0FBRTtJQUNGQyxRQUFBQSxlQUFNO0lBQ05DLElBQUFBLFdBQUU7SUFDRkMsTUFBQUEsYUFBSTtJQUNKQyxJQUFBQSxXQUFFO0lBQ0ZDLGNBQUFBLHFCQUFZO0lBQ1pDLFdBQUFBLGtCQUFTO0lBQ1RDLElBQUFBLFdBQUU7SUFDRkMsUUFBQUEsZUFBTTtBQUNSO01BRUEsV0FBZWYifQ==

package/dist/field/elements/injectVoid.d.ts

@@ -0,0 +1,4 @@
+import type { Element } from 'slate';
+import { Editor } from 'slate';
+export declare const injectVoidElement: (editor: Editor, element: Element) => void;
+//# sourceMappingURL=injectVoid.d.ts.map

package/dist/field/elements/injectVoid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectVoid.d.ts","sourceRoot":"","sources":["../../../src/field/elements/injectVoid.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAEpC,OAAO,EAAE,MAAM,EAAc,MAAM,OAAO,CAAA;AAM1C,eAAO,MAAM,iBAAiB,WAAY,MAAM,WAAW,OAAO,KAAG,IAqBpE,CAAA"}

package/dist/field/elements/injectVoid.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "injectVoidElement", {
+    enumerable: true,
+    get: function() {
+        return injectVoidElement;
+    }
+});
+const _slate = require("slate");
+const _isLastSelectedElementEmpty = require("./isLastSelectedElementEmpty");
+const injectVoidElement = (editor, element)=>{
+    const lastSelectedElementIsEmpty = (0, _isLastSelectedElementEmpty.isLastSelectedElementEmpty)(editor);
+    const previous = _slate.Editor.previous(editor);
+    if (lastSelectedElementIsEmpty) {
+        // If previous node is void
+        if (previous?.[0] && _slate.Editor.isVoid(editor, previous[0])) {
+            // Insert a blank element between void nodes
+            // so user can place cursor between void nodes
+            _slate.Transforms.insertNodes(editor, {
+                children: [
+                    {
+                        text: ''
+                    }
+                ]
+            });
+            _slate.Transforms.setNodes(editor, element);
+        // Otherwise just set the empty node equal to new void
+        } else {
+            _slate.Transforms.setNodes(editor, element);
+        }
+    } else {
+        _slate.Transforms.insertNodes(editor, element);
+    }
+    // Add an empty node after the new void
+    _slate.Transforms.insertNodes(editor, {
+        children: [
+            {
+                text: ''
+            }
+        ]
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9maWVsZC9lbGVtZW50cy9pbmplY3RWb2lkLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRWxlbWVudCB9IGZyb20gJ3NsYXRlJ1xuXG5pbXBvcnQgeyBFZGl0b3IsIFRyYW5zZm9ybXMgfSBmcm9tICdzbGF0ZSdcblxuaW1wb3J0IHR5cGUgeyBFbGVtZW50Tm9kZSB9IGZyb20gJy4uLy4uL3R5cGVzJ1xuXG5pbXBvcnQgeyBpc0xhc3RTZWxlY3RlZEVsZW1lbnRFbXB0eSB9IGZyb20gJy4vaXNMYXN0U2VsZWN0ZWRFbGVtZW50RW1wdHknXG5cbmV4cG9ydCBjb25zdCBpbmplY3RWb2lkRWxlbWVudCA9IChlZGl0b3I6IEVkaXRvciwgZWxlbWVudDogRWxlbWVudCk6IHZvaWQgPT4ge1xuICBjb25zdCBsYXN0U2VsZWN0ZWRFbGVtZW50SXNFbXB0eSA9IGlzTGFzdFNlbGVjdGVkRWxlbWVudEVtcHR5KGVkaXRvcilcbiAgY29uc3QgcHJldmlvdXMgPSBFZGl0b3IucHJldmlvdXM8RWxlbWVudE5vZGU+KGVkaXRvcilcblxuICBpZiAobGFzdFNlbGVjdGVkRWxlbWVudElzRW1wdHkpIHtcbiAgICAvLyBJZiBwcmV2aW91cyBub2RlIGlzIHZvaWRcbiAgICBpZiAocHJldmlvdXM/LlswXSAmJiBFZGl0b3IuaXNWb2lkKGVkaXRvciwgcHJldmlvdXNbMF0pKSB7XG4gICAgICAvLyBJbnNlcnQgYSBibGFuayBlbGVtZW50IGJldHdlZW4gdm9pZCBub2Rlc1xuICAgICAgLy8gc28gdXNlciBjYW4gcGxhY2UgY3Vyc29yIGJldHdlZW4gdm9pZCBub2Rlc1xuICAgICAgVHJhbnNmb3Jtcy5pbnNlcnROb2RlcyhlZGl0b3IsIHsgY2hpbGRyZW46IFt7IHRleHQ6ICcnIH1dIH0pXG4gICAgICBUcmFuc2Zvcm1zLnNldE5vZGVzKGVkaXRvciwgZWxlbWVudClcbiAgICAgIC8vIE90aGVyd2lzZSBqdXN0IHNldCB0aGUgZW1wdHkgbm9kZSBlcXVhbCB0byBuZXcgdm9pZFxuICAgIH0gZWxzZSB7XG4gICAgICBUcmFuc2Zvcm1zLnNldE5vZGVzKGVkaXRvciwgZWxlbWVudClcbiAgICB9XG4gIH0gZWxzZSB7XG4gICAgVHJhbnNmb3Jtcy5pbnNlcnROb2RlcyhlZGl0b3IsIGVsZW1lbnQpXG4gIH1cblxuICAvLyBBZGQgYW4gZW1wdHkgbm9kZSBhZnRlciB0aGUgbmV3IHZvaWRcbiAgVHJhbnNmb3Jtcy5pbnNlcnROb2RlcyhlZGl0b3IsIHsgY2hpbGRyZW46IFt7IHRleHQ6ICcnIH1dIH0pXG59XG4iXSwibmFtZXMiOlsiaW5qZWN0Vm9pZEVsZW1lbnQiLCJlZGl0b3IiLCJlbGVtZW50IiwibGFzdFNlbGVjdGVkRWxlbWVudElzRW1wdHkiLCJpc0xhc3RTZWxlY3RlZEVsZW1lbnRFbXB0eSIsInByZXZpb3VzIiwiRWRpdG9yIiwiaXNWb2lkIiwiVHJhbnNmb3JtcyIsImluc2VydE5vZGVzIiwiY2hpbGRyZW4iLCJ0ZXh0Iiwic2V0Tm9kZXMiXSwibWFwcGluZ3MiOiI7Ozs7K0JBUWFBOzs7ZUFBQUE7Ozt1QkFOc0I7NENBSVE7QUFFcEMsTUFBTUEsb0JBQW9CLENBQUNDLFFBQWdCQztJQUNoRCxNQUFNQyw2QkFBNkJDLElBQUFBLHNEQUEwQixFQUFDSDtJQUM5RCxNQUFNSSxXQUFXQyxhQUFNLENBQUNELFFBQVEsQ0FBY0o7SUFFOUMsSUFBSUUsNEJBQTRCO1FBQzlCLDJCQUEyQjtRQUMzQixJQUFJRSxVQUFVLENBQUMsRUFBRSxJQUFJQyxhQUFNLENBQUNDLE1BQU0sQ0FBQ04sUUFBUUksUUFBUSxDQUFDLEVBQUUsR0FBRztZQUN2RCw0Q0FBNEM7WUFDNUMsOENBQThDO1lBQzlDRyxpQkFBVSxDQUFDQyxXQUFXLENBQUNSLFFBQVE7Z0JBQUVTLFVBQVU7b0JBQUM7d0JBQUVDLE1BQU07b0JBQUc7aUJBQUU7WUFBQztZQUMxREgsaUJBQVUsQ0FBQ0ksUUFBUSxDQUFDWCxRQUFRQztRQUM1QixzREFBc0Q7UUFDeEQsT0FBTztZQUNMTSxpQkFBVSxDQUFDSSxRQUFRLENBQUNYLFFBQVFDO1FBQzlCO0lBQ0YsT0FBTztRQUNMTSxpQkFBVSxDQUFDQyxXQUFXLENBQUNSLFFBQVFDO0lBQ2pDO0lBRUEsdUNBQXVDO0lBQ3ZDTSxpQkFBVSxDQUFDQyxXQUFXLENBQUNSLFFBQVE7UUFBRVMsVUFBVTtZQUFDO2dCQUFFQyxNQUFNO1lBQUc7U0FBRTtJQUFDO0FBQzVEIn0=

package/dist/field/elements/isActive.d.ts

@@ -0,0 +1,4 @@
+import { Editor } from 'slate';
+declare const isElementActive: (editor: Editor, format: string, blockType?: string) => boolean;
+export default isElementActive;
+//# sourceMappingURL=isActive.d.ts.map

package/dist/field/elements/isActive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isActive.d.ts","sourceRoot":"","sources":["../../../src/field/elements/isActive.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAW,MAAM,OAAO,CAAA;AAEvC,QAAA,MAAM,eAAe,WAAY,MAAM,UAAU,MAAM,yBAAuB,OAW7E,CAAA;AAED,eAAe,eAAe,CAAA"}

package/dist/field/elements/isActive.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _slate = require("slate");
+const isElementActive = (editor, format, blockType = 'type')=>{
+    if (!editor.selection) return false;
+    const [match] = Array.from(_slate.Editor.nodes(editor, {
+        at: _slate.Editor.unhangRange(editor, editor.selection),
+        match: (n)=>!_slate.Editor.isEditor(n) && _slate.Element.isElement(n) && n[blockType] === format
+    }));
+    return !!match;
+};
+const _default = isElementActive;
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9maWVsZC9lbGVtZW50cy9pc0FjdGl2ZS50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRWRpdG9yLCBFbGVtZW50IH0gZnJvbSAnc2xhdGUnXG5cbmNvbnN0IGlzRWxlbWVudEFjdGl2ZSA9IChlZGl0b3I6IEVkaXRvciwgZm9ybWF0OiBzdHJpbmcsIGJsb2NrVHlwZSA9ICd0eXBlJyk6IGJvb2xlYW4gPT4ge1xuICBpZiAoIWVkaXRvci5zZWxlY3Rpb24pIHJldHVybiBmYWxzZVxuXG4gIGNvbnN0IFttYXRjaF0gPSBBcnJheS5mcm9tKFxuICAgIEVkaXRvci5ub2RlcyhlZGl0b3IsIHtcbiAgICAgIGF0OiBFZGl0b3IudW5oYW5nUmFuZ2UoZWRpdG9yLCBlZGl0b3Iuc2VsZWN0aW9uKSxcbiAgICAgIG1hdGNoOiAobikgPT4gIUVkaXRvci5pc0VkaXRvcihuKSAmJiBFbGVtZW50LmlzRWxlbWVudChuKSAmJiBuW2Jsb2NrVHlwZV0gPT09IGZvcm1hdCxcbiAgICB9KSxcbiAgKVxuXG4gIHJldHVybiAhIW1hdGNoXG59XG5cbmV4cG9ydCBkZWZhdWx0IGlzRWxlbWVudEFjdGl2ZVxuIl0sIm5hbWVzIjpbImlzRWxlbWVudEFjdGl2ZSIsImVkaXRvciIsImZvcm1hdCIsImJsb2NrVHlwZSIsInNlbGVjdGlvbiIsIm1hdGNoIiwiQXJyYXkiLCJmcm9tIiwiRWRpdG9yIiwibm9kZXMiLCJhdCIsInVuaGFuZ1JhbmdlIiwibiIsImlzRWRpdG9yIiwiRWxlbWVudCIsImlzRWxlbWVudCJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFlQTs7O2VBQUE7Ozt1QkFmZ0M7QUFFaEMsTUFBTUEsa0JBQWtCLENBQUNDLFFBQWdCQyxRQUFnQkMsWUFBWSxNQUFNO0lBQ3pFLElBQUksQ0FBQ0YsT0FBT0csU0FBUyxFQUFFLE9BQU87SUFFOUIsTUFBTSxDQUFDQyxNQUFNLEdBQUdDLE1BQU1DLElBQUksQ0FDeEJDLGFBQU0sQ0FBQ0MsS0FBSyxDQUFDUixRQUFRO1FBQ25CUyxJQUFJRixhQUFNLENBQUNHLFdBQVcsQ0FBQ1YsUUFBUUEsT0FBT0csU0FBUztRQUMvQ0MsT0FBTyxDQUFDTyxJQUFNLENBQUNKLGFBQU0sQ0FBQ0ssUUFBUSxDQUFDRCxNQUFNRSxjQUFPLENBQUNDLFNBQVMsQ0FBQ0gsTUFBTUEsQ0FBQyxDQUFDVCxVQUFVLEtBQUtEO0lBQ2hGO0lBR0YsT0FBTyxDQUFDLENBQUNHO0FBQ1g7TUFFQSxXQUFlTCJ9

package/dist/field/elements/isBlockElement.d.ts

@@ -0,0 +1,9 @@
+import { Editor } from 'slate';
+/**
+ * Returns true, if the provided node is a Block Element.
+ * Note: Using Editor.isBlock() is not sufficient, as since slate 0.90 it returns `true` for Text nodes and the editor as well.
+ *
+ * Related Issue: https://github.com/ianstormtaylor/slate/issues/5287
+ */
+export declare const isBlockElement: (editor: Editor, node: any) => node is import("../../types").ElementNode;
+//# sourceMappingURL=isBlockElement.d.ts.map