@lofcz/platejs-list 52.0.11

package/dist/src-Dvsp2AeZ.js

@@ -0,0 +1,803 @@
+import { c } from "react-compiler-runtime";
+import React from "react";
+import { KEYS, NodeApi, PathApi, createTSlatePlugin, getInjectMatch, isDefined, isHtmlBlockElement, postCleanHtml, traverseHtmlElements } from "platejs";
+import { setIndent } from "@platejs/indent";
+
+//#region src/lib/types.ts
+const ListStyleType = {
+	ArabicIndic: "arabic-indic",
+	Armenian: "armenian",
+	Bengali: "bengali",
+	Cambodian: "cambodian",
+	Circle: "circle",
+	CjkDecimal: "cjk-decimal",
+	CjkEarthlyBranch: "cjk-earthly-branch",
+	CjkHeavenlyStem: "cjk-heavenly-stem",
+	Decimal: "decimal",
+	DecimalLeadingZero: "decimal-leading-zero",
+	Devanagari: "devanagari",
+	Disc: "disc",
+	DisclosureClosed: "disclosure-closed",
+	DisclosureOpen: "disclosure-open",
+	EthiopicNumeric: "ethiopic-numeric",
+	Georgian: "georgian",
+	Gujarati: "gujarati",
+	Gurmukhi: "gurmukhi",
+	Hebrew: "hebrew",
+	Hiragana: "hiragana",
+	HiraganaIroha: "hiragana-iroha",
+	Inherit: "inherit",
+	Initial: "initial",
+	JapaneseFormal: "japanese-formal",
+	JapaneseInformal: "japanese-informal",
+	Kannada: "kannada",
+	Katakana: "katakana",
+	KatakanaIroha: "katakana-iroha",
+	Khmer: "khmer",
+	KoreanHangulFormal: "korean-hangul-formal",
+	KoreanHanjaFormal: "korean-hanja-formal",
+	KoreanHanjaInformal: "korean-hanja-informal",
+	Lao: "lao",
+	LowerAlpha: "lower-alpha",
+	LowerArmenian: "lower-armenian",
+	LowerGreek: "lower-greek",
+	LowerLatin: "lower-latin",
+	LowerRoman: "lower-roman",
+	Malayalam: "malayalam",
+	Mongolian: "mongolian",
+	Myanmar: "myanmar",
+	None: "none",
+	Oriya: "oriya",
+	Persian: "persian",
+	SimpChineseFormal: "simp-chinese-formal",
+	SimpChineseInformal: "simp-chinese-informal",
+	Square: "square",
+	Tamil: "tamil",
+	Telugu: "telugu",
+	Thai: "thai",
+	Tibetan: "tibetan",
+	TradChineseFormal: "trad-chinese-formal",
+	TradChineseInformal: "trad-chinese-informal",
+	UpperAlpha: "upper-alpha",
+	UpperArmenian: "upper-armenian",
+	UpperLatin: "upper-latin",
+	UpperRoman: "upper-roman"
+};
+const ULIST_STYLE_TYPES = [
+	ListStyleType.Disc,
+	ListStyleType.Circle,
+	ListStyleType.Square,
+	ListStyleType.DisclosureOpen,
+	ListStyleType.DisclosureClosed
+];
+
+//#endregion
+//#region src/lib/queries/areEqListStyleType.ts
+const areEqListStyleType = (_editor, entries, { listStyleType = ListStyleType.Disc }) => {
+	let eqListStyleType = true;
+	for (const entry of entries) {
+		const [block] = entry;
+		if (listStyleType === KEYS.listTodo) {
+			if (!Object.hasOwn(block, KEYS.listChecked)) {
+				eqListStyleType = false;
+				break;
+			}
+			continue;
+		}
+		if (!block[KEYS.listType] || block[KEYS.listType] !== listStyleType) {
+			eqListStyleType = false;
+			break;
+		}
+	}
+	return eqListStyleType;
+};
+
+//#endregion
+//#region src/lib/queries/getListChildren.ts
+/**
+* Get all list items that are children of the current list item (have bigger
+* indent). Stops when encountering an item with equal or lower indent.
+*/
+const getListChildren = (editor, entry) => {
+	const children = [];
+	const [node, path] = entry;
+	const parentIndent = node[KEYS.indent];
+	if (!isDefined(parentIndent) || !isDefined(node[KEYS.listType])) return children;
+	let currentPath = path;
+	while (true) {
+		const nextPath = PathApi.next(currentPath);
+		if (!nextPath) break;
+		const nextNode = NodeApi.get(editor, nextPath);
+		if (!nextNode) break;
+		const nextIndent = nextNode[KEYS.indent];
+		if (!isDefined(nextIndent) || !isDefined(nextNode[KEYS.listType])) break;
+		if (nextIndent <= parentIndent) break;
+		children.push([nextNode, nextPath]);
+		currentPath = nextPath;
+	}
+	return children;
+};
+
+//#endregion
+//#region src/lib/queries/expandListItemsWithChildren.ts
+/**
+* Expands a list of blocks to include list item children. For each list item in
+* the input, adds all its children (items with bigger indent). Non-list blocks
+* are kept as-is. Requires id to be set on the blocks.
+*
+* @returns Array of block entries with list items expanded to include their
+*   children
+*/
+const expandListItemsWithChildren = (editor, entries) => {
+	const expandedEntries = [];
+	const processedIds = /* @__PURE__ */ new Set();
+	entries.forEach((entry) => {
+		const [node] = entry;
+		if (processedIds.has(node.id)) return;
+		expandedEntries.push(entry);
+		processedIds.add(node.id);
+		if (isDefined(node[KEYS.listType]) && isDefined(node[KEYS.indent])) getListChildren(editor, entry).forEach((childEntry) => {
+			if (!processedIds.has(childEntry[0].id)) {
+				expandedEntries.push(childEntry);
+				processedIds.add(childEntry[0].id);
+			}
+		});
+	});
+	return expandedEntries;
+};
+
+//#endregion
+//#region src/lib/queries/getListAbove.ts
+const getListAbove = (editor, options) => editor.api.above({
+	...options,
+	match: (node) => isDefined(node[KEYS.listType])
+});
+
+//#endregion
+//#region src/lib/queries/getSiblingList.ts
+/**
+* Get the next sibling indent list node. Default query: the sibling node should
+* have the same listStyleType.
+*/
+const getSiblingList = (_editor, [node, path], { breakOnEqIndentNeqListStyleType = true, breakOnListRestart = false, breakOnLowerIndent = true, breakQuery, eqIndent = true, getNextEntry, getPreviousEntry, query }) => {
+	if (!getPreviousEntry && !getNextEntry) return;
+	const getSiblingEntry = getNextEntry ?? getPreviousEntry;
+	let nextEntry = getSiblingEntry([node, path]);
+	while (true) {
+		if (!nextEntry) return;
+		const [nextNode, nextPath] = nextEntry;
+		const indent = node[KEYS.indent];
+		const nextIndent = nextNode[KEYS.indent];
+		if (breakQuery?.(nextNode, node)) return;
+		if (!isDefined(nextIndent)) return;
+		if (breakOnListRestart) {
+			if (getPreviousEntry && node[KEYS.listRestart]) return;
+			if (getNextEntry && nextNode[KEYS.listRestart]) return;
+		}
+		if (breakOnLowerIndent && nextIndent < indent) return;
+		if (breakOnEqIndentNeqListStyleType && nextIndent === indent && nextNode[KEYS.listType] !== node[KEYS.listType]) return;
+		let valid = !query || query(nextNode, node);
+		if (valid) {
+			valid = !eqIndent || nextIndent === indent;
+			if (valid) return [nextNode, nextPath];
+		}
+		nextEntry = getSiblingEntry(nextEntry);
+	}
+};
+
+//#endregion
+//#region src/lib/queries/getNextList.ts
+/** Get the next indent list. */
+const getNextList = (editor, entry, options) => getSiblingList(editor, entry, {
+	getNextEntry: ([, currPath]) => {
+		const nextPath = PathApi.next(currPath);
+		const nextNode = NodeApi.get(editor, nextPath);
+		if (!nextNode) return;
+		return [nextNode, nextPath];
+	},
+	...options,
+	getPreviousEntry: void 0
+});
+
+//#endregion
+//#region src/lib/queries/getPreviousList.ts
+/** Get the previous indent list node. */
+const getPreviousList = (editor, entry, options) => getSiblingList(editor, entry, {
+	getPreviousEntry: ([, currPath]) => {
+		const prevPath = PathApi.previous(currPath);
+		if (!prevPath) return;
+		const prevNode = NodeApi.get(editor, prevPath);
+		if (!prevNode) return;
+		return [prevNode, prevPath];
+	},
+	...options,
+	getNextEntry: void 0
+});
+
+//#endregion
+//#region src/lib/queries/getListSiblings.ts
+const getListSiblings = (editor, entry, { current = true, next = true, previous = true, ...options } = {}) => {
+	const siblings = [];
+	const node = entry[0];
+	if (!node[KEYS.listType] && !Object.hasOwn(node, KEYS.listChecked)) return siblings;
+	let iterEntry = entry;
+	if (previous) while (true) {
+		const prevEntry = getPreviousList(editor, iterEntry, options);
+		if (!prevEntry) break;
+		siblings.push(prevEntry);
+		iterEntry = prevEntry;
+	}
+	if (current) siblings.push(entry);
+	if (next) {
+		iterEntry = entry;
+		while (true) {
+			const nextEntry = getNextList(editor, iterEntry, options);
+			if (!nextEntry) break;
+			siblings.push(nextEntry);
+			iterEntry = nextEntry;
+		}
+	}
+	return siblings;
+};
+
+//#endregion
+//#region src/lib/queries/getSiblingListStyleType.ts
+/**
+* Get the first sibling list style type at the given indent. If none, return
+* the entry list style type.
+*/
+const getSiblingListStyleType = (editor, { entry, indent, ...options }) => {
+	const siblings = getListSiblings(editor, [{
+		...entry[0],
+		indent
+	}, entry[1]], {
+		breakOnEqIndentNeqListStyleType: false,
+		current: false,
+		eqIndent: true,
+		...options
+	});
+	return siblings.length > 0 ? siblings[0][0][KEYS.listType] : entry[0][KEYS.listType];
+};
+
+//#endregion
+//#region src/lib/queries/isOrderedList.ts
+function isOrderedList(element) {
+	return !!element.listStyleType && !ULIST_STYLE_TYPES.includes(element.listStyleType);
+}
+
+//#endregion
+//#region src/lib/queries/someList.ts
+const someList = (editor, type) => !!editor.selection && editor.api.some({ match: (n) => {
+	if (Object.hasOwn(n, KEYS.listChecked)) return false;
+	const list = n[KEYS.listType];
+	return Array.isArray(type) ? type.includes(list) : list === type;
+} });
+
+//#endregion
+//#region src/lib/queries/someTodoList.ts
+const someTodoList = (editor) => editor.api.some({
+	at: editor.selection,
+	match: (n) => {
+		const list = n[KEYS.listType];
+		const isHasProperty = Object.hasOwn(n, KEYS.listChecked);
+		return n.type === "p" && isHasProperty && list === KEYS.listTodo;
+	}
+});
+
+//#endregion
+//#region src/lib/normalizers/normalizeListNotIndented.ts
+/** Unset listStyle, listStart if KEYS.indent is not defined. */
+const normalizeListNotIndented = (editor, [node, path]) => {
+	if (!isDefined(node[KEYS.indent]) && (node[KEYS.listType] || node[KEYS.listStart])) {
+		editor.tf.unsetNodes([KEYS.listType, KEYS.listStart], { at: path });
+		return true;
+	}
+};
+
+//#endregion
+//#region src/lib/normalizers/normalizeListStart.ts
+const getListExpectedListStart = (entry, prevEntry) => {
+	const [node] = entry;
+	const [prevNode] = prevEntry ?? [null];
+	const restart = node[KEYS.listRestart] ?? null;
+	const restartPolite = node[KEYS.listRestartPolite] ?? null;
+	if (restart) return restart;
+	if (restartPolite && !prevNode) return restartPolite;
+	if (prevNode) return (prevNode[KEYS.listStart] ?? 1) + 1;
+	return 1;
+};
+const normalizeListStart = (editor, entry, options) => editor.tf.withoutNormalizing(() => {
+	const [node, path] = entry;
+	const listStyleType = node[KEYS.listType];
+	const listStart = node[KEYS.listStart];
+	if (!listStyleType) return;
+	const expectedListStart = getListExpectedListStart(entry, getPreviousList(editor, entry, options));
+	if (isDefined(listStart) && expectedListStart === 1) {
+		editor.tf.unsetNodes(KEYS.listStart, { at: path });
+		return true;
+	}
+	if (listStart !== expectedListStart && expectedListStart > 1) {
+		editor.tf.setNodes({ [KEYS.listStart]: expectedListStart }, { at: path });
+		return true;
+	}
+	return false;
+});
+
+//#endregion
+//#region src/lib/normalizers/withInsertBreakList.ts
+const withInsertBreakList = ({ editor, tf: { insertBreak } }) => ({ transforms: { insertBreak() {
+	const nodeEntry = editor.api.above();
+	if (!nodeEntry) return insertBreak();
+	const [node, path] = nodeEntry;
+	if (!isDefined(node[KEYS.listType]) || node[KEYS.listType] !== KEYS.listTodo || editor.api.isExpanded() || !editor.api.isEnd(editor.selection?.focus, path)) return insertBreak();
+	editor.tf.withoutNormalizing(() => {
+		insertBreak();
+		const newEntry = editor.api.above();
+		if (newEntry) editor.tf.setNodes({ checked: false }, { at: newEntry[1] });
+	});
+} } });
+
+//#endregion
+//#region src/lib/transforms/indentList.ts
+/** Increase the indentation of the selected blocks. */
+const indentList = (editor, { listStyleType = ListStyleType.Disc, ...options } = {}) => {
+	setIndent(editor, {
+		offset: 1,
+		setNodesProps: () => ({ [KEYS.listType]: listStyleType }),
+		...options
+	});
+};
+const indentTodo = (editor, { listStyleType = ListStyleType.Disc, ...options } = {}) => {
+	setIndent(editor, {
+		offset: 1,
+		setNodesProps: () => ({
+			[KEYS.listChecked]: false,
+			[KEYS.listType]: listStyleType
+		}),
+		...options
+	});
+};
+
+//#endregion
+//#region src/lib/transforms/outdentList.ts
+/** Decrease the indentation of the selected blocks. */
+const outdentList = (editor, options = {}) => {
+	setIndent(editor, {
+		offset: -1,
+		unsetNodesProps: [KEYS.listType, KEYS.listChecked],
+		...options
+	});
+};
+
+//#endregion
+//#region src/lib/transforms/setListNode.ts
+const setListNode = (editor, { at, indent = 0, listStyleType = ListStyleType.Disc }) => {
+	const newIndent = indent || indent + 1;
+	editor.tf.setNodes({
+		[KEYS.indent]: newIndent,
+		[KEYS.listType]: listStyleType
+	}, { at });
+};
+const setIndentTodoNode = (editor, { at, indent = 0, listStyleType = KEYS.listTodo }) => {
+	const newIndent = indent || indent + 1;
+	editor.tf.setNodes({
+		[KEYS.indent]: newIndent,
+		[KEYS.listChecked]: false,
+		[KEYS.listType]: listStyleType
+	}, { at });
+};
+
+//#endregion
+//#region src/lib/transforms/setListNodes.ts
+/**
+* Set indent list to the given entries. Add indent if listStyleType was not
+* defined.
+*/
+const setListNodes = (editor, entries, { listStyleType = ListStyleType.Disc }) => {
+	editor.tf.withoutNormalizing(() => {
+		entries.forEach((entry) => {
+			const [node, path] = entry;
+			let indent = node[KEYS.indent] ?? 0;
+			indent = node[KEYS.listType] || Object.hasOwn(node, KEYS.listChecked) ? indent : indent + 1;
+			if (listStyleType === "todo") {
+				editor.tf.unsetNodes(KEYS.listType, { at: path });
+				setIndentTodoNode(editor, {
+					at: path,
+					indent,
+					listStyleType
+				});
+				return;
+			}
+			editor.tf.unsetNodes(KEYS.listChecked, { at: path });
+			setListNode(editor, {
+				at: path,
+				indent,
+				listStyleType
+			});
+		});
+	});
+};
+
+//#endregion
+//#region src/lib/transforms/setListSiblingNodes.ts
+/** Set indent list to entry + siblings. */
+const setListSiblingNodes = (editor, entry, { getSiblingListOptions, listStyleType = ListStyleType.Disc }) => {
+	editor.tf.withoutNormalizing(() => {
+		getListSiblings(editor, entry, getSiblingListOptions).forEach(([node, path]) => {
+			if (listStyleType === KEYS.listTodo) {
+				editor.tf.unsetNodes(KEYS.listType, { at: path });
+				setIndentTodoNode(editor, {
+					at: path,
+					indent: node[KEYS.indent],
+					listStyleType
+				});
+			} else {
+				editor.tf.unsetNodes(KEYS.listChecked, { at: path });
+				setListNode(editor, {
+					at: path,
+					indent: node[KEYS.indent],
+					listStyleType
+				});
+			}
+		});
+	});
+};
+
+//#endregion
+//#region src/lib/transforms/toggleListSet.ts
+/** Set indent list if not set. */
+const toggleListSet = (editor, [node, _path], { listStyleType = ListStyleType.Disc, ...options }) => {
+	if (Object.hasOwn(node, KEYS.listChecked) || node[KEYS.listType]) return;
+	if (listStyleType === "todo") indentTodo(editor, {
+		listStyleType,
+		...options
+	});
+	else indentList(editor, {
+		listStyleType,
+		...options
+	});
+	return true;
+};
+
+//#endregion
+//#region src/lib/transforms/toggleListUnset.ts
+/** Unset list style type if already set. */
+const toggleListUnset = (editor, [node, path], { listStyleType = ListStyleType.Disc }) => {
+	if (listStyleType === KEYS.listTodo && Object.hasOwn(node, KEYS.listChecked)) {
+		editor.tf.unsetNodes(KEYS.listChecked, { at: path });
+		outdentList(editor, { listStyleType });
+		return true;
+	}
+	if (listStyleType === node[KEYS.listType]) {
+		editor.tf.unsetNodes([KEYS.listType], { at: path });
+		outdentList(editor, { listStyleType });
+		return true;
+	}
+};
+
+//#endregion
+//#region src/lib/transforms/toggleList.ts
+/** Toggle indent list. */
+const toggleList = (editor, options, getSiblingListOptions) => {
+	const { listRestart, listRestartPolite, listStyleType } = options;
+	/**
+	* True - One or more blocks were converted to lists or changed such that they
+	* remain lists.
+	*
+	* False - One or more list blocks were unset.
+	*
+	* Null - No action was taken.
+	*/
+	const setList = (() => {
+		const { getSiblingListOptions: _getSiblingListOptions } = editor.getOptions(BaseListPlugin);
+		if (editor.api.isCollapsed()) {
+			const entry = editor.api.block();
+			if (!entry) return null;
+			if (toggleListSet(editor, entry, options)) return true;
+			if (toggleListUnset(editor, entry, { listStyleType })) return false;
+			setListSiblingNodes(editor, entry, {
+				getSiblingListOptions: {
+					..._getSiblingListOptions,
+					...getSiblingListOptions
+				},
+				listStyleType
+			});
+			return true;
+		}
+		if (editor.api.isExpanded()) {
+			const match = getInjectMatch(editor, editor.getPlugin({ key: KEYS.list }));
+			const entries = [...editor.api.nodes({
+				block: true,
+				match
+			})];
+			if (areEqListStyleType(editor, entries, { listStyleType })) {
+				editor.tf.withoutNormalizing(() => {
+					entries.forEach((entry) => {
+						const [node, path] = entry;
+						const indent = node[KEYS.indent];
+						editor.tf.unsetNodes(KEYS.listType, { at: path });
+						if (indent > 1) editor.tf.setNodes({ [KEYS.indent]: indent - 1 }, { at: path });
+						else editor.tf.unsetNodes([KEYS.indent, KEYS.listChecked], { at: path });
+					});
+				});
+				return false;
+			}
+			setListNodes(editor, entries, { listStyleType });
+			return true;
+		}
+		return null;
+	})();
+	const restartValue = listRestart || listRestartPolite;
+	const isRestart = !!listRestart;
+	if (setList && restartValue) {
+		const entry = getListAbove(editor, { at: editor.api.start(editor.selection) });
+		if (!entry) return;
+		const isFirst = !getPreviousList(editor, entry);
+		/**
+		* Only apply listRestartPolite if this is the first item and restartValue >
+		* 1.
+		*/
+		if (!isRestart && (!isFirst || restartValue <= 0)) return;
+		if (isRestart && restartValue === 1 && isFirst) return;
+		const prop = isRestart ? KEYS.listRestart : KEYS.listRestartPolite;
+		editor.tf.setNodes({ [prop]: restartValue }, { at: entry[1] });
+	}
+};
+
+//#endregion
+//#region src/lib/transforms/toggleListByPath.ts
+const toggleListByPath = (editor, [node, path], listStyleType) => {
+	editor.tf.setNodes({
+		[KEYS.indent]: node.indent ?? 1,
+		[KEYS.listChecked]: false,
+		[KEYS.listType]: listStyleType,
+		type: KEYS.p
+	}, { at: path });
+};
+const toggleListByPathUnSet = (editor, [, path]) => editor.tf.unsetNodes([
+	KEYS.listType,
+	KEYS.indent,
+	KEYS.listChecked
+], { at: path });
+
+//#endregion
+//#region src/lib/withNormalizeList.ts
+const withNormalizeList = ({ editor, getOptions, tf: { normalizeNode } }) => ({ transforms: { normalizeNode([node, path]) {
+	if (editor.tf.withoutNormalizing(() => {
+		if (normalizeListNotIndented(editor, [node, path])) return true;
+		if (normalizeListStart(editor, [node, path], getOptions().getSiblingListOptions)) return true;
+	})) return;
+	return normalizeNode([node, path]);
+} } });
+
+//#endregion
+//#region src/lib/withList.ts
+const withList = (ctx) => {
+	const { editor, getOptions, tf: { apply, resetBlock } } = ctx;
+	return { transforms: {
+		resetBlock(options) {
+			if (editor.api.block(options)?.[0]?.[KEYS.listType]) {
+				outdentList(editor);
+				return;
+			}
+			return resetBlock(options);
+		},
+		...withNormalizeList(ctx).transforms,
+		...withInsertBreakList(ctx).transforms,
+		apply(operation) {
+			const { getSiblingListOptions } = getOptions();
+			/**
+			* If there is a previous indent list, the inserted indent list style
+			* type should be the same. Only for lower-roman and upper-roman as it
+			* overlaps with lower-alpha and upper-alpha.
+			*/
+			if (operation.type === "insert_node") {
+				const listStyleType = operation.node[KEYS.listType];
+				if (listStyleType && ["lower-roman", "upper-roman"].includes(listStyleType)) {
+					const prevNodeEntry = getPreviousList(editor, [operation.node, operation.path], {
+						breakOnEqIndentNeqListStyleType: false,
+						eqIndent: false,
+						...getSiblingListOptions
+					});
+					if (prevNodeEntry) {
+						const prevListStyleType = prevNodeEntry[0][KEYS.listType];
+						if (prevListStyleType === ListStyleType.LowerAlpha && listStyleType === ListStyleType.LowerRoman) operation.node[KEYS.listType] = ListStyleType.LowerAlpha;
+						else if (prevListStyleType === ListStyleType.UpperAlpha && listStyleType === ListStyleType.UpperRoman) operation.node[KEYS.listType] = ListStyleType.UpperAlpha;
+					}
+				}
+			}
+			/**
+			* When inserting a line break, remove listRestart and listRestartPolite
+			* from the new list item.
+			*/
+			if (operation.type === "split_node" && operation.properties[KEYS.listType]) {
+				delete operation.properties[KEYS.listRestart];
+				delete operation.properties[KEYS.listRestartPolite];
+			}
+			apply(operation);
+			const affectedPaths = [];
+			switch (operation.type) {
+				case "insert_node":
+				case "remove_node":
+				case "set_node":
+					affectedPaths.push(operation.path);
+					break;
+				case "merge_node":
+					affectedPaths.push(PathApi.previous(operation.path));
+					break;
+				case "move_node":
+					affectedPaths.push(operation.path, operation.newPath);
+					break;
+				case "split_node":
+					affectedPaths.push(operation.path, PathApi.next(operation.path));
+					break;
+			}
+			const isListItem = (node) => KEYS.listType in node;
+			affectedPaths.forEach((affectedPath) => {
+				let entry = editor.api.node(affectedPath);
+				if (!entry) return;
+				/**
+				* Even if the affected node isn't a list item, the subsequent node
+				* might be, in which case we want to normalize that node instead.
+				*/
+				if (!isListItem(entry[0])) entry = editor.api.node(PathApi.next(affectedPath));
+				while (entry && isListItem(entry[0])) {
+					/**
+					* Break early since the subsequent list items will already have
+					* been normalized by the `apply` that modified the current node.
+					*/
+					if (normalizeListStart(editor, entry, getSiblingListOptions)) break;
+					entry = getNextList(editor, entry, {
+						...getSiblingListOptions,
+						breakOnEqIndentNeqListStyleType: false,
+						breakOnLowerIndent: false,
+						eqIndent: false
+					});
+				}
+			});
+		}
+	} };
+};
+
+//#endregion
+//#region src/lib/BaseListPlugin.tsx
+const BaseListPlugin = createTSlatePlugin({
+	key: KEYS.list,
+	inject: {
+		plugins: { [KEYS.html]: { parser: { transformData: ({ data }) => {
+			const { body } = new DOMParser().parseFromString(data, "text/html");
+			const lisWithNestedLists = [];
+			traverseHtmlElements(body, (element) => {
+				if (element.tagName === "LI") {
+					const nestedLists = [];
+					Array.from(element.children).forEach((child) => {
+						if (child.tagName === "UL" || child.tagName === "OL") nestedLists.push(child);
+					});
+					if (nestedLists.length > 0) lisWithNestedLists.push({
+						li: element,
+						nestedLists
+					});
+				}
+				return true;
+			});
+			lisWithNestedLists.forEach(({ li, nestedLists }) => {
+				nestedLists.forEach((nestedList) => {
+					nestedList.remove();
+					if (li.parentNode) li.parentNode.insertBefore(nestedList, li.nextSibling);
+				});
+			});
+			traverseHtmlElements(body, (element) => {
+				if (element.tagName === "LI") {
+					const htmlElement = element;
+					const { childNodes } = element;
+					const liChildren = [];
+					childNodes.forEach((child) => {
+						if (child.nodeType === Node.ELEMENT_NODE) {
+							const childElement = child;
+							if (isHtmlBlockElement(childElement)) {
+								liChildren.push(...childElement.childNodes);
+								return;
+							}
+						}
+						liChildren.push(child);
+					});
+					element.replaceChildren(...liChildren);
+					const ariaLevel = element.getAttribute("aria-level");
+					if (ariaLevel) htmlElement.dataset.indent = ariaLevel;
+					else {
+						let indent = 0;
+						let parent = element.parentElement;
+						while (parent && parent !== body) {
+							if (parent.tagName === "UL" || parent.tagName === "OL") indent++;
+							parent = parent.parentElement;
+						}
+						if (indent > 0) htmlElement.dataset.indent = String(indent);
+					}
+					const listStyleType = htmlElement.style.listStyleType;
+					if (listStyleType) htmlElement.dataset.listStyleType = listStyleType;
+					else {
+						const listParent = element.closest("ul, ol");
+						if (listParent) {
+							const parentListStyleType = listParent.style.listStyleType;
+							if (parentListStyleType) htmlElement.dataset.listStyleType = parentListStyleType;
+							else if (listParent.tagName === "UL") htmlElement.dataset.listStyleType = "disc";
+							else if (listParent.tagName === "OL") htmlElement.dataset.listStyleType = "decimal";
+						}
+					}
+					return false;
+				}
+				return true;
+			});
+			return postCleanHtml(body.innerHTML);
+		} } } },
+		targetPlugins: [KEYS.p]
+	},
+	options: { getListStyleType: (element) => element.style.listStyleType },
+	parsers: { html: { deserializer: {
+		isElement: true,
+		rules: [{ validNodeName: "LI" }],
+		parse: ({ editor, element, getOptions }) => {
+			const dataIndent = element.dataset.indent;
+			const ariaLevel = element.getAttribute("aria-level");
+			const indent = dataIndent ? Number(dataIndent) : Number(ariaLevel);
+			const listStyleType = element.dataset.listStyleType || getOptions().getListStyleType?.(element);
+			return {
+				indent: indent || void 0,
+				listStyleType: listStyleType || void 0,
+				type: editor.getType(KEYS.p)
+			};
+		}
+	} } },
+	render: { belowNodes: (props) => {
+		if (!props.element.listStyleType) return;
+		return (props$1) => /* @__PURE__ */ React.createElement(List, props$1);
+	} },
+	rules: {
+		break: {
+			empty: "reset",
+			splitReset: false
+		},
+		delete: { start: "reset" },
+		merge: { removeEmpty: false },
+		match: ({ node }) => isDefined(node[KEYS.listType])
+	}
+}).overrideEditor(withList);
+function List(props) {
+	const $ = c(9);
+	const { listStart, listStyleType } = props.element;
+	const List$1 = isOrderedList(props.element) ? "ol" : "ul";
+	let t0;
+	if ($[0] !== listStyleType) {
+		t0 = {
+			listStyleType,
+			margin: 0,
+			padding: 0,
+			position: "relative"
+		};
+		$[0] = listStyleType;
+		$[1] = t0;
+	} else t0 = $[1];
+	let t1;
+	if ($[2] !== props.children) {
+		t1 = /* @__PURE__ */ React.createElement("li", null, props.children);
+		$[2] = props.children;
+		$[3] = t1;
+	} else t1 = $[3];
+	let t2;
+	if ($[4] !== List$1 || $[5] !== listStart || $[6] !== t0 || $[7] !== t1) {
+		t2 = /* @__PURE__ */ React.createElement(List$1, {
+			style: t0,
+			start: listStart
+		}, t1);
+		$[4] = List$1;
+		$[5] = listStart;
+		$[6] = t0;
+		$[7] = t1;
+		$[8] = t2;
+	} else t2 = $[8];
+	return t2;
+}
+
+//#endregion
+export { getListChildren as A, getSiblingListStyleType as C, getSiblingList as D, getNextList as E, ListStyleType as M, ULIST_STYLE_TYPES as N, getListAbove as O, isOrderedList as S, getPreviousList as T, getListExpectedListStart as _, toggleListByPathUnSet as a, someTodoList as b, toggleListSet as c, setIndentTodoNode as d, setListNode as f, withInsertBreakList as g, indentTodo as h, toggleListByPath as i, areEqListStyleType as j, expandListItemsWithChildren as k, setListSiblingNodes as l, indentList as m, withList as n, toggleList as o, outdentList as p, withNormalizeList as r, toggleListUnset as s, BaseListPlugin as t, setListNodes as u, normalizeListStart as v, getListSiblings as w, someList as x, normalizeListNotIndented as y };
+//# sourceMappingURL=src-Dvsp2AeZ.js.map