@worktile/theia 15.3.2 → 16.0.0

package/esm2022/plugins/list/normalizers/normalize-no.mjs

@@ -0,0 +1,43 @@
+import { Editor, Transforms, Path, Element } from 'slate';
+import * as TheQueries from '../../../queries';
+import * as TheTransforms from '../../../transforms';
+// 列表续号
+export const normalizeNo = (editor, nodeEntry) => {
+    const [listNode, listPath] = nodeEntry;
+    let moved = false;
+    Editor.withoutNormalizing(editor, () => {
+        /**
+         * 获取nextList判断是否为同类型list
+         * 如果为同类型list，则把nextList children移动到当前list的尾部, 并删除nextList
+         */
+        const nextPath = Path.next(listPath);
+        const nextNode = TheQueries.getNode(editor, nextPath);
+        if (nextNode && Element.isElement(nextNode) && Element.isElement(listNode) && nextNode.type === listNode.type) {
+            TheTransforms.moveChildren(editor, {
+                at: [nextNode, nextPath],
+                to: listPath.concat(listNode.children.length)
+            });
+            Transforms.removeNodes(editor, { at: nextPath });
+            moved = true;
+        }
+        if (listPath[listPath.length - 1] !== 0) {
+            /**
+             * 获取prevList判断是否为同类型list
+             * 如果为同类型list，则把当前list children移动到prevList的尾部, 并删除当前List
+             */
+            const currentListNode = TheQueries.getNode(editor, listPath);
+            const prevPath = Path.previous(listPath);
+            const prevNode = TheQueries.getNode(editor, prevPath);
+            if (prevNode && Element.isElement(prevNode) && Element.isElement(currentListNode) && prevNode.type === currentListNode.type) {
+                TheTransforms.moveChildren(editor, {
+                    at: [currentListNode, listPath],
+                    to: prevPath.concat(prevNode.children.length)
+                });
+                Transforms.removeNodes(editor, { at: listPath });
+                moved = true;
+            }
+        }
+    });
+    return moved;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/plugins/list/on-key-down-list.mjs

@@ -0,0 +1,33 @@
+import { moveListItemUp } from './transforms/move-list-item-up';
+import { moveListItemDown } from './transforms/move-list-item-down';
+import { getListItemEntry } from './queries/get-list-item-entry';
+import * as TheQueries from '../../queries';
+export function onKeyDownList(e, editor) {
+    let moved = false;
+    if (e.key === 'Tab') {
+        const res = getListItemEntry(editor, {});
+        if (!res) {
+            return false;
+        }
+        const { list, listItem } = res;
+        const [, listItemPath] = listItem;
+        e.preventDefault();
+        // move up with shift+tab
+        const shiftTab = e.shiftKey;
+        if (shiftTab) {
+            moved = moveListItemUp(editor, { list, listItem });
+            if (moved) {
+                e.preventDefault();
+                return true;
+            }
+        }
+        // move down with tab
+        const tab = !e.shiftKey;
+        if (tab && !TheQueries.isFirstChild(listItemPath)) {
+            moveListItemDown(editor, { list, listItem });
+            return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/plugins/list/queries/get-list-item-entry.mjs

@@ -0,0 +1,28 @@
+import { ElementKinds } from '../../../constants';
+import { isList } from './is-list';
+import * as TheQueries from '../../../queries';
+/**
+ * 如果at（默认= selection）位于ul> li> p中，则返回li和ul节点条目。
+ */
+export const getListItemEntry = (editor, { at = editor.selection } = {}) => {
+    if (at && TheQueries.isNodeTypeIn(editor, ElementKinds.listItem, { at })) {
+        const selectionParent = TheQueries.getParent(editor, at);
+        if (!selectionParent)
+            return;
+        const [, paragraphPath] = selectionParent;
+        const listItem = TheQueries.getAboveByType(editor, ElementKinds.listItem, { at }) || TheQueries.getParent(editor, paragraphPath);
+        if (!listItem)
+            return;
+        const [listItemNode, listItemPath] = listItem;
+        if (listItemNode.type !== ElementKinds.listItem)
+            return;
+        const list = TheQueries.getParent(editor, listItemPath);
+        if (!list || !isList(list[0]))
+            return;
+        return {
+            list,
+            listItem
+        };
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWxpc3QtaXRlbS1lbnRyeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3NyYy9wbHVnaW5zL2xpc3QvcXVlcmllcy9nZXQtbGlzdC1pdGVtLWVudHJ5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUVsRCxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQ25DLE9BQU8sS0FBSyxVQUFVLE1BQU0sa0JBQWtCLENBQUM7QUFFL0M7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRyxDQUFDLE1BQWlCLEVBQUUsRUFBRSxFQUFFLEdBQUcsTUFBTSxDQUFDLFNBQVMsS0FBK0IsRUFBRSxFQUFFLEVBQUU7SUFDNUcsSUFBSSxFQUFFLElBQUksVUFBVSxDQUFDLFlBQVksQ0FBQyxNQUFNLEVBQUUsWUFBWSxDQUFDLFFBQVEsRUFBRSxFQUFFLEVBQUUsRUFBRSxDQUFDLEVBQUU7UUFDdEUsTUFBTSxlQUFlLEdBQUcsVUFBVSxDQUFDLFNBQVMsQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFDekQsSUFBSSxDQUFDLGVBQWU7WUFBRSxPQUFPO1FBQzdCLE1BQU0sQ0FBQyxFQUFFLGFBQWEsQ0FBQyxHQUFHLGVBQWUsQ0FBQztRQUUxQyxNQUFNLFFBQVEsR0FBRyxVQUFVLENBQUMsY0FBYyxDQUFDLE1BQU0sRUFBRSxZQUFZLENBQUMsUUFBUSxFQUFFLEVBQUUsRUFBRSxFQUFFLENBQUMsSUFBSSxVQUFVLENBQUMsU0FBUyxDQUFDLE1BQU0sRUFBRSxhQUFhLENBQUMsQ0FBQztRQUVqSSxJQUFJLENBQUMsUUFBUTtZQUFFLE9BQU87UUFDdEIsTUFBTSxDQUFDLFlBQVksRUFBRSxZQUFZLENBQUMsR0FBRyxRQUFRLENBQUM7UUFFOUMsSUFBSyxZQUFnQyxDQUFDLElBQUksS0FBSyxZQUFZLENBQUMsUUFBUTtZQUFFLE9BQU87UUFFN0UsTUFBTSxJQUFJLEdBQUcsVUFBVSxDQUFDLFNBQVMsQ0FBQyxNQUFNLEVBQUUsWUFBWSxDQUFDLENBQUM7UUFDeEQsSUFBSSxDQUFDLElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFrQixDQUFDO1lBQUUsT0FBTztRQUV2RCxPQUFPO1lBQ0gsSUFBSTtZQUNKLFFBQVE7U0FDWCxDQUFDO0tBQ0w7QUFDTCxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBMb2NhdGlvbiB9IGZyb20gJ3NsYXRlJztcbmltcG9ydCB7IFRoZUVkaXRvciB9IGZyb20gJy4uLy4uLy4uL2ludGVyZmFjZXMnO1xuaW1wb3J0IHsgRWxlbWVudEtpbmRzIH0gZnJvbSAnLi4vLi4vLi4vY29uc3RhbnRzJztcbmltcG9ydCB7IEN1c3RvbUVsZW1lbnQsIExpc3RJdGVtRWxlbWVudCB9IGZyb20gJy4uLy4uLy4uL2N1c3RvbS10eXBlcyc7XG5pbXBvcnQgeyBpc0xpc3QgfSBmcm9tICcuL2lzLWxpc3QnO1xuaW1wb3J0ICogYXMgVGhlUXVlcmllcyBmcm9tICcuLi8uLi8uLi9xdWVyaWVzJztcblxuLyoqXG4gKiDlpoLmnpxhdO+8iOm7mOiupD0gc2VsZWN0aW9u77yJ5L2N5LqOdWw+IGxpPiBw5Lit77yM5YiZ6L+U5ZuebGnlkox1bOiKgueCueadoeebruOAglxuICovXG5leHBvcnQgY29uc3QgZ2V0TGlzdEl0ZW1FbnRyeSA9IChlZGl0b3I6IFRoZUVkaXRvciwgeyBhdCA9IGVkaXRvci5zZWxlY3Rpb24gfTogeyBhdD86IExvY2F0aW9uIHwgbnVsbCB9ID0ge30pID0+IHtcbiAgICBpZiAoYXQgJiYgVGhlUXVlcmllcy5pc05vZGVUeXBlSW4oZWRpdG9yLCBFbGVtZW50S2luZHMubGlzdEl0ZW0sIHsgYXQgfSkpIHtcbiAgICAgICAgY29uc3Qgc2VsZWN0aW9uUGFyZW50ID0gVGhlUXVlcmllcy5nZXRQYXJlbnQoZWRpdG9yLCBhdCk7XG4gICAgICAgIGlmICghc2VsZWN0aW9uUGFyZW50KSByZXR1cm47XG4gICAgICAgIGNvbnN0IFssIHBhcmFncmFwaFBhdGhdID0gc2VsZWN0aW9uUGFyZW50O1xuXG4gICAgICAgIGNvbnN0IGxpc3RJdGVtID0gVGhlUXVlcmllcy5nZXRBYm92ZUJ5VHlwZShlZGl0b3IsIEVsZW1lbnRLaW5kcy5saXN0SXRlbSwgeyBhdCB9KSB8fCBUaGVRdWVyaWVzLmdldFBhcmVudChlZGl0b3IsIHBhcmFncmFwaFBhdGgpO1xuXG4gICAgICAgIGlmICghbGlzdEl0ZW0pIHJldHVybjtcbiAgICAgICAgY29uc3QgW2xpc3RJdGVtTm9kZSwgbGlzdEl0ZW1QYXRoXSA9IGxpc3RJdGVtO1xuXG4gICAgICAgIGlmICgobGlzdEl0ZW1Ob2RlIGFzIExpc3RJdGVtRWxlbWVudCkudHlwZSAhPT0gRWxlbWVudEtpbmRzLmxpc3RJdGVtKSByZXR1cm47XG5cbiAgICAgICAgY29uc3QgbGlzdCA9IFRoZVF1ZXJpZXMuZ2V0UGFyZW50KGVkaXRvciwgbGlzdEl0ZW1QYXRoKTtcbiAgICAgICAgaWYgKCFsaXN0IHx8ICFpc0xpc3QobGlzdFswXSBhcyBDdXN0b21FbGVtZW50KSkgcmV0dXJuO1xuXG4gICAgICAgIHJldHVybiB7XG4gICAgICAgICAgICBsaXN0LFxuICAgICAgICAgICAgbGlzdEl0ZW1cbiAgICAgICAgfTtcbiAgICB9XG59O1xuIl19

package/esm2022/plugins/list/queries/get-start-list-item.mjs

@@ -0,0 +1,27 @@
+import { ElementKinds } from '../../../constants';
+import { getListTypes } from './get-list-types';
+/**
+ * 获取 List 中 ListItems，过滤掉空列表嵌套
+ * @param node
+ * @param initialValue
+ * @returns
+ */
+export const getStartListItem = (node, initialValue) => {
+    if (!initialValue) {
+        initialValue = [];
+    }
+    if (node) {
+        return node.reduce((result, current) => {
+            if (current.type === ElementKinds.listItem && !getListTypes().includes(current.children[0].type)) {
+                result.push(current);
+            }
+            else {
+                if (current.children) {
+                    getStartListItem(current.children, result);
+                }
+            }
+            return result;
+        }, initialValue);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/plugins/list/queries/has-list-in-list-item.mjs

@@ -0,0 +1,27 @@
+import { ElementKinds } from '../../../constants';
+import { match } from '../../../utils/match';
+import { getListTypes } from './get-list-types';
+/**
+ *
+ */
+export const hasListInListItem = (listItemNode) => {
+    const sublist = listItemNode.children.find(n => match(n, { type: getListTypes() }));
+    return listItemNode.children.length > 1 && sublist;
+};
+/**
+ * p + ul/ol structure
+ * @param listItemNode
+ */
+export const hasStableListInListItem = (listItemNode) => {
+    const sublist = listItemNode.children.find(n => match(n, { type: getListTypes() }));
+    return listItemNode.children.length === 2 && sublist;
+};
+/**
+ * li + p structure
+ * @param listItemNode
+ */
+export const hasStableListItem = (listItemNode) => {
+    const type = listItemNode.children[0].type;
+    return listItemNode.children.length === 1 && type === ElementKinds.paragraph;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/plugins/list/queries/is-in-list.mjs

@@ -0,0 +1,6 @@
+import { ElementKinds } from '../../../constants';
+import * as TheQueries from '../../../queries';
+export const isInList = (editor, at = editor.selection) => {
+    return TheQueries.isNodeTypeIn(editor, [ElementKinds.numberedList, ElementKinds.bulletedList], { at });
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtaW4tbGlzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3NyYy9wbHVnaW5zL2xpc3QvcXVlcmllcy9pcy1pbi1saXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNsRCxPQUFPLEtBQUssVUFBVSxNQUFNLGtCQUFrQixDQUFDO0FBRS9DLE1BQU0sQ0FBQyxNQUFNLFFBQVEsR0FBRyxDQUFDLE1BQWlCLEVBQUUsS0FBa0MsTUFBTSxDQUFDLFNBQVMsRUFBRSxFQUFFO0lBQzlGLE9BQU8sVUFBVSxDQUFDLFlBQVksQ0FBQyxNQUFNLEVBQUUsQ0FBQyxZQUFZLENBQUMsWUFBWSxFQUFFLFlBQVksQ0FBQyxZQUFZLENBQUMsRUFBRSxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUM7QUFDM0csQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGF0aCwgUG9pbnQsIFJhbmdlIH0gZnJvbSAnc2xhdGUnO1xuaW1wb3J0IHsgVGhlRWRpdG9yIH0gZnJvbSAnLi4vLi4vLi4vaW50ZXJmYWNlcyc7XG5pbXBvcnQgeyBFbGVtZW50S2luZHMgfSBmcm9tICcuLi8uLi8uLi9jb25zdGFudHMnO1xuaW1wb3J0ICogYXMgVGhlUXVlcmllcyBmcm9tICcuLi8uLi8uLi9xdWVyaWVzJztcblxuZXhwb3J0IGNvbnN0IGlzSW5MaXN0ID0gKGVkaXRvcjogVGhlRWRpdG9yLCBhdDogUGF0aCB8IFJhbmdlIHwgUG9pbnQgfCBudWxsID0gZWRpdG9yLnNlbGVjdGlvbikgPT4ge1xuICAgIHJldHVybiBUaGVRdWVyaWVzLmlzTm9kZVR5cGVJbihlZGl0b3IsIFtFbGVtZW50S2luZHMubnVtYmVyZWRMaXN0LCBFbGVtZW50S2luZHMuYnVsbGV0ZWRMaXN0XSwgeyBhdCB9KTtcbn07XG4iXX0=

package/esm2022/plugins/list/queries/is-list-nested.mjs

@@ -0,0 +1,10 @@
+import { Editor } from 'slate';
+import { ElementKinds } from '../../../constants';
+/**
+ * Is the list nested, i.e. its parent is a list item.
+ */
+export const isListNested = (editor, listPath, options) => {
+    const [listParentNode] = Editor.parent(editor, listPath);
+    return listParentNode.type === ElementKinds.listItem;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtbGlzdC1uZXN0ZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9zcmMvcGx1Z2lucy9saXN0L3F1ZXJpZXMvaXMtbGlzdC1uZXN0ZWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBUSxNQUFNLE9BQU8sQ0FBQztBQUdyQyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFbEQ7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsQ0FBQyxNQUFpQixFQUFFLFFBQWMsRUFBRSxPQUFhLEVBQUUsRUFBRTtJQUM3RSxNQUFNLENBQUMsY0FBYyxDQUFDLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDekQsT0FBUSxjQUFnQyxDQUFDLElBQUksS0FBSyxZQUFZLENBQUMsUUFBUSxDQUFDO0FBQzVFLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVkaXRvciwgUGF0aCB9IGZyb20gJ3NsYXRlJztcbmltcG9ydCB7IFRoZUVkaXRvciB9IGZyb20gJy4uLy4uLy4uL2ludGVyZmFjZXMnO1xuaW1wb3J0IHsgQ3VzdG9tRWxlbWVudCB9IGZyb20gJy4uLy4uLy4uL2N1c3RvbS10eXBlcyc7XG5pbXBvcnQgeyBFbGVtZW50S2luZHMgfSBmcm9tICcuLi8uLi8uLi9jb25zdGFudHMnO1xuXG4vKipcbiAqIElzIHRoZSBsaXN0IG5lc3RlZCwgaS5lLiBpdHMgcGFyZW50IGlzIGEgbGlzdCBpdGVtLlxuICovXG5leHBvcnQgY29uc3QgaXNMaXN0TmVzdGVkID0gKGVkaXRvcjogVGhlRWRpdG9yLCBsaXN0UGF0aDogUGF0aCwgb3B0aW9ucz86IGFueSkgPT4ge1xuICAgIGNvbnN0IFtsaXN0UGFyZW50Tm9kZV0gPSBFZGl0b3IucGFyZW50KGVkaXRvciwgbGlzdFBhdGgpO1xuICAgIHJldHVybiAobGlzdFBhcmVudE5vZGUgYXMgQ3VzdG9tRWxlbWVudCkudHlwZSA9PT0gRWxlbWVudEtpbmRzLmxpc3RJdGVtO1xufTtcbiJdfQ==

package/esm2022/plugins/list/queries/is-list.mjs

@@ -0,0 +1,5 @@
+import { LIST_BLOCK_TYPES } from '../../../constants/node-types';
+export const isList = (n) => {
+    return [...LIST_BLOCK_TYPES].includes(n.type);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtbGlzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3NyYy9wbHVnaW5zL2xpc3QvcXVlcmllcy9pcy1saXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBRWpFLE1BQU0sQ0FBQyxNQUFNLE1BQU0sR0FBRyxDQUFDLENBQWdCLEVBQUUsRUFBRTtJQUN2QyxPQUFPLENBQUMsR0FBRyxnQkFBZ0IsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDbEQsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ3VzdG9tRWxlbWVudCB9IGZyb20gJy4uLy4uLy4uL2N1c3RvbS10eXBlcyc7XG5pbXBvcnQgeyBMSVNUX0JMT0NLX1RZUEVTIH0gZnJvbSAnLi4vLi4vLi4vY29uc3RhbnRzL25vZGUtdHlwZXMnO1xuXG5leHBvcnQgY29uc3QgaXNMaXN0ID0gKG46IEN1c3RvbUVsZW1lbnQpID0+IHtcbiAgICByZXR1cm4gWy4uLkxJU1RfQkxPQ0tfVFlQRVNdLmluY2x1ZGVzKG4udHlwZSk7XG59O1xuIl19

package/{esm2020 → esm2022}/plugins/list/queries/is-node-type-list.mjs

@@ -2,4 +2,4 @@ import { ElementKinds } from '../../../constants/node-types';
 export const isNodeTypeList = (n) => {
     return [ElementKinds.bulletedList, ElementKinds.numberedList].includes(n.type);
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtbm9kZS10eXBlLWxpc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9zcmMvcGx1Z2lucy9saXN0L3F1ZXJpZXMvaXMtbm9kZS10eXBlLWxpc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBRTdELE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxDQUFDLENBQU8sRUFBZ0IsRUFBRTtJQUNwRCxPQUFPLENBQUMsWUFBWSxDQUFDLFlBQVksRUFBRSxZQUFZLENBQUMsWUFBWSxDQUFDLENBQUMsUUFBUSxDQUFFLENBQWEsQ0FBQyxJQUFJLENBQUMsQ0FBQztBQUNoRyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFbGVtZW50LCBOb2RlIH0gZnJvbSAnc2xhdGUnO1xuaW1wb3J0IHsgRWxlbWVudEtpbmRzIH0gZnJvbSAnLi4vLi4vLi4vY29uc3RhbnRzL25vZGUtdHlwZXMnO1xuXG5leHBvcnQgY29uc3QgaXNOb2RlVHlwZUxpc3QgPSAobjogTm9kZSk6IG4gaXMgRWxlbWVudCA9PiB7XG4gICAgcmV0dXJuIFtFbGVtZW50S2luZHMuYnVsbGV0ZWRMaXN0LCBFbGVtZW50S2luZHMubnVtYmVyZWRMaXN0XS5pbmNsdWRlcygobiBhcyBFbGVtZW50KS50eXBlKTtcbn07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtbm9kZS10eXBlLWxpc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9zcmMvcGx1Z2lucy9saXN0L3F1ZXJpZXMvaXMtbm9kZS10eXBlLWxpc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBRTdELE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxDQUFDLENBQU8sRUFBc0IsRUFBRTtJQUMxRCxPQUFPLENBQUMsWUFBWSxDQUFDLFlBQVksRUFBRSxZQUFZLENBQUMsWUFBWSxDQUFDLENBQUMsUUFBUSxDQUFFLENBQW1CLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDdEcsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTm9kZSB9IGZyb20gJ3NsYXRlJztcbmltcG9ydCB7IEN1c3RvbUVsZW1lbnQgfSBmcm9tICcuLi8uLi8uLi9jdXN0b20tdHlwZXMnO1xuaW1wb3J0IHsgRWxlbWVudEtpbmRzIH0gZnJvbSAnLi4vLi4vLi4vY29uc3RhbnRzL25vZGUtdHlwZXMnO1xuXG5leHBvcnQgY29uc3QgaXNOb2RlVHlwZUxpc3QgPSAobjogTm9kZSk6IG4gaXMgQ3VzdG9tRWxlbWVudCA9PiB7XG4gICAgcmV0dXJuIFtFbGVtZW50S2luZHMuYnVsbGV0ZWRMaXN0LCBFbGVtZW50S2luZHMubnVtYmVyZWRMaXN0XS5pbmNsdWRlcygobiBhcyBDdXN0b21FbGVtZW50KS50eXBlKTtcbn07XG4iXX0=

package/esm2022/plugins/list/queries/is-selection-at-list-item-start.mjs

@@ -0,0 +1,13 @@
+import { ElementKinds } from '../../../constants';
+import * as TheQueries from '../../../queries';
+/**
+ * Is the selection focus at the start of its parent block.
+ */
+export const isSelectionAtListItemStart = (editor) => {
+    const listItemEntry = TheQueries.getAboveByType(editor, [ElementKinds.listItem]);
+    if (listItemEntry) {
+        return TheQueries.isStart(editor, editor.selection.focus, listItemEntry[1]);
+    }
+    return false;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtc2VsZWN0aW9uLWF0LWxpc3QtaXRlbS1zdGFydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3NyYy9wbHVnaW5zL2xpc3QvcXVlcmllcy9pcy1zZWxlY3Rpb24tYXQtbGlzdC1pdGVtLXN0YXJ0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNsRCxPQUFPLEtBQUssVUFBVSxNQUFNLGtCQUFrQixDQUFDO0FBRS9DOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sMEJBQTBCLEdBQUcsQ0FBQyxNQUFpQixFQUFFLEVBQUU7SUFDNUQsTUFBTSxhQUFhLEdBQUcsVUFBVSxDQUFDLGNBQWMsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxZQUFZLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQztJQUNqRixJQUFJLGFBQWEsRUFBRTtRQUNmLE9BQU8sVUFBVSxDQUFDLE9BQU8sQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLFNBQVMsQ0FBQyxLQUFLLEVBQUUsYUFBYSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7S0FDL0U7SUFDRCxPQUFPLEtBQUssQ0FBQztBQUNqQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUaGVFZGl0b3IgfSBmcm9tICcuLi8uLi8uLi9pbnRlcmZhY2VzJztcbmltcG9ydCB7IEVsZW1lbnRLaW5kcyB9IGZyb20gJy4uLy4uLy4uL2NvbnN0YW50cyc7XG5pbXBvcnQgKiBhcyBUaGVRdWVyaWVzIGZyb20gJy4uLy4uLy4uL3F1ZXJpZXMnO1xuXG4vKipcbiAqIElzIHRoZSBzZWxlY3Rpb24gZm9jdXMgYXQgdGhlIHN0YXJ0IG9mIGl0cyBwYXJlbnQgYmxvY2suXG4gKi9cbmV4cG9ydCBjb25zdCBpc1NlbGVjdGlvbkF0TGlzdEl0ZW1TdGFydCA9IChlZGl0b3I6IFRoZUVkaXRvcikgPT4ge1xuICAgIGNvbnN0IGxpc3RJdGVtRW50cnkgPSBUaGVRdWVyaWVzLmdldEFib3ZlQnlUeXBlKGVkaXRvciwgW0VsZW1lbnRLaW5kcy5saXN0SXRlbV0pO1xuICAgIGlmIChsaXN0SXRlbUVudHJ5KSB7XG4gICAgICAgIHJldHVybiBUaGVRdWVyaWVzLmlzU3RhcnQoZWRpdG9yLCBlZGl0b3Iuc2VsZWN0aW9uLmZvY3VzLCBsaXN0SXRlbUVudHJ5WzFdKTtcbiAgICB9XG4gICAgcmV0dXJuIGZhbHNlO1xufTtcbiJdfQ==

package/esm2022/plugins/list/queries/is-selection-in-same-list-item.mjs

@@ -0,0 +1,17 @@
+import { Range, Path } from 'slate';
+import { getAboveByType } from '../../../queries/get-above-by-type';
+import { ElementKinds } from '../../../constants/node-types';
+/**
+ * Is the selection in same li
+ */
+export const isSelectionInSameListItem = (editor) => {
+    const { selection } = editor;
+    if (!selection) {
+        return false;
+    }
+    const [start, end] = Range.edges(selection);
+    const startListItemEntry = getAboveByType(editor, ElementKinds.listItem, { at: start.path });
+    const endListItemEntry = getAboveByType(editor, ElementKinds.listItem, { at: end.path });
+    return startListItemEntry && endListItemEntry && Path.equals(startListItemEntry[1], endListItemEntry[1]);
+};
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/plugins/list/queries/is-single-list-item.mjs

@@ -6,4 +6,4 @@ import { isNodeTypeList } from './is-node-type-list';
 export const isSingleListItem = (list) => {
     return isNodeTypeList(list) && list.children.length === 1 && !hasListInListItem(list.children[0]);
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtc2luZ2xlLWxpc3QtaXRlbS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3NyYy9wbHVnaW5zL2xpc3QvcXVlcmllcy9pcy1zaW5nbGUtbGlzdC1pdGVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzVELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVyRDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLENBQUMsSUFBVSxFQUFFLEVBQUU7SUFDM0MsT0FBTyxjQUFjLENBQUMsSUFBSSxDQUFDLElBQUssSUFBSSxDQUFDLFFBQW1CLENBQUMsTUFBTSxLQUFLLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFZLENBQUMsQ0FBQztBQUM3SCxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOb2RlLCBFbGVtZW50IH0gZnJvbSAnc2xhdGUnO1xuaW1wb3J0IHsgaGFzTGlzdEluTGlzdEl0ZW0gfSBmcm9tICcuL2hhcy1saXN0LWluLWxpc3QtaXRlbSc7XG5pbXBvcnQgeyBpc05vZGVUeXBlTGlzdCB9IGZyb20gJy4vaXMtbm9kZS10eXBlLWxpc3QnO1xuXG4vKipcbiAqIGxpc3Qg5LitIOaYr+WQpuaYr+WNleS4qmxpc3RJdGVt77yM5LiUbGlzdEl0ZW3msqHmnInlrZDliJfooahcbiAqL1xuZXhwb3J0IGNvbnN0IGlzU2luZ2xlTGlzdEl0ZW0gPSAobGlzdDogTm9kZSkgPT4ge1xuICAgIHJldHVybiBpc05vZGVUeXBlTGlzdChsaXN0KSAmJiAobGlzdC5jaGlsZHJlbiBhcyBOb2RlW10pLmxlbmd0aCA9PT0gMSAmJiAhaGFzTGlzdEluTGlzdEl0ZW0obGlzdC5jaGlsZHJlblswXSBhcyBFbGVtZW50KTtcbn07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtc2luZ2xlLWxpc3QtaXRlbS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3NyYy9wbHVnaW5zL2xpc3QvcXVlcmllcy9pcy1zaW5nbGUtbGlzdC1pdGVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzVELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVyRDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLENBQUMsSUFBVSxFQUFFLEVBQUU7SUFDM0MsT0FBTyxjQUFjLENBQUMsSUFBSSxDQUFDLElBQUssSUFBSSxDQUFDLFFBQW1CLENBQUMsTUFBTSxLQUFLLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFrQixDQUFDLENBQUM7QUFDbkksQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTm9kZSB9IGZyb20gJ3NsYXRlJztcbmltcG9ydCB7IEN1c3RvbUVsZW1lbnQgfSBmcm9tICcuLi8uLi8uLi9jdXN0b20tdHlwZXMnO1xuaW1wb3J0IHsgaGFzTGlzdEluTGlzdEl0ZW0gfSBmcm9tICcuL2hhcy1saXN0LWluLWxpc3QtaXRlbSc7XG5pbXBvcnQgeyBpc05vZGVUeXBlTGlzdCB9IGZyb20gJy4vaXMtbm9kZS10eXBlLWxpc3QnO1xuXG4vKipcbiAqIGxpc3Qg5LitIOaYr+WQpuaYr+WNleS4qmxpc3RJdGVt77yM5LiUbGlzdEl0ZW3msqHmnInlrZDliJfooahcbiAqL1xuZXhwb3J0IGNvbnN0IGlzU2luZ2xlTGlzdEl0ZW0gPSAobGlzdDogTm9kZSkgPT4ge1xuICAgIHJldHVybiBpc05vZGVUeXBlTGlzdChsaXN0KSAmJiAobGlzdC5jaGlsZHJlbiBhcyBOb2RlW10pLmxlbmd0aCA9PT0gMSAmJiAhaGFzTGlzdEluTGlzdEl0ZW0obGlzdC5jaGlsZHJlblswXSBhcyBDdXN0b21FbGVtZW50KTtcbn07XG4iXX0=

package/esm2022/plugins/list/transforms/insert-list-data.mjs

@@ -0,0 +1,72 @@
+import { Node, Path, Transforms, Editor } from 'slate';
+import { hasListInListItem } from '../queries/has-list-in-list-item';
+import { getListItemEntry } from '../queries/get-list-item-entry';
+import * as TheQueries from '../../../queries';
+export const insertListData = (editor, { fromList, toListItemEntry }) => {
+    const { children } = fromList;
+    const [toListItem, toListItemPath] = toListItemEntry;
+    const nextListItemPath = Path.next(toListItemPath);
+    const toListItemIsEmptyParagraph = TheQueries.isEmptyParagraph(editor, editor.selection.anchor);
+    const hasSubList = hasListInListItem(toListItem);
+    let selectPath = [...toListItemPath];
+    const liIndex = selectPath.pop();
+    selectPath = [...selectPath, liIndex + children.length];
+    Editor.withoutNormalizing(editor, () => {
+        if (toListItemIsEmptyParagraph && hasSubList) {
+            Transforms.insertNodes(editor, children, { at: nextListItemPath });
+        }
+        else {
+            const insertListItemPath = toListItemIsEmptyParagraph ? toListItemPath : nextListItemPath;
+            // 如果粘贴目标listItem为空，则先删除listItem
+            if (toListItemIsEmptyParagraph) {
+                Transforms.removeNodes(editor, { at: insertListItemPath });
+                selectPath = Path.previous(selectPath);
+            }
+            Transforms.insertNodes(editor, children, { at: insertListItemPath });
+        }
+        /**
+         * 粘贴目标lisItem有子列表
+         */
+        if (hasSubList) {
+            const paragraphPath = toListItemPath.concat([0]);
+            const nextSubListPath = Path.next(paragraphPath);
+            // 判断粘贴数据是否是多级
+            if (hasListInListItem(fromList.children[0])) {
+                // 设置粘贴后正确选区
+                Transforms.select(editor, Editor.end(editor, nextListItemPath));
+                // 获取当前选区所在listItem entry
+                const currentListItemEntry = getListItemEntry(editor, {});
+                // 获取粘贴目标listItem中的子列表
+                const { children: subListChildren } = Node.get(editor, nextSubListPath);
+                /**
+                 * 复制子列表数据
+                 * 之所以是复制，而不是移动，因为无法单纯一次性移动子列表的所有listItem（不包含subList本身）到目标位置，
+                 * 需要循环移动才可以
+                 **/
+                Transforms.insertNodes(editor, subListChildren, {
+                    at: Path.next(currentListItemEntry.listItem[1])
+                });
+                // 删除已被复制后无用的listItem/listItem subList
+                Transforms.delete(editor, {
+                    at: toListItemIsEmptyParagraph ? toListItemPath : nextSubListPath
+                });
+                return;
+            }
+            Transforms.select(editor, Editor.end(editor, selectPath));
+            // 粘贴数据不是多级
+            const currentListItemEntry = getListItemEntry(editor, {});
+            Transforms.moveNodes(editor, {
+                at: nextSubListPath,
+                to: currentListItemEntry.listItem[1].concat(1)
+            });
+            if (toListItemIsEmptyParagraph) {
+                Transforms.delete(editor, { at: toListItemPath });
+            }
+            return;
+        }
+    });
+    // 粘贴目标listItem没有子列表, 设置选区
+    Transforms.select(editor, Editor.end(editor, selectPath));
+    return;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"insert-list-data.js","sourceRoot":"","sources":["../../../../../../packages/src/plugins/list/transforms/insert-list-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAG5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAc/C,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,MAAiB,EAAE,EAAE,QAAQ,EAAE,eAAe,EAAyB,EAAE,EAAE;IACtG,MAAM,EAAE,QAAQ,EAAE,GAAG,QAAQ,CAAC;IAC9B,MAAM,CAAC,UAAU,EAAE,cAAc,CAAC,GAAG,eAAe,CAAC;IACrD,MAAM,gBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACnD,MAAM,0BAA0B,GAAG,UAAU,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAChG,MAAM,UAAU,GAAG,iBAAiB,CAAC,UAA2B,CAAC,CAAC;IAElE,IAAI,UAAU,GAAG,CAAC,GAAG,cAAc,CAAC,CAAC;IACrC,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC;IACjC,UAAU,GAAG,CAAC,GAAG,UAAU,EAAE,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;IAExD,MAAM,CAAC,kBAAkB,CAAC,MAAM,EAAE,GAAG,EAAE;QACnC,IAAI,0BAA0B,IAAI,UAAU,EAAE;YAC1C,UAAU,CAAC,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,gBAAgB,EAAE,CAAC,CAAC;SACtE;aAAM;YACH,MAAM,kBAAkB,GAAG,0BAA0B,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,gBAAgB,CAAC;YAC1F,gCAAgC;YAChC,IAAI,0BAA0B,EAAE;gBAC5B,UAAU,CAAC,WAAW,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,kBAAkB,EAAE,CAAC,CAAC;gBAC3D,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;aAC1C;YACD,UAAU,CAAC,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,kBAAkB,EAAE,CAAC,CAAC;SACxE;QAED;;WAEG;QACH,IAAI,UAAU,EAAE;YACZ,MAAM,aAAa,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACjD,MAAM,eAAe,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YAEjD,cAAc;YACd,IAAI,iBAAiB,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAkB,CAAC,EAAE;gBAC1D,YAAY;gBACZ,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;gBAEhE,yBAAyB;gBACzB,MAAM,oBAAoB,GAAG,gBAAgB,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;gBAC1D,sBAAsB;gBACtB,MAAM,EAAE,QAAQ,EAAE,eAAe,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,eAAe,CAAkB,CAAC;gBAEzF;;;;oBAII;gBACJ,UAAU,CAAC,WAAW,CAAC,MAAM,EAAE,eAAyB,EAAE;oBACtD,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;iBAClD,CAAC,CAAC;gBACH,sCAAsC;gBACtC,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE;oBACtB,EAAE,EAAE,0BAA0B,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,eAAe;iBACpE,CAAC,CAAC;gBACH,OAAO;aACV;YAED,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;YAE1D,WAAW;YACX,MAAM,oBAAoB,GAAG,gBAAgB,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;YAC1D,UAAU,CAAC,SAAS,CAAC,MAAM,EAAE;gBACzB,EAAE,EAAE,eAAe;gBACnB,EAAE,EAAE,oBAAoB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;aACjD,CAAC,CAAC;YAEH,IAAI,0BAA0B,EAAE;gBAC5B,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,cAAc,EAAE,CAAC,CAAC;aACrD;YACD,OAAO;SACV;IACL,CAAC,CAAC,CAAC;IAEH,0BAA0B;IAC1B,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;IAC1D,OAAO;AACX,CAAC,CAAC","sourcesContent":["import { NodeEntry, Ancestor, Node, Path, Transforms, Editor } from 'slate';\nimport { TheEditor } from '../../../interfaces';\nimport { CustomElement } from '../../../custom-types';\nimport { hasListInListItem } from '../queries/has-list-in-list-item';\nimport { getListItemEntry } from '../queries/get-list-item-entry';\nimport * as TheQueries from '../../../queries';\n\nexport interface InsertListDataOptions {\n    /**\n     * 要粘贴的list数据\n     */\n    fromList: CustomElement;\n\n    /**\n     * 粘贴list数据至此\n     */\n    toListItemEntry: NodeEntry<Ancestor>;\n}\n\nexport const insertListData = (editor: TheEditor, { fromList, toListItemEntry }: InsertListDataOptions) => {\n    const { children } = fromList;\n    const [toListItem, toListItemPath] = toListItemEntry;\n    const nextListItemPath = Path.next(toListItemPath);\n    const toListItemIsEmptyParagraph = TheQueries.isEmptyParagraph(editor, editor.selection.anchor);\n    const hasSubList = hasListInListItem(toListItem as CustomElement);\n\n    let selectPath = [...toListItemPath];\n    const liIndex = selectPath.pop();\n    selectPath = [...selectPath, liIndex + children.length];\n\n    Editor.withoutNormalizing(editor, () => {\n        if (toListItemIsEmptyParagraph && hasSubList) {\n            Transforms.insertNodes(editor, children, { at: nextListItemPath });\n        } else {\n            const insertListItemPath = toListItemIsEmptyParagraph ? toListItemPath : nextListItemPath;\n            // 如果粘贴目标listItem为空，则先删除listItem\n            if (toListItemIsEmptyParagraph) {\n                Transforms.removeNodes(editor, { at: insertListItemPath });\n                selectPath = Path.previous(selectPath);\n            }\n            Transforms.insertNodes(editor, children, { at: insertListItemPath });\n        }\n\n        /**\n         * 粘贴目标lisItem有子列表\n         */\n        if (hasSubList) {\n            const paragraphPath = toListItemPath.concat([0]);\n            const nextSubListPath = Path.next(paragraphPath);\n\n            // 判断粘贴数据是否是多级\n            if (hasListInListItem(fromList.children[0] as CustomElement)) {\n                // 设置粘贴后正确选区\n                Transforms.select(editor, Editor.end(editor, nextListItemPath));\n\n                // 获取当前选区所在listItem entry\n                const currentListItemEntry = getListItemEntry(editor, {});\n                // 获取粘贴目标listItem中的子列表\n                const { children: subListChildren } = Node.get(editor, nextSubListPath) as CustomElement;\n\n                /**\n                 * 复制子列表数据\n                 * 之所以是复制，而不是移动，因为无法单纯一次性移动子列表的所有listItem（不包含subList本身）到目标位置，\n                 * 需要循环移动才可以\n                 **/\n                Transforms.insertNodes(editor, subListChildren as Node[], {\n                    at: Path.next(currentListItemEntry.listItem[1])\n                });\n                // 删除已被复制后无用的listItem/listItem subList\n                Transforms.delete(editor, {\n                    at: toListItemIsEmptyParagraph ? toListItemPath : nextSubListPath\n                });\n                return;\n            }\n\n            Transforms.select(editor, Editor.end(editor, selectPath));\n\n            // 粘贴数据不是多级\n            const currentListItemEntry = getListItemEntry(editor, {});\n            Transforms.moveNodes(editor, {\n                at: nextSubListPath,\n                to: currentListItemEntry.listItem[1].concat(1)\n            });\n\n            if (toListItemIsEmptyParagraph) {\n                Transforms.delete(editor, { at: toListItemPath });\n            }\n            return;\n        }\n    });\n\n    // 粘贴目标listItem没有子列表, 设置选区\n    Transforms.select(editor, Editor.end(editor, selectPath));\n    return;\n};\n"]}

package/esm2022/plugins/list/transforms/insert-list-item.mjs

@@ -0,0 +1,72 @@
+import { Editor, Path, Range, Transforms, Element } from 'slate';
+import { TheEditor } from '../../../interfaces';
+import { ElementKinds } from '../../../constants';
+import * as TheQueries from '../../../queries';
+/**
+ * Insert list item if selection in li>p.
+ */
+export const insertListItem = (editor) => {
+    if (editor.selection && !TheQueries.isRangeAtRoot(editor.selection)) {
+        const paragraphEntry = TheQueries.getAboveByType(editor, ElementKinds.paragraph);
+        if (!paragraphEntry) {
+            return;
+        }
+        const [, paragraphPath] = paragraphEntry;
+        const [listItemNode, listItemPath] = Editor.parent(editor, paragraphPath);
+        if (Element.isElement(listItemNode) && listItemNode.type !== ElementKinds.listItem) {
+            return;
+        }
+        if (!Range.isCollapsed(editor.selection)) {
+            Transforms.delete(editor);
+        }
+        const isEnd = TheQueries.isBlockTextEmptyAfterSelection(editor);
+        const nextNodePath = Path.next(paragraphPath);
+        const nextListItemPath = Path.next(listItemPath);
+        const nextEnd = Editor.end(editor, listItemPath);
+        /**
+         * If not end, split nodes, wrap a list item on the new paragraph and move it to the next list item
+         */
+        if (!isEnd) {
+            Editor.withoutNormalizing(editor, () => {
+                Transforms.splitNodes(editor, { at: editor.selection, always: true });
+                Transforms.wrapNodes(editor, {
+                    type: ElementKinds.listItem,
+                    children: []
+                }, { at: nextNodePath });
+                Transforms.moveNodes(editor, {
+                    at: nextNodePath,
+                    to: nextListItemPath
+                });
+            });
+        }
+        else {
+            /**
+             * If end, split nodes
+             */
+            Editor.withoutNormalizing(editor, () => {
+                Transforms.splitNodes(editor, {
+                    always: true,
+                    mode: 'highest',
+                    match: (n) => {
+                        const path = n && TheEditor.findPath(editor, n);
+                        return path && path.length === nextListItemPath.length;
+                    }
+                });
+            });
+        }
+        /**
+         * If there is a list in the list item, move it to the next list item
+         */
+        if (TheQueries.getNode(editor, nextNodePath)) {
+            Transforms.moveNodes(editor, {
+                at: Editor.range(editor, nextNodePath, nextEnd),
+                to: nextListItemPath.concat(1),
+                match: (n) => {
+                    return listItemNode.children.includes(n);
+                }
+            });
+        }
+        return true;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/plugins/list/transforms/move-list-item-down.mjs

@@ -0,0 +1,41 @@
+import { Editor, Path, Transforms } from 'slate';
+import { getListItemEntry } from '../queries/get-list-item-entry';
+import { hasListInListItem } from '../queries/has-list-in-list-item';
+import { moveListItemSublistItemsToList } from './move-list-item-sublist-items-to-list';
+import { isNodeTypeList } from '../queries/is-node-type-list';
+export const moveListItemDown = (editor, { list, listItem }) => {
+    const [listNode] = list;
+    const [, listItemPath] = listItem;
+    Editor.withoutNormalizing(editor, () => {
+        // 以前的兄弟是新父级
+        const previousSiblingItem = Editor.node(editor, Path.previous(listItemPath));
+        if (previousSiblingItem) {
+            const [previousNode, previousPath] = previousSiblingItem;
+            const lastChildIndexOfPreviousNode = previousNode.children.length - 1;
+            const lastChildOfPreviousNode = previousNode.children[lastChildIndexOfPreviousNode];
+            const newPath = previousPath.concat(isNodeTypeList(lastChildOfPreviousNode)
+                ? [lastChildIndexOfPreviousNode, lastChildOfPreviousNode.children.length]
+                : [previousNode.children.length]);
+            if (!isNodeTypeList(lastChildOfPreviousNode)) {
+                // 创建新子列表
+                const type = listNode.type;
+                Transforms.wrapNodes(editor, { type, children: [] }, {
+                    at: listItemPath
+                });
+            }
+            // 将当前listItem移动到子列表
+            Transforms.moveNodes(editor, {
+                at: listItemPath,
+                to: newPath
+            });
+            const currentListItemEntry = getListItemEntry(editor, {});
+            if (hasListInListItem(currentListItemEntry.listItem[0])) {
+                moveListItemSublistItemsToList(editor, {
+                    fromListItem: currentListItemEntry.listItem,
+                    toList: currentListItemEntry.list
+                });
+            }
+        }
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/plugins/list/transforms/move-list-item-sublist-items-to-list-item-sublist.mjs

@@ -0,0 +1,43 @@
+import { Path, Transforms } from 'slate';
+import { moveChildren } from '../../../transforms/move-children';
+import { getListItemSublist } from '../queries/get-list-item-sublist';
+import * as TheQueries from '../../../queries';
+/**
+ * Move fromListItem sublist list items to the end of `toListItem` sublist.
+ * If there is no `toListItem` sublist, insert one.
+ */
+export const moveListItemSublistItemsToListItemSublist = (editor, { fromListItem, toListItem, start }, options) => {
+    const [, fromListItemPath] = fromListItem;
+    const [toListItemNode, toListItemPath] = toListItem;
+    const fromListItemSublist = getListItemSublist(fromListItem, options);
+    if (!fromListItemSublist)
+        return 0;
+    const [, fromListItemSublistPath] = fromListItemSublist;
+    const toListItemSublist = getListItemSublist(toListItem, options);
+    let to;
+    if (!toListItemSublist) {
+        const fromList = TheQueries.getParent(editor, fromListItemPath);
+        if (!fromList)
+            return 0;
+        const [fromListNode] = fromList;
+        const fromListType = fromListNode.type;
+        const toListItemSublistPath = toListItemPath.concat([toListItemNode.children.length]);
+        Transforms.insertNodes(editor, { type: fromListType, children: [] }, { at: toListItemSublistPath });
+        to = toListItemSublistPath.concat([0]);
+    }
+    else if (start) {
+        const [, toListItemSublistPath] = toListItemSublist;
+        to = toListItemSublistPath.concat([0]);
+    }
+    else {
+        to = Path.next(TheQueries.getLastChildPath(toListItemSublist));
+    }
+    const moved = moveChildren(editor, {
+        at: Path.previous(fromListItemSublistPath),
+        to
+    });
+    // Remove the empty list
+    Transforms.delete(editor, { at: fromListItemPath });
+    return moved;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW92ZS1saXN0LWl0ZW0tc3VibGlzdC1pdGVtcy10by1saXN0LWl0ZW0tc3VibGlzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3NyYy9wbHVnaW5zL2xpc3QvdHJhbnNmb3Jtcy9tb3ZlLWxpc3QtaXRlbS1zdWJsaXN0LWl0ZW1zLXRvLWxpc3QtaXRlbS1zdWJsaXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBdUIsSUFBSSxFQUFFLFVBQVUsRUFBRSxNQUFNLE9BQU8sQ0FBQztBQUc5RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFDakUsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDdEUsT0FBTyxLQUFLLFVBQVUsTUFBTSxrQkFBa0IsQ0FBQztBQW1CL0M7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0seUNBQXlDLEdBQUcsQ0FDckQsTUFBaUIsRUFDakIsRUFBRSxZQUFZLEVBQUUsVUFBVSxFQUFFLEtBQUssRUFBb0QsRUFDckYsT0FBYSxFQUNmLEVBQUU7SUFDQSxNQUFNLENBQUMsRUFBRSxnQkFBZ0IsQ0FBQyxHQUFHLFlBQVksQ0FBQztJQUMxQyxNQUFNLENBQUMsY0FBYyxFQUFFLGNBQWMsQ0FBQyxHQUFHLFVBQVUsQ0FBQztJQUVwRCxNQUFNLG1CQUFtQixHQUFHLGtCQUFrQixDQUFDLFlBQVksRUFBRSxPQUFPLENBQUMsQ0FBQztJQUN0RSxJQUFJLENBQUMsbUJBQW1CO1FBQUUsT0FBTyxDQUFDLENBQUM7SUFDbkMsTUFBTSxDQUFDLEVBQUUsdUJBQXVCLENBQUMsR0FBRyxtQkFBbUIsQ0FBQztJQUV4RCxNQUFNLGlCQUFpQixHQUFHLGtCQUFrQixDQUFDLFVBQVUsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUVsRSxJQUFJLEVBQVEsQ0FBQztJQUViLElBQUksQ0FBQyxpQkFBaUIsRUFBRTtRQUNwQixNQUFNLFFBQVEsR0FBRyxVQUFVLENBQUMsU0FBUyxDQUFDLE1BQU0sRUFBRSxnQkFBZ0IsQ0FBQyxDQUFDO1FBQ2hFLElBQUksQ0FBQyxRQUFRO1lBQUUsT0FBTyxDQUFDLENBQUM7UUFDeEIsTUFBTSxDQUFDLFlBQVksQ0FBQyxHQUFHLFFBQVEsQ0FBQztRQUVoQyxNQUFNLFlBQVksR0FBSSxZQUE4QixDQUFDLElBQUksQ0FBQztRQUMxRCxNQUFNLHFCQUFxQixHQUFHLGNBQWMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxjQUFjLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7UUFDdEYsVUFBVSxDQUFDLFdBQVcsQ0FBQyxNQUFNLEVBQUUsRUFBRSxJQUFJLEVBQUUsWUFBWSxFQUFFLFFBQVEsRUFBRSxFQUFFLEVBQW1CLEVBQUUsRUFBRSxFQUFFLEVBQUUscUJBQXFCLEVBQUUsQ0FBQyxDQUFDO1FBRXJILEVBQUUsR0FBRyxxQkFBcUIsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0tBQzFDO1NBQU0sSUFBSSxLQUFLLEVBQUU7UUFDZCxNQUFNLENBQUMsRUFBRSxxQkFBcUIsQ0FBQyxHQUFHLGlCQUFpQixDQUFDO1FBQ3BELEVBQUUsR0FBRyxxQkFBcUIsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0tBQzFDO1NBQU07UUFDSCxFQUFFLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsZ0JBQWdCLENBQUMsaUJBQWlCLENBQUMsQ0FBQyxDQUFDO0tBQ2xFO0lBRUQsTUFBTSxLQUFLLEdBQUcsWUFBWSxDQUFDLE1BQU0sRUFBRTtRQUMvQixFQUFFLEVBQUUsSUFBSSxDQUFDLFFBQVEsQ0FBQyx1QkFBdUIsQ0FBQztRQUMxQyxFQUFFO0tBQ0wsQ0FBQyxDQUFDO0lBRUgsd0JBQXdCO0lBQ3hCLFVBQVUsQ0FBQyxNQUFNLENBQUMsTUFBTSxFQUFFLEVBQUUsRUFBRSxFQUFFLGdCQUFnQixFQUFFLENBQUMsQ0FBQztJQUVwRCxPQUFPLEtBQUssQ0FBQztBQUNqQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBbmNlc3RvciwgTm9kZUVudHJ5LCBQYXRoLCBUcmFuc2Zvcm1zIH0gZnJvbSAnc2xhdGUnO1xuaW1wb3J0IHsgVGhlRWRpdG9yIH0gZnJvbSAnLi4vLi4vLi4vaW50ZXJmYWNlcyc7XG5pbXBvcnQgeyBDdXN0b21FbGVtZW50IH0gZnJvbSAnLi4vLi4vLi4vY3VzdG9tLXR5cGVzJztcbmltcG9ydCB7IG1vdmVDaGlsZHJlbiB9IGZyb20gJy4uLy4uLy4uL3RyYW5zZm9ybXMvbW92ZS1jaGlsZHJlbic7XG5pbXBvcnQgeyBnZXRMaXN0SXRlbVN1Ymxpc3QgfSBmcm9tICcuLi9xdWVyaWVzL2dldC1saXN0LWl0ZW0tc3VibGlzdCc7XG5pbXBvcnQgKiBhcyBUaGVRdWVyaWVzIGZyb20gJy4uLy4uLy4uL3F1ZXJpZXMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIE1vdmVMaXN0SXRlbVN1Ymxpc3RJdGVtc1RvTGlzdEl0ZW1TdWJsaXN0T3B0aW9ucyB7XG4gICAgLyoqXG4gICAgICogVGhlIGxpc3QgaXRlbSB0byBtZXJnZS5cbiAgICAgKi9cbiAgICBmcm9tTGlzdEl0ZW06IE5vZGVFbnRyeTxBbmNlc3Rvcj47XG5cbiAgICAvKipcbiAgICAgKiBUaGUgbGlzdCBpdGVtIHdoZXJlIHRvIG1lcmdlLlxuICAgICAqL1xuICAgIHRvTGlzdEl0ZW06IE5vZGVFbnRyeTxBbmNlc3Rvcj47XG5cbiAgICAvKipcbiAgICAgKiBNb3ZlIHRvIHRoZSBzdGFydCBvZiB0aGUgbGlzdCBpbnN0ZWFkIG9mIHRoZSBlbmQuXG4gICAgICovXG4gICAgc3RhcnQ/OiBib29sZWFuO1xufVxuXG4vKipcbiAqIE1vdmUgZnJvbUxpc3RJdGVtIHN1Ymxpc3QgbGlzdCBpdGVtcyB0byB0aGUgZW5kIG9mIGB0b0xpc3RJdGVtYCBzdWJsaXN0LlxuICogSWYgdGhlcmUgaXMgbm8gYHRvTGlzdEl0ZW1gIHN1Ymxpc3QsIGluc2VydCBvbmUuXG4gKi9cbmV4cG9ydCBjb25zdCBtb3ZlTGlzdEl0ZW1TdWJsaXN0SXRlbXNUb0xpc3RJdGVtU3VibGlzdCA9IChcbiAgICBlZGl0b3I6IFRoZUVkaXRvcixcbiAgICB7IGZyb21MaXN0SXRlbSwgdG9MaXN0SXRlbSwgc3RhcnQgfTogTW92ZUxpc3RJdGVtU3VibGlzdEl0ZW1zVG9MaXN0SXRlbVN1Ymxpc3RPcHRpb25zLFxuICAgIG9wdGlvbnM/OiBhbnlcbikgPT4ge1xuICAgIGNvbnN0IFssIGZyb21MaXN0SXRlbVBhdGhdID0gZnJvbUxpc3RJdGVtO1xuICAgIGNvbnN0IFt0b0xpc3RJdGVtTm9kZSwgdG9MaXN0SXRlbVBhdGhdID0gdG9MaXN0SXRlbTtcblxuICAgIGNvbnN0IGZyb21MaXN0SXRlbVN1Ymxpc3QgPSBnZXRMaXN0SXRlbVN1Ymxpc3QoZnJvbUxpc3RJdGVtLCBvcHRpb25zKTtcbiAgICBpZiAoIWZyb21MaXN0SXRlbVN1Ymxpc3QpIHJldHVybiAwO1xuICAgIGNvbnN0IFssIGZyb21MaXN0SXRlbVN1Ymxpc3RQYXRoXSA9IGZyb21MaXN0SXRlbVN1Ymxpc3Q7XG5cbiAgICBjb25zdCB0b0xpc3RJdGVtU3VibGlzdCA9IGdldExpc3RJdGVtU3VibGlzdCh0b0xpc3RJdGVtLCBvcHRpb25zKTtcblxuICAgIGxldCB0bzogUGF0aDtcblxuICAgIGlmICghdG9MaXN0SXRlbVN1Ymxpc3QpIHtcbiAgICAgICAgY29uc3QgZnJvbUxpc3QgPSBUaGVRdWVyaWVzLmdldFBhcmVudChlZGl0b3IsIGZyb21MaXN0SXRlbVBhdGgpO1xuICAgICAgICBpZiAoIWZyb21MaXN0KSByZXR1cm4gMDtcbiAgICAgICAgY29uc3QgW2Zyb21MaXN0Tm9kZV0gPSBmcm9tTGlzdDtcblxuICAgICAgICBjb25zdCBmcm9tTGlzdFR5cGUgPSAoZnJvbUxpc3ROb2RlIGFzIEN1c3RvbUVsZW1lbnQpLnR5cGU7XG4gICAgICAgIGNvbnN0IHRvTGlzdEl0ZW1TdWJsaXN0UGF0aCA9IHRvTGlzdEl0ZW1QYXRoLmNvbmNhdChbdG9MaXN0SXRlbU5vZGUuY2hpbGRyZW4ubGVuZ3RoXSk7XG4gICAgICAgIFRyYW5zZm9ybXMuaW5zZXJ0Tm9kZXMoZWRpdG9yLCB7IHR5cGU6IGZyb21MaXN0VHlwZSwgY2hpbGRyZW46IFtdIH0gYXMgQ3VzdG9tRWxlbWVudCwgeyBhdDogdG9MaXN0SXRlbVN1Ymxpc3RQYXRoIH0pO1xuXG4gICAgICAgIHRvID0gdG9MaXN0SXRlbVN1Ymxpc3RQYXRoLmNvbmNhdChbMF0pO1xuICAgIH0gZWxzZSBpZiAoc3RhcnQpIHtcbiAgICAgICAgY29uc3QgWywgdG9MaXN0SXRlbVN1Ymxpc3RQYXRoXSA9IHRvTGlzdEl0ZW1TdWJsaXN0O1xuICAgICAgICB0byA9IHRvTGlzdEl0ZW1TdWJsaXN0UGF0aC5jb25jYXQoWzBdKTtcbiAgICB9IGVsc2Uge1xuICAgICAgICB0byA9IFBhdGgubmV4dChUaGVRdWVyaWVzLmdldExhc3RDaGlsZFBhdGgodG9MaXN0SXRlbVN1Ymxpc3QpKTtcbiAgICB9XG5cbiAgICBjb25zdCBtb3ZlZCA9IG1vdmVDaGlsZHJlbihlZGl0b3IsIHtcbiAgICAgICAgYXQ6IFBhdGgucHJldmlvdXMoZnJvbUxpc3RJdGVtU3VibGlzdFBhdGgpLFxuICAgICAgICB0b1xuICAgIH0pO1xuXG4gICAgLy8gUmVtb3ZlIHRoZSBlbXB0eSBsaXN0XG4gICAgVHJhbnNmb3Jtcy5kZWxldGUoZWRpdG9yLCB7IGF0OiBmcm9tTGlzdEl0ZW1QYXRoIH0pO1xuXG4gICAgcmV0dXJuIG1vdmVkO1xufTtcbiJdfQ==

package/esm2022/plugins/list/transforms/move-list-item-sublist-items-to-list.mjs

@@ -0,0 +1,30 @@
+import { Editor, Path, Transforms } from 'slate';
+import { getListTypes } from '../queries/get-list-types';
+import { moveChildren } from '../../../transforms/move-children';
+import * as TheQueries from '../../../queries';
+/**
+ * 将 fromListItem 子列表的列表项移到 toList
+ */
+export const moveListItemSublistItemsToList = (editor, { fromListItem, toList, location }) => {
+    const fromListItemSublist = TheQueries.findDescendant(editor, {
+        at: fromListItem[1],
+        match: {
+            type: getListTypes()
+        }
+    });
+    if (!fromListItemSublist)
+        return 0;
+    const [, fromListItemSublistPath] = fromListItemSublist;
+    const lastChildPath = TheQueries.getLastChildPath(toList);
+    let moved;
+    Editor.withoutNormalizing(editor, () => {
+        moved = moveChildren(editor, {
+            at: fromListItemSublistPath,
+            to: location ? toList[1].concat(location) : Path.next(lastChildPath)
+        });
+        // 删除空白列表
+        Transforms.delete(editor, { at: fromListItemSublistPath });
+    });
+    return moved;
+};
+//# sourceMappingURL=data:application/json;base64,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