@lofcz/platejs-list-classic 52.0.11 → 52.3.6

package/dist/BaseListPlugin-n9uuTtLe.js

@@ -1386,5 +1386,4 @@ const BaseListPlugin = createTSlatePlugin({
 } }));
 
 //#endregion
-export { moveListItemsToList as A, getHighestEmptyList as B, insertTodoListItem as C, removeFirstListItem as D, moveListItems as E, getTodoListItemEntry as F, isListNested as H, getPropsIfTaskList as I, getPropsIfTaskListLiNode as L, isListRoot as M, isAcrossListItems as N, moveListItemUp as O, hasListChild as P, getListRoot as R, moveListItemSublistItemsToListItemSublist as S, insertListItem as T, getListTypes as V, toggleBulletedList as _, BaseNumberedListPlugin as a, toggleTaskList as b, withNormalizeList as c, normalizeListItem as d, withInsertFragmentList as f, withDeleteBackwardList as g, withDeleteForwardList as h, BaseListPlugin as i, moveListItemDown as j, unwrapList as k, normalizeNestedList as l, withDeleteFragmentList as m, BaseListItemContentPlugin as n, BaseTaskListPlugin as o, withInsertBreakList as p, BaseListItemPlugin as r, withList as s, BaseBulletedListPlugin as t, getDeepInlineChildren as u, toggleList as v, BaseTodoListPlugin as w, removeListItem as x, toggleNumberedList as y, getListItemEntry as z };
-//# sourceMappingURL=BaseListPlugin-n9uuTtLe.js.map
+export { moveListItemsToList as A, getHighestEmptyList as B, insertTodoListItem as C, removeFirstListItem as D, moveListItems as E, getTodoListItemEntry as F, isListNested as H, getPropsIfTaskList as I, getPropsIfTaskListLiNode as L, isListRoot as M, isAcrossListItems as N, moveListItemUp as O, hasListChild as P, getListRoot as R, moveListItemSublistItemsToListItemSublist as S, insertListItem as T, getListTypes as V, toggleBulletedList as _, BaseNumberedListPlugin as a, toggleTaskList as b, withNormalizeList as c, normalizeListItem as d, withInsertFragmentList as f, withDeleteBackwardList as g, withDeleteForwardList as h, BaseListPlugin as i, moveListItemDown as j, unwrapList as k, normalizeNestedList as l, withDeleteFragmentList as m, BaseListItemContentPlugin as n, BaseTaskListPlugin as o, withInsertBreakList as p, BaseListItemPlugin as r, withList as s, BaseBulletedListPlugin as t, getDeepInlineChildren as u, toggleList as v, BaseTodoListPlugin as w, removeListItem as x, toggleNumberedList as y, getListItemEntry as z };

package/dist/BaseTodoListPlugin-C3ztdXje.d.ts

@@ -0,0 +1,15 @@
+import * as platejs12 from "platejs";
+import { TElement } from "platejs";
+
+//#region src/lib/BaseTodoListPlugin.d.ts
+interface TTodoListItemElement extends TElement {
+  checked?: boolean;
+}
+declare const BaseTodoListPlugin: platejs12.SlatePlugin<platejs12.PluginConfig<"action_item", {
+  inheritCheckStateOnLineEndBreak: boolean;
+  inheritCheckStateOnLineStartBreak: boolean;
+}, {}, Record<"action_item", {
+  toggle: () => void;
+}>, {}>>;
+//#endregion
+export { TTodoListItemElement as n, BaseTodoListPlugin as t };

package/dist/index.d.ts

@@ -1,2 +1,351 @@
-import { $ as moveListItemDown, A as BaseNumberedListPlugin, B as RemoveListItemOptions, C as withDeleteBackwardList, D as BaseListItemContentPlugin, E as BaseBulletedListPlugin, F as unindentListItems, G as moveListItemsToList, H as removeFirstListItem, I as toggleBulletedList, J as MoveListItemUpOptions, K as MoveListItemsOptions, L as toggleList, M as ListConfig, N as unwrapList, O as BaseListItemPlugin, P as UnindentListItemsOptions, Q as MoveListItemDownOptions, R as toggleNumberedList, S as withDeleteForwardList, T as TTodoListItemElement, U as moveListSiblingsAfterCursor, V as removeListItem, W as MergeListItemIntoListOptions, X as MoveListItemSublistItemsToListItemSublistOptions, Y as moveListItemUp, Z as moveListItemSublistItemsToListItemSublist, _ as withNormalizeList, a as hasListChild, b as withInsertBreakList, c as getPropsIfTaskList, d as getListRoot, et as insertTodoListItem, f as getListItemEntry, g as normalizeListItem, h as getDeepInlineChildren, i as isAcrossListItems, j as BaseTaskListPlugin, k as BaseListPlugin, l as getPropsIfTaskListLiNode, m as normalizeNestedList, n as isListRoot, nt as insertListItem, o as getTodoListItemEntry, p as getHighestEmptyList, q as moveListItems, r as isListNested, rt as indentListItems, s as GetPropsIfTaskListLiNodeOptions, t as someList, tt as InsertListItemOptions, u as getListTypes, v as withList, w as BaseTodoListPlugin, x as withDeleteFragmentList, y as withInsertFragmentList, z as toggleTaskList } from "./index-CYSu3DSy";
+import { n as TTodoListItemElement, t as BaseTodoListPlugin } from "./BaseTodoListPlugin-C3ztdXje";
+import * as platejs6 from "platejs";
+import { Ancestor, Descendant, EditorNodesOptions, ElementEntry, NodeEntry, OmitFirst, OverrideEditor, Path, PluginConfig, Point, SlateEditor, TElement, TLocation, TRange } from "platejs";
+
+//#region src/lib/transforms/indentListItems.d.ts
+declare const indentListItems: (editor: SlateEditor) => void;
+//#endregion
+//#region src/lib/transforms/insertListItem.d.ts
+type InsertListItemOptions = {
+  inheritCheckStateOnLineEndBreak?: boolean;
+  inheritCheckStateOnLineStartBreak?: boolean;
+};
+/** Insert list item if selection in li>p. TODO: test */
+declare const insertListItem: (editor: SlateEditor, options?: InsertListItemOptions) => boolean;
+//#endregion
+//#region src/lib/transforms/insertTodoListItem.d.ts
+/** Insert todo list item if selection in li>p. TODO: test */
+declare const insertTodoListItem: (editor: SlateEditor) => boolean;
+//#endregion
+//#region src/lib/transforms/moveListItemDown.d.ts
+type MoveListItemDownOptions = {
+  list: ElementEntry;
+  listItem: ElementEntry;
+};
+declare const moveListItemDown: (editor: SlateEditor, {
+  list,
+  listItem
+}: MoveListItemDownOptions) => false | undefined;
+//#endregion
+//#region src/lib/transforms/moveListItemSublistItemsToListItemSublist.d.ts
+type MoveListItemSublistItemsToListItemSublistOptions = {
+  /** The list item to merge. */
+  fromListItem: ElementEntry;
+  /** The list item where to merge. */
+  toListItem: ElementEntry;
+  /** Move to the start of the list instead of the end. */
+  start?: boolean;
+};
+/**
+ * Move fromListItem sublist list items to the end of `toListItem` sublist. If
+ * there is no `toListItem` sublist, insert one.
+ */
+declare const moveListItemSublistItemsToListItemSublist: (editor: SlateEditor, {
+  fromListItem,
+  start,
+  toListItem
+}: MoveListItemSublistItemsToListItemSublistOptions) => boolean;
+//#endregion
+//#region src/lib/transforms/moveListItemUp.d.ts
+type MoveListItemUpOptions = {
+  list: ElementEntry;
+  listItem: ElementEntry;
+};
+/** Move a list item up. */
+declare const moveListItemUp: (editor: SlateEditor, {
+  list,
+  listItem
+}: MoveListItemUpOptions) => boolean;
+//#endregion
+//#region src/lib/transforms/moveListItems.d.ts
+type MoveListItemsOptions = {
+  at?: EditorNodesOptions['at'];
+  enableResetOnShiftTab?: boolean;
+  increase?: boolean;
+};
+declare const moveListItems: (editor: SlateEditor, {
+  at,
+  enableResetOnShiftTab,
+  increase
+}?: MoveListItemsOptions) => boolean | undefined;
+//#endregion
+//#region src/lib/transforms/moveListItemsToList.d.ts
+type MergeListItemIntoListOptions = {
+  /**
+   * Delete `fromListItem` sublist if true.
+   *
+   * @default true
+   */
+  deleteFromList?: boolean;
+  /** List items of the list will be moved. */
+  fromList?: ElementEntry;
+  /** List items of the sublist of this node will be moved. */
+  fromListItem?: ElementEntry;
+  fromStartIndex?: number;
+  to?: Path;
+  /** List items will be moved in this list. */
+  toList?: ElementEntry;
+  /** List position where to move the list items. */
+  toListIndex?: number | null;
+};
+/**
+ * Move the list items of the sublist of `fromListItem` to `toList` (if
+ * `fromListItem` is defined). Move the list items of `fromList` to `toList` (if
+ * `fromList` is defined).
+ */
+declare const moveListItemsToList: (editor: SlateEditor, {
+  deleteFromList,
+  fromList,
+  fromListItem,
+  fromStartIndex,
+  to: _to,
+  toList,
+  toListIndex
+}: MergeListItemIntoListOptions) => boolean;
+//#endregion
+//#region src/lib/transforms/moveListSiblingsAfterCursor.d.ts
+declare const moveListSiblingsAfterCursor: (editor: SlateEditor, {
+  at,
+  to
+}: {
+  at: Path;
+  to: Path;
+}) => boolean | void;
+//#endregion
+//#region src/lib/transforms/removeFirstListItem.d.ts
+/** If list is not nested and if li is not the first child, move li up. */
+declare const removeFirstListItem: (editor: SlateEditor, {
+  list,
+  listItem
+}: {
+  list: ElementEntry;
+  listItem: ElementEntry;
+}) => boolean;
+//#endregion
+//#region src/lib/transforms/removeListItem.d.ts
+type RemoveListItemOptions = {
+  list: ElementEntry;
+  listItem: ElementEntry;
+  reverse?: boolean;
+};
+/** Remove list item and move its sublist to list if any. */
+declare const removeListItem: (editor: SlateEditor, {
+  list,
+  listItem,
+  reverse
+}: RemoveListItemOptions) => boolean;
+//#endregion
+//#region src/lib/transforms/toggleList.d.ts
+declare const toggleList: (editor: SlateEditor, {
+  type
+}: {
+  type: string;
+}) => boolean;
+declare const toggleBulletedList: (editor: SlateEditor) => boolean;
+declare const toggleTaskList: (editor: SlateEditor, defaultChecked?: boolean) => boolean;
+declare const toggleNumberedList: (editor: SlateEditor) => boolean;
+//#endregion
+//#region src/lib/transforms/unindentListItems.d.ts
+type UnindentListItemsOptions = Omit<MoveListItemsOptions, 'increase'>;
+declare const unindentListItems: (editor: SlateEditor, options?: UnindentListItemsOptions) => boolean | undefined;
+//#endregion
+//#region src/lib/transforms/unwrapList.d.ts
+declare const unwrapList: (editor: SlateEditor, {
+  at
+}?: {
+  at?: Path;
+}) => void;
+//#endregion
+//#region src/lib/BaseListPlugin.d.ts
+type ListConfig = PluginConfig<'listClassic', {
+  enableResetOnShiftTab?: boolean;
+  /** Inherit the checked state of above node after insert break at the end */
+  inheritCheckStateOnLineEndBreak?: boolean;
+  /** Inherit the checked state of below node after insert break at the start */
+  inheritCheckStateOnLineStartBreak?: boolean;
+  /** Valid children types for list items, in addition to p and ul types. */
+  validLiChildrenTypes?: string[];
+}, {}, {
+  toggle: {
+    bulletedList: OmitFirst<typeof toggleBulletedList>;
+    list: OmitFirst<typeof toggleList>;
+    numberedList: OmitFirst<typeof toggleNumberedList>;
+    taskList: OmitFirst<typeof toggleTaskList>;
+  };
+}>;
+declare const BaseBulletedListPlugin: platejs6.SlatePlugin<PluginConfig<"ul", {}, {}, Record<"ul", {
+  toggle: () => void;
+}>, {}>>;
+declare const BaseNumberedListPlugin: platejs6.SlatePlugin<PluginConfig<"ol", {}, {}, Record<"ol", {
+  toggle: () => void;
+}>, {}>>;
+declare const BaseTaskListPlugin: platejs6.SlatePlugin<PluginConfig<"taskList", {
+  inheritCheckStateOnLineEndBreak: boolean;
+  inheritCheckStateOnLineStartBreak: boolean;
+}, {}, Record<"taskList", {
+  toggle: () => void;
+}>, {}>>;
+declare const BaseListItemPlugin: platejs6.SlatePlugin<PluginConfig<"li", {}, {}, {}, {}>>;
+declare const BaseListItemContentPlugin: platejs6.SlatePlugin<PluginConfig<"lic", {}, {}, {}, {}>>;
+/** Enables support for bulleted, numbered and to-do lists. */
+declare const BaseListPlugin: platejs6.SlatePlugin<PluginConfig<"listClassic", {
+  enableResetOnShiftTab?: boolean;
+  /** Inherit the checked state of above node after insert break at the end */
+  inheritCheckStateOnLineEndBreak?: boolean;
+  /** Inherit the checked state of below node after insert break at the start */
+  inheritCheckStateOnLineStartBreak?: boolean;
+  /** Valid children types for list items, in addition to p and ul types. */
+  validLiChildrenTypes?: string[];
+}, {}, {
+  toggle: {
+    bulletedList: (() => boolean) & (() => boolean);
+    list: ((args_0: {
+      type: string;
+    }) => boolean) & ((args_0: {
+      type: string;
+    }) => boolean);
+    numberedList: (() => boolean) & (() => boolean);
+    taskList: ((defaultChecked?: boolean | undefined) => boolean) & ((defaultChecked?: boolean | undefined) => boolean);
+  };
+}, {}>>;
+//#endregion
+//#region src/lib/withDeleteBackwardList.d.ts
+declare const withDeleteBackwardList: OverrideEditor<ListConfig>;
+//#endregion
+//#region src/lib/withDeleteForwardList.d.ts
+declare const withDeleteForwardList: OverrideEditor<ListConfig>;
+//#endregion
+//#region src/lib/withDeleteFragmentList.d.ts
+declare const withDeleteFragmentList: OverrideEditor<ListConfig>;
+//#endregion
+//#region src/lib/withInsertBreakList.d.ts
+declare const withInsertBreakList: OverrideEditor<ListConfig>;
+//#endregion
+//#region src/lib/withInsertFragmentList.d.ts
+declare const withInsertFragmentList: OverrideEditor<ListConfig>;
+//#endregion
+//#region src/lib/withList.d.ts
+declare const withList: OverrideEditor<ListConfig>;
+//#endregion
+//#region src/lib/withNormalizeList.d.ts
+/** Normalize list node to force the ul>li>p+ul structure. */
+declare const withNormalizeList: OverrideEditor<ListConfig>;
+//#endregion
+//#region src/lib/normalizers/normalizeListItem.d.ts
+/**
+ * Recursively get all the:
+ *
+ * - Block children
+ * - Inline children except those at excludeDepth
+ */
+declare const getDeepInlineChildren: (editor: SlateEditor, {
+  children
+}: {
+  children: NodeEntry<Descendant>[];
+}) => NodeEntry<Descendant>[];
+/**
+ * If the list item has no child: insert an empty list item container. Else:
+ * move the children that are not valid to the list item container.
+ */
+declare const normalizeListItem: (editor: SlateEditor, {
+  listItem,
+  validLiChildrenTypes
+}: {
+  listItem: ElementEntry;
+} & ListConfig["options"]) => boolean;
+//#endregion
+//#region src/lib/normalizers/normalizeNestedList.d.ts
+declare const normalizeNestedList: (editor: SlateEditor, {
+  nestedListItem
+}: {
+  nestedListItem: ElementEntry;
+}) => boolean | undefined;
+//#endregion
+//#region src/lib/queries/getHighestEmptyList.d.ts
+/**
+ * Find the highest end list that can be deleted. Its path should be different
+ * to diffListPath. If the highest end list 2+ items, return liPath. Get the
+ * parent list until:
+ *
+ * - The list has less than 2 items.
+ * - Its path is not equals to diffListPath.
+ */
+declare const getHighestEmptyList: (editor: SlateEditor, {
+  diffListPath,
+  liPath
+}: {
+  liPath: Path;
+  diffListPath?: Path;
+}) => Path | undefined;
+//#endregion
+//#region src/lib/queries/getListItemEntry.d.ts
+/**
+ * Returns the nearest li and ul / ol wrapping node entries for a given path
+ * (default = selection)
+ */
+declare const getListItemEntry: (editor: SlateEditor, {
+  at
+}?: {
+  at?: TLocation | null;
+}) => {
+  list: ElementEntry;
+  listItem: ElementEntry;
+} | undefined;
+//#endregion
+//#region src/lib/queries/getListRoot.d.ts
+/** Searches upward for the root list element */
+declare const getListRoot: (editor: SlateEditor, at?: Path | Point | TRange | null) => ElementEntry | undefined;
+//#endregion
+//#region src/lib/queries/getListTypes.d.ts
+declare const getListTypes: (editor: SlateEditor) => string[];
+//#endregion
+//#region src/lib/queries/getTaskListProps.d.ts
+type GetPropsIfTaskListLiNodeOptions = {
+  liNode: TElement;
+  inherit?: boolean;
+};
+declare const getPropsIfTaskListLiNode: (editor: SlateEditor, {
+  inherit,
+  liNode: node
+}: GetPropsIfTaskListLiNodeOptions) => {
+  checked: boolean;
+} | undefined;
+declare const getPropsIfTaskList: (editor: SlateEditor, type: string, partial?: {
+  checked?: boolean;
+}) => {
+  checked: boolean;
+} | undefined;
+//#endregion
+//#region src/lib/queries/getTodoListItemEntry.d.ts
+/**
+ * Returns the nearest li and ul / ol wrapping node entries for a given path
+ * (default = selection)
+ */
+declare const getTodoListItemEntry: (editor: SlateEditor, {
+  at
+}?: {
+  at?: TLocation | null;
+}) => {
+  list: ElementEntry;
+  listItem: ElementEntry;
+} | undefined;
+//#endregion
+//#region src/lib/queries/hasListChild.d.ts
+/** Is there a list child in the node. */
+declare const hasListChild: (editor: SlateEditor, node: Ancestor) => boolean;
+//#endregion
+//#region src/lib/queries/isAcrossListItems.d.ts
+/** Is selection across blocks with list items */
+declare const isAcrossListItems: (editor: SlateEditor, at?: TRange | null) => boolean;
+//#endregion
+//#region src/lib/queries/isListNested.d.ts
+/** Is the list nested, i.e. its parent is a list item. */
+declare const isListNested: (editor: SlateEditor, listPath: Path) => boolean;
+//#endregion
+//#region src/lib/queries/isListRoot.d.ts
+declare const isListRoot: (editor: SlateEditor, node: Descendant) => boolean;
+//#endregion
+//#region src/lib/queries/someList.d.ts
+declare const someList: (editor: SlateEditor, type: string) => boolean;
+//#endregion
 export { BaseBulletedListPlugin, BaseListItemContentPlugin, BaseListItemPlugin, BaseListPlugin, BaseNumberedListPlugin, BaseTaskListPlugin, BaseTodoListPlugin, GetPropsIfTaskListLiNodeOptions, InsertListItemOptions, ListConfig, MergeListItemIntoListOptions, MoveListItemDownOptions, MoveListItemSublistItemsToListItemSublistOptions, MoveListItemUpOptions, MoveListItemsOptions, RemoveListItemOptions, TTodoListItemElement, UnindentListItemsOptions, getDeepInlineChildren, getHighestEmptyList, getListItemEntry, getListRoot, getListTypes, getPropsIfTaskList, getPropsIfTaskListLiNode, getTodoListItemEntry, hasListChild, indentListItems, insertListItem, insertTodoListItem, isAcrossListItems, isListNested, isListRoot, moveListItemDown, moveListItemSublistItemsToListItemSublist, moveListItemUp, moveListItems, moveListItemsToList, moveListSiblingsAfterCursor, normalizeListItem, normalizeNestedList, removeFirstListItem, removeListItem, someList, toggleBulletedList, toggleList, toggleNumberedList, toggleTaskList, unindentListItems, unwrapList, withDeleteBackwardList, withDeleteForwardList, withDeleteFragmentList, withInsertBreakList, withInsertFragmentList, withList, withNormalizeList };

package/dist/index.js

@@ -34,5 +34,4 @@ const unindentListItems = (editor, options = {}) => moveListItems(editor, {
 });
 
 //#endregion
-export { BaseBulletedListPlugin, BaseListItemContentPlugin, BaseListItemPlugin, BaseListPlugin, BaseNumberedListPlugin, BaseTaskListPlugin, BaseTodoListPlugin, getDeepInlineChildren, getHighestEmptyList, getListItemEntry, getListRoot, getListTypes, getPropsIfTaskList, getPropsIfTaskListLiNode, getTodoListItemEntry, hasListChild, indentListItems, insertListItem, insertTodoListItem, isAcrossListItems, isListNested, isListRoot, moveListItemDown, moveListItemSublistItemsToListItemSublist, moveListItemUp, moveListItems, moveListItemsToList, moveListSiblingsAfterCursor, normalizeListItem, normalizeNestedList, removeFirstListItem, removeListItem, someList, toggleBulletedList, toggleList, toggleNumberedList, toggleTaskList, unindentListItems, unwrapList, withDeleteBackwardList, withDeleteForwardList, withDeleteFragmentList, withInsertBreakList, withInsertFragmentList, withList, withNormalizeList };
-//# sourceMappingURL=index.js.map
+export { BaseBulletedListPlugin, BaseListItemContentPlugin, BaseListItemPlugin, BaseListPlugin, BaseNumberedListPlugin, BaseTaskListPlugin, BaseTodoListPlugin, getDeepInlineChildren, getHighestEmptyList, getListItemEntry, getListRoot, getListTypes, getPropsIfTaskList, getPropsIfTaskListLiNode, getTodoListItemEntry, hasListChild, indentListItems, insertListItem, insertTodoListItem, isAcrossListItems, isListNested, isListRoot, moveListItemDown, moveListItemSublistItemsToListItemSublist, moveListItemUp, moveListItems, moveListItemsToList, moveListSiblingsAfterCursor, normalizeListItem, normalizeNestedList, removeFirstListItem, removeListItem, someList, toggleBulletedList, toggleList, toggleNumberedList, toggleTaskList, unindentListItems, unwrapList, withDeleteBackwardList, withDeleteForwardList, withDeleteFragmentList, withInsertBreakList, withInsertFragmentList, withList, withNormalizeList };

package/dist/react/index.d.ts

@@ -1,19 +1,51 @@
-import { T as TTodoListItemElement } from "../index-CYSu3DSy";
+import { n as TTodoListItemElement } from "../BaseTodoListPlugin-C3ztdXje";
+import * as platejs0 from "platejs";
+import * as platejs_react0 from "platejs/react";
 
 //#region src/react/ListPlugin.d.ts
-declare const BulletedListPlugin: any;
-declare const TaskListPlugin: any;
-declare const NumberedListPlugin: any;
-declare const ListItemContentPlugin: any;
-declare const ListItemPlugin: any;
+declare const BulletedListPlugin: platejs_react0.PlatePlugin<platejs0.PluginConfig<"ul", {}, {}, Record<"ul", {
+  toggle: () => void;
+}>, {}>>;
+declare const TaskListPlugin: platejs_react0.PlatePlugin<platejs0.PluginConfig<"taskList", {
+  inheritCheckStateOnLineEndBreak: boolean;
+  inheritCheckStateOnLineStartBreak: boolean;
+}, {}, Record<"taskList", {
+  toggle: () => void;
+}>, {}>>;
+declare const NumberedListPlugin: platejs_react0.PlatePlugin<platejs0.PluginConfig<"ol", {}, {}, Record<"ol", {
+  toggle: () => void;
+}>, {}>>;
+declare const ListItemContentPlugin: platejs_react0.PlatePlugin<platejs0.PluginConfig<"lic", {}, {}, {}, {}>>;
+declare const ListItemPlugin: platejs_react0.PlatePlugin<platejs0.PluginConfig<"li", {}, {}, {}, {}>>;
 /**
  * Enables support for bulleted, numbered and to-do lists with React-specific
  * features.
  */
-declare const ListPlugin: any;
+declare const ListPlugin: platejs_react0.PlatePlugin<platejs0.PluginConfig<"listClassic", {
+  enableResetOnShiftTab?: boolean;
+  inheritCheckStateOnLineEndBreak?: boolean;
+  inheritCheckStateOnLineStartBreak?: boolean;
+  validLiChildrenTypes?: string[];
+}, {}, {
+  toggle: {
+    bulletedList: (() => boolean) & (() => boolean);
+    list: ((args_0: {
+      type: string;
+    }) => boolean) & ((args_0: {
+      type: string;
+    }) => boolean);
+    numberedList: (() => boolean) & (() => boolean);
+    taskList: ((defaultChecked?: boolean | undefined) => boolean) & ((defaultChecked?: boolean | undefined) => boolean);
+  };
+}, {}>>;
 //#endregion
 //#region src/react/TodoListPlugin.d.ts
-declare const TodoListPlugin: any;
+declare const TodoListPlugin: platejs_react0.PlatePlugin<platejs0.PluginConfig<"action_item", {
+  inheritCheckStateOnLineEndBreak: boolean;
+  inheritCheckStateOnLineStartBreak: boolean;
+}, {}, Record<"action_item", {
+  toggle: () => void;
+}>, {}>>;
 //#endregion
 //#region src/react/hooks/useListToolbarButton.d.ts
 declare const useListToolbarButtonState: ({
@@ -22,11 +54,11 @@ declare const useListToolbarButtonState: ({
   nodeType?: string | undefined;
 }) => {
   nodeType: string;
-  pressed: any;
+  pressed: boolean;
 };
 declare const useListToolbarButton: (state: ReturnType<typeof useListToolbarButtonState>) => {
   props: {
-    pressed: any;
+    pressed: boolean;
     onClick: () => void;
     onMouseDown: (e: React.MouseEvent<HTMLButtonElement>) => void;
   };
@@ -45,5 +77,4 @@ declare const useTodoListElement: (state: ReturnType<typeof useTodoListElementSt
   };
 };
 //#endregion
-export { BulletedListPlugin, ListItemContentPlugin, ListItemPlugin, ListPlugin, NumberedListPlugin, TaskListPlugin, TodoListPlugin, useListToolbarButton, useListToolbarButtonState, useTodoListElement, useTodoListElementState };
-//# sourceMappingURL=index.d.ts.map
+export { BulletedListPlugin, ListItemContentPlugin, ListItemPlugin, ListPlugin, NumberedListPlugin, TaskListPlugin, TodoListPlugin, useListToolbarButton, useListToolbarButtonState, useTodoListElement, useTodoListElementState };

package/dist/react/index.js

@@ -152,5 +152,4 @@ const useTodoListElement = (state) => {
 };
 
 //#endregion
-export { BulletedListPlugin, ListItemContentPlugin, ListItemPlugin, ListPlugin, NumberedListPlugin, TaskListPlugin, TodoListPlugin, useListToolbarButton, useListToolbarButtonState, useTodoListElement, useTodoListElementState };
-//# sourceMappingURL=index.js.map
+export { BulletedListPlugin, ListItemContentPlugin, ListItemPlugin, ListPlugin, NumberedListPlugin, TaskListPlugin, TodoListPlugin, useListToolbarButton, useListToolbarButtonState, useTodoListElement, useTodoListElementState };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lofcz/platejs-list-classic",
-  "version": "52.0.11",
+  "version": "52.3.6",
   "description": "List Classic plugin for Plate",
   "keywords": [
     "plate",
@@ -33,7 +33,8 @@
     "react-compiler-runtime": "^1.0.0"
   },
   "devDependencies": {
-    "@plate/scripts": "1.0.0"
+    "@plate/scripts": "1.0.0",
+    "platejs": "npm:@lofcz/platejs@52.3.6"
   },
   "peerDependencies": {
     "platejs": ">=52.0.11",

package/dist/BaseListPlugin-n9uuTtLe.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"BaseListPlugin-n9uuTtLe.js","names":["Path","SlateEditor","TElement","KEYS","isListNested","editor","listPath","listParentNode","api","parent","type","getType","li","SlateEditor","KEYS","getListTypes","editor","getType","olClassic","ulClassic","taskList","Path","SlateEditor","PathApi","KEYS","getListTypes","getHighestEmptyList","editor","diffListPath","liPath","list","api","above","at","match","type","listNode","listPath","equals","children","length","liParent","getType","li","ElementEntry","Path","SlateEditor","TElement","TLocation","KEYS","NodeApi","RangeApi","getListItemEntry","editor","at","selection","list","listItem","liType","getType","li","_at","isRange","isCollapsed","focus","path","anchor","node","get","api","above","match","type","parent","ElementEntry","Path","Point","SlateEditor","TElement","TRange","getListTypes","getListRoot","editor","at","selection","parentList","api","above","match","type","parentListPath","SlateEditor","TElement","KEYS","GetPropsIfTaskListLiNodeOptions","liNode","inherit","getPropsIfTaskListLiNode","editor","node","getType","li","type","checked","undefined","getPropsIfTaskList","partial","taskList","ElementEntry","Path","SlateEditor","TElement","TLocation","KEYS","NodeApi","RangeApi","getTodoListItemEntry","editor","at","selection","list","listItem","todoType","getType","listTodoClassic","_at","isRange","isCollapsed","focus","path","anchor","node","get","api","above","match","type","parent","Ancestor","SlateEditor","match","getListTypes","hasListChild","editor","node","children","some","n","type","SlateEditor","TRange","KEYS","RangeApi","isAcrossListItems","editor","at","selection","isCollapsed","isAcrossBlocks","api","isAt","blocks","some","match","type","getType","li","Descendant","SlateEditor","ElementApi","getListTypes","isListRoot","editor","node","isElement","includes","type","ElementEntry","SlateEditor","TElement","match","PathApi","getListTypes","MoveListItemDownOptions","list","listItem","moveListItemDown","editor","moved","listNode","listItemPath","previousListItemPath","previous","previousSiblingItem","api","node","previousNode","previousPath","sublist","children","find","n","type","newPath","concat","length","tf","withoutNormalizing","wrapNodes","at","moveNodes","to","ElementEntry","Path","SlateEditor","NodeApi","PathApi","getListTypes","MergeListItemIntoListOptions","deleteFromList","fromList","fromListItem","fromStartIndex","to","toList","toListIndex","moveListItemsToList","editor","_to","fromListPath","moved","tf","withoutNormalizing","fromListItemSublist","api","descendant","at","match","type","lastChildPath","lastChild","next","concat","moveNodes","children","fromIndex","delete","Path","SlateEditor","ElementApi","KEYS","NodeApi","getListTypes","unwrapList","editor","at","ancestorListTypeCheck","api","above","match","type","selection","commonNode","common","anchor","path","focus","isElement","includes","tf","withoutNormalizing","unwrapNodes","getType","li","split","ElementEntry","Path","SlateEditor","TElement","KEYS","NodeApi","PathApi","hasListChild","moveListItemsToList","unwrapList","MoveListItemUpOptions","list","listItem","moveListItemUp","editor","move","listNode","listPath","liNode","liPath","liParent","api","above","at","match","type","getType","li","toListPath","next","_error","condA","condB","isLastChild","tf","insertNodes","children","toListNode","get","fromListItem","toList","deleteFromList","fromList","fromStartIndex","concat","liParentPath","movedUpLiPath","moveNodes","to","moved","withoutNormalizing","ElementEntry","SlateEditor","isListNested","moveListItemUp","removeFirstListItem","editor","list","listItem","listPath","EditorNodesOptions","Path","PathRef","SlateEditor","KEYS","PathApi","isListNested","moveListItemDown","moveListItemUp","removeFirstListItem","MoveListItemsOptions","at","enableResetOnShiftTab","increase","moveListItems","editor","selection","undefined","_nodes","api","nodes","match","type","getType","lic","lics","Array","from","length","highestLicPaths","highestLicPathRefs","forEach","licPath","liPath","parent","isAncestor","some","path","highestLiPath","push","pathRef","licPathRefsToMove","reverse","tf","withoutNormalizing","moved","licPathRef","unref","listItem","parentList","_moved","list","SlateEditor","TElement","KEYS","PathApi","InsertListItemOptions","inheritCheckStateOnLineEndBreak","inheritCheckStateOnLineStartBreak","insertListItem","editor","options","liType","getType","li","licType","lic","selection","licEntry","api","above","match","type","paragraphPath","listItemEntry","parent","listItemNode","listItemPath","optionalTasklistProps","checked","undefined","success","tf","withoutNormalizing","isCollapsed","delete","isStart","focus","isEnd","isEmpty","after","nextParagraphPath","next","nextListItemPath","insertNodes","children","text","at","marks","select","splitNodes","wrapNodes","moveNodes","to","collapse","edge","length","concat","TElement","createSlatePlugin","KEYS","getTodoListItemEntry","insertTodoListItem","TTodoListItemElement","checked","BaseTodoListPlugin","key","listTodoClassic","node","isElement","options","inheritCheckStateOnLineEndBreak","inheritCheckStateOnLineStartBreak","overrideEditor","editor","tf","insertBreak","transforms","insertBreakTodoList","selection","res","inserted","extendTransforms","type","toggle","toggleBlock","SlateEditor","KEYS","PathApi","BaseTodoListPlugin","insertTodoListItem","editor","inheritCheckStateOnLineEndBreak","inheritCheckStateOnLineStartBreak","getOptions","todoType","getType","listTodoClassic","selection","todoEntry","api","above","match","type","todo","paragraphPath","success","tf","withoutNormalizing","isCollapsed","delete","isStart","focus","isEnd","isEmpty","after","nextParagraphPath","next","insertNodes","checked","children","text","at","marks","select","splitNodes","ElementEntry","Path","SlateEditor","TElement","NodeApi","PathApi","getListTypes","MoveListItemSublistItemsToListItemSublistOptions","fromListItem","toListItem","start","moveListItemSublistItemsToListItemSublist","editor","fromListItemPath","toListItemPath","moved","tf","withoutNormalizing","fromListItemSublist","api","descendant","at","match","type","fromListItemSublistPath","toListItemSublist","to","fromList","parent","fromListNode","fromListType","toListItemSublistPath","concat","insertNodes","children","next","lastChild","moveNodes","delete","ElementEntry","SlateEditor","TElement","deleteMerge","KEYS","PathApi","getPropsIfTaskListLiNode","hasListChild","moveListItemsToList","moveListItemSublistItemsToListItemSublist","RemoveListItemOptions","list","listItem","reverse","removeListItem","editor","liNode","liPath","api","isExpanded","previousLiPath","previous","success","tf","withoutNormalizing","previousLi","node","tempLiPath","next","insertNodes","children","text","type","getType","lic","inherit","li","at","tempLi","tempLiPathRef","pathRef","fromListItem","toListItem","unref","removeNodes","toList","toListIndex","SlateEditor","TElement","ElementApi","KEYS","NodeApi","RangeApi","BaseListPlugin","getListItemEntry","getListTypes","getPropsIfTaskList","unwrapList","ToggleListOptions","type","checked","_toggleList","editor","tf","withoutNormalizing","selection","validLiChildrenTypes","getOptions","api","isCollapsed","isAt","blocks","res","list","setNodes","at","mode","match","n","isElement","includes","children","wrapNodes","_nodes","nodes","getType","p","Array","from","blockAbove","block","lic","listItem","li","path","startPoint","endPoint","edges","commonEntry","common","startList","node","start","endList","end","rangeLength","Math","min","length","rootPathLength","filter","forEach","_n","toggleList","toggleBulletedList","ulClassic","toggleTaskList","defaultChecked","taskList","toggleNumberedList","olClassic","NodeEntry","OverrideEditor","TElement","deleteMerge","KEYS","PathApi","ListConfig","isAcrossListItems","isListNested","getListItemEntry","removeFirstListItem","removeListItem","withDeleteBackwardList","editor","tf","deleteBackward","transforms","unit","deleteBackwardList","res","moved","list","listItem","api","isAt","start","match","node","type","getType","li","withoutNormalizing","hasPrevious","resetBlock","at","pointBeforeListItem","before","selection","focus","currentLic","hasMultipleChildren","anchor","licType","lic","_licNodes","nodes","mode","children","length","reverse","leftoverListItem","parent","removeNodes","EditorTransforms","ElementEntry","OverrideEditor","SlateEditor","TElement","KEYS","NodeApi","PathApi","ListConfig","getListItemEntry","getListRoot","hasListChild","isAcrossListItems","moveListItemsToList","moveListItemUp","removeFirstListItem","removeListItem","selectionIsNotInAListHandler","editor","pointAfterSelection","api","after","selection","focus","nextSiblingListRes","at","listItem","parentBlockEntity","block","anchor","string","tf","removeNodes","sublistRes","selectionIsInAListHandler","res","list","defaultDelete","unit","liType","getType","li","_nodes","nodes","mode","match","node","path","length","isNodeLi","type","isSiblingOfNodeLi","get","next","liWithSiblings","Array","from","entry","pointAfterListItem","listRoot","deleteFromList","fromList","toList","siblingListItem","siblingList","parent","reverse","licType","lic","_licNodes","nextSelectableLic","children","leftoverListItem","nestedList","nestedListItem","withDeleteForwardList","deleteForward","transforms","deleteForwardList","skipDefaultDelete","isAt","end","withoutNormalizing","OverrideEditor","SlateEditor","TRange","deleteMerge","KEYS","ListConfig","getHighestEmptyList","hasListChild","isAcrossListItems","getLiStart","editor","start","api","selection","above","at","match","type","getType","li","withDeleteFragmentList","tf","deleteFragment","transforms","direction","deleteFragmentList","deleted","withoutNormalizing","end","liEnd","liEndCanBeDeleted","liEndPathRef","pathRef","undefined","liStart","liEndPath","unref","listStart","parent","deletePath","diffListPath","liPath","removeNodes","OverrideEditor","KEYS","ListConfig","getListItemEntry","insertListItem","moveListItemUp","withInsertBreakList","editor","getOptions","tf","insertBreak","transforms","insertBreakList","selection","res","moved","list","listItem","api","isEmpty","block","match","type","getType","li","didReset","resetBlock","at","inserted","Ancestor","AncestorEntry","Descendant","DescendantEntry","ElementEntry","OverrideEditor","Path","TElement","TText","ElementApi","KEYS","NodeApi","PathApi","ListConfig","getPropsIfTaskListLiNode","isListRoot","withInsertFragmentList","editor","tf","insertFragment","listItemType","getType","li","listItemContentType","lic","getFirstAncestorOfType","root","entry","type","ancestor","parent","get","findListItemsWithContent","first","prev","node","children","trimList","listRoot","_texts","texts","textEntries","Array","from","commonAncestorEntry","reduce","commonAncestor","textEntry","isAncestor","common","rest","wrapNodeIntoListItem","props","Record","isSingleLic","fragment","isFragmentOnlyListRoot","length","nodes","filter","isElement","getTextAndListItemNodes","liEntry","licEntry","liPath","licNode","licPath","isEmptyNode","string","flatMap","map","v","inherit","liNode","textNode","listItemNodes","currentSublists","newLic","newSublists","insertNodes","at","next","select","removeNodes","path","text","transforms","api","match","mode","Descendant","ElementEntry","NodeEntry","PathRef","SlateEditor","TElement","KEYS","match","NodeApi","PathApi","ListConfig","getListTypes","moveListItemUp","getDeepInlineChildren","editor","children","inlineChildren","child","api","isBlock","push","Array","from","normalizeListItem","listItem","validLiChildrenTypes","changed","allValidLiChildrenTypes","Set","getType","lic","olClassic","taskList","ulClassic","liPath","liChildren","invalidLiChildrenPathRefs","filter","has","type","map","childPath","pathRef","firstLiChild","firstLiChildNode","firstLiChildPath","tf","insertNodes","create","block","at","concat","parent","sublist","reverse","forEach","c","list","removeNodes","includes","setNodes","licChildren","length","blockPathRefs","licChild","to","next","path","moveNodes","unref","ref","ElementEntry","SlateEditor","match","PathApi","getListTypes","normalizeNestedList","editor","nestedListItem","path","parentNode","api","parent","hasParentList","type","previousListItemPath","previous","previousSiblingItem","node","previousPath","newPath","concat","tf","moveNodes","at","to","OverrideEditor","TElement","ElementApi","KEYS","match","NodeApi","PathApi","ListConfig","normalizeListItem","normalizeNestedList","getListTypes","isListRoot","moveListItemsToList","withNormalizeList","editor","getOptions","tf","normalizeNode","transforms","node","path","liType","getType","li","licType","lic","defaultType","p","isElement","nonLiChild","Array","from","children","find","child","type","wrapNodes","at","taskList","nonTaskListItems","filter","length","withoutNormalizing","forEach","itemPath","setNodes","checked","taskListItems","unsetNodes","some","item","removeNodes","nextPath","next","nextNode","get","deleteFromList","fromList","toList","prevPath","previous","prevNode","nestedListItem","listItem","validLiChildrenTypes","api","parent","OverrideEditor","KEYS","RangeApi","ListConfig","unwrapList","moveListItems","withDeleteBackwardList","withDeleteForwardList","withDeleteFragmentList","withInsertBreakList","withInsertFragmentList","withNormalizeList","withList","ctx","editor","getOptions","tf","resetBlock","tab","transforms","options","api","block","at","match","type","getType","li","apply","workRange","selection","isCollapsed","anchor","focus","isBackward","unhangRange","select","listSelected","some","enableResetOnShiftTab","increase","reverse","OmitFirst","PluginConfig","bindFirst","createSlatePlugin","createTSlatePlugin","KEYS","toggleBulletedList","toggleList","toggleNumberedList","toggleTaskList","withList","ListConfig","enableResetOnShiftTab","inheritCheckStateOnLineEndBreak","inheritCheckStateOnLineStartBreak","validLiChildrenTypes","toggle","bulletedList","list","numberedList","taskList","BaseBulletedListPlugin","key","ulClassic","node","isContainer","isElement","parsers","html","deserializer","rules","validNodeName","render","as","extendTransforms","editor","BaseNumberedListPlugin","olClassic","BaseTaskListPlugin","options","BaseListItemPlugin","li","inject","plugins","parser","preInsert","type","api","some","match","isStrictSiblings","BaseListItemContentPlugin","lic","BaseListPlugin","listClassic","overrideEditor","extendEditorTransforms"],"sources":["../src/lib/queries/isListNested.ts","../src/lib/queries/getListTypes.ts","../src/lib/queries/getHighestEmptyList.ts","../src/lib/queries/getListItemEntry.ts","../src/lib/queries/getListRoot.ts","../src/lib/queries/getTaskListProps.ts","../src/lib/queries/getTodoListItemEntry.ts","../src/lib/queries/hasListChild.ts","../src/lib/queries/isAcrossListItems.ts","../src/lib/queries/isListRoot.ts","../src/lib/transforms/moveListItemDown.ts","../src/lib/transforms/moveListItemsToList.ts","../src/lib/transforms/unwrapList.ts","../src/lib/transforms/moveListItemUp.ts","../src/lib/transforms/removeFirstListItem.ts","../src/lib/transforms/moveListItems.ts","../src/lib/transforms/insertListItem.ts","../src/lib/BaseTodoListPlugin.ts","../src/lib/transforms/insertTodoListItem.ts","../src/lib/transforms/moveListItemSublistItemsToListItemSublist.ts","../src/lib/transforms/removeListItem.ts","../src/lib/transforms/toggleList.ts","../src/lib/withDeleteBackwardList.ts","../src/lib/withDeleteForwardList.ts","../src/lib/withDeleteFragmentList.ts","../src/lib/withInsertBreakList.ts","../src/lib/withInsertFragmentList.ts","../src/lib/normalizers/normalizeListItem.ts","../src/lib/normalizers/normalizeNestedList.ts","../src/lib/withNormalizeList.ts","../src/lib/withList.ts","../src/lib/BaseListPlugin.ts"],"sourcesContent":["import type { Path, SlateEditor, TElement } from 'platejs';\n\nimport { KEYS } from 'platejs';\n\n/** Is the list nested, i.e. its parent is a list item. */\nexport const isListNested = (editor: SlateEditor, listPath: Path) => {\n  const listParentNode = editor.api.parent<TElement>(listPath)?.[0];\n\n  return listParentNode?.type === editor.getType(KEYS.li);\n};\n","import type { SlateEditor } from 'platejs';\n\nimport { KEYS } from 'platejs';\n\nexport const getListTypes = (editor: SlateEditor) => [\n  editor.getType(KEYS.olClassic),\n  editor.getType(KEYS.ulClassic),\n  editor.getType(KEYS.taskList),\n];\n","import { type Path, type SlateEditor, PathApi } from 'platejs';\nimport { KEYS } from 'platejs';\n\nimport { getListTypes } from './getListTypes';\n\n/**\n * Find the highest end list that can be deleted. Its path should be different\n * to diffListPath. If the highest end list 2+ items, return liPath. Get the\n * parent list until:\n *\n * - The list has less than 2 items.\n * - Its path is not equals to diffListPath.\n */\nexport const getHighestEmptyList = (\n  editor: SlateEditor,\n  {\n    diffListPath,\n    liPath,\n  }: {\n    liPath: Path;\n    diffListPath?: Path;\n  }\n): Path | undefined => {\n  const list = editor.api.above({\n    at: liPath,\n    match: { type: getListTypes(editor) },\n  });\n\n  if (!list) return;\n\n  const [listNode, listPath] = list;\n\n  if (!diffListPath || !PathApi.equals(listPath, diffListPath)) {\n    if (listNode.children.length < 2) {\n      const liParent = editor.api.above({\n        at: listPath,\n        match: { type: editor.getType(KEYS.li) },\n      });\n\n      if (liParent) {\n        return (\n          getHighestEmptyList(editor, { diffListPath, liPath: liParent[1] }) ||\n          listPath\n        );\n      }\n    }\n\n    return liPath;\n  }\n};\n","import {\n  type ElementEntry,\n  type Path,\n  type SlateEditor,\n  type TElement,\n  type TLocation,\n  KEYS,\n  NodeApi,\n  RangeApi,\n} from 'platejs';\n\n/**\n * Returns the nearest li and ul / ol wrapping node entries for a given path\n * (default = selection)\n */\nexport const getListItemEntry = (\n  editor: SlateEditor,\n  { at = editor.selection }: { at?: TLocation | null } = {}\n): { list: ElementEntry; listItem: ElementEntry } | undefined => {\n  const liType = editor.getType(KEYS.li);\n\n  let _at: Path;\n\n  if (RangeApi.isRange(at) && !RangeApi.isCollapsed(at)) {\n    _at = at.focus.path;\n  } else if (RangeApi.isRange(at)) {\n    _at = at.anchor.path;\n  } else {\n    _at = at as Path;\n  }\n  if (_at) {\n    const node = NodeApi.get<TElement>(editor, _at);\n\n    if (node) {\n      const listItem = editor.api.above<TElement>({\n        at: _at,\n        match: { type: liType },\n      });\n\n      if (listItem) {\n        const list = editor.api.parent<TElement>(listItem[1])!;\n\n        return { list, listItem };\n      }\n    }\n  }\n};\n","import type {\n  ElementEntry,\n  Path,\n  Point,\n  SlateEditor,\n  TElement,\n  TRange,\n} from 'platejs';\n\nimport { getListTypes } from './getListTypes';\n\n/** Searches upward for the root list element */\nexport const getListRoot = (\n  editor: SlateEditor,\n  at: Path | Point | TRange | null = editor.selection\n): ElementEntry | undefined => {\n  if (!at) return;\n\n  const parentList = editor.api.above<TElement>({\n    at,\n    match: {\n      type: getListTypes(editor),\n    },\n  });\n\n  if (parentList) {\n    const [, parentListPath] = parentList;\n\n    return getListRoot(editor, parentListPath) ?? parentList;\n  }\n};\n","import { type SlateEditor, type TElement, KEYS } from 'platejs';\n\nexport type GetPropsIfTaskListLiNodeOptions = {\n  liNode: TElement;\n  inherit?: boolean;\n};\n\nexport const getPropsIfTaskListLiNode = (\n  editor: SlateEditor,\n  { inherit = false, liNode: node }: GetPropsIfTaskListLiNodeOptions\n) =>\n  editor.getType(KEYS.li) === node.type && 'checked' in node\n    ? { checked: inherit ? (node.checked as boolean) : false }\n    : undefined;\n\nexport const getPropsIfTaskList = (\n  editor: SlateEditor,\n  type: string,\n  partial: { checked?: boolean } = {}\n) =>\n  editor.getType(KEYS.taskList) === type\n    ? { checked: false, ...partial }\n    : undefined;\n","import {\n  type ElementEntry,\n  type Path,\n  type SlateEditor,\n  type TElement,\n  type TLocation,\n  KEYS,\n  NodeApi,\n  RangeApi,\n} from 'platejs';\n\n/**\n * Returns the nearest li and ul / ol wrapping node entries for a given path\n * (default = selection)\n */\nexport const getTodoListItemEntry = (\n  editor: SlateEditor,\n  { at = editor.selection }: { at?: TLocation | null } = {}\n): { list: ElementEntry; listItem: ElementEntry } | undefined => {\n  const todoType = editor.getType(KEYS.listTodoClassic);\n\n  let _at: Path;\n\n  if (RangeApi.isRange(at) && !RangeApi.isCollapsed(at)) {\n    _at = at.focus.path;\n  } else if (RangeApi.isRange(at)) {\n    _at = at.anchor.path;\n  } else {\n    _at = at as Path;\n  }\n  if (_at) {\n    const node = NodeApi.get<TElement>(editor, _at);\n\n    if (node) {\n      const listItem = editor.api.above<TElement>({\n        at: _at,\n        match: { type: todoType },\n      });\n\n      if (listItem) {\n        const list = editor.api.parent<TElement>(listItem[1])!;\n\n        return { list, listItem };\n      }\n    }\n  }\n};\n","import { type Ancestor, type SlateEditor, match } from 'platejs';\n\nimport { getListTypes } from './getListTypes';\n\n/** Is there a list child in the node. */\nexport const hasListChild = (editor: SlateEditor, node: Ancestor) =>\n  node.children.some((n) => match(n, [], { type: getListTypes(editor) }));\n","import { type SlateEditor, type TRange, KEYS, RangeApi } from 'platejs';\n\n/** Is selection across blocks with list items */\nexport const isAcrossListItems = (\n  editor: SlateEditor,\n  at: TRange | null = editor.selection\n) => {\n  if (!at || RangeApi.isCollapsed(at)) {\n    return false;\n  }\n\n  const isAcrossBlocks = editor.api.isAt({ at, blocks: true });\n\n  if (!isAcrossBlocks) return false;\n\n  return editor.api.some({\n    at,\n    match: { type: editor.getType(KEYS.li) },\n  });\n};\n","import { type Descendant, type SlateEditor, ElementApi } from 'platejs';\n\nimport { getListTypes } from './getListTypes';\n\nexport const isListRoot = (editor: SlateEditor, node: Descendant): boolean =>\n  ElementApi.isElement(node) && getListTypes(editor).includes(node.type);\n","import {\n  type ElementEntry,\n  type SlateEditor,\n  type TElement,\n  match,\n  PathApi,\n} from 'platejs';\n\nimport { getListTypes } from '../queries/index';\n\nexport type MoveListItemDownOptions = {\n  list: ElementEntry;\n  listItem: ElementEntry;\n};\n\nexport const moveListItemDown = (\n  editor: SlateEditor,\n  { list, listItem }: MoveListItemDownOptions\n) => {\n  let moved = false;\n\n  const [listNode] = list;\n  const [, listItemPath] = listItem;\n\n  const previousListItemPath = PathApi.previous(listItemPath);\n\n  if (!previousListItemPath) {\n    return;\n  }\n\n  // Previous sibling is the new parent\n  const previousSiblingItem = editor.api.node(previousListItemPath);\n\n  if (previousSiblingItem) {\n    const [previousNode, previousPath] = previousSiblingItem;\n\n    const sublist = (previousNode.children as TElement[]).find((n) =>\n      match(n, [], { type: getListTypes(editor) })\n    );\n    const newPath = previousPath.concat(\n      sublist ? [1, sublist.children.length] : [1]\n    );\n\n    editor.tf.withoutNormalizing(() => {\n      if (!sublist) {\n        // Create new sublist\n        editor.tf.wrapNodes<TElement>(\n          { children: [], type: listNode.type },\n          { at: listItemPath }\n        );\n      }\n\n      // Move the current item to the sublist\n      editor.tf.moveNodes({\n        at: listItemPath,\n        to: newPath,\n      });\n\n      moved = true;\n    });\n  }\n\n  return moved;\n};\n","import {\n  type ElementEntry,\n  type Path,\n  type SlateEditor,\n  NodeApi,\n  PathApi,\n} from 'platejs';\n\nimport { getListTypes } from '../queries/getListTypes';\n\nexport type MergeListItemIntoListOptions = {\n  /**\n   * Delete `fromListItem` sublist if true.\n   *\n   * @default true\n   */\n  deleteFromList?: boolean;\n\n  /** List items of the list will be moved. */\n  fromList?: ElementEntry;\n\n  /** List items of the sublist of this node will be moved. */\n  fromListItem?: ElementEntry;\n\n  fromStartIndex?: number;\n\n  to?: Path;\n\n  /** List items will be moved in this list. */\n  toList?: ElementEntry;\n\n  /** List position where to move the list items. */\n  toListIndex?: number | null;\n};\n\n/**\n * Move the list items of the sublist of `fromListItem` to `toList` (if\n * `fromListItem` is defined). Move the list items of `fromList` to `toList` (if\n * `fromList` is defined).\n */\nexport const moveListItemsToList = (\n  editor: SlateEditor,\n  {\n    deleteFromList = true,\n    fromList,\n    fromListItem,\n    fromStartIndex,\n    to: _to,\n    toList,\n    toListIndex = null,\n  }: MergeListItemIntoListOptions\n) => {\n  let fromListPath: Path | undefined;\n  let moved: boolean | void = false;\n\n  editor.tf.withoutNormalizing(() => {\n    if (fromListItem) {\n      const fromListItemSublist = editor.api.descendant({\n        at: fromListItem[1],\n        match: {\n          type: getListTypes(editor),\n        },\n      });\n\n      if (!fromListItemSublist) return;\n\n      fromListPath = fromListItemSublist?.[1];\n    } else if (fromList) {\n      fromListPath = fromList[1];\n    } else {\n      return;\n    }\n\n    let to: Path | null = null;\n\n    if (_to) to = _to;\n    if (toList) {\n      if (toListIndex === null) {\n        const lastChildPath = NodeApi.lastChild(editor, toList[1])?.[1];\n        to = lastChildPath\n          ? PathApi.next(lastChildPath)\n          : toList[1].concat([0]);\n      } else {\n        to = toList[1].concat([toListIndex]);\n      }\n    }\n    if (!to) return;\n\n    moved = editor.tf.moveNodes({\n      at: fromListPath,\n      children: true,\n      fromIndex: fromStartIndex,\n      to,\n    });\n\n    // Remove the empty list\n    if (deleteFromList) {\n      editor.tf.delete({ at: fromListPath });\n    }\n  });\n\n  return moved;\n};\n","import {\n  type Path,\n  type SlateEditor,\n  ElementApi,\n  KEYS,\n  NodeApi,\n} from 'platejs';\n\nimport { getListTypes } from '../queries/index';\n\nexport const unwrapList = (editor: SlateEditor, { at }: { at?: Path } = {}) => {\n  const ancestorListTypeCheck = () => {\n    if (editor.api.above({ at, match: { type: getListTypes(editor) } })) {\n      return true;\n    }\n    // The selection's common node might be a list type\n    if (!at && editor.selection) {\n      const commonNode = NodeApi.common(\n        editor,\n        editor.selection.anchor.path,\n        editor.selection.focus.path\n      )!;\n\n      if (\n        ElementApi.isElement(commonNode[0]) &&\n        getListTypes(editor).includes(commonNode[0].type)\n      ) {\n        return true;\n      }\n    }\n\n    return false;\n  };\n\n  editor.tf.withoutNormalizing(() => {\n    do {\n      // const licEntry = editor.api.block({\n      //   at,\n      //   match: { type: editor.getType(BaseListItemContentPlugin) },\n      // });\n\n      // Allow other LIC types\n      // if (licEntry) {\n      //   editor.tf.setNodes(\n      //     { type: editor.getType(BaseParagraphPlugin) },\n      //     { at }\n      //   );\n      // }\n\n      editor.tf.unwrapNodes({\n        at,\n        match: { type: editor.getType(KEYS.li) },\n        split: true,\n      });\n\n      editor.tf.unwrapNodes({\n        at,\n        match: {\n          type: getListTypes(editor),\n        },\n        split: true,\n      });\n    } while (ancestorListTypeCheck());\n  });\n};\n","import {\n  type ElementEntry,\n  type Path,\n  type SlateEditor,\n  type TElement,\n  KEYS,\n  NodeApi,\n  PathApi,\n} from 'platejs';\n\nimport { hasListChild } from '../queries/hasListChild';\nimport { moveListItemsToList } from './moveListItemsToList';\nimport { unwrapList } from './unwrapList';\n\nexport type MoveListItemUpOptions = {\n  list: ElementEntry;\n  listItem: ElementEntry;\n};\n\n/** Move a list item up. */\nexport const moveListItemUp = (\n  editor: SlateEditor,\n  { list, listItem }: MoveListItemUpOptions\n) => {\n  const move = () => {\n    const [listNode, listPath] = list;\n    const [liNode, liPath] = listItem;\n\n    const liParent = editor.api.above<TElement>({\n      at: listPath,\n      match: { type: editor.getType(KEYS.li) },\n    });\n\n    if (!liParent) {\n      let toListPath: Path;\n\n      try {\n        toListPath = PathApi.next(listPath);\n      } catch (_error) {\n        return;\n      }\n\n      const condA = hasListChild(editor, liNode);\n      const condB = !NodeApi.isLastChild(editor, liPath);\n\n      if (condA || condB) {\n        // Insert a new list next to `list`\n        editor.tf.insertNodes(\n          {\n            children: [],\n            type: listNode.type,\n          },\n          { at: toListPath }\n        );\n      }\n      if (condA) {\n        const toListNode = NodeApi.get<TElement>(editor, toListPath);\n\n        if (!toListNode) return;\n\n        // Move li sub-lis to the new list\n        moveListItemsToList(editor, {\n          fromListItem: listItem,\n          toList: [toListNode, toListPath],\n        });\n      }\n      // If there is siblings li, move them to the new list\n      if (condB) {\n        const toListNode = NodeApi.get<TElement>(editor, toListPath);\n\n        if (!toListNode) return;\n\n        // Move next lis to the new list\n        moveListItemsToList(editor, {\n          deleteFromList: false,\n          fromList: list,\n          fromStartIndex: liPath.at(-1)! + 1,\n          toList: [toListNode, toListPath],\n        });\n      }\n\n      // Finally, unwrap the list\n      unwrapList(editor, { at: liPath.concat(0) });\n\n      return true;\n    }\n\n    const [, liParentPath] = liParent;\n\n    const toListPath = liPath.concat([1]);\n\n    // If li has next siblings, we need to move them.\n    if (!NodeApi.isLastChild(editor, liPath)) {\n      // If li has no sublist, insert one.\n      if (!hasListChild(editor, liNode)) {\n        editor.tf.insertNodes(\n          {\n            children: [],\n            type: listNode.type,\n          },\n          { at: toListPath }\n        );\n      }\n\n      const toListNode = NodeApi.get<TElement>(editor, toListPath);\n\n      if (!toListNode) return;\n\n      // Move next siblings to li sublist.\n      moveListItemsToList(editor, {\n        deleteFromList: false,\n        fromListItem: liParent,\n        fromStartIndex: liPath.at(-1)! + 1,\n        toList: [toListNode, toListPath],\n      });\n    }\n\n    const movedUpLiPath = PathApi.next(liParentPath);\n\n    // Move li one level up: next to the li parent.\n    editor.tf.moveNodes({\n      at: liPath,\n      to: movedUpLiPath,\n    });\n\n    return true;\n  };\n\n  let moved: boolean | undefined = false;\n\n  editor.tf.withoutNormalizing(() => {\n    moved = move();\n  });\n\n  return moved;\n};\n","import type { ElementEntry, SlateEditor } from 'platejs';\n\nimport { isListNested } from '../queries/isListNested';\nimport { moveListItemUp } from './moveListItemUp';\n\n/** If list is not nested and if li is not the first child, move li up. */\nexport const removeFirstListItem = (\n  editor: SlateEditor,\n  {\n    list,\n    listItem,\n  }: {\n    list: ElementEntry;\n    listItem: ElementEntry;\n  }\n) => {\n  const [, listPath] = list;\n\n  if (!isListNested(editor, listPath)) {\n    moveListItemUp(editor, { list, listItem });\n\n    return true;\n  }\n\n  return false;\n};\n","import {\n  type EditorNodesOptions,\n  type Path,\n  type PathRef,\n  type SlateEditor,\n  KEYS,\n  PathApi,\n} from 'platejs';\n\nimport { isListNested } from '../queries/isListNested';\nimport { moveListItemDown } from './moveListItemDown';\nimport { moveListItemUp } from './moveListItemUp';\nimport { removeFirstListItem } from './removeFirstListItem';\n\nexport type MoveListItemsOptions = {\n  at?: EditorNodesOptions['at'];\n  enableResetOnShiftTab?: boolean;\n  increase?: boolean;\n};\n\nexport const moveListItems = (\n  editor: SlateEditor,\n  {\n    at = editor.selection ?? undefined,\n    enableResetOnShiftTab,\n    increase = true,\n  }: MoveListItemsOptions = {}\n) => {\n  const _nodes = editor.api.nodes({\n    at,\n    match: {\n      type: editor.getType(KEYS.lic),\n    },\n  });\n\n  // Get the selected lic\n  const lics = Array.from(_nodes);\n\n  if (lics.length === 0) return;\n\n  const highestLicPaths: Path[] = [];\n  const highestLicPathRefs: PathRef[] = [];\n\n  // Filter out the nested lic, we just need to move the highest ones\n  lics.forEach((lic) => {\n    const licPath = lic[1];\n    const liPath = PathApi.parent(licPath);\n\n    const isAncestor = highestLicPaths.some((path) => {\n      const highestLiPath = PathApi.parent(path);\n\n      return PathApi.isAncestor(highestLiPath, liPath);\n    });\n\n    if (!isAncestor) {\n      highestLicPaths.push(licPath);\n      highestLicPathRefs.push(editor.api.pathRef(licPath));\n    }\n  });\n\n  const licPathRefsToMove = increase\n    ? highestLicPathRefs\n    : highestLicPathRefs.reverse();\n\n  return editor.tf.withoutNormalizing(() => {\n    let moved = false;\n\n    licPathRefsToMove.forEach((licPathRef) => {\n      const licPath = licPathRef.unref();\n\n      if (!licPath) return;\n\n      const listItem = editor.api.parent(licPath);\n\n      if (!listItem) return;\n\n      const parentList = editor.api.parent(listItem[1]);\n\n      if (!parentList) return;\n\n      let _moved: any;\n\n      if (increase) {\n        _moved = moveListItemDown(editor, {\n          list: parentList as any,\n          listItem: listItem as any,\n        });\n      } else if (isListNested(editor, parentList[1])) {\n        // un-indent a sub-list item\n        _moved = moveListItemUp(editor, {\n          list: parentList as any,\n          listItem: listItem as any,\n        });\n      } else if (enableResetOnShiftTab) {\n        // unindenting a top level list item, effectively breaking apart the list.\n        _moved = removeFirstListItem(editor, {\n          list: parentList as any,\n          listItem: listItem as any,\n        });\n      }\n\n      moved = _moved || moved;\n    });\n\n    return moved;\n  });\n};\n","import { type SlateEditor, type TElement, KEYS, PathApi } from 'platejs';\n\nexport type InsertListItemOptions = {\n  inheritCheckStateOnLineEndBreak?: boolean;\n  inheritCheckStateOnLineStartBreak?: boolean;\n};\n\n/** Insert list item if selection in li>p. TODO: test */\nexport const insertListItem = (\n  editor: SlateEditor,\n  options: InsertListItemOptions = {}\n): boolean => {\n  const liType = editor.getType(KEYS.li);\n  const licType = editor.getType(KEYS.lic);\n\n  if (!editor.selection) {\n    return false;\n  }\n\n  const licEntry = editor.api.above({ match: { type: licType } });\n\n  if (!licEntry) return false;\n\n  const [, paragraphPath] = licEntry;\n\n  const listItemEntry = editor.api.parent(paragraphPath);\n\n  if (!listItemEntry) return false;\n\n  const [listItemNode, listItemPath] = listItemEntry;\n\n  if (listItemNode.type !== liType) return false;\n\n  const optionalTasklistProps =\n    'checked' in listItemNode ? { checked: false } : undefined;\n\n  let success = false;\n\n  editor.tf.withoutNormalizing(() => {\n    if (!editor.api.isCollapsed()) {\n      editor.tf.delete();\n    }\n\n    const isStart = editor.api.isStart(editor.selection!.focus, paragraphPath);\n    const isEnd = editor.api.isEmpty(editor.selection, { after: true });\n\n    const nextParagraphPath = PathApi.next(paragraphPath);\n    const nextListItemPath = PathApi.next(listItemPath);\n\n    /** If start, insert a list item before */\n    if (isStart) {\n      if (optionalTasklistProps && options.inheritCheckStateOnLineStartBreak) {\n        optionalTasklistProps.checked = listItemNode.checked as boolean;\n      }\n\n      editor.tf.insertNodes(\n        {\n          children: [{ children: [{ text: '' }], type: licType }],\n          ...optionalTasklistProps,\n          type: liType,\n        },\n        { at: listItemPath }\n      );\n\n      success = true;\n\n      return;\n    }\n    /**\n     * If not end, split nodes, wrap a list item on the new paragraph and move\n     * it to the next list item\n     */\n    if (isEnd) {\n      /** If end, insert a list item after and select it */\n      const marks = editor.api.marks() || {};\n\n      if (optionalTasklistProps && options.inheritCheckStateOnLineEndBreak) {\n        optionalTasklistProps.checked = listItemNode.checked as boolean;\n      }\n\n      editor.tf.insertNodes(\n        {\n          children: [{ children: [{ text: '', ...marks }], type: licType }],\n          ...optionalTasklistProps,\n          type: liType,\n        },\n        { at: nextListItemPath }\n      );\n      editor.tf.select(nextListItemPath);\n    } else {\n      editor.tf.withoutNormalizing(() => {\n        editor.tf.splitNodes();\n        editor.tf.wrapNodes<TElement>(\n          {\n            children: [],\n            ...optionalTasklistProps,\n            type: liType,\n          },\n          { at: nextParagraphPath }\n        );\n        editor.tf.moveNodes({\n          at: nextParagraphPath,\n          to: nextListItemPath,\n        });\n        editor.tf.select(nextListItemPath);\n        editor.tf.collapse({\n          edge: 'start',\n        });\n      });\n    }\n    /** If there is a list in the list item, move it to the next list item */\n    if (listItemNode.children.length > 1) {\n      editor.tf.moveNodes({\n        at: nextParagraphPath,\n        to: nextListItemPath.concat(1),\n      });\n    }\n\n    success = true;\n  });\n\n  return success;\n};\n","import { type TElement, createSlatePlugin, KEYS } from 'platejs';\n\nimport { getTodoListItemEntry } from './queries';\nimport { insertTodoListItem } from './transforms';\n\nexport interface TTodoListItemElement extends TElement {\n  checked?: boolean;\n}\n\nexport const BaseTodoListPlugin = createSlatePlugin({\n  key: KEYS.listTodoClassic,\n  node: { isElement: true },\n  options: {\n    inheritCheckStateOnLineEndBreak: false,\n    inheritCheckStateOnLineStartBreak: false,\n  },\n})\n  .overrideEditor(({ editor, tf: { insertBreak } }) => ({\n    transforms: {\n      insertBreak() {\n        const insertBreakTodoList = () => {\n          if (!editor.selection) return;\n\n          const res = getTodoListItemEntry(editor);\n\n          // If selection is in a todo li\n          if (res) {\n            const inserted = insertTodoListItem(editor);\n\n            if (inserted) return true;\n          }\n        };\n\n        if (insertBreakTodoList()) return;\n\n        insertBreak();\n      },\n    },\n  }))\n  .extendTransforms(({ editor, type }) => ({\n    toggle: () => {\n      editor.tf.toggleBlock(type);\n    },\n  }));\n","import { type SlateEditor, KEYS, PathApi } from 'platejs';\n\nimport { BaseTodoListPlugin } from '../BaseTodoListPlugin';\n\n/** Insert todo list item if selection in li>p. TODO: test */\nexport const insertTodoListItem = (editor: SlateEditor): boolean => {\n  const { inheritCheckStateOnLineEndBreak, inheritCheckStateOnLineStartBreak } =\n    editor.getOptions(BaseTodoListPlugin);\n  const todoType = editor.getType(KEYS.listTodoClassic);\n\n  if (!editor.selection) {\n    return false;\n  }\n\n  const todoEntry = editor.api.above({ match: { type: todoType } });\n\n  if (!todoEntry) return false;\n\n  const [todo, paragraphPath] = todoEntry;\n\n  let success = false;\n\n  editor.tf.withoutNormalizing(() => {\n    if (!editor.api.isCollapsed()) {\n      editor.tf.delete();\n    }\n\n    const isStart = editor.api.isStart(editor.selection!.focus, paragraphPath);\n    const isEnd = editor.api.isEmpty(editor.selection, { after: true });\n\n    const nextParagraphPath = PathApi.next(paragraphPath);\n\n    /** If start, insert a list item before */\n    if (isStart) {\n      editor.tf.insertNodes(\n        {\n          checked: inheritCheckStateOnLineStartBreak ? todo.checked : false,\n          children: [{ text: '' }],\n          type: todoType,\n        },\n        { at: paragraphPath }\n      );\n\n      success = true;\n\n      return;\n    }\n    /** If not end, split the nodes */\n    if (isEnd) {\n      /** If end, insert a list item after and select it */\n      const marks = editor.api.marks() || {};\n      editor.tf.insertNodes(\n        {\n          checked: inheritCheckStateOnLineEndBreak ? todo.checked : false,\n          children: [{ text: '', ...marks }],\n          type: todoType,\n        },\n        { at: nextParagraphPath }\n      );\n      editor.tf.select(nextParagraphPath);\n    } else {\n      editor.tf.withoutNormalizing(() => {\n        editor.tf.splitNodes();\n      });\n    }\n\n    success = true;\n  });\n\n  return success;\n};\n","import {\n  type ElementEntry,\n  type Path,\n  type SlateEditor,\n  type TElement,\n  NodeApi,\n  PathApi,\n} from 'platejs';\n\nimport { getListTypes } from '../queries/getListTypes';\n\nexport type MoveListItemSublistItemsToListItemSublistOptions = {\n  /** The list item to merge. */\n  fromListItem: ElementEntry;\n\n  /** The list item where to merge. */\n  toListItem: ElementEntry;\n\n  /** Move to the start of the list instead of the end. */\n  start?: boolean;\n};\n\n/**\n * Move fromListItem sublist list items to the end of `toListItem` sublist. If\n * there is no `toListItem` sublist, insert one.\n */\nexport const moveListItemSublistItemsToListItemSublist = (\n  editor: SlateEditor,\n  {\n    fromListItem,\n    start,\n    toListItem,\n  }: MoveListItemSublistItemsToListItemSublistOptions\n) => {\n  const [, fromListItemPath] = fromListItem;\n  const [, toListItemPath] = toListItem;\n  let moved: boolean | void = false;\n\n  editor.tf.withoutNormalizing(() => {\n    const fromListItemSublist = editor.api.descendant<TElement>({\n      at: fromListItemPath,\n      match: {\n        type: getListTypes(editor),\n      },\n    });\n\n    if (!fromListItemSublist) return;\n\n    const [, fromListItemSublistPath] = fromListItemSublist;\n\n    const toListItemSublist = editor.api.descendant<TElement>({\n      at: toListItemPath,\n      match: {\n        type: getListTypes(editor),\n      },\n    });\n\n    let to: Path;\n\n    if (!toListItemSublist) {\n      const fromList = editor.api.parent(fromListItemPath);\n\n      if (!fromList) return;\n\n      const [fromListNode] = fromList;\n\n      const fromListType = fromListNode.type;\n\n      const toListItemSublistPath = toListItemPath.concat([1]);\n\n      editor.tf.insertNodes(\n        { children: [], type: fromListType as string },\n        { at: toListItemSublistPath }\n      );\n\n      to = toListItemSublistPath.concat([0]);\n    } else if (start) {\n      const [, toListItemSublistPath] = toListItemSublist;\n      to = toListItemSublistPath.concat([0]);\n    } else {\n      to = PathApi.next(NodeApi.lastChild(editor, toListItemSublist[1])![1]);\n    }\n\n    moved = editor.tf.moveNodes({\n      at: fromListItemSublistPath,\n      children: true,\n      to,\n    });\n\n    // Remove the empty list\n    editor.tf.delete({ at: fromListItemSublistPath });\n  });\n\n  return moved;\n};\n","import {\n  type ElementEntry,\n  type SlateEditor,\n  type TElement,\n  deleteMerge,\n  KEYS,\n  PathApi,\n} from 'platejs';\n\nimport { getPropsIfTaskListLiNode, hasListChild } from '../queries';\nimport { moveListItemsToList } from './moveListItemsToList';\nimport { moveListItemSublistItemsToListItemSublist } from './moveListItemSublistItemsToListItemSublist';\n\nexport type RemoveListItemOptions = {\n  list: ElementEntry;\n  listItem: ElementEntry;\n  reverse?: boolean;\n};\n\n/** Remove list item and move its sublist to list if any. */\nexport const removeListItem = (\n  editor: SlateEditor,\n  { list, listItem, reverse = true }: RemoveListItemOptions\n) => {\n  const [liNode, liPath] = listItem;\n\n  // Stop if the list item has no sublist\n  if (editor.api.isExpanded() || !hasListChild(editor, liNode)) {\n    return false;\n  }\n\n  const previousLiPath = PathApi.previous(liPath);\n\n  let success = false;\n\n  editor.tf.withoutNormalizing(() => {\n    /**\n     * If there is a previous li, we need to move sub-lis to the previous li. As\n     * we need to delete first, we will:\n     *\n     * 1. Insert a temporary li: tempLi\n     * 2. Move sub-lis to tempLi\n     * 3. Delete\n     * 4. Move sub-lis from tempLi to the previous li.\n     * 5. Remove tempLi\n     */\n    if (previousLiPath) {\n      const previousLi = editor.api.node<TElement>(previousLiPath);\n\n      if (!previousLi) return;\n\n      // 1\n      let tempLiPath = PathApi.next(liPath);\n      editor.tf.insertNodes(\n        {\n          children: [\n            {\n              children: [{ text: '' }],\n              type: editor.getType(KEYS.lic),\n            },\n          ],\n          ...getPropsIfTaskListLiNode(editor, {\n            inherit: true,\n            liNode: previousLi[0],\n          }),\n          type: editor.getType(KEYS.li),\n        },\n        { at: tempLiPath }\n      );\n\n      const tempLi = editor.api.node<TElement>(tempLiPath);\n\n      if (!tempLi) return;\n\n      const tempLiPathRef = editor.api.pathRef(tempLi[1]);\n\n      // 2\n      moveListItemSublistItemsToListItemSublist(editor, {\n        fromListItem: listItem,\n        toListItem: tempLi,\n      });\n\n      // 3\n      deleteMerge(editor, {\n        reverse,\n      });\n\n      tempLiPath = tempLiPathRef.unref()!;\n\n      // 4\n      moveListItemSublistItemsToListItemSublist(editor, {\n        fromListItem: [tempLi[0], tempLiPath],\n        toListItem: previousLi,\n      });\n\n      // 5\n      editor.tf.removeNodes({ at: tempLiPath });\n\n      success = true;\n\n      return;\n    }\n\n    // If it's the first li, move the sublist to the parent list\n    moveListItemsToList(editor, {\n      fromListItem: listItem,\n      toList: list,\n      toListIndex: 1,\n    });\n  });\n\n  return success;\n};\n","import {\n  type SlateEditor,\n  type TElement,\n  ElementApi,\n  KEYS,\n  NodeApi,\n  RangeApi,\n} from 'platejs';\n\nimport { BaseListPlugin } from '../BaseListPlugin';\nimport {\n  getListItemEntry,\n  getListTypes,\n  getPropsIfTaskList,\n} from '../queries/index';\nimport { unwrapList } from './unwrapList';\n\ntype ToggleListOptions = { type: string; checked?: boolean };\n\nconst _toggleList = (\n  editor: SlateEditor,\n  { checked = false, type }: ToggleListOptions\n) =>\n  editor.tf.withoutNormalizing(() => {\n    if (!editor.selection) {\n      return;\n    }\n\n    const { validLiChildrenTypes } = editor.getOptions(BaseListPlugin);\n\n    if (editor.api.isCollapsed() || !editor.api.isAt({ blocks: true })) {\n      // selection is collapsed\n      const res = getListItemEntry(editor);\n\n      if (res) {\n        const { list } = res;\n\n        if (list[0].type === type) {\n          unwrapList(editor);\n        } else {\n          editor.tf.setNodes(\n            { type },\n            {\n              at: editor.selection,\n              mode: 'lowest',\n              match: (n) =>\n                ElementApi.isElement(n) &&\n                getListTypes(editor).includes(n.type),\n            }\n          );\n        }\n      } else {\n        const list = { children: [], type };\n        editor.tf.wrapNodes<TElement>(list);\n\n        const _nodes = editor.api.nodes({\n          match: { type: editor.getType(KEYS.p) },\n        });\n        const nodes = Array.from(_nodes);\n\n        const blockAbove = editor.api.block({\n          match: { type: validLiChildrenTypes },\n        });\n\n        if (!blockAbove) {\n          editor.tf.setNodes({\n            type: editor.getType(KEYS.lic),\n          });\n        }\n\n        const listItem = {\n          children: [],\n          ...getPropsIfTaskList(editor, type, { checked }),\n          type: editor.getType(KEYS.li),\n        };\n\n        for (const [, path] of nodes) {\n          editor.tf.wrapNodes<TElement>(listItem, {\n            at: path,\n          });\n        }\n      }\n    } else {\n      // selection is a range\n\n      const [startPoint, endPoint] = RangeApi.edges(editor.selection!);\n      const commonEntry = NodeApi.common<TElement>(\n        editor,\n        startPoint.path,\n        endPoint.path\n      )!;\n\n      if (\n        getListTypes(editor).includes(commonEntry[0].type) ||\n        (commonEntry[0] as TElement).type === editor.getType(KEYS.li)\n      ) {\n        if ((commonEntry[0] as TElement).type === type) {\n          unwrapList(editor);\n        } else {\n          const startList = editor.api.node({\n            at: RangeApi.start(editor.selection),\n            match: { type: getListTypes(editor) },\n            mode: 'lowest',\n          });\n          const endList = editor.api.node({\n            at: RangeApi.end(editor.selection),\n            match: { type: getListTypes(editor) },\n            mode: 'lowest',\n          });\n          const rangeLength = Math.min(\n            startList![1].length,\n            endList![1].length\n          );\n\n          editor.tf.setNodes(\n            { type },\n            {\n              at: editor.selection,\n              mode: 'all',\n              match: (n, path) =>\n                ElementApi.isElement(n) &&\n                getListTypes(editor).includes(n.type) &&\n                path.length >= rangeLength,\n            }\n          );\n        }\n      } else {\n        const rootPathLength = commonEntry[1].length;\n        const _nodes = editor.api.nodes<TElement>({\n          mode: 'all',\n        });\n        const nodes = Array.from(_nodes).filter(\n          ([, path]) => path.length === rootPathLength + 1\n        );\n\n        nodes.forEach((n) => {\n          if (getListTypes(editor).includes(n[0].type)) {\n            editor.tf.setNodes(\n              { type },\n              {\n                at: n[1],\n                mode: 'all',\n                match: (_n) =>\n                  ElementApi.isElement(_n) &&\n                  getListTypes(editor).includes(_n.type),\n              }\n            );\n          } else {\n            if (!validLiChildrenTypes?.includes(n[0].type)) {\n              editor.tf.setNodes(\n                { type: editor.getType(KEYS.lic) },\n                { at: n[1] }\n              );\n            }\n\n            const listItem = {\n              children: [],\n              ...getPropsIfTaskList(editor, type, { checked }),\n              type: editor.getType(KEYS.li),\n            };\n            editor.tf.wrapNodes<TElement>(listItem, {\n              at: n[1],\n            });\n\n            const list = { children: [], type };\n            editor.tf.wrapNodes<TElement>(list, { at: n[1] });\n          }\n        });\n      }\n    }\n  });\n\nexport const toggleList = (editor: SlateEditor, { type }: { type: string }) =>\n  _toggleList(editor, { type });\n\nexport const toggleBulletedList = (editor: SlateEditor) =>\n  toggleList(editor, { type: editor.getType(KEYS.ulClassic) });\n\nexport const toggleTaskList = (editor: SlateEditor, defaultChecked = false) =>\n  _toggleList(editor, {\n    checked: defaultChecked,\n    type: editor.getType(KEYS.taskList),\n  });\n\nexport const toggleNumberedList = (editor: SlateEditor) =>\n  toggleList(editor, { type: editor.getType(KEYS.olClassic) });\n","import {\n  type NodeEntry,\n  type OverrideEditor,\n  type TElement,\n  deleteMerge,\n  KEYS,\n  PathApi,\n} from 'platejs';\n\nimport type { ListConfig } from './BaseListPlugin';\n\nimport { isAcrossListItems, isListNested } from './queries';\nimport { getListItemEntry } from './queries/getListItemEntry';\nimport { removeFirstListItem } from './transforms/removeFirstListItem';\nimport { removeListItem } from './transforms/removeListItem';\n\nexport const withDeleteBackwardList: OverrideEditor<ListConfig> = ({\n  editor,\n  tf: { deleteBackward },\n}) => ({\n  transforms: {\n    deleteBackward(unit) {\n      const deleteBackwardList = () => {\n        const res = getListItemEntry(editor, {});\n        let moved: boolean | undefined = false;\n\n        if (res) {\n          const { list, listItem } = res;\n\n          if (\n            editor.api.isAt({\n              start: true,\n              match: (node) => node.type === editor.getType(KEYS.li),\n            })\n          ) {\n            editor.tf.withoutNormalizing(() => {\n              moved = removeFirstListItem(editor, { list, listItem });\n\n              if (moved) return true;\n\n              moved = removeListItem(editor, { list, listItem });\n\n              if (moved) return true;\n              if (\n                !PathApi.hasPrevious(listItem[1]) &&\n                !isListNested(editor, list[1])\n              ) {\n                editor.tf.resetBlock({ at: listItem[1] });\n\n                moved = true;\n\n                return;\n              }\n\n              const pointBeforeListItem = editor.api.before(\n                editor.selection!.focus\n              );\n\n              let currentLic: NodeEntry<TElement> | undefined;\n              let hasMultipleChildren = false;\n\n              if (\n                pointBeforeListItem &&\n                isAcrossListItems(editor, {\n                  anchor: editor.selection!.anchor,\n                  focus: pointBeforeListItem,\n                })\n              ) {\n                const licType = editor.getType(KEYS.lic);\n                const _licNodes = editor.api.nodes<TElement>({\n                  at: listItem[1],\n                  mode: 'lowest',\n                  match: (node) => node.type === licType,\n                });\n                currentLic = [..._licNodes][0];\n                hasMultipleChildren = currentLic[0].children.length > 1;\n              }\n\n              deleteMerge(editor, {\n                reverse: true,\n                unit,\n              });\n              moved = true;\n\n              if (!currentLic || !hasMultipleChildren) return;\n\n              const leftoverListItem = editor.api.node<TElement>(\n                PathApi.parent(currentLic[1])\n              )!;\n\n              if (\n                leftoverListItem &&\n                leftoverListItem[0].children.length === 0\n              ) {\n                editor.tf.removeNodes({ at: leftoverListItem[1] });\n              }\n            });\n          }\n        }\n\n        return moved;\n      };\n\n      if (deleteBackwardList()) return;\n\n      deleteBackward(unit);\n    },\n  },\n});\n","import {\n  type EditorTransforms,\n  type ElementEntry,\n  type OverrideEditor,\n  type SlateEditor,\n  type TElement,\n  KEYS,\n  NodeApi,\n  PathApi,\n} from 'platejs';\n\nimport type { ListConfig } from './BaseListPlugin';\n\nimport {\n  getListItemEntry,\n  getListRoot,\n  hasListChild,\n  isAcrossListItems,\n} from './queries/index';\nimport {\n  moveListItemsToList,\n  moveListItemUp,\n  removeFirstListItem,\n  removeListItem,\n} from './transforms/index';\n\nconst selectionIsNotInAListHandler = (editor: SlateEditor): boolean => {\n  const pointAfterSelection = editor.api.after(editor.selection!.focus);\n\n  if (pointAfterSelection) {\n    // there is a block after it\n    const nextSiblingListRes = getListItemEntry(editor, {\n      at: pointAfterSelection,\n    });\n\n    if (nextSiblingListRes) {\n      // the next block is a list\n      const { listItem } = nextSiblingListRes;\n      const parentBlockEntity = editor.api.block({\n        at: editor.selection!.anchor,\n      });\n\n      if (!editor.api.string(parentBlockEntity![1])) {\n        // the selected block is empty\n        editor.tf.removeNodes();\n\n        return true;\n      }\n      if (hasListChild(editor, listItem[0])) {\n        // the next block has children, so we have to move the first item up\n        const sublistRes = getListItemEntry(editor, {\n          at: [...listItem[1], 1, 0, 0],\n        });\n\n        moveListItemUp(editor, sublistRes!);\n      }\n    }\n  }\n\n  return false;\n};\n\nconst selectionIsInAListHandler = (\n  editor: SlateEditor,\n  res: { list: ElementEntry; listItem: ElementEntry },\n  defaultDelete: EditorTransforms['deleteBackward'],\n  unit: 'block' | 'character' | 'line' | 'word' = 'character'\n): boolean => {\n  const { listItem } = res;\n\n  // if it has no children\n  if (!hasListChild(editor, listItem[0])) {\n    const liType = editor.getType(KEYS.li);\n    const _nodes = editor.api.nodes({\n      at: listItem[1],\n      mode: 'lowest',\n      match: (node, path) => {\n        if (path.length === 0) {\n          return false;\n        }\n\n        const isNodeLi = (node as TElement).type === liType;\n        const isSiblingOfNodeLi =\n          NodeApi.get<TElement>(editor, PathApi.next(path))?.type === liType;\n\n        return isNodeLi && isSiblingOfNodeLi;\n      },\n    });\n    const liWithSiblings = Array.from(_nodes, (entry) => entry[1])[0];\n\n    if (!liWithSiblings) {\n      // there are no more list item in the list\n      const pointAfterListItem = editor.api.after(listItem[1]);\n\n      if (pointAfterListItem) {\n        // there is a block after it\n        const nextSiblingListRes = getListItemEntry(editor, {\n          at: pointAfterListItem,\n        });\n\n        if (nextSiblingListRes) {\n          // it is a list so we merge the lists\n          const listRoot = getListRoot(editor, listItem[1]);\n\n          moveListItemsToList(editor, {\n            deleteFromList: true,\n            fromList: nextSiblingListRes.list,\n            toList: listRoot,\n          });\n\n          return true;\n        }\n      }\n\n      return false;\n    }\n\n    const siblingListItem = editor.api.node<TElement>(\n      PathApi.next(liWithSiblings)\n    );\n\n    if (!siblingListItem) return false;\n\n    const siblingList = editor.api.parent<TElement>(siblingListItem[1]);\n\n    if (\n      siblingList &&\n      removeListItem(editor, {\n        list: siblingList,\n        listItem: siblingListItem,\n        reverse: false,\n      })\n    ) {\n      return true;\n    }\n\n    const pointAfterListItem = editor.api.after(editor.selection!.focus);\n\n    if (\n      !pointAfterListItem ||\n      !isAcrossListItems(editor, {\n        anchor: editor.selection!.anchor,\n        focus: pointAfterListItem,\n      })\n    ) {\n      return false;\n    }\n\n    // get closest lic ancestor of next selectable\n    const licType = editor.getType(KEYS.lic);\n    const _licNodes = editor.api.nodes<TElement>({\n      at: pointAfterListItem.path,\n      mode: 'lowest',\n      match: (node) => node.type === licType,\n    });\n    const nextSelectableLic = [..._licNodes][0];\n\n    // let slate handle single child cases\n    if (nextSelectableLic[0].children.length < 2) return false;\n\n    // manually run default delete\n    defaultDelete(unit);\n\n    const leftoverListItem = editor.api.node<TElement>(\n      PathApi.parent(nextSelectableLic[1])\n    )!;\n\n    if (leftoverListItem && leftoverListItem[0].children.length === 0) {\n      // remove the leftover empty list item\n      editor.tf.removeNodes({ at: leftoverListItem[1] });\n    }\n\n    return true;\n  }\n\n  // if it has children\n  const nestedList = editor.api.node<TElement>(\n    PathApi.next([...listItem[1], 0])\n  );\n\n  if (!nestedList) return false;\n\n  const nestedListItem = Array.from(\n    NodeApi.children<TElement>(editor, nestedList[1])\n  )[0];\n\n  if (\n    removeFirstListItem(editor, {\n      list: nestedList,\n      listItem: nestedListItem,\n    })\n  ) {\n    return true;\n  }\n  if (\n    removeListItem(editor, {\n      list: nestedList,\n      listItem: nestedListItem,\n    })\n  ) {\n    return true;\n  }\n\n  return false;\n};\n\nexport const withDeleteForwardList: OverrideEditor<ListConfig> = ({\n  editor,\n  tf: { deleteForward },\n}) => ({\n  transforms: {\n    deleteForward(unit) {\n      const deleteForwardList = () => {\n        let skipDefaultDelete = false;\n\n        if (!editor?.selection) {\n          return skipDefaultDelete;\n        }\n        if (!editor.api.isAt({ end: true })) {\n          return skipDefaultDelete;\n        }\n\n        editor.tf.withoutNormalizing(() => {\n          const res = getListItemEntry(editor, {});\n\n          if (!res) {\n            skipDefaultDelete = selectionIsNotInAListHandler(editor);\n\n            return;\n          }\n\n          skipDefaultDelete = selectionIsInAListHandler(\n            editor,\n            res,\n            deleteForward,\n            unit\n          );\n        });\n\n        return skipDefaultDelete;\n      };\n\n      if (deleteForwardList()) return;\n\n      deleteForward(unit);\n    },\n  },\n});\n","import {\n  type OverrideEditor,\n  type SlateEditor,\n  type TRange,\n  deleteMerge,\n  KEYS,\n} from 'platejs';\n\nimport type { ListConfig } from './BaseListPlugin';\n\nimport { getHighestEmptyList } from './queries/getHighestEmptyList';\nimport { hasListChild } from './queries/index';\nimport { isAcrossListItems } from './queries/isAcrossListItems';\n\nconst getLiStart = (editor: SlateEditor) => {\n  const start = editor.api.start(editor.selection as TRange);\n\n  return editor.api.above({\n    at: start,\n    match: { type: editor.getType(KEYS.li) },\n  });\n};\n\nexport const withDeleteFragmentList: OverrideEditor<ListConfig> = ({\n  editor,\n  tf: { deleteFragment },\n}) => ({\n  transforms: {\n    deleteFragment(direction) {\n      const deleteFragmentList = () => {\n        let deleted = false;\n\n        editor.tf.withoutNormalizing(() => {\n          // Selection should be across list items\n          if (!isAcrossListItems(editor)) return;\n\n          /**\n           * Check if the end li can be deleted (if it has no sublist). Store\n           * the path ref to delete it after deleteMerge.\n           */\n          const end = editor.api.end(editor.selection as TRange);\n          const liEnd = editor.api.above({\n            at: end,\n            match: { type: editor.getType(KEYS.li) },\n          });\n          const liEndCanBeDeleted = liEnd && !hasListChild(editor, liEnd[0]);\n          const liEndPathRef = liEndCanBeDeleted\n            ? editor.api.pathRef(liEnd![1])\n            : undefined;\n\n          // use deleteFragment when selection wrapped around list\n          if (!getLiStart(editor) || !liEnd) {\n            deleted = false;\n\n            return;\n          }\n\n          /** Delete fragment and move end block children to start block */\n          deleteMerge(editor);\n\n          const liStart = getLiStart(editor);\n\n          if (liEndPathRef) {\n            const liEndPath = liEndPathRef.unref()!;\n            const listStart = liStart && editor.api.parent(liStart[1]);\n\n            const deletePath = getHighestEmptyList(editor, {\n              diffListPath: listStart?.[1],\n              liPath: liEndPath,\n            });\n\n            if (deletePath) {\n              editor.tf.removeNodes({ at: deletePath });\n            }\n\n            deleted = true;\n          }\n        });\n\n        return deleted;\n      };\n\n      if (deleteFragmentList()) return;\n\n      deleteFragment(direction);\n    },\n  },\n});\n","import { type OverrideEditor, KEYS } from 'platejs';\n\nimport type { ListConfig } from './BaseListPlugin';\n\nimport { getListItemEntry } from './queries/getListItemEntry';\nimport { insertListItem } from './transforms/insertListItem';\nimport { moveListItemUp } from './transforms/moveListItemUp';\n\nexport const withInsertBreakList: OverrideEditor<ListConfig> = ({\n  editor,\n  getOptions,\n  tf: { insertBreak },\n}) => ({\n  transforms: {\n    insertBreak() {\n      const insertBreakList = () => {\n        if (!editor.selection) return;\n\n        const res = getListItemEntry(editor, {});\n        let moved: boolean | undefined;\n\n        // If selection is in a li\n        if (res) {\n          const { list, listItem } = res;\n\n          // If selected li is empty, move it up.\n          if (editor.api.isEmpty(editor.selection, { block: true })) {\n            moved = moveListItemUp(editor, {\n              list,\n              listItem,\n            });\n\n            if (moved) return true;\n          }\n        }\n\n        const block = editor.api.block({\n          match: { type: editor.getType(KEYS.li) },\n        });\n        if (block && editor.api.isEmpty(editor.selection, { block: true })) {\n          const didReset = editor.tf.resetBlock({ at: block[1] });\n\n          if (didReset) return true;\n        }\n\n        /** If selection is in li > p, insert li. */\n        if (!moved) {\n          const inserted = insertListItem(editor, getOptions());\n\n          if (inserted) return true;\n        }\n      };\n\n      if (insertBreakList()) return;\n\n      insertBreak();\n    },\n  },\n});\n","import {\n  type Ancestor,\n  type AncestorEntry,\n  type Descendant,\n  type DescendantEntry,\n  type ElementEntry,\n  type OverrideEditor,\n  type Path,\n  type TElement,\n  type TText,\n  ElementApi,\n  KEYS,\n  NodeApi,\n  PathApi,\n} from 'platejs';\n\nimport type { ListConfig } from './BaseListPlugin';\n\nimport { getPropsIfTaskListLiNode, isListRoot } from './queries';\n\nexport const withInsertFragmentList: OverrideEditor<ListConfig> = ({\n  editor,\n  tf: { insertFragment },\n}) => {\n  const listItemType = editor.getType(KEYS.li);\n  const listItemContentType = editor.getType(KEYS.lic);\n\n  const getFirstAncestorOfType = (\n    root: Descendant,\n    entry: DescendantEntry,\n    type: string\n  ): AncestorEntry => {\n    let ancestor: Path = PathApi.parent(entry[1]);\n\n    while (NodeApi.get<TElement>(root, ancestor)!.type !== type) {\n      ancestor = PathApi.parent(ancestor);\n    }\n\n    return [NodeApi.get<Ancestor>(root, ancestor)!, ancestor];\n  };\n\n  const findListItemsWithContent = (first: Descendant): Descendant[] => {\n    let prev: Descendant | null = null;\n    let node = first;\n\n    while (\n      isListRoot(editor, node) ||\n      (node.type === listItemType &&\n        (node.children as TElement[])[0].type !== listItemContentType)\n    ) {\n      prev = node;\n      [node] = node.children as Descendant[];\n    }\n\n    return prev ? (prev.children as Descendant[]) : [node];\n  };\n\n  /**\n   * Removes the \"empty\" leading lis. Empty in this context means lis only with\n   * other lis as children.\n   *\n   * @returns If argument is not a list root, returns it, otherwise returns ul[]\n   *   or li[].\n   */\n  const trimList = (listRoot: Descendant): TElement[] => {\n    if (!isListRoot(editor, listRoot)) {\n      return [listRoot as TElement];\n    }\n\n    const _texts = NodeApi.texts(listRoot);\n    const textEntries = Array.from(_texts);\n\n    const commonAncestorEntry = textEntries.reduce(\n      (commonAncestor, textEntry) =>\n        PathApi.isAncestor(commonAncestor[1], textEntry[1])\n          ? commonAncestor\n          : (NodeApi.common(listRoot, textEntry[1], commonAncestor[1]) as any),\n      // any list item would do, we grab the first one\n      getFirstAncestorOfType(listRoot, textEntries[0], listItemType)\n    );\n\n    const [first, ...rest] = isListRoot(\n      editor,\n      commonAncestorEntry[0] as Descendant\n    )\n      ? (commonAncestorEntry[0] as any).children\n      : [commonAncestorEntry[0]];\n\n    return [...findListItemsWithContent(first), ...rest];\n  };\n\n  const wrapNodeIntoListItem = (\n    node: Descendant,\n    props?: Record<string, any>\n  ): TElement =>\n    node.type === listItemType\n      ? (node as TElement)\n      : ({\n          children: [node],\n          ...props,\n          type: listItemType,\n        } as TElement);\n\n  /**\n   * Checks if the fragment only consists of a single LIC in which case it is\n   * considered the user's intention was to copy a text, not a list\n   */\n  const isSingleLic = (fragment: Descendant[]) => {\n    const isFragmentOnlyListRoot =\n      fragment.length === 1 && isListRoot(editor, fragment[0]);\n\n    return (\n      isFragmentOnlyListRoot &&\n      [...NodeApi.nodes({ children: fragment } as any)]\n        .filter((entry): entry is ElementEntry =>\n          ElementApi.isElement(entry[0])\n        )\n        .filter(([node]) => node.type === listItemContentType).length === 1\n    );\n  };\n\n  const getTextAndListItemNodes = (\n    fragment: Descendant[],\n    liEntry: ElementEntry,\n    licEntry: ElementEntry\n  ) => {\n    const [, liPath] = liEntry;\n    const [licNode, licPath] = licEntry;\n    const isEmptyNode = !NodeApi.string(licNode);\n    const [first, ...rest] = fragment.flatMap(trimList).map((v) =>\n      wrapNodeIntoListItem(\n        v,\n        getPropsIfTaskListLiNode(editor, {\n          inherit: true,\n          liNode: liEntry[0],\n        })\n      )\n    );\n    let textNode: TText;\n    let listItemNodes: TElement[];\n\n    if (isListRoot(editor, fragment[0])) {\n      if (isSingleLic(fragment)) {\n        textNode = first as any;\n        listItemNodes = rest as TElement[];\n      } else if (isEmptyNode) {\n        // FIXME: is there a more direct way to set this?\n        const li = NodeApi.get(editor, liPath);\n        const [, ...currentSublists] = li!.children as TElement[];\n        const [newLic, ...newSublists] = first.children as TElement[];\n        editor.tf.insertNodes(newLic, {\n          at: PathApi.next(licPath),\n          select: true,\n        });\n        editor.tf.removeNodes({\n          at: licPath,\n        });\n\n        if (newSublists?.length) {\n          if (currentSublists?.length) {\n            // TODO: any better way to compile the path where the LIs of the newly inserted element will be inserted?\n            const path = [...liPath, 1, 0];\n            editor.tf.insertNodes(newSublists[0].children as TElement[], {\n              at: path,\n              select: true,\n            });\n          } else {\n            editor.tf.insertNodes(newSublists, {\n              at: PathApi.next(licPath),\n              select: true,\n            });\n          }\n        }\n\n        textNode = { text: '' };\n        listItemNodes = rest as TElement[];\n      } else {\n        textNode = { text: '' };\n        listItemNodes = [first as TElement, ...(rest as TElement[])];\n      }\n    } else {\n      textNode = first as any;\n      listItemNodes = rest as TElement[];\n    }\n\n    return { listItemNodes, textNode };\n  };\n\n  return {\n    transforms: {\n      insertFragment(fragment) {\n        let liEntry = editor.api.node<TElement>({\n          match: { type: listItemType },\n          mode: 'lowest',\n        });\n\n        // not inserting into a list item, delegate to other plugins\n        if (!liEntry) {\n          return insertFragment(\n            isListRoot(editor, fragment[0])\n              ? [{ text: '' }, ...fragment]\n              : fragment\n          );\n        }\n\n        // delete selection (if necessary) so that it can check if needs to insert into an empty block\n        insertFragment([{ text: '' }] as any);\n\n        // refetch to find the currently selected LI after the deletion above is performed\n        liEntry = editor.api.node<TElement>({\n          match: { type: listItemType },\n          mode: 'lowest',\n        });\n\n        // Check again if liEntry is undefined after the deletion above.\n        // This prevents unexpected behavior when pasting while a list is highlighted\n        if (!liEntry) {\n          return insertFragment(\n            isListRoot(editor, fragment[0])\n              ? [{ text: '' }, ...fragment]\n              : fragment\n          );\n        }\n\n        const licEntry = editor.api.node<TElement>({\n          match: { type: listItemContentType },\n          mode: 'lowest',\n        });\n\n        if (!licEntry) {\n          return insertFragment(\n            isListRoot(editor, fragment[0])\n              ? [{ text: '' }, ...fragment]\n              : fragment\n          );\n        }\n\n        const { listItemNodes, textNode } = getTextAndListItemNodes(\n          fragment,\n          liEntry!,\n          licEntry\n        );\n\n        insertFragment<TText>([textNode]); // insert text if needed\n\n        const [, liPath] = liEntry!;\n\n        return editor.tf.insertNodes(listItemNodes, {\n          at: PathApi.next(liPath),\n          select: true,\n        });\n      },\n    },\n  };\n};\n","import {\n  type Descendant,\n  type ElementEntry,\n  type NodeEntry,\n  type PathRef,\n  type SlateEditor,\n  type TElement,\n  KEYS,\n  match,\n  NodeApi,\n  PathApi,\n} from 'platejs';\n\nimport type { ListConfig } from '../BaseListPlugin';\n\nimport { getListTypes } from '../queries/index';\nimport { moveListItemUp } from '../transforms/index';\n\n/**\n * Recursively get all the:\n *\n * - Block children\n * - Inline children except those at excludeDepth\n */\nexport const getDeepInlineChildren = (\n  editor: SlateEditor,\n  {\n    children,\n  }: {\n    children: NodeEntry<Descendant>[];\n  }\n) => {\n  const inlineChildren: NodeEntry<Descendant>[] = [];\n\n  for (const child of children) {\n    if (editor.api.isBlock(child[0])) {\n      inlineChildren.push(\n        ...getDeepInlineChildren(editor, {\n          children: Array.from(NodeApi.children(editor, child[1])),\n        })\n      );\n    } else {\n      inlineChildren.push(child);\n    }\n  }\n\n  return inlineChildren;\n};\n\n/**\n * If the list item has no child: insert an empty list item container. Else:\n * move the children that are not valid to the list item container.\n */\nexport const normalizeListItem = (\n  editor: SlateEditor,\n  {\n    listItem,\n    validLiChildrenTypes = [],\n  }: { listItem: ElementEntry } & ListConfig['options']\n) => {\n  let changed = false;\n\n  const allValidLiChildrenTypes = new Set([\n    editor.getType(KEYS.lic),\n    editor.getType(KEYS.olClassic),\n    editor.getType(KEYS.taskList),\n    editor.getType(KEYS.ulClassic),\n    ...validLiChildrenTypes,\n  ]);\n\n  const [, liPath] = listItem;\n  const liChildren = Array.from(\n    NodeApi.children<TElement>(editor, listItem[1])\n  );\n\n  // Get invalid (type) li children path refs to be moved\n  const invalidLiChildrenPathRefs = liChildren\n    .filter(([child]) => !allValidLiChildrenTypes.has(child.type))\n    .map(([, childPath]) => editor.api.pathRef(childPath));\n\n  const firstLiChild: ElementEntry | undefined = liChildren[0];\n  const [firstLiChildNode, firstLiChildPath] = firstLiChild ?? [];\n\n  // If li has no child or inline child, insert lic\n  if (!firstLiChild || !editor.api.isBlock(firstLiChildNode)) {\n    editor.tf.insertNodes(\n      editor.api.create.block({\n        type: editor.getType(KEYS.lic),\n      }),\n      {\n        at: liPath.concat([0]),\n      }\n    );\n\n    return true;\n  }\n  // If first li child is a block but not lic, set it to lic\n  if (\n    editor.api.isBlock(firstLiChildNode) &&\n    !match(firstLiChildNode, [], {\n      type: editor.getType(KEYS.lic),\n    })\n  ) {\n    if (\n      match(firstLiChildNode, [], {\n        type: getListTypes(editor),\n      })\n    ) {\n      // the listItem has no lic so we move the children up a level\n      const parent = editor.api.parent(listItem[1]);\n      const sublist = firstLiChild;\n      const children = Array.from(\n        NodeApi.children<TElement>(editor, firstLiChild[1])\n      ).reverse();\n      children.forEach((c) => {\n        moveListItemUp(editor, {\n          list: sublist,\n          listItem: c,\n        });\n      });\n\n      editor.tf.removeNodes({ at: [...parent![1], 0] });\n\n      return true;\n    }\n    // Allow block elements listed as valid li children types to be a first child instead of LIC\n    if (validLiChildrenTypes.includes(firstLiChildNode.type)) {\n      return true;\n    }\n\n    editor.tf.setNodes(\n      {\n        type: editor.getType(KEYS.lic),\n      },\n      {\n        at: firstLiChildPath,\n      }\n    );\n\n    changed = true;\n  }\n\n  const licChildren = Array.from(NodeApi.children(editor, firstLiChild[1]));\n\n  if (licChildren.length > 0) {\n    const blockPathRefs: PathRef[] = [];\n    const inlineChildren: NodeEntry[] = [];\n\n    // Check that lic has no block children\n    for (const licChild of licChildren) {\n      if (!editor.api.isBlock(licChild[0])) {\n        break;\n      }\n\n      blockPathRefs.push(editor.api.pathRef(licChild[1]));\n\n      inlineChildren.push(\n        ...getDeepInlineChildren(editor, {\n          children: Array.from(NodeApi.children(editor, licChild[1])),\n        })\n      );\n    }\n\n    const to = PathApi.next(licChildren.at(-1)![1]);\n\n    // Move lic nested inline children to its children\n    inlineChildren.reverse().forEach(([, path]) => {\n      editor.tf.moveNodes({\n        at: path,\n        to,\n      });\n    });\n\n    // Remove lic block children\n    blockPathRefs.forEach((pathRef) => {\n      const path = pathRef.unref();\n\n      if (path) {\n        editor.tf.removeNodes({\n          at: path,\n        });\n      }\n    });\n\n    if (blockPathRefs.length > 0) {\n      changed = true;\n    }\n  }\n  if (changed) return true;\n\n  // Ensure that any text nodes under the list are inside the list item container\n  invalidLiChildrenPathRefs.reverse().forEach((ref) => {\n    const path = ref.unref();\n\n    if (path) {\n      editor.tf.moveNodes({\n        at: path,\n        to: firstLiChildPath.concat([0]),\n      });\n    }\n  });\n\n  return invalidLiChildrenPathRefs.length > 0;\n};\n","import { type ElementEntry, type SlateEditor, match, PathApi } from 'platejs';\n\nimport { getListTypes } from '../queries/index';\n\n// When pasting from e.g. Google Docs, the structure of nested lists like \"ul -> ul\"\n// should be normalized to \"ul -> li -> lic + ul\".\n// In other words, a nested list as a direct children of a list should be moved into a previous list item sibling\nexport const normalizeNestedList = (\n  editor: SlateEditor,\n  { nestedListItem }: { nestedListItem: ElementEntry }\n) => {\n  const [, path] = nestedListItem;\n\n  const parentNode = editor.api.parent(path);\n  const hasParentList =\n    parentNode && match(parentNode[0], [], { type: getListTypes(editor) });\n\n  if (!hasParentList) {\n    return false;\n  }\n\n  const previousListItemPath = PathApi.previous(path);\n\n  if (!previousListItemPath) {\n    return false;\n  }\n\n  // Previous sibling is the new parent\n  const previousSiblingItem = editor.api.node(previousListItemPath);\n\n  if (previousSiblingItem) {\n    const [, previousPath] = previousSiblingItem;\n    const newPath = previousPath.concat([1]);\n\n    // Move the current item to the sublist\n    editor.tf.moveNodes({\n      at: path,\n      to: newPath,\n    });\n\n    return true;\n  }\n};\n","import {\n  type OverrideEditor,\n  type TElement,\n  ElementApi,\n  KEYS,\n  match,\n  NodeApi,\n  PathApi,\n} from 'platejs';\n\nimport type { ListConfig } from './BaseListPlugin';\n\nimport { normalizeListItem } from './normalizers/normalizeListItem';\nimport { normalizeNestedList } from './normalizers/normalizeNestedList';\nimport { getListTypes, isListRoot } from './queries';\nimport { moveListItemsToList } from './transforms';\n\n/** Normalize list node to force the ul>li>p+ul structure. */\nexport const withNormalizeList: OverrideEditor<ListConfig> = ({\n  editor,\n  getOptions,\n  tf: { normalizeNode },\n}) => ({\n  transforms: {\n    normalizeNode([node, path]) {\n      const liType = editor.getType(KEYS.li);\n      const licType = editor.getType(KEYS.lic);\n      const defaultType = editor.getType(KEYS.p);\n\n      if (!ElementApi.isElement(node)) {\n        return normalizeNode([node, path]);\n      }\n      if (isListRoot(editor, node)) {\n        const nonLiChild = Array.from(NodeApi.children(editor, path)).find(\n          ([child]) => child.type !== liType\n        );\n\n        if (nonLiChild) {\n          return editor.tf.wrapNodes<TElement>(\n            { children: [], type: liType },\n            { at: nonLiChild[1] }\n          );\n        }\n\n        // add \"checked\" prop to list-item nodes if they have a taskList parent but no \"checked\" prop\n        // remove \"checked\" prop from list-item nodes if they do not have a taskList parent but a \"checked\" prop\n        if (node.type === editor.getType(KEYS.taskList)) {\n          const nonTaskListItems = Array.from(\n            NodeApi.children(editor, path)\n          ).filter(([child]) => child.type === liType && !('checked' in child));\n\n          if (nonTaskListItems.length > 0) {\n            return editor.tf.withoutNormalizing(() =>\n              nonTaskListItems.forEach(([, itemPath]) => {\n                editor.tf.setNodes({ checked: false }, { at: itemPath });\n              })\n            );\n          }\n        } else {\n          const taskListItems = Array.from(\n            NodeApi.children(editor, path)\n          ).filter(([child]) => child.type === liType && 'checked' in child);\n\n          if (taskListItems.length > 0) {\n            return editor.tf.withoutNormalizing(() =>\n              taskListItems.forEach(([, itemPath]) => {\n                editor.tf.unsetNodes('checked', { at: itemPath });\n              })\n            );\n          }\n        }\n      }\n      // remove empty list\n      if (match(node, [], { type: getListTypes(editor) })) {\n        if (\n          node.children.length === 0 ||\n          !node.children.some((item) => item.type === liType)\n        ) {\n          return editor.tf.removeNodes({ at: path });\n        }\n\n        const nextPath = PathApi.next(path);\n        const nextNode = NodeApi.get<TElement>(editor, nextPath)!;\n\n        // Has a list afterwards with the same type\n        if (nextNode?.type === node.type) {\n          moveListItemsToList(editor, {\n            deleteFromList: true,\n            fromList: [nextNode, nextPath],\n            toList: [node, path],\n          });\n        }\n\n        const prevPath = PathApi.previous(path)!;\n        const prevNode = NodeApi.get<TElement>(editor, prevPath);\n\n        // Has a list before with the same type\n        if (prevNode?.type === node.type) {\n          editor.tf.normalizeNode([prevNode, prevPath]);\n\n          // early return since this node will no longer exists\n          return;\n        }\n        if (normalizeNestedList(editor, { nestedListItem: [node, path] })) {\n          return;\n        }\n      }\n      if (\n        node.type === editor.getType(KEYS.li) &&\n        normalizeListItem(editor, {\n          listItem: [node, path],\n          validLiChildrenTypes: getOptions().validLiChildrenTypes,\n        })\n      ) {\n        return;\n      }\n      // LIC should have LI parent. If not, set LIC to DEFAULT type.\n      if (\n        node.type === licType &&\n        licType !== defaultType &&\n        editor.api.parent(path)?.[0].type !== liType\n      ) {\n        editor.tf.setNodes({ type: defaultType }, { at: path });\n\n        return;\n      }\n\n      normalizeNode([node, path]);\n    },\n  },\n});\n","import { type OverrideEditor, KEYS, RangeApi } from 'platejs';\n\nimport type { ListConfig } from './BaseListPlugin';\n\nimport { unwrapList } from '.';\nimport { moveListItems } from './transforms/index';\nimport { withDeleteBackwardList } from './withDeleteBackwardList';\nimport { withDeleteForwardList } from './withDeleteForwardList';\nimport { withDeleteFragmentList } from './withDeleteFragmentList';\nimport { withInsertBreakList } from './withInsertBreakList';\nimport { withInsertFragmentList } from './withInsertFragmentList';\nimport { withNormalizeList } from './withNormalizeList';\n\nexport const withList: OverrideEditor<ListConfig> = (ctx) => {\n  const {\n    editor,\n    getOptions,\n    tf: { resetBlock, tab },\n  } = ctx;\n\n  return {\n    transforms: {\n      resetBlock: (options) => {\n        if (\n          editor.api.block({\n            at: options?.at,\n            match: { type: editor.getType(KEYS.li) },\n          })\n        ) {\n          unwrapList(editor);\n          return;\n        }\n\n        return resetBlock(options);\n      },\n      tab: (options) => {\n        const apply = () => {\n          let workRange = editor.selection;\n\n          if (editor.selection) {\n            const { selection } = editor;\n\n            // Unhang the expanded selection\n            if (!editor.api.isCollapsed()) {\n              const { anchor, focus } = RangeApi.isBackward(selection)\n                ? {\n                    anchor: { ...selection.focus },\n                    focus: { ...selection.anchor },\n                  }\n                : {\n                    anchor: { ...selection.anchor },\n                    focus: { ...selection.focus },\n                  };\n\n              // This is a workaround for a Slate bug\n              // See: https://github.com/ianstormtaylor/slate/pull/5039\n              const unhangRange = editor.api.unhangRange({ anchor, focus });\n\n              if (unhangRange) {\n                workRange = unhangRange;\n                editor.tf.select(unhangRange);\n              }\n            }\n\n            // check if we're in a list context.\n            const listSelected = editor.api.some({\n              match: { type: editor.getType(KEYS.li) },\n            });\n\n            if (workRange && listSelected) {\n              moveListItems(editor, {\n                at: workRange,\n                enableResetOnShiftTab: getOptions().enableResetOnShiftTab,\n                increase: !options.reverse,\n              });\n\n              return true; // Prevent default\n            }\n          }\n        };\n\n        if (apply()) return true;\n\n        return tab(options);\n      },\n      ...withInsertBreakList(ctx).transforms,\n      ...withDeleteBackwardList(ctx).transforms,\n      ...withDeleteForwardList(ctx as any).transforms,\n      ...withDeleteFragmentList(ctx as any).transforms,\n      ...withInsertFragmentList(ctx as any).transforms,\n      ...withNormalizeList(ctx as any).transforms,\n    },\n  };\n};\n","import {\n  type OmitFirst,\n  type PluginConfig,\n  bindFirst,\n  createSlatePlugin,\n  createTSlatePlugin,\n  KEYS,\n} from 'platejs';\n\nimport {\n  toggleBulletedList,\n  toggleList,\n  toggleNumberedList,\n  toggleTaskList,\n} from './transforms';\nimport { withList } from './withList';\n\nexport type ListConfig = PluginConfig<\n  'listClassic',\n  {\n    enableResetOnShiftTab?: boolean;\n    /** Inherit the checked state of above node after insert break at the end */\n    inheritCheckStateOnLineEndBreak?: boolean;\n    /** Inherit the checked state of below node after insert break at the start */\n    inheritCheckStateOnLineStartBreak?: boolean;\n    /** Valid children types for list items, in addition to p and ul types. */\n    validLiChildrenTypes?: string[];\n  },\n  {},\n  {\n    toggle: {\n      bulletedList: OmitFirst<typeof toggleBulletedList>;\n      list: OmitFirst<typeof toggleList>;\n      numberedList: OmitFirst<typeof toggleNumberedList>;\n      taskList: OmitFirst<typeof toggleTaskList>;\n    };\n  }\n>;\n\nexport const BaseBulletedListPlugin = createSlatePlugin({\n  key: KEYS.ulClassic,\n  node: { isContainer: true, isElement: true },\n  parsers: {\n    html: {\n      deserializer: {\n        rules: [\n          {\n            validNodeName: 'UL',\n          },\n        ],\n      },\n    },\n  },\n  render: { as: 'ul' },\n}).extendTransforms(({ editor }) => ({\n  toggle: () => {\n    toggleBulletedList(editor);\n  },\n}));\n\nexport const BaseNumberedListPlugin = createSlatePlugin({\n  key: KEYS.olClassic,\n  node: { isContainer: true, isElement: true },\n  parsers: { html: { deserializer: { rules: [{ validNodeName: 'OL' }] } } },\n  render: { as: 'ol' },\n}).extendTransforms(({ editor }) => ({\n  toggle: () => {\n    toggleNumberedList(editor);\n  },\n}));\n\nexport const BaseTaskListPlugin = createSlatePlugin({\n  key: KEYS.taskList,\n  node: { isContainer: true, isElement: true },\n  options: {\n    inheritCheckStateOnLineEndBreak: false,\n    inheritCheckStateOnLineStartBreak: false,\n  },\n  render: { as: 'ul' },\n}).extendTransforms(({ editor }) => ({\n  toggle: () => {\n    toggleTaskList(editor);\n  },\n}));\n\nexport const BaseListItemPlugin = createSlatePlugin({\n  key: KEYS.li,\n  inject: {\n    plugins: {\n      [KEYS.html]: {\n        parser: {\n          preInsert: ({ editor, type }) => editor.api.some({ match: { type } }),\n        },\n      },\n    },\n  },\n  node: { isContainer: true, isElement: true, isStrictSiblings: true },\n  parsers: { html: { deserializer: { rules: [{ validNodeName: 'LI' }] } } },\n  render: { as: 'li' },\n});\n\nexport const BaseListItemContentPlugin = createSlatePlugin({\n  key: KEYS.lic,\n  node: {\n    isElement: true,\n  },\n});\n\n/** Enables support for bulleted, numbered and to-do lists. */\nexport const BaseListPlugin = createTSlatePlugin<ListConfig>({\n  key: KEYS.listClassic,\n  plugins: [\n    BaseBulletedListPlugin,\n    BaseNumberedListPlugin,\n    BaseTaskListPlugin,\n    BaseListItemPlugin,\n    BaseListItemContentPlugin,\n  ],\n})\n  .overrideEditor(withList)\n  .extendEditorTransforms(({ editor }) => ({\n    toggle: {\n      bulletedList: bindFirst(toggleBulletedList, editor),\n      list: bindFirst(toggleList, editor),\n      numberedList: bindFirst(toggleNumberedList, editor),\n      taskList: bindFirst(toggleTaskList, editor),\n    },\n  }));\n"],"mappings":"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"}

package/dist/index-CYSu3DSy.d.ts

@@ -1,328 +0,0 @@
-import { Ancestor, Descendant, EditorNodesOptions, ElementEntry, NodeEntry, OmitFirst, OverrideEditor, Path, PluginConfig, Point, SlateEditor, TElement, TLocation, TRange } from "platejs";
-
-//#region src/lib/transforms/indentListItems.d.ts
-declare const indentListItems: (editor: SlateEditor) => void;
-//#endregion
-//#region src/lib/transforms/insertListItem.d.ts
-type InsertListItemOptions = {
-  inheritCheckStateOnLineEndBreak?: boolean;
-  inheritCheckStateOnLineStartBreak?: boolean;
-};
-/** Insert list item if selection in li>p. TODO: test */
-declare const insertListItem: (editor: SlateEditor, options?: InsertListItemOptions) => boolean;
-//#endregion
-//#region src/lib/transforms/insertTodoListItem.d.ts
-/** Insert todo list item if selection in li>p. TODO: test */
-declare const insertTodoListItem: (editor: SlateEditor) => boolean;
-//#endregion
-//#region src/lib/transforms/moveListItemDown.d.ts
-type MoveListItemDownOptions = {
-  list: ElementEntry;
-  listItem: ElementEntry;
-};
-declare const moveListItemDown: (editor: SlateEditor, {
-  list,
-  listItem
-}: MoveListItemDownOptions) => false | undefined;
-//#endregion
-//#region src/lib/transforms/moveListItemSublistItemsToListItemSublist.d.ts
-type MoveListItemSublistItemsToListItemSublistOptions = {
-  /** The list item to merge. */
-  fromListItem: ElementEntry;
-  /** The list item where to merge. */
-  toListItem: ElementEntry;
-  /** Move to the start of the list instead of the end. */
-  start?: boolean;
-};
-/**
- * Move fromListItem sublist list items to the end of `toListItem` sublist. If
- * there is no `toListItem` sublist, insert one.
- */
-declare const moveListItemSublistItemsToListItemSublist: (editor: SlateEditor, {
-  fromListItem,
-  start,
-  toListItem
-}: MoveListItemSublistItemsToListItemSublistOptions) => boolean;
-//#endregion
-//#region src/lib/transforms/moveListItemUp.d.ts
-type MoveListItemUpOptions = {
-  list: ElementEntry;
-  listItem: ElementEntry;
-};
-/** Move a list item up. */
-declare const moveListItemUp: (editor: SlateEditor, {
-  list,
-  listItem
-}: MoveListItemUpOptions) => boolean;
-//#endregion
-//#region src/lib/transforms/moveListItems.d.ts
-type MoveListItemsOptions = {
-  at?: EditorNodesOptions['at'];
-  enableResetOnShiftTab?: boolean;
-  increase?: boolean;
-};
-declare const moveListItems: (editor: SlateEditor, {
-  at,
-  enableResetOnShiftTab,
-  increase
-}?: MoveListItemsOptions) => any;
-//#endregion
-//#region src/lib/transforms/moveListItemsToList.d.ts
-type MergeListItemIntoListOptions = {
-  /**
-   * Delete `fromListItem` sublist if true.
-   *
-   * @default true
-   */
-  deleteFromList?: boolean;
-  /** List items of the list will be moved. */
-  fromList?: ElementEntry;
-  /** List items of the sublist of this node will be moved. */
-  fromListItem?: ElementEntry;
-  fromStartIndex?: number;
-  to?: Path;
-  /** List items will be moved in this list. */
-  toList?: ElementEntry;
-  /** List position where to move the list items. */
-  toListIndex?: number | null;
-};
-/**
- * Move the list items of the sublist of `fromListItem` to `toList` (if
- * `fromListItem` is defined). Move the list items of `fromList` to `toList` (if
- * `fromList` is defined).
- */
-declare const moveListItemsToList: (editor: SlateEditor, {
-  deleteFromList,
-  fromList,
-  fromListItem,
-  fromStartIndex,
-  to: _to,
-  toList,
-  toListIndex
-}: MergeListItemIntoListOptions) => boolean;
-//#endregion
-//#region src/lib/transforms/moveListSiblingsAfterCursor.d.ts
-declare const moveListSiblingsAfterCursor: (editor: SlateEditor, {
-  at,
-  to
-}: {
-  at: Path;
-  to: Path;
-}) => any;
-//#endregion
-//#region src/lib/transforms/removeFirstListItem.d.ts
-/** If list is not nested and if li is not the first child, move li up. */
-declare const removeFirstListItem: (editor: SlateEditor, {
-  list,
-  listItem
-}: {
-  list: ElementEntry;
-  listItem: ElementEntry;
-}) => boolean;
-//#endregion
-//#region src/lib/transforms/removeListItem.d.ts
-type RemoveListItemOptions = {
-  list: ElementEntry;
-  listItem: ElementEntry;
-  reverse?: boolean;
-};
-/** Remove list item and move its sublist to list if any. */
-declare const removeListItem: (editor: SlateEditor, {
-  list,
-  listItem,
-  reverse
-}: RemoveListItemOptions) => boolean;
-//#endregion
-//#region src/lib/transforms/toggleList.d.ts
-declare const toggleList: (editor: SlateEditor, {
-  type
-}: {
-  type: string;
-}) => any;
-declare const toggleBulletedList: (editor: SlateEditor) => any;
-declare const toggleTaskList: (editor: SlateEditor, defaultChecked?: boolean) => any;
-declare const toggleNumberedList: (editor: SlateEditor) => any;
-//#endregion
-//#region src/lib/transforms/unindentListItems.d.ts
-type UnindentListItemsOptions = Omit<MoveListItemsOptions, 'increase'>;
-declare const unindentListItems: (editor: SlateEditor, options?: UnindentListItemsOptions) => any;
-//#endregion
-//#region src/lib/transforms/unwrapList.d.ts
-declare const unwrapList: (editor: SlateEditor, {
-  at
-}?: {
-  at?: Path;
-}) => void;
-//#endregion
-//#region src/lib/BaseListPlugin.d.ts
-type ListConfig = PluginConfig<'listClassic', {
-  enableResetOnShiftTab?: boolean;
-  /** Inherit the checked state of above node after insert break at the end */
-  inheritCheckStateOnLineEndBreak?: boolean;
-  /** Inherit the checked state of below node after insert break at the start */
-  inheritCheckStateOnLineStartBreak?: boolean;
-  /** Valid children types for list items, in addition to p and ul types. */
-  validLiChildrenTypes?: string[];
-}, {}, {
-  toggle: {
-    bulletedList: OmitFirst<typeof toggleBulletedList>;
-    list: OmitFirst<typeof toggleList>;
-    numberedList: OmitFirst<typeof toggleNumberedList>;
-    taskList: OmitFirst<typeof toggleTaskList>;
-  };
-}>;
-declare const BaseBulletedListPlugin: any;
-declare const BaseNumberedListPlugin: any;
-declare const BaseTaskListPlugin: any;
-declare const BaseListItemPlugin: any;
-declare const BaseListItemContentPlugin: any;
-/** Enables support for bulleted, numbered and to-do lists. */
-declare const BaseListPlugin: any;
-//#endregion
-//#region src/lib/BaseTodoListPlugin.d.ts
-interface TTodoListItemElement extends TElement {
-  checked?: boolean;
-}
-declare const BaseTodoListPlugin: any;
-//#endregion
-//#region src/lib/withDeleteBackwardList.d.ts
-declare const withDeleteBackwardList: OverrideEditor<ListConfig>;
-//#endregion
-//#region src/lib/withDeleteForwardList.d.ts
-declare const withDeleteForwardList: OverrideEditor<ListConfig>;
-//#endregion
-//#region src/lib/withDeleteFragmentList.d.ts
-declare const withDeleteFragmentList: OverrideEditor<ListConfig>;
-//#endregion
-//#region src/lib/withInsertBreakList.d.ts
-declare const withInsertBreakList: OverrideEditor<ListConfig>;
-//#endregion
-//#region src/lib/withInsertFragmentList.d.ts
-declare const withInsertFragmentList: OverrideEditor<ListConfig>;
-//#endregion
-//#region src/lib/withList.d.ts
-declare const withList: OverrideEditor<ListConfig>;
-//#endregion
-//#region src/lib/withNormalizeList.d.ts
-/** Normalize list node to force the ul>li>p+ul structure. */
-declare const withNormalizeList: OverrideEditor<ListConfig>;
-//#endregion
-//#region src/lib/normalizers/normalizeListItem.d.ts
-/**
- * Recursively get all the:
- *
- * - Block children
- * - Inline children except those at excludeDepth
- */
-declare const getDeepInlineChildren: (editor: SlateEditor, {
-  children
-}: {
-  children: NodeEntry<Descendant>[];
-}) => NodeEntry<Descendant>[];
-/**
- * If the list item has no child: insert an empty list item container. Else:
- * move the children that are not valid to the list item container.
- */
-declare const normalizeListItem: (editor: SlateEditor, {
-  listItem,
-  validLiChildrenTypes
-}: {
-  listItem: ElementEntry;
-} & ListConfig["options"]) => boolean;
-//#endregion
-//#region src/lib/normalizers/normalizeNestedList.d.ts
-declare const normalizeNestedList: (editor: SlateEditor, {
-  nestedListItem
-}: {
-  nestedListItem: ElementEntry;
-}) => boolean | undefined;
-//#endregion
-//#region src/lib/queries/getHighestEmptyList.d.ts
-/**
- * Find the highest end list that can be deleted. Its path should be different
- * to diffListPath. If the highest end list 2+ items, return liPath. Get the
- * parent list until:
- *
- * - The list has less than 2 items.
- * - Its path is not equals to diffListPath.
- */
-declare const getHighestEmptyList: (editor: SlateEditor, {
-  diffListPath,
-  liPath
-}: {
-  liPath: Path;
-  diffListPath?: Path;
-}) => Path | undefined;
-//#endregion
-//#region src/lib/queries/getListItemEntry.d.ts
-/**
- * Returns the nearest li and ul / ol wrapping node entries for a given path
- * (default = selection)
- */
-declare const getListItemEntry: (editor: SlateEditor, {
-  at
-}?: {
-  at?: TLocation | null;
-}) => {
-  list: ElementEntry;
-  listItem: ElementEntry;
-} | undefined;
-//#endregion
-//#region src/lib/queries/getListRoot.d.ts
-/** Searches upward for the root list element */
-declare const getListRoot: (editor: SlateEditor, at?: Path | Point | TRange | null) => ElementEntry | undefined;
-//#endregion
-//#region src/lib/queries/getListTypes.d.ts
-declare const getListTypes: (editor: SlateEditor) => any[];
-//#endregion
-//#region src/lib/queries/getTaskListProps.d.ts
-type GetPropsIfTaskListLiNodeOptions = {
-  liNode: TElement;
-  inherit?: boolean;
-};
-declare const getPropsIfTaskListLiNode: (editor: SlateEditor, {
-  inherit,
-  liNode: node
-}: GetPropsIfTaskListLiNodeOptions) => {
-  checked: boolean;
-} | undefined;
-declare const getPropsIfTaskList: (editor: SlateEditor, type: string, partial?: {
-  checked?: boolean;
-}) => {
-  checked: boolean;
-} | undefined;
-//#endregion
-//#region src/lib/queries/getTodoListItemEntry.d.ts
-/**
- * Returns the nearest li and ul / ol wrapping node entries for a given path
- * (default = selection)
- */
-declare const getTodoListItemEntry: (editor: SlateEditor, {
-  at
-}?: {
-  at?: TLocation | null;
-}) => {
-  list: ElementEntry;
-  listItem: ElementEntry;
-} | undefined;
-//#endregion
-//#region src/lib/queries/hasListChild.d.ts
-/** Is there a list child in the node. */
-declare const hasListChild: (editor: SlateEditor, node: Ancestor) => any;
-//#endregion
-//#region src/lib/queries/isAcrossListItems.d.ts
-/** Is selection across blocks with list items */
-declare const isAcrossListItems: (editor: SlateEditor, at?: TRange | null) => any;
-//#endregion
-//#region src/lib/queries/isListNested.d.ts
-/** Is the list nested, i.e. its parent is a list item. */
-declare const isListNested: (editor: SlateEditor, listPath: Path) => boolean;
-//#endregion
-//#region src/lib/queries/isListRoot.d.ts
-declare const isListRoot: (editor: SlateEditor, node: Descendant) => boolean;
-//#endregion
-//#region src/lib/queries/someList.d.ts
-declare const someList: (editor: SlateEditor, type: string) => boolean;
-//#endregion
-export { moveListItemDown as $, BaseNumberedListPlugin as A, RemoveListItemOptions as B, withDeleteBackwardList as C, BaseListItemContentPlugin as D, BaseBulletedListPlugin as E, unindentListItems as F, moveListItemsToList as G, removeFirstListItem as H, toggleBulletedList as I, MoveListItemUpOptions as J, MoveListItemsOptions as K, toggleList as L, ListConfig as M, unwrapList as N, BaseListItemPlugin as O, UnindentListItemsOptions as P, MoveListItemDownOptions as Q, toggleNumberedList as R, withDeleteForwardList as S, TTodoListItemElement as T, moveListSiblingsAfterCursor as U, removeListItem as V, MergeListItemIntoListOptions as W, MoveListItemSublistItemsToListItemSublistOptions as X, moveListItemUp as Y, moveListItemSublistItemsToListItemSublist as Z, withNormalizeList as _, hasListChild as a, withInsertBreakList as b, getPropsIfTaskList as c, getListRoot as d, insertTodoListItem as et, getListItemEntry as f, normalizeListItem as g, getDeepInlineChildren as h, isAcrossListItems as i, BaseTaskListPlugin as j, BaseListPlugin as k, getPropsIfTaskListLiNode as l, normalizeNestedList as m, isListRoot as n, insertListItem as nt, getTodoListItemEntry as o, getHighestEmptyList as p, moveListItems as q, isListNested as r, indentListItems as rt, GetPropsIfTaskListLiNodeOptions as s, someList as t, InsertListItemOptions as tt, getListTypes as u, withList as v, BaseTodoListPlugin as w, withDeleteFragmentList as x, withInsertFragmentList as y, toggleTaskList as z };
-//# sourceMappingURL=index-CYSu3DSy.d.ts.map

package/dist/index-CYSu3DSy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-CYSu3DSy.d.ts","names":[],"sources":["../src/lib/transforms/indentListItems.ts","../src/lib/transforms/insertListItem.ts","../src/lib/transforms/insertTodoListItem.ts","../src/lib/transforms/moveListItemDown.ts","../src/lib/transforms/moveListItemSublistItemsToListItemSublist.ts","../src/lib/transforms/moveListItemUp.ts","../src/lib/transforms/moveListItems.ts","../src/lib/transforms/moveListItemsToList.ts","../src/lib/transforms/moveListSiblingsAfterCursor.ts","../src/lib/transforms/removeFirstListItem.ts","../src/lib/transforms/removeListItem.ts","../src/lib/transforms/toggleList.ts","../src/lib/transforms/unindentListItems.ts","../src/lib/transforms/unwrapList.ts","../src/lib/BaseListPlugin.ts","../src/lib/BaseTodoListPlugin.ts","../src/lib/withDeleteBackwardList.ts","../src/lib/withDeleteForwardList.ts","../src/lib/withDeleteFragmentList.ts","../src/lib/withInsertBreakList.ts","../src/lib/withInsertFragmentList.ts","../src/lib/withList.ts","../src/lib/withNormalizeList.ts","../src/lib/normalizers/normalizeListItem.ts","../src/lib/normalizers/normalizeNestedList.ts","../src/lib/queries/getHighestEmptyList.ts","../src/lib/queries/getListItemEntry.ts","../src/lib/queries/getListRoot.ts","../src/lib/queries/getListTypes.ts","../src/lib/queries/getTaskListProps.ts","../src/lib/queries/getTodoListItemEntry.ts","../src/lib/queries/hasListChild.ts","../src/lib/queries/isAcrossListItems.ts","../src/lib/queries/isListNested.ts","../src/lib/queries/isListRoot.ts","../src/lib/queries/someList.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["SlateEditor","getListItemEntry","someList","editor","type","list","SlateEditor","moveListItems","indentListItems","editor","increase","ElementEntry","Path","SlateEditor","TElement","match","NodeApi","PathApi","getListTypes","moveListSiblingsAfterCursor","editor","at","to","offset","parent","listNode","get","listEntry","type","isParent","tf","moveNodes","children","fromIndex","SlateEditor","MoveListItemsOptions","moveListItems","UnindentListItemsOptions","Omit","unindentListItems","editor","options","increase"],"sources":["../src/lib/queries/someList.ts","../src/lib/transforms/indentListItems.ts","../src/lib/transforms/moveListSiblingsAfterCursor.ts","../src/lib/transforms/unindentListItems.ts"],"sourcesContent":["import type { SlateEditor } from 'platejs';\n\nimport { getListItemEntry } from '../index';\n\nexport const someList = (editor: SlateEditor, type: string) =>\n  getListItemEntry(editor)?.list?.[0].type === type;\n","import type { SlateEditor } from 'platejs';\n\nimport { moveListItems } from './moveListItems';\n\nexport const indentListItems = (editor: SlateEditor) => {\n  moveListItems(editor, { increase: true });\n};\n","import {\n  type ElementEntry,\n  type Path,\n  type SlateEditor,\n  type TElement,\n  match,\n  NodeApi,\n  PathApi,\n} from 'platejs';\n\nimport { getListTypes } from '../queries/getListTypes';\n\nexport const moveListSiblingsAfterCursor = (\n  editor: SlateEditor,\n  {\n    at,\n    to,\n  }: {\n    at: Path;\n    to: Path;\n  }\n) => {\n  const offset = at.at(-1)!;\n  at = PathApi.parent(at);\n  const listNode = NodeApi.get<TElement>(editor, at)!;\n  const listEntry: ElementEntry = [listNode, at];\n\n  if (\n    !match(listNode, [], { type: getListTypes(editor) }) ||\n    PathApi.isParent(at, to) // avoid moving nodes within its own list\n  ) {\n    return false;\n  }\n\n  return editor.tf.moveNodes({\n    at: listEntry[1],\n    children: true,\n    fromIndex: offset + 1,\n    to,\n  });\n};\n","import type { SlateEditor } from 'platejs';\n\nimport { type MoveListItemsOptions, moveListItems } from './moveListItems';\n\nexport type UnindentListItemsOptions = Omit<MoveListItemsOptions, 'increase'>;\n\nexport const unindentListItems = (\n  editor: SlateEditor,\n  options: UnindentListItemsOptions = {}\n) => moveListItems(editor, { ...options, increase: false });\n"],"mappings":";;;;AAIA,MAAaE,YAAYC,QAAqBC,SAC5CH,iBAAiBE,OAAO,EAAEE,OAAO,GAAGD,SAASA;;;;ACD/C,MAAaI,mBAAmBC,WAAwB;AACtDF,eAAcE,QAAQ,EAAEC,UAAU,MAAM,CAAC;;;;;ACO3C,MAAaS,+BACXC,QACA,EACEC,IACAC,SAKC;CACH,MAAMC,SAASF,GAAGA,GAAG,GAAG;AACxBA,MAAKJ,QAAQO,OAAOH,GAAG;CACvB,MAAMI,WAAWT,QAAQU,IAAcN,QAAQC,GAAG;CAClD,MAAMM,YAA0B,CAACF,UAAUJ,GAAG;AAE9C,KACE,CAACN,MAAMU,UAAU,EAAE,EAAE,EAAEG,MAAMV,aAAaE,OAAM,EAAG,CAAC,IACpDH,QAAQY,SAASR,IAAIC,GAAG,CAExB,QAAO;AAGT,QAAOF,OAAOU,GAAGC,UAAU;EACzBV,IAAIM,UAAU;EACdK,UAAU;EACVC,WAAWV,SAAS;EACpBD;EACD,CAAC;;;;;ACjCJ,MAAaiB,qBACXC,QACAC,UAAoC,EAAE,KACnCL,cAAcI,QAAQ;CAAE,GAAGC;CAASC,UAAU;CAAO,CAAC"}

package/dist/react/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/react/ListPlugin.tsx","../../src/react/TodoListPlugin.tsx","../../src/react/hooks/useListToolbarButton.ts","../../src/react/hooks/useTodoListElement.ts"],"sourcesContent":[],"mappings":";;;cAWa;cAEA;cAEA;AAJA,cAMA,qBAN0D,EAAA,GAAA;AAE1D,cAMA,cANkD,EAAA,GAAA;AAE/D;AAEA;AAEA;AAMA;cAAa;;;cCrBA;;;cCCA;;;;;EFMA,QAAA,EAAA,MAAA;EAEA,OAAA,EAAA,GAAA;AAEb,CAAA;AAEa,cEIA,oBFJgE,EAAA,CAAA,KAAA,EEKpE,UFLoE,CAAA,OEKlD,yBFLkD,CAAA,EAAA,GAAA;EAEhE,KAAA,EAAA;IAMA,OAAA,EAQX,GAAA;;qBEAqB,KAAA,CAAM,WAAW;;AD7BxC,CAAA;;;cEAa;;AHOb;WGJW;AHIX,CAAA,EAAA,GAAa,GAAA;AAEA,cGQA,kBHRkD,EAAA,CAAA,KAAA,EGStD,UHTsD,CAAA,OGSpC,uBHToC,CAAA,EAAA,GAAA;EAElD,aAAA,EAAA;IAEA,OAAA,EAAA,OAAA;IAEA,eAAkD,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,IAAA;EAMlD,CAAA"}

package/dist/react/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["toPlatePlugin","BaseBulletedListPlugin","BaseListItemContentPlugin","BaseListItemPlugin","BaseListPlugin","BaseNumberedListPlugin","BaseTaskListPlugin","BulletedListPlugin","TaskListPlugin","NumberedListPlugin","ListItemContentPlugin","ListItemPlugin","ListPlugin","plugins","toPlatePlugin","BaseTodoListPlugin","TodoListPlugin","KEYS","useEditorRef","useEditorSelector","ListPlugin","useListToolbarButtonState","t0","$","_c","t1","undefined","nodeType","t2","ulClassic","t3","t4","editor","selection","api","some","match","type","getType","pressed","t5","useListToolbarButton","state","getTransforms","tf","toggle","list","props","onClick","onMouseDown","_temp","e","preventDefault","useEditorRef","useReadOnly","TTodoListItemElement","useTodoListElementState","t0","$","_c","element","editor","checked","readOnly","t1","useTodoListElement","state","value","tf","setNodes","at","t2","checkboxProps","onCheckedChange"],"sources":["../../src/react/ListPlugin.tsx","../../src/react/TodoListPlugin.tsx","../../src/react/hooks/useListToolbarButton.ts","../../src/react/hooks/useTodoListElement.ts"],"sourcesContent":["import { toPlatePlugin } from 'platejs/react';\n\nimport {\n  BaseBulletedListPlugin,\n  BaseListItemContentPlugin,\n  BaseListItemPlugin,\n  BaseListPlugin,\n  BaseNumberedListPlugin,\n  BaseTaskListPlugin,\n} from '../lib';\n\nexport const BulletedListPlugin = toPlatePlugin(BaseBulletedListPlugin);\n\nexport const TaskListPlugin = toPlatePlugin(BaseTaskListPlugin);\n\nexport const NumberedListPlugin = toPlatePlugin(BaseNumberedListPlugin);\n\nexport const ListItemContentPlugin = toPlatePlugin(BaseListItemContentPlugin);\n\nexport const ListItemPlugin = toPlatePlugin(BaseListItemPlugin);\n\n/**\n * Enables support for bulleted, numbered and to-do lists with React-specific\n * features.\n */\nexport const ListPlugin = toPlatePlugin(BaseListPlugin, {\n  plugins: [\n    BulletedListPlugin,\n    TaskListPlugin,\n    NumberedListPlugin,\n    ListItemPlugin,\n    ListItemContentPlugin,\n  ],\n});\n","import { toPlatePlugin } from 'platejs/react';\n\nimport { BaseTodoListPlugin } from '../lib/BaseTodoListPlugin';\n\nexport const TodoListPlugin = toPlatePlugin(BaseTodoListPlugin);\n","import { KEYS } from 'platejs';\nimport { useEditorRef, useEditorSelector } from 'platejs/react';\n\nimport { ListPlugin } from '../ListPlugin';\n\nexport const useListToolbarButtonState = ({\n  nodeType = KEYS.ulClassic as string,\n} = {}) => {\n  const pressed = useEditorSelector(\n    (editor) =>\n      !!editor.selection &&\n      editor.api.some({ match: { type: editor.getType(nodeType) } }),\n    [nodeType]\n  );\n\n  return {\n    nodeType,\n    pressed,\n  };\n};\n\nexport const useListToolbarButton = (\n  state: ReturnType<typeof useListToolbarButtonState>\n) => {\n  const editor = useEditorRef();\n  const tf = editor.getTransforms(ListPlugin);\n\n  return {\n    props: {\n      pressed: state.pressed,\n      onClick: () => {\n        tf.toggle.list({ type: state.nodeType });\n      },\n      onMouseDown: (e: React.MouseEvent<HTMLButtonElement>) => {\n        e.preventDefault();\n      },\n    },\n  };\n};\n","import { useEditorRef, useReadOnly } from 'platejs/react';\n\nimport type { TTodoListItemElement } from '../../lib';\n\nexport const useTodoListElementState = ({\n  element,\n}: {\n  element: TTodoListItemElement;\n}): any => {\n  const editor = useEditorRef();\n  const { checked } = element;\n  const readOnly = useReadOnly();\n\n  return {\n    checked,\n    editor,\n    element,\n    readOnly,\n  };\n};\n\nexport const useTodoListElement = (\n  state: ReturnType<typeof useTodoListElementState>\n) => {\n  const { checked, element, readOnly } = state;\n  const editor = useEditorRef();\n\n  return {\n    checkboxProps: {\n      checked: !!checked,\n      onCheckedChange: (value: boolean) => {\n        if (readOnly) return;\n\n        editor.tf.setNodes<TTodoListItemElement>(\n          { checked: value },\n          { at: element }\n        );\n      },\n    },\n  };\n};\n"],"mappings":"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"}