mmintel/e-tib.com
1
0
Fork 0
Code Issues Pull Requests 2 Actions 150 Packages Projects Releases Wiki Activity
Files
b13f628b5506a5902bdfb96fe8fe69ced4214a03
e-tib.com/.next/dev/server/vendor-chunks/@lexical+list@0.41.0.js
Marc Mintel d14122005d Initial commit: E-TIB production hardening & E2E foundation 
Former-commit-id: ef04fca3d76375630c05aac117bf586953f3b657
2026-04-28 19:11:38 +02:00

25 lines
167 KiB
JavaScript
Raw Blame History

"use strict";
/*
* ATTENTION: An "eval-source-map" devtool has been used.
* This devtool is neither made for production nor for readable output files.
* It uses "eval()" calls to create a separate source file with attached SourceMaps in the browser devtools.
* If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
* or disable the default devtool with "devtool: false".
* If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
*/
exports.id = "vendor-chunks/@lexical+list@0.41.0";
exports.ids = ["vendor-chunks/@lexical+list@0.41.0"];
exports.modules = {
/***/ "(rsc)/./node_modules/.pnpm/@lexical+list@0.41.0/node_modules/@lexical/list/LexicalList.dev.mjs":
/*!************************************************************************************************!*\
!*** ./node_modules/.pnpm/@lexical+list@0.41.0/node_modules/@lexical/list/LexicalList.dev.mjs ***!
\************************************************************************************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */ $createListItemNode: () => (/* binding */ $createListItemNode),\n/* harmony export */ $createListNode: () => (/* binding */ $createListNode),\n/* harmony export */ $getListDepth: () => (/* binding */ $getListDepth),\n/* harmony export */ $handleListInsertParagraph: () => (/* binding */ $handleListInsertParagraph),\n/* harmony export */ $insertList: () => (/* binding */ $insertList),\n/* harmony export */ $isListItemNode: () => (/* binding */ $isListItemNode),\n/* harmony export */ $isListNode: () => (/* binding */ $isListNode),\n/* harmony export */ $removeList: () => (/* binding */ $removeList),\n/* harmony export */ CheckListExtension: () => (/* binding */ CheckListExtension),\n/* harmony export */ INSERT_CHECK_LIST_COMMAND: () => (/* binding */ INSERT_CHECK_LIST_COMMAND),\n/* harmony export */ INSERT_ORDERED_LIST_COMMAND: () => (/* binding */ INSERT_ORDERED_LIST_COMMAND),\n/* harmony export */ INSERT_UNORDERED_LIST_COMMAND: () => (/* binding */ INSERT_UNORDERED_LIST_COMMAND),\n/* harmony export */ ListExtension: () => (/* binding */ ListExtension),\n/* harmony export */ ListItemNode: () => (/* binding */ ListItemNode),\n/* harmony export */ ListNode: () => (/* binding */ ListNode),\n/* harmony export */ REMOVE_LIST_COMMAND: () => (/* binding */ REMOVE_LIST_COMMAND),\n/* harmony export */ UPDATE_LIST_START_COMMAND: () => (/* binding */ UPDATE_LIST_START_COMMAND),\n/* harmony export */ insertList: () => (/* binding */ insertList),\n/* harmony export */ registerCheckList: () => (/* binding */ registerCheckList),\n/* harmony export */ registerList: () => (/* binding */ registerList),\n/* harmony export */ registerListStrictIndentTransform: () => (/* binding */ registerListStrictIndentTransform),\n/* harmony export */ removeList: () => (/* binding */ removeList)\n/* harmony export */ });\n/* harmony import */ var _lexical_extension__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @lexical/extension */ \"(rsc)/./node_modules/.pnpm/@lexical+extension@0.41.0/node_modules/@lexical/extension/LexicalExtension.dev.mjs\");\n/* harmony import */ var _lexical_utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @lexical/utils */ \"(rsc)/./node_modules/.pnpm/@lexical+utils@0.41.0/node_modules/@lexical/utils/LexicalUtils.dev.mjs\");\n/* harmony import */ var lexical__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! lexical */ \"(rsc)/./node_modules/.pnpm/lexical@0.41.0/node_modules/lexical/Lexical.dev.mjs\");\n/* harmony import */ var _lexical_selection__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @lexical/selection */ \"(rsc)/./node_modules/.pnpm/@lexical+selection@0.41.0/node_modules/@lexical/selection/LexicalSelection.dev.mjs\");\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n\n\n\n\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n// Do not require this module directly! Use normal `invariant` calls.\n\nfunction formatDevErrorMessage(message) {\n throw new Error(message);\n}\n\n/**\n * Checks the depth of listNode from the root node.\n * @param listNode - The ListNode to be checked.\n * @returns The depth of the ListNode.\n */\nfunction $getListDepth(listNode) {\n let depth = 1;\n let parent = listNode.getParent();\n while (parent != null) {\n if ($isListItemNode(parent)) {\n const parentList = parent.getParent();\n if ($isListNode(parentList)) {\n depth++;\n parent = parentList.getParent();\n continue;\n }\n {\n formatDevErrorMessage(`A ListItemNode must have a ListNode for a parent.`);\n }\n }\n return depth;\n }\n return depth;\n}\n\n/**\n * Finds the nearest ancestral ListNode and returns it, throws an invariant if listItem is not a ListItemNode.\n * @param listItem - The node to be checked.\n * @returns The ListNode found.\n */\nfunction $getTopListNode(listItem) {\n let list = listItem.getParent();\n if (!$isListNode(list)) {\n {\n formatDevErrorMessage(`A ListItemNode must have a ListNode for a parent.`);\n }\n }\n let parent = list;\n while (parent !== null) {\n parent = parent.getParent();\n if ($isListNode(parent)) {\n list = parent;\n }\n }\n return list;\n}\n\n/**\n * A recursive Depth-First Search (Postorder Traversal) that finds all of a node's children\n * that are of type ListItemNode and returns them in an array.\n * @param node - The ListNode to start the search.\n * @returns An array containing all nodes of type ListItemNode found.\n */\n// This should probably be $getAllChildrenOfType\nfunction $getAllListItems(node) {\n let listItemNodes = [];\n const listChildren = node.getChildren().filter($isListItemNode);\n for (let i = 0; i < listChildren.length; i++) {\n const listItemNode = listChildren[i];\n const firstChild = listItemNode.getFirstChild();\n if ($isListNode(firstChild)) {\n listItemNodes = listItemNodes.concat($getAllListItems(firstChild));\n } else {\n listItemNodes.push(listItemNode);\n }\n }\n return listItemNodes;\n}\n\n/**\n * Checks to see if the passed node is a ListItemNode and has a ListNode as a child.\n * @param node - The node to be checked.\n * @returns true if the node is a ListItemNode and has a ListNode child, false otherwise.\n */\nfunction isNestedListNode(node) {\n return $isListItemNode(node) && $isListNode(node.getFirstChild());\n}\n\n/**\n * Takes a deeply nested ListNode or ListItemNode and traverses up the branch to delete the first\n * ancestral ListNode (which could be the root ListNode) or ListItemNode with siblings, essentially\n * bringing the deeply nested node up the branch once. Would remove sublist if it has siblings.\n * Should not break ListItem -> List -> ListItem chain as empty List/ItemNodes should be removed on .remove().\n * @param sublist - The nested ListNode or ListItemNode to be brought up the branch.\n */\nfunction $removeHighestEmptyListParent(sublist) {\n // Nodes may be repeatedly indented, to create deeply nested lists that each\n // contain just one bullet.\n // Our goal is to remove these (empty) deeply nested lists. The easiest\n // way to do that is crawl back up the tree until we find a node that has siblings\n // (e.g. is actually part of the list contents) and delete that, or delete\n // the root of the list (if no list nodes have siblings.)\n let emptyListPtr = sublist;\n while (emptyListPtr.getNextSibling() == null && emptyListPtr.getPreviousSibling() == null) {\n const parent = emptyListPtr.getParent();\n if (parent == null || !($isListItemNode(parent) || $isListNode(parent))) {\n break;\n }\n emptyListPtr = parent;\n }\n emptyListPtr.remove();\n}\n\n/**\n * Wraps a node into a ListItemNode.\n * @param node - The node to be wrapped into a ListItemNode\n * @returns The ListItemNode which the passed node is wrapped in.\n */\nfunction $wrapInListItem(node) {\n const listItemWrapper = $createListItemNode();\n return listItemWrapper.append(node);\n}\n\n/**\n * Calculates the start value for a new list created by splitting an existing list.\n */\nfunction $getNewListStart(list, listItem) {\n return list.getStart() + listItem.getIndexWithinParent();\n}\n\nfunction $isSelectingEmptyListItem(anchorNode, nodes) {\n return $isListItemNode(anchorNode) && (nodes.length === 0 || nodes.length === 1 && anchorNode.is(nodes[0]) && anchorNode.getChildrenSize() === 0);\n}\n\n/**\n * Inserts a new ListNode. If the selection's anchor node is an empty ListItemNode and is a child of\n * the root/shadow root, it will replace the ListItemNode with a ListNode and the old ListItemNode.\n * Otherwise it will replace its parent with a new ListNode and re-insert the ListItemNode and any previous children.\n * If the selection's anchor node is not an empty ListItemNode, it will add a new ListNode or merge an existing ListNode,\n * unless the the node is a leaf node, in which case it will attempt to find a ListNode up the branch and replace it with\n * a new ListNode, or create a new ListNode at the nearest root/shadow root.\n * @param listType - The type of list, \"number\" | \"bullet\" | \"check\".\n */\nfunction $insertList(listType) {\n const selection = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$getSelection)();\n if (selection !== null) {\n let nodes = selection.getNodes();\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isRangeSelection)(selection)) {\n const anchorAndFocus = selection.getStartEndPoints();\n if (!(anchorAndFocus !== null)) {\n formatDevErrorMessage(`insertList: anchor should be defined`);\n }\n const [anchor] = anchorAndFocus;\n const anchorNode = anchor.getNode();\n const anchorNodeParent = anchorNode.getParent();\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isRootOrShadowRoot)(anchorNode)) {\n const firstChild = anchorNode.getFirstChild();\n if (firstChild) {\n nodes = firstChild.selectStart().getNodes();\n } else {\n const paragraph = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$createParagraphNode)();\n anchorNode.append(paragraph);\n nodes = paragraph.select().getNodes();\n }\n } else if ($isSelectingEmptyListItem(anchorNode, nodes)) {\n const list = $createListNode(listType);\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isRootOrShadowRoot)(anchorNodeParent)) {\n anchorNode.replace(list);\n const listItem = $createListItemNode();\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isElementNode)(anchorNode)) {\n listItem.setFormat(anchorNode.getFormatType());\n listItem.setIndent(anchorNode.getIndent());\n }\n list.append(listItem);\n } else if ($isListItemNode(anchorNode)) {\n const parent = anchorNode.getParentOrThrow();\n append(list, parent.getChildren());\n parent.replace(list);\n }\n return;\n }\n }\n const handled = new Set();\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isElementNode)(node) && node.isEmpty() && !$isListItemNode(node) && !handled.has(node.getKey())) {\n $createListOrMerge(node, listType);\n continue;\n }\n let parent = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isLeafNode)(node) ? node.getParent() : $isListItemNode(node) && node.isEmpty() ? node : null;\n while (parent != null) {\n const parentKey = parent.getKey();\n if ($isListNode(parent)) {\n if (!handled.has(parentKey)) {\n const newListNode = $createListNode(listType);\n append(newListNode, parent.getChildren());\n parent.replace(newListNode);\n handled.add(parentKey);\n }\n break;\n } else {\n const nextParent = parent.getParent();\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isRootOrShadowRoot)(nextParent) && !handled.has(parentKey)) {\n handled.add(parentKey);\n $createListOrMerge(parent, listType);\n break;\n }\n parent = nextParent;\n }\n }\n }\n }\n}\nfunction append(node, nodesToAppend) {\n node.splice(node.getChildrenSize(), 0, nodesToAppend);\n}\nfunction $createListOrMerge(node, listType) {\n if ($isListNode(node)) {\n return node;\n }\n const previousSibling = node.getPreviousSibling();\n const nextSibling = node.getNextSibling();\n const listItem = $createListItemNode();\n append(listItem, node.getChildren());\n let targetList;\n if ($isListNode(previousSibling) && listType === previousSibling.getListType()) {\n previousSibling.append(listItem);\n // if the same type of list is on both sides, merge them.\n if ($isListNode(nextSibling) && listType === nextSibling.getListType()) {\n append(previousSibling, nextSibling.getChildren());\n nextSibling.remove();\n }\n targetList = previousSibling;\n } else if ($isListNode(nextSibling) && listType === nextSibling.getListType()) {\n nextSibling.getFirstChildOrThrow().insertBefore(listItem);\n targetList = nextSibling;\n } else {\n const list = $createListNode(listType);\n list.append(listItem);\n node.replace(list);\n targetList = list;\n }\n // listItem needs to be attached to root prior to setting indent\n listItem.setFormat(node.getFormatType());\n listItem.setIndent(node.getIndent());\n\n // Preserve element-anchored selections by updating them to anchor to the listItem instead of the listNode.\n const selection = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$getSelection)();\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isRangeSelection)(selection)) {\n if (targetList.getKey() === selection.anchor.key) {\n selection.anchor.set(listItem.getKey(), selection.anchor.offset, 'element');\n }\n if (targetList.getKey() === selection.focus.key) {\n selection.focus.set(listItem.getKey(), selection.focus.offset, 'element');\n }\n }\n node.remove();\n return targetList;\n}\n\n/**\n * A recursive function that goes through each list and their children, including nested lists,\n * appending list2 children after list1 children and updating ListItemNode values.\n * @param list1 - The first list to be merged.\n * @param list2 - The second list to be merged.\n */\nfunction mergeLists(list1, list2) {\n const listItem1 = list1.getLastChild();\n const listItem2 = list2.getFirstChild();\n if (listItem1 && listItem2 && isNestedListNode(listItem1) && isNestedListNode(listItem2)) {\n mergeLists(listItem1.getFirstChild(), listItem2.getFirstChild());\n listItem2.remove();\n }\n const toMerge = list2.getChildren();\n if (toMerge.length > 0) {\n list1.append(...toMerge);\n }\n list2.remove();\n}\n\n/**\n * Searches for the nearest ancestral ListNode and removes it. If selection is an empty ListItemNode\n * it will remove the whole list, including the ListItemNode. For each ListItemNode in the ListNode,\n * removeList will also generate new ParagraphNodes in the removed ListNode's place. Any child node\n * inside a ListItemNode will be appended to the new ParagraphNodes.\n */\nfunction $removeList() {\n const selection = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$getSelection)();\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isRangeSelection)(selection)) {\n const listNodes = new Set();\n const nodes = selection.getNodes();\n const anchorNode = selection.anchor.getNode();\n if ($isSelectingEmptyListItem(anchorNode, nodes)) {\n listNodes.add($getTopListNode(anchorNode));\n } else {\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isLeafNode)(node)) {\n const listItemNode = (0,_lexical_utils__WEBPACK_IMPORTED_MODULE_1__.$getNearestNodeOfType)(node, ListItemNode);\n if (listItemNode != null) {\n listNodes.add($getTopListNode(listItemNode));\n }\n }\n }\n }\n for (const listNode of listNodes) {\n let insertionPoint = listNode;\n const listItems = $getAllListItems(listNode);\n for (const listItemNode of listItems) {\n const paragraph = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$createParagraphNode)().setTextStyle(selection.style).setTextFormat(selection.format);\n append(paragraph, listItemNode.getChildren());\n insertionPoint.insertAfter(paragraph);\n insertionPoint = paragraph;\n\n // When the anchor and focus fall on the textNode\n // we don't have to change the selection because the textNode will be appended to\n // the newly generated paragraph.\n // When selection is in empty nested list item, selection is actually on the listItemNode.\n // When the corresponding listItemNode is deleted and replaced by the newly generated paragraph\n // we should manually set the selection's focus and anchor to the newly generated paragraph.\n if (listItemNode.__key === selection.anchor.key) {\n (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$setPointFromCaret)(selection.anchor, (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$normalizeCaret)((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$getChildCaret)(paragraph, 'next')));\n }\n if (listItemNode.__key === selection.focus.key) {\n (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$setPointFromCaret)(selection.focus, (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$normalizeCaret)((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$getChildCaret)(paragraph, 'next')));\n }\n listItemNode.remove();\n }\n listNode.remove();\n }\n }\n}\n\n/**\n * Takes the value of a child ListItemNode and makes it the value the ListItemNode\n * should be if it isn't already. Also ensures that checked is undefined if the\n * parent does not have a list type of 'check'.\n * @param list - The list whose children are updated.\n */\nfunction updateChildrenListItemValue(list) {\n const isNotChecklist = list.getListType() !== 'check';\n let value = list.getStart();\n for (const child of list.getChildren()) {\n if ($isListItemNode(child)) {\n if (child.getValue() !== value) {\n child.setValue(value);\n }\n if (isNotChecklist && child.getLatest().__checked != null) {\n child.setChecked(undefined);\n }\n if (!$isListNode(child.getFirstChild())) {\n value++;\n }\n }\n }\n}\n\n/**\n * Merge the next sibling list if same type.\n * <ul> will merge with <ul>, but NOT <ul> with <ol>.\n * @param list - The list whose next sibling should be potentially merged\n */\nfunction mergeNextSiblingListIfSameType(list) {\n const nextSibling = list.getNextSibling();\n if ($isListNode(nextSibling) && list.getListType() === nextSibling.getListType()) {\n mergeLists(list, nextSibling);\n }\n}\n\n/**\n * Adds an empty ListNode/ListItemNode chain at listItemNode, so as to\n * create an indent effect. Won't indent ListItemNodes that have a ListNode as\n * a child, but does merge sibling ListItemNodes if one has a nested ListNode.\n * @param listItemNode - The ListItemNode to be indented.\n */\nfunction $handleIndent(listItemNode) {\n // go through each node and decide where to move it.\n const removed = new Set();\n if (isNestedListNode(listItemNode) || removed.has(listItemNode.getKey())) {\n return;\n }\n const parent = listItemNode.getParent();\n\n // We can cast both of the below `isNestedListNode` only returns a boolean type instead of a user-defined type guards\n const nextSibling = listItemNode.getNextSibling();\n const previousSibling = listItemNode.getPreviousSibling();\n // if there are nested lists on either side, merge them all together.\n\n if (isNestedListNode(nextSibling) && isNestedListNode(previousSibling)) {\n const innerList = previousSibling.getFirstChild();\n if ($isListNode(innerList)) {\n innerList.append(listItemNode);\n const nextInnerList = nextSibling.getFirstChild();\n if ($isListNode(nextInnerList)) {\n const children = nextInnerList.getChildren();\n append(innerList, children);\n nextSibling.remove();\n removed.add(nextSibling.getKey());\n }\n }\n } else if (isNestedListNode(nextSibling)) {\n // if the ListItemNode is next to a nested ListNode, merge them\n const innerList = nextSibling.getFirstChild();\n if ($isListNode(innerList)) {\n const firstChild = innerList.getFirstChild();\n if (firstChild !== null) {\n firstChild.insertBefore(listItemNode);\n }\n }\n } else if (isNestedListNode(previousSibling)) {\n const innerList = previousSibling.getFirstChild();\n if ($isListNode(innerList)) {\n innerList.append(listItemNode);\n }\n } else {\n // otherwise, we need to create a new nested ListNode\n\n if ($isListNode(parent)) {\n const newListItem = $createListItemNode().setTextFormat(listItemNode.getTextFormat()).setTextStyle(listItemNode.getTextStyle());\n const newList = $createListNode(parent.getListType()).setTextFormat(parent.getTextFormat()).setTextStyle(parent.getTextStyle());\n newListItem.append(newList);\n newList.append(listItemNode);\n if (previousSibling) {\n previousSibling.insertAfter(newListItem);\n } else if (nextSibling) {\n nextSibling.insertBefore(newListItem);\n } else {\n parent.append(newListItem);\n }\n }\n }\n}\n\n/**\n * Removes an indent by removing an empty ListNode/ListItemNode chain. An indented ListItemNode\n * has a great grandparent node of type ListNode, which is where the ListItemNode will reside\n * within as a child.\n * @param listItemNode - The ListItemNode to remove the indent (outdent).\n */\nfunction $handleOutdent(listItemNode) {\n // go through each node and decide where to move it.\n\n if (isNestedListNode(listItemNode)) {\n return;\n }\n const parentList = listItemNode.getParent();\n const grandparentListItem = parentList ? parentList.getParent() : undefined;\n const greatGrandparentList = grandparentListItem ? grandparentListItem.getParent() : undefined;\n // If it doesn't have these ancestors, it's not indented.\n\n if ($isListNode(greatGrandparentList) && $isListItemNode(grandparentListItem) && $isListNode(parentList)) {\n // if it's the first child in it's parent list, insert it into the\n // great grandparent list before the grandparent\n const firstChild = parentList ? parentList.getFirstChild() : undefined;\n const lastChild = parentList ? parentList.getLastChild() : undefined;\n if (listItemNode.is(firstChild)) {\n grandparentListItem.insertBefore(listItemNode);\n if (parentList.isEmpty()) {\n grandparentListItem.remove();\n }\n // if it's the last child in it's parent list, insert it into the\n // great grandparent list after the grandparent.\n } else if (listItemNode.is(lastChild)) {\n grandparentListItem.insertAfter(listItemNode);\n if (parentList.isEmpty()) {\n grandparentListItem.remove();\n }\n } else {\n // otherwise, we need to split the siblings into two new nested lists\n const listType = parentList.getListType();\n const previousSiblingsListItem = $createListItemNode();\n const previousSiblingsList = $createListNode(listType);\n previousSiblingsListItem.append(previousSiblingsList);\n listItemNode.getPreviousSiblings().forEach(sibling => previousSiblingsList.append(sibling));\n const nextSiblingsListItem = $createListItemNode();\n const nextSiblingsList = $createListNode(listType);\n nextSiblingsListItem.append(nextSiblingsList);\n append(nextSiblingsList, listItemNode.getNextSiblings());\n // put the sibling nested lists on either side of the grandparent list item in the great grandparent.\n grandparentListItem.insertBefore(previousSiblingsListItem);\n grandparentListItem.insertAfter(nextSiblingsListItem);\n // replace the grandparent list item (now between the siblings) with the outdented list item.\n grandparentListItem.replace(listItemNode);\n }\n }\n}\n\n/**\n * Attempts to insert a ParagraphNode at selection and selects the new node. The selection must contain a ListItemNode\n * or a node that does not already contain text. If its grandparent is the root/shadow root, it will get the ListNode\n * (which should be the parent node) and insert the ParagraphNode as a sibling to the ListNode. If the ListNode is\n * nested in a ListItemNode instead, it will add the ParagraphNode after the grandparent ListItemNode.\n * Throws an invariant if the selection is not a child of a ListNode.\n * @returns true if a ParagraphNode was inserted successfully, false if there is no selection\n * or the selection does not contain a ListItemNode or the node already holds text.\n */\nfunction $handleListInsertParagraph(restoreNumbering = false) {\n const selection = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$getSelection)();\n if (!(0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isRangeSelection)(selection) || !selection.isCollapsed()) {\n return false;\n }\n // Only run this code on empty list items (including whitespace-only)\n const anchor = selection.anchor.getNode();\n let listItem = null;\n if ($isListItemNode(anchor) && anchor.getChildrenSize() === 0) {\n // Truly empty list item (element selection)\n listItem = anchor;\n } else if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isTextNode)(anchor)) {\n // Check if the entire list item contains only whitespace text nodes\n const parentListItem = anchor.getParent();\n if ($isListItemNode(parentListItem) && parentListItem.getChildren().every(node => (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isTextNode)(node) && node.getTextContent().trim() === '')) {\n listItem = parentListItem;\n }\n }\n if (listItem === null) {\n return false;\n }\n const topListNode = $getTopListNode(listItem);\n const parent = listItem.getParent();\n if (!$isListNode(parent)) {\n formatDevErrorMessage(`A ListItemNode must have a ListNode for a parent.`);\n }\n const grandparent = parent.getParent();\n let replacementNode;\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isRootOrShadowRoot)(grandparent)) {\n replacementNode = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$createParagraphNode)();\n topListNode.insertAfter(replacementNode);\n } else if ($isListItemNode(grandparent)) {\n replacementNode = $createListItemNode();\n grandparent.insertAfter(replacementNode);\n } else {\n return false;\n }\n replacementNode.setTextStyle(selection.style).setTextFormat(selection.format).select();\n const nextSiblings = listItem.getNextSiblings();\n if (nextSiblings.length > 0) {\n const newStart = restoreNumbering ? $getNewListStart(parent, listItem) : 1;\n const newList = $createListNode(parent.getListType(), newStart);\n if ($isListItemNode(replacementNode)) {\n const newListItem = $createListItemNode();\n newListItem.append(newList);\n replacementNode.insertAfter(newListItem);\n } else {\n replacementNode.insertAfter(newList);\n }\n newList.append(...nextSiblings);\n }\n\n // Don't leave hanging nested empty lists\n $removeHighestEmptyListParent(listItem);\n return true;\n}\n\nfunction applyMarkerStyles(dom, node, prevNode) {\n const styles = (0,_lexical_selection__WEBPACK_IMPORTED_MODULE_2__.getStyleObjectFromCSS)(node.__textStyle);\n for (const k in styles) {\n dom.style.setProperty(`--listitem-marker-${k}`, styles[k]);\n }\n if (prevNode) {\n for (const k in (0,_lexical_selection__WEBPACK_IMPORTED_MODULE_2__.getStyleObjectFromCSS)(prevNode.__textStyle)) {\n if (!(k in styles)) {\n dom.style.removeProperty(`--listitem-marker-${k}`);\n }\n }\n }\n}\n\n/** @noInheritDoc */\nclass ListItemNode extends lexical__WEBPACK_IMPORTED_MODULE_0__.ElementNode {\n /** @internal */\n __value;\n /** @internal */\n __checked;\n\n /** @internal */\n $config() {\n return this.config('listitem', {\n $transform: node => {\n if (node.__checked == null) {\n return;\n }\n const parent = node.getParent();\n if ($isListNode(parent)) {\n if (parent.getListType() !== 'check' && node.getChecked() != null) {\n node.setChecked(undefined);\n }\n }\n },\n extends: lexical__WEBPACK_IMPORTED_MODULE_0__.ElementNode,\n importDOM: (0,lexical__WEBPACK_IMPORTED_MODULE_0__.buildImportMap)({\n li: () => ({\n conversion: $convertListItemElement,\n priority: 0\n })\n })\n });\n }\n constructor(value = 1, checked = undefined, key) {\n super(key);\n this.__value = value === undefined ? 1 : value;\n this.__checked = checked;\n }\n afterCloneFrom(prevNode) {\n super.afterCloneFrom(prevNode);\n this.__value = prevNode.__value;\n this.__checked = prevNode.__checked;\n }\n createDOM(config) {\n const element = document.createElement('li');\n this.updateListItemDOM(null, element, config);\n return element;\n }\n updateListItemDOM(prevNode, dom, config) {\n updateListItemChecked(dom, this, prevNode);\n dom.value = this.__value;\n $setListItemThemeClassNames(dom, config.theme, this);\n const prevStyle = prevNode ? prevNode.__style : '';\n const nextStyle = this.__style;\n if (prevStyle !== nextStyle) {\n if (nextStyle === '') {\n dom.removeAttribute('style');\n } else {\n dom.style.cssText = nextStyle;\n }\n }\n applyMarkerStyles(dom, this, prevNode);\n }\n updateDOM(prevNode, dom, config) {\n // @ts-expect-error - this is always HTMLListItemElement\n const element = dom;\n this.updateListItemDOM(prevNode, element, config);\n return false;\n }\n updateFromJSON(serializedNode) {\n return super.updateFromJSON(serializedNode).setValue(serializedNode.value).setChecked(serializedNode.checked);\n }\n exportDOM(editor) {\n const element = this.createDOM(editor._config);\n const formatType = this.getFormatType();\n if (formatType) {\n element.style.textAlign = formatType;\n }\n const direction = this.getDirection();\n if (direction) {\n element.dir = direction;\n }\n return {\n element\n };\n }\n exportJSON() {\n return {\n ...super.exportJSON(),\n checked: this.getChecked(),\n value: this.getValue()\n };\n }\n append(...nodes) {\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isElementNode)(node) && this.canMergeWith(node)) {\n const children = node.getChildren();\n this.append(...children);\n node.remove();\n } else {\n super.append(node);\n }\n }\n return this;\n }\n replace(replaceWithNode, includeChildren) {\n if ($isListItemNode(replaceWithNode)) {\n return super.replace(replaceWithNode);\n }\n this.setIndent(0);\n const list = this.getParentOrThrow();\n if (!$isListNode(list)) {\n return replaceWithNode;\n }\n if (list.__first === this.getKey()) {\n list.insertBefore(replaceWithNode);\n } else if (list.__last === this.getKey()) {\n list.insertAfter(replaceWithNode);\n } else {\n // Split the list\n const newList = $createListNode(list.getListType());\n let nextSibling = this.getNextSibling();\n while (nextSibling) {\n const nodeToAppend = nextSibling;\n nextSibling = nextSibling.getNextSibling();\n newList.append(nodeToAppend);\n }\n list.insertAfter(replaceWithNode);\n replaceWithNode.insertAfter(newList);\n }\n if (includeChildren) {\n if (!(0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isElementNode)(replaceWithNode)) {\n formatDevErrorMessage(`includeChildren should only be true for ElementNodes`);\n }\n this.getChildren().forEach(child => {\n replaceWithNode.append(child);\n });\n }\n this.remove();\n if (list.getChildrenSize() === 0) {\n list.remove();\n }\n return replaceWithNode;\n }\n insertAfter(node, restoreSelection = true) {\n const listNode = this.getParentOrThrow();\n if (!$isListNode(listNode)) {\n {\n formatDevErrorMessage(`insertAfter: list node is not parent of list item node`);\n }\n }\n if ($isListItemNode(node)) {\n return super.insertAfter(node, restoreSelection);\n }\n const siblings = this.getNextSiblings();\n\n // Split the lists and insert the node in between them\n listNode.insertAfter(node, restoreSelection);\n if (siblings.length !== 0) {\n const newListNode = $createListNode(listNode.getListType());\n siblings.forEach(sibling => newListNode.append(sibling));\n node.insertAfter(newListNode, restoreSelection);\n }\n return node;\n }\n remove(preserveEmptyParent) {\n const prevSibling = this.getPreviousSibling();\n const nextSibling = this.getNextSibling();\n super.remove(preserveEmptyParent);\n if (prevSibling && nextSibling && isNestedListNode(prevSibling) && isNestedListNode(nextSibling)) {\n mergeLists(prevSibling.getFirstChild(), nextSibling.getFirstChild());\n nextSibling.remove();\n }\n }\n insertNewAfter(_, restoreSelection = true) {\n const newElement = $createListItemNode().updateFromJSON(this.exportJSON()).setChecked(this.getChecked() ? false : undefined);\n this.insertAfter(newElement, restoreSelection);\n return newElement;\n }\n collapseAtStart(selection) {\n const paragraph = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$createParagraphNode)();\n const children = this.getChildren();\n children.forEach(child => paragraph.append(child));\n const listNode = this.getParentOrThrow();\n const listNodeParent = listNode.getParentOrThrow();\n const isIndented = $isListItemNode(listNodeParent);\n if (listNode.getChildrenSize() === 1) {\n if (isIndented) {\n // if the list node is nested, we just want to remove it,\n // effectively unindenting it.\n listNode.remove();\n listNodeParent.select();\n } else {\n listNode.insertBefore(paragraph);\n listNode.remove();\n // If we have selection on the list item, we'll need to move it\n // to the paragraph\n const anchor = selection.anchor;\n const focus = selection.focus;\n const key = paragraph.getKey();\n if (anchor.type === 'element' && anchor.getNode().is(this)) {\n anchor.set(key, anchor.offset, 'element');\n }\n if (focus.type === 'element' && focus.getNode().is(this)) {\n focus.set(key, focus.offset, 'element');\n }\n }\n } else {\n listNode.insertBefore(paragraph);\n this.remove();\n }\n return true;\n }\n getValue() {\n const self = this.getLatest();\n return self.__value;\n }\n setValue(value) {\n const self = this.getWritable();\n self.__value = value;\n return self;\n }\n getChecked() {\n const self = this.getLatest();\n let listType;\n const parent = this.getParent();\n if ($isListNode(parent)) {\n listType = parent.getListType();\n }\n return listType === 'check' ? Boolean(self.__checked) : undefined;\n }\n setChecked(checked) {\n const self = this.getWritable();\n self.__checked = checked;\n return self;\n }\n toggleChecked() {\n const self = this.getWritable();\n return self.setChecked(!self.__checked);\n }\n getIndent() {\n // If we don't have a parent, we are likely serializing\n const parent = this.getParent();\n if (parent === null || !this.isAttached()) {\n return this.getLatest().__indent;\n }\n // ListItemNode should always have a ListNode for a parent.\n let listNodeParent = parent.getParentOrThrow();\n let indentLevel = 0;\n while ($isListItemNode(listNodeParent)) {\n listNodeParent = listNodeParent.getParentOrThrow().getParentOrThrow();\n indentLevel++;\n }\n return indentLevel;\n }\n setIndent(indent) {\n if (!(typeof indent === 'number')) {\n formatDevErrorMessage(`Invalid indent value.`);\n }\n indent = Math.floor(indent);\n if (!(indent >= 0)) {\n formatDevErrorMessage(`Indent value must be non-negative.`);\n }\n let currentIndent = this.getIndent();\n while (currentIndent !== indent) {\n if (currentIndent < indent) {\n $handleIndent(this);\n currentIndent++;\n } else {\n $handleOutdent(this);\n currentIndent--;\n }\n }\n return this;\n }\n\n /** @deprecated @internal */\n canInsertAfter(node) {\n return $isListItemNode(node);\n }\n\n /** @deprecated @internal */\n canReplaceWith(replacement) {\n return $isListItemNode(replacement);\n }\n canMergeWith(node) {\n return $isListItemNode(node) || (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isParagraphNode)(node);\n }\n extractWithChild(child, selection) {\n if (!(0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isRangeSelection)(selection)) {\n return false;\n }\n const anchorNode = selection.anchor.getNode();\n const focusNode = selection.focus.getNode();\n return this.isParentOf(anchorNode) && this.isParentOf(focusNode) && this.getTextContent().length === selection.getTextContent().length;\n }\n isParentRequired() {\n return true;\n }\n createParentElementNode() {\n return $createListNode('bullet');\n }\n canMergeWhenEmpty() {\n return true;\n }\n}\nfunction $setListItemThemeClassNames(dom, editorThemeClasses, node) {\n const classesToAdd = [];\n const classesToRemove = [];\n const listTheme = editorThemeClasses.list;\n const listItemClassName = listTheme ? listTheme.listitem : undefined;\n let nestedListItemClassName;\n if (listTheme && listTheme.nested) {\n nestedListItemClassName = listTheme.nested.listitem;\n }\n if (listItemClassName !== undefined) {\n classesToAdd.push(...(0,lexical__WEBPACK_IMPORTED_MODULE_0__.normalizeClassNames)(listItemClassName));\n }\n if (listTheme) {\n const parentNode = node.getParent();\n const isCheckList = $isListNode(parentNode) && parentNode.getListType() === 'check';\n const checked = node.getChecked();\n if (!isCheckList || checked) {\n classesToRemove.push(listTheme.listitemUnchecked);\n }\n if (!isCheckList || !checked) {\n classesToRemove.push(listTheme.listitemChecked);\n }\n if (isCheckList) {\n classesToAdd.push(checked ? listTheme.listitemChecked : listTheme.listitemUnchecked);\n }\n }\n if (nestedListItemClassName !== undefined) {\n const nestedListItemClasses = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.normalizeClassNames)(nestedListItemClassName);\n if (node.getChildren().some(child => $isListNode(child))) {\n classesToAdd.push(...nestedListItemClasses);\n } else {\n classesToRemove.push(...nestedListItemClasses);\n }\n }\n if (classesToRemove.length > 0) {\n (0,lexical__WEBPACK_IMPORTED_MODULE_0__.removeClassNamesFromElement)(dom, ...classesToRemove);\n }\n if (classesToAdd.length > 0) {\n (0,lexical__WEBPACK_IMPORTED_MODULE_0__.addClassNamesToElement)(dom, ...classesToAdd);\n }\n}\nfunction updateListItemChecked(dom, listItemNode, prevListItemNode) {\n const parent = listItemNode.getParent();\n const isCheckbox = $isListNode(parent) && parent.getListType() === 'check' &&\n // Only add attributes for leaf list items\n !$isListNode(listItemNode.getFirstChild());\n if (!isCheckbox) {\n dom.removeAttribute('role');\n dom.removeAttribute('tabIndex');\n dom.removeAttribute('aria-checked');\n } else {\n dom.setAttribute('role', 'checkbox');\n dom.setAttribute('tabIndex', '-1');\n if (!prevListItemNode || listItemNode.__checked !== prevListItemNode.__checked) {\n dom.setAttribute('aria-checked', listItemNode.getChecked() ? 'true' : 'false');\n }\n }\n}\nfunction $convertListItemElement(domNode) {\n const isGitHubCheckList = domNode.classList.contains('task-list-item');\n if (isGitHubCheckList) {\n for (const child of domNode.children) {\n if (child.tagName === 'INPUT') {\n return $convertCheckboxInput(child);\n }\n }\n }\n const isJoplinCheckList = domNode.classList.contains('joplin-checkbox');\n if (isJoplinCheckList) {\n for (const child of domNode.children) {\n if (child.classList.contains('checkbox-wrapper') && child.children.length > 0 && child.children[0].tagName === 'INPUT') {\n return $convertCheckboxInput(child.children[0]);\n }\n }\n }\n const ariaCheckedAttr = domNode.getAttribute('aria-checked');\n const checked = ariaCheckedAttr === 'true' ? true : ariaCheckedAttr === 'false' ? false : undefined;\n return {\n node: $createListItemNode(checked)\n };\n}\nfunction $convertCheckboxInput(domNode) {\n const isCheckboxInput = domNode.getAttribute('type') === 'checkbox';\n if (!isCheckboxInput) {\n return {\n node: null\n };\n }\n const checked = domNode.hasAttribute('checked');\n return {\n node: $createListItemNode(checked)\n };\n}\n\n/**\n * Creates a new List Item node, passing true/false will convert it to a checkbox input.\n * @param checked - Is the List Item a checkbox and, if so, is it checked? undefined/null: not a checkbox, true/false is a checkbox and checked/unchecked, respectively.\n * @returns The new List Item.\n */\nfunction $createListItemNode(checked) {\n return (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$applyNodeReplacement)(new ListItemNode(undefined, checked));\n}\n\n/**\n * Checks to see if the node is a ListItemNode.\n * @param node - The node to be checked.\n * @returns true if the node is a ListItemNode, false otherwise.\n */\nfunction $isListItemNode(node) {\n return node instanceof ListItemNode;\n}\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n/** @noInheritDoc */\nclass ListNode extends lexical__WEBPACK_IMPORTED_MODULE_0__.ElementNode {\n /** @internal */\n __tag;\n /** @internal */\n __start;\n /** @internal */\n __listType;\n\n /** @internal */\n $config() {\n return this.config('list', {\n $transform: node => {\n mergeNextSiblingListIfSameType(node);\n updateChildrenListItemValue(node);\n },\n extends: lexical__WEBPACK_IMPORTED_MODULE_0__.ElementNode,\n importDOM: (0,lexical__WEBPACK_IMPORTED_MODULE_0__.buildImportMap)({\n ol: () => ({\n conversion: $convertListNode,\n priority: 0\n }),\n ul: () => ({\n conversion: $convertListNode,\n priority: 0\n })\n })\n });\n }\n constructor(listType = 'number', start = 1, key) {\n super(key);\n const _listType = TAG_TO_LIST_TYPE[listType] || listType;\n this.__listType = _listType;\n this.__tag = _listType === 'number' ? 'ol' : 'ul';\n this.__start = start;\n }\n afterCloneFrom(prevNode) {\n super.afterCloneFrom(prevNode);\n this.__listType = prevNode.__listType;\n this.__tag = prevNode.__tag;\n this.__start = prevNode.__start;\n }\n getTag() {\n return this.getLatest().__tag;\n }\n setListType(type) {\n const writable = this.getWritable();\n writable.__listType = type;\n writable.__tag = type === 'number' ? 'ol' : 'ul';\n return writable;\n }\n getListType() {\n return this.getLatest().__listType;\n }\n getStart() {\n return this.getLatest().__start;\n }\n setStart(start) {\n const self = this.getWritable();\n self.__start = start;\n return self;\n }\n\n // View\n\n createDOM(config, _editor) {\n const tag = this.__tag;\n const dom = document.createElement(tag);\n if (this.__start !== 1) {\n dom.setAttribute('start', String(this.__start));\n }\n // @ts-expect-error Internal field.\n dom.__lexicalListType = this.__listType;\n $setListThemeClassNames(dom, config.theme, this);\n return dom;\n }\n updateDOM(prevNode, dom, config) {\n if (prevNode.__tag !== this.__tag || prevNode.__listType !== this.__listType) {\n return true;\n }\n $setListThemeClassNames(dom, config.theme, this);\n if (prevNode.__start !== this.__start) {\n dom.setAttribute('start', String(this.__start));\n }\n return false;\n }\n updateFromJSON(serializedNode) {\n return super.updateFromJSON(serializedNode).setListType(serializedNode.listType).setStart(serializedNode.start);\n }\n exportDOM(editor) {\n const element = this.createDOM(editor._config, editor);\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.isHTMLElement)(element)) {\n if (this.__start !== 1) {\n element.setAttribute('start', String(this.__start));\n }\n if (this.__listType === 'check') {\n element.setAttribute('__lexicalListType', 'check');\n }\n }\n return {\n element\n };\n }\n exportJSON() {\n return {\n ...super.exportJSON(),\n listType: this.getListType(),\n start: this.getStart(),\n tag: this.getTag()\n };\n }\n canBeEmpty() {\n return false;\n }\n canIndent() {\n return false;\n }\n splice(start, deleteCount, nodesToInsert) {\n let listItemNodesToInsert = nodesToInsert;\n for (let i = 0; i < nodesToInsert.length; i++) {\n const node = nodesToInsert[i];\n if (!$isListItemNode(node)) {\n if (listItemNodesToInsert === nodesToInsert) {\n listItemNodesToInsert = [...nodesToInsert];\n }\n listItemNodesToInsert[i] = $createListItemNode().append((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isElementNode)(node) && !($isListNode(node) || node.isInline()) ? (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$createTextNode)(node.getTextContent()) : node);\n }\n }\n return super.splice(start, deleteCount, listItemNodesToInsert);\n }\n extractWithChild(child) {\n return $isListItemNode(child);\n }\n}\nfunction $setListThemeClassNames(dom, editorThemeClasses, node) {\n const classesToAdd = [];\n const classesToRemove = [];\n const listTheme = editorThemeClasses.list;\n if (listTheme !== undefined) {\n const listLevelsClassNames = listTheme[`${node.__tag}Depth`] || [];\n const listDepth = $getListDepth(node) - 1;\n const normalizedListDepth = listDepth % listLevelsClassNames.length;\n const listLevelClassName = listLevelsClassNames[normalizedListDepth];\n const listClassName = listTheme[node.__tag];\n let nestedListClassName;\n const nestedListTheme = listTheme.nested;\n const checklistClassName = listTheme.checklist;\n if (nestedListTheme !== undefined && nestedListTheme.list) {\n nestedListClassName = nestedListTheme.list;\n }\n if (listClassName !== undefined) {\n classesToAdd.push(listClassName);\n }\n if (checklistClassName !== undefined && node.__listType === 'check') {\n classesToAdd.push(checklistClassName);\n }\n if (listLevelClassName !== undefined) {\n classesToAdd.push(...(0,lexical__WEBPACK_IMPORTED_MODULE_0__.normalizeClassNames)(listLevelClassName));\n for (let i = 0; i < listLevelsClassNames.length; i++) {\n if (i !== normalizedListDepth) {\n classesToRemove.push(node.__tag + i);\n }\n }\n }\n if (nestedListClassName !== undefined) {\n const nestedListItemClasses = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.normalizeClassNames)(nestedListClassName);\n if (listDepth > 1) {\n classesToAdd.push(...nestedListItemClasses);\n } else {\n classesToRemove.push(...nestedListItemClasses);\n }\n }\n }\n if (classesToRemove.length > 0) {\n (0,lexical__WEBPACK_IMPORTED_MODULE_0__.removeClassNamesFromElement)(dom, ...classesToRemove);\n }\n if (classesToAdd.length > 0) {\n (0,lexical__WEBPACK_IMPORTED_MODULE_0__.addClassNamesToElement)(dom, ...classesToAdd);\n }\n}\n\n/*\n * This function normalizes the children of a ListNode after the conversion from HTML,\n * ensuring that they are all ListItemNodes and contain either a single nested ListNode\n * or some other inline content.\n */\nfunction $normalizeChildren(nodes) {\n const normalizedListItems = [];\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if ($isListItemNode(node)) {\n normalizedListItems.push(node);\n const children = node.getChildren();\n if (children.length > 1) {\n children.forEach(child => {\n if ($isListNode(child)) {\n normalizedListItems.push($wrapInListItem(child));\n }\n });\n }\n } else {\n normalizedListItems.push($wrapInListItem(node));\n }\n }\n return normalizedListItems;\n}\nfunction isDomChecklist(domNode) {\n if (domNode.getAttribute('__lexicallisttype') === 'check' ||\n // is github checklist\n domNode.classList.contains('contains-task-list') ||\n // is joplin checklist\n domNode.getAttribute('data-is-checklist') === '1') {\n return true;\n }\n // if children are checklist items, the node is a checklist ul. Applicable for googledoc checklist pasting.\n for (const child of domNode.childNodes) {\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.isHTMLElement)(child) && child.hasAttribute('aria-checked')) {\n return true;\n }\n }\n return false;\n}\nfunction $convertListNode(domNode) {\n const nodeName = domNode.nodeName.toLowerCase();\n let node = null;\n if (nodeName === 'ol') {\n // @ts-ignore\n const start = domNode.start;\n node = $createListNode('number', start);\n } else if (nodeName === 'ul') {\n if (isDomChecklist(domNode)) {\n node = $createListNode('check');\n } else {\n node = $createListNode('bullet');\n }\n }\n return {\n after: $normalizeChildren,\n node\n };\n}\nconst TAG_TO_LIST_TYPE = {\n ol: 'number',\n ul: 'bullet'\n};\n\n/**\n * Creates a ListNode of listType.\n * @param listType - The type of list to be created. Can be 'number', 'bullet', or 'check'.\n * @param start - Where an ordered list starts its count, start = 1 if left undefined.\n * @returns The new ListNode\n */\nfunction $createListNode(listType = 'number', start = 1) {\n return (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$applyNodeReplacement)(new ListNode(listType, start));\n}\n\n/**\n * Checks to see if the node is a ListNode.\n * @param node - The node to be checked.\n * @returns true if the node is a ListNode, false otherwise.\n */\nfunction $isListNode(node) {\n return node instanceof ListNode;\n}\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nconst INSERT_CHECK_LIST_COMMAND = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.createCommand)('INSERT_CHECK_LIST_COMMAND');\n\n/**\n * Registers the checklist plugin with the editor.\n * @param editor The LexicalEditor instance.\n * @param options Optional configuration.\n * - disableTakeFocusOnClick: If true, clicking a checklist item will not focus the editor (useful for mobile).\n */\nfunction registerCheckList(editor, options) {\n const disableTakeFocusOnClick = options && options.disableTakeFocusOnClick || false;\n const configHandleClick = event => {\n handleClick(event, disableTakeFocusOnClick);\n };\n const configHandleSelectDefaults = event => {\n handleSelectDefaults(event, disableTakeFocusOnClick);\n };\n return (0,lexical__WEBPACK_IMPORTED_MODULE_0__.mergeRegister)(editor.registerCommand(INSERT_CHECK_LIST_COMMAND, () => {\n $insertList('check');\n return true;\n }, lexical__WEBPACK_IMPORTED_MODULE_0__.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical__WEBPACK_IMPORTED_MODULE_0__.KEY_ARROW_DOWN_COMMAND, event => {\n return handleArrowUpOrDown(event, editor, false);\n }, lexical__WEBPACK_IMPORTED_MODULE_0__.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical__WEBPACK_IMPORTED_MODULE_0__.KEY_ARROW_UP_COMMAND, event => {\n return handleArrowUpOrDown(event, editor, true);\n }, lexical__WEBPACK_IMPORTED_MODULE_0__.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical__WEBPACK_IMPORTED_MODULE_0__.KEY_ESCAPE_COMMAND, () => {\n const activeItem = getActiveCheckListItem();\n if (activeItem != null) {\n const rootElement = editor.getRootElement();\n if (rootElement != null) {\n rootElement.focus();\n }\n return true;\n }\n return false;\n }, lexical__WEBPACK_IMPORTED_MODULE_0__.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical__WEBPACK_IMPORTED_MODULE_0__.KEY_SPACE_COMMAND, event => {\n const activeItem = getActiveCheckListItem();\n if (activeItem != null && editor.isEditable()) {\n editor.update(() => {\n const listItemNode = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$getNearestNodeFromDOMNode)(activeItem);\n if ($isListItemNode(listItemNode)) {\n event.preventDefault();\n listItemNode.toggleChecked();\n }\n });\n return true;\n }\n return false;\n }, lexical__WEBPACK_IMPORTED_MODULE_0__.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical__WEBPACK_IMPORTED_MODULE_0__.KEY_ARROW_LEFT_COMMAND, event => {\n return editor.getEditorState().read(() => {\n const selection = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$getSelection)();\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isRangeSelection)(selection) && selection.isCollapsed()) {\n const {\n anchor\n } = selection;\n const isElement = anchor.type === 'element';\n if (isElement || anchor.offset === 0) {\n const anchorNode = anchor.getNode();\n const elementNode = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$findMatchingParent)(anchorNode, node => (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isElementNode)(node) && !node.isInline());\n if ($isListItemNode(elementNode)) {\n const parent = elementNode.getParent();\n if ($isListNode(parent) && parent.getListType() === 'check' && (isElement || elementNode.getFirstDescendant() === anchorNode)) {\n const domNode = editor.getElementByKey(elementNode.__key);\n if (domNode != null && document.activeElement !== domNode) {\n domNode.focus();\n event.preventDefault();\n return true;\n }\n }\n }\n }\n }\n return false;\n });\n }, lexical__WEBPACK_IMPORTED_MODULE_0__.COMMAND_PRIORITY_LOW), editor.registerRootListener((rootElement, prevElement) => {\n if (rootElement !== null) {\n rootElement.addEventListener('click', configHandleClick);\n // Use capture so we run before other listeners that might move focus.\n rootElement.addEventListener('pointerdown', configHandleSelectDefaults, {\n capture: true\n });\n // Some browsers / integrations still generate mousedown events; handle them too.\n rootElement.addEventListener('mousedown', configHandleSelectDefaults, {\n capture: true\n });\n // Intercept touchstart to stop the mobile browser from placing the caret\n // and opening the keyboard when tapping the checklist marker.\n rootElement.addEventListener('touchstart', configHandleSelectDefaults, {\n capture: true,\n passive: false\n });\n }\n if (prevElement !== null) {\n prevElement.removeEventListener('click', configHandleClick);\n prevElement.removeEventListener('pointerdown', configHandleSelectDefaults, {\n capture: true\n });\n prevElement.removeEventListener('mousedown', configHandleSelectDefaults, {\n capture: true\n });\n prevElement.removeEventListener('touchstart', configHandleSelectDefaults, {\n capture: true\n });\n }\n }));\n}\nfunction handleCheckItemEvent(event, callback) {\n const target = event.target;\n if (!(0,lexical__WEBPACK_IMPORTED_MODULE_0__.isHTMLElement)(target)) {\n return;\n }\n\n // Ignore clicks on LI that have nested lists\n const firstChild = target.firstChild;\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.isHTMLElement)(firstChild) && (firstChild.tagName === 'UL' || firstChild.tagName === 'OL')) {\n return;\n }\n const parentNode = target.parentNode;\n\n // @ts-ignore internal field\n if (!parentNode || parentNode.__lexicalListType !== 'check') {\n return;\n }\n let clientX = null;\n let pointerType = null;\n if ('clientX' in event) {\n clientX = event.clientX;\n } else if ('touches' in event) {\n const touches = event.touches;\n if (touches.length > 0) {\n clientX = touches[0].clientX;\n pointerType = 'touch';\n }\n }\n\n // If we couldn't resolve a clientX (unexpected input), bail out.\n if (clientX == null) {\n return;\n }\n const rect = target.getBoundingClientRect();\n const zoom = (0,_lexical_utils__WEBPACK_IMPORTED_MODULE_1__.calculateZoomLevel)(target);\n const clientXInPixels = clientX / zoom;\n\n // Use getComputedStyle if available, otherwise fallback to 0px width\n const beforeStyles = window.getComputedStyle ? window.getComputedStyle(target, '::before') : {\n width: '0px'\n };\n const beforeWidthInPixels = parseFloat(beforeStyles.width);\n\n // Make click area slightly larger for touch devices to improve accessibility\n // Determine whether this is a touch event; some environments may supply\n // pointerType on PointerEvent while touch events use the `touches` API above.\n const isTouchEvent = pointerType === 'touch' || event.pointerType === 'touch';\n const clickAreaPadding = isTouchEvent ? 32 : 0; // Add 32px padding for touch events\n\n if (target.dir === 'rtl' ? clientXInPixels < rect.right + clickAreaPadding && clientXInPixels > rect.right - beforeWidthInPixels - clickAreaPadding : clientXInPixels > rect.left - clickAreaPadding && clientXInPixels < rect.left + beforeWidthInPixels + clickAreaPadding) {\n callback();\n }\n}\nfunction handleClick(event, disableFocusOnClick) {\n handleCheckItemEvent(event, () => {\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.isHTMLElement)(event.target)) {\n const domNode = event.target;\n const editor = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.getNearestEditorFromDOMNode)(domNode);\n if (editor != null && editor.isEditable()) {\n editor.update(() => {\n const node = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$getNearestNodeFromDOMNode)(domNode);\n if ($isListItemNode(node)) {\n if (disableFocusOnClick) {\n (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$addUpdateTag)(lexical__WEBPACK_IMPORTED_MODULE_0__.SKIP_SELECTION_FOCUS_TAG);\n (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$addUpdateTag)(lexical__WEBPACK_IMPORTED_MODULE_0__.SKIP_DOM_SELECTION_TAG);\n } else {\n domNode.focus();\n }\n node.toggleChecked();\n }\n });\n }\n }\n });\n}\n\n/**\n * Prevents default focus switch behavior\n *\n * @param event might be of type PointerEvent, MouseEvent, or TouchEvent, hence the generic Event type\n *\n */\nfunction handleSelectDefaults(event, disableTakeFocusOnClick) {\n handleCheckItemEvent(event, () => {\n // Prevents caret moving when clicking on check mark.\n event.preventDefault();\n if (disableTakeFocusOnClick) {\n event.stopPropagation();\n }\n });\n}\nfunction getActiveCheckListItem() {\n const activeElement = document.activeElement;\n return (0,lexical__WEBPACK_IMPORTED_MODULE_0__.isHTMLElement)(activeElement) && activeElement.tagName === 'LI' && activeElement.parentNode != null &&\n // @ts-ignore internal field\n activeElement.parentNode.__lexicalListType === 'check' ? activeElement : null;\n}\nfunction findCheckListItemSibling(node, backward) {\n let sibling = backward ? node.getPreviousSibling() : node.getNextSibling();\n let parent = node;\n\n // Going up in a tree to get non-null sibling\n while (sibling == null && $isListItemNode(parent)) {\n // Get li -> parent ul/ol -> parent li\n parent = parent.getParentOrThrow().getParent();\n if (parent != null) {\n sibling = backward ? parent.getPreviousSibling() : parent.getNextSibling();\n }\n }\n\n // Going down in a tree to get first non-nested list item\n while ($isListItemNode(sibling)) {\n const firstChild = backward ? sibling.getLastChild() : sibling.getFirstChild();\n if (!$isListNode(firstChild)) {\n return sibling;\n }\n sibling = backward ? firstChild.getLastChild() : firstChild.getFirstChild();\n }\n return null;\n}\nfunction handleArrowUpOrDown(event, editor, backward) {\n const activeItem = getActiveCheckListItem();\n if (activeItem != null) {\n editor.update(() => {\n const listItem = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$getNearestNodeFromDOMNode)(activeItem);\n if (!$isListItemNode(listItem)) {\n return;\n }\n const nextListItem = findCheckListItemSibling(listItem, backward);\n if (nextListItem != null) {\n nextListItem.selectStart();\n const dom = editor.getElementByKey(nextListItem.__key);\n if (dom != null) {\n event.preventDefault();\n setTimeout(() => {\n dom.focus();\n }, 0);\n }\n }\n });\n }\n return false;\n}\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nconst UPDATE_LIST_START_COMMAND = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.createCommand)('UPDATE_LIST_START_COMMAND');\nconst INSERT_UNORDERED_LIST_COMMAND = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.createCommand)('INSERT_UNORDERED_LIST_COMMAND');\nconst INSERT_ORDERED_LIST_COMMAND = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.createCommand)('INSERT_ORDERED_LIST_COMMAND');\nconst REMOVE_LIST_COMMAND = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.createCommand)('REMOVE_LIST_COMMAND');\nfunction registerList(editor, options) {\n const removeListener = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.mergeRegister)(editor.registerCommand(INSERT_ORDERED_LIST_COMMAND, () => {\n $insertList('number');\n return true;\n }, lexical__WEBPACK_IMPORTED_MODULE_0__.COMMAND_PRIORITY_LOW), editor.registerCommand(UPDATE_LIST_START_COMMAND, payload => {\n const {\n listNodeKey,\n newStart\n } = payload;\n const listNode = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$getNodeByKey)(listNodeKey);\n if (!$isListNode(listNode)) {\n return false;\n }\n if (listNode.getListType() === 'number') {\n listNode.setStart(newStart);\n updateChildrenListItemValue(listNode);\n }\n return true;\n }, lexical__WEBPACK_IMPORTED_MODULE_0__.COMMAND_PRIORITY_LOW), editor.registerCommand(INSERT_UNORDERED_LIST_COMMAND, () => {\n $insertList('bullet');\n return true;\n }, lexical__WEBPACK_IMPORTED_MODULE_0__.COMMAND_PRIORITY_LOW), editor.registerCommand(REMOVE_LIST_COMMAND, () => {\n $removeList();\n return true;\n }, lexical__WEBPACK_IMPORTED_MODULE_0__.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical__WEBPACK_IMPORTED_MODULE_0__.INSERT_PARAGRAPH_COMMAND, () => {\n const shouldRestore = options && options.restoreNumbering;\n return $handleListInsertParagraph(!!shouldRestore);\n }, lexical__WEBPACK_IMPORTED_MODULE_0__.COMMAND_PRIORITY_LOW), editor.registerNodeTransform(ListItemNode, node => {\n const firstChild = node.getFirstChild();\n if (firstChild) {\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isTextNode)(firstChild)) {\n const style = firstChild.getStyle();\n const format = firstChild.getFormat();\n if (node.getTextStyle() !== style) {\n node.setTextStyle(style);\n }\n if (node.getTextFormat() !== format) {\n node.setTextFormat(format);\n }\n }\n } else {\n // If it's empty, check the selection\n const selection = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$getSelection)();\n if ((0,lexical__WEBPACK_IMPORTED_MODULE_0__.$isRangeSelection)(selection) && (selection.style !== node.getTextStyle() || selection.format !== node.getTextFormat()) && selection.isCollapsed() && node.is(selection.anchor.getNode())) {\n node.setTextStyle(selection.style).setTextFormat(selection.format);\n }\n }\n }), editor.registerNodeTransform(lexical__WEBPACK_IMPORTED_MODULE_0__.TextNode, node => {\n const listItemParentNode = node.getParent();\n if ($isListItemNode(listItemParentNode) && node.is(listItemParentNode.getFirstChild())) {\n const style = node.getStyle();\n const format = node.getFormat();\n if (style !== listItemParentNode.getTextStyle() || format !== listItemParentNode.getTextFormat()) {\n listItemParentNode.setTextStyle(style).setTextFormat(format);\n }\n }\n }));\n return removeListener;\n}\nfunction registerListStrictIndentTransform(editor) {\n const $formatListIndentStrict = listItemNode => {\n const listNode = listItemNode.getParent();\n if ($isListNode(listItemNode.getFirstChild()) || !$isListNode(listNode)) {\n return;\n }\n const startingListItemNode = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.$findMatchingParent)(listItemNode, node => $isListItemNode(node) && $isListNode(node.getParent()) && $isListItemNode(node.getPreviousSibling()));\n if (startingListItemNode === null && listItemNode.getIndent() > 0) {\n listItemNode.setIndent(0);\n } else if ($isListItemNode(startingListItemNode)) {\n const prevListItemNode = startingListItemNode.getPreviousSibling();\n if ($isListItemNode(prevListItemNode)) {\n const endListItemNode = $findChildrenEndListItemNode(prevListItemNode);\n const endListNode = endListItemNode.getParent();\n if ($isListNode(endListNode)) {\n const prevDepth = $getListDepth(endListNode);\n const depth = $getListDepth(listNode);\n if (prevDepth + 1 < depth) {\n listItemNode.setIndent(prevDepth);\n }\n }\n }\n }\n };\n const $processListWithStrictIndent = listNode => {\n const queue = [listNode];\n while (queue.length > 0) {\n const node = queue.shift();\n if (!$isListNode(node)) {\n continue;\n }\n for (const child of node.getChildren()) {\n if ($isListItemNode(child)) {\n $formatListIndentStrict(child);\n const firstChild = child.getFirstChild();\n if ($isListNode(firstChild)) {\n queue.push(firstChild);\n }\n }\n }\n }\n };\n return editor.registerNodeTransform(ListNode, $processListWithStrictIndent);\n}\nfunction $findChildrenEndListItemNode(listItemNode) {\n let current = listItemNode;\n let firstChild = current.getFirstChild();\n while ($isListNode(firstChild)) {\n const lastChild = firstChild.getLastChild();\n if ($isListItemNode(lastChild)) {\n current = lastChild;\n firstChild = current.getFirstChild();\n } else {\n break;\n }\n }\n return current;\n}\n\n/**\n * @deprecated use {@link $insertList} from an update or command listener.\n *\n * Inserts a new ListNode. If the selection's anchor node is an empty ListItemNode and is a child of\n * the root/shadow root, it will replace the ListItemNode with a ListNode and the old ListItemNode.\n * Otherwise it will replace its parent with a new ListNode and re-insert the ListItemNode and any previous children.\n * If the selection's anchor node is not an empty ListItemNode, it will add a new ListNode or merge an existing ListNode,\n * unless the the node is a leaf node, in which case it will attempt to find a ListNode up the branch and replace it with\n * a new ListNode, or create a new ListNode at the nearest root/shadow root.\n * @param editor - The lexical editor.\n * @param listType - The type of list, \"number\" | \"bullet\" | \"check\".\n */\nfunction insertList(editor, listType) {\n editor.update(() => $insertList(listType));\n}\n\n/**\n * @deprecated use {@link $removeList} from an update or command listener.\n *\n * Searches for the nearest ancestral ListNode and removes it. If selection is an empty ListItemNode\n * it will remove the whole list, including the ListItemNode. For each ListItemNode in the ListNode,\n * removeList will also generate new ParagraphNodes in the removed ListNode's place. Any child node\n * inside a ListItemNode will be appended to the new ParagraphNodes.\n * @param editor - The lexical editor.\n */\nfunction removeList(editor) {\n editor.update(() => $removeList());\n}\n/**\n * Configures {@link ListNode}, {@link ListItemNode} and registers\n * the strict indent transform if `hasStrictIndent` is true (default false).\n */\nconst ListExtension = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.defineExtension)({\n build(editor, config, state) {\n return (0,_lexical_extension__WEBPACK_IMPORTED_MODULE_3__.namedSignals)(config);\n },\n config: (0,lexical__WEBPACK_IMPORTED_MODULE_0__.safeCast)({\n hasStrictIndent: false,\n shouldPreserveNumbering: false\n }),\n name: '@lexical/list/List',\n nodes: () => [ListNode, ListItemNode],\n register(editor, config, state) {\n const stores = state.getOutput();\n return (0,lexical__WEBPACK_IMPORTED_MODULE_0__.mergeRegister)((0,_lexical_extension__WEBPACK_IMPORTED_MODULE_3__.effect)(() => {\n return registerList(editor, {\n restoreNumbering: stores.shouldPreserveNumbering.value\n });\n }), (0,_lexical_extension__WEBPACK_IMPORTED_MODULE_3__.effect)(() => stores.hasStrictIndent.value ? registerListStrictIndentTransform(editor) : undefined));\n }\n});\n/**\n * Registers checklist functionality for {@link ListNode} and\n * {@link ListItemNode} with a\n * {@link INSERT_CHECK_LIST_COMMAND} listener and\n * the expected keyboard and mouse interactions for\n * checkboxes.\n */\nconst CheckListExtension = (0,lexical__WEBPACK_IMPORTED_MODULE_0__.defineExtension)({\n config: (0,lexical__WEBPACK_IMPORTED_MODULE_0__.safeCast)({\n disableTakeFocusOnClick: false\n }),\n dependencies: [ListExtension],\n name: '@lexical/list/CheckList',\n register: registerCheckList\n});\n\n\n//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"(rsc)/./node_modules/.pnpm/@lexical+list@0.41.0/node_modules/@lexical/list/LexicalList.dev.mjs","mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;;AAE0D;AACyH;AACwd;AAChlB;;AAE3D;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,yBAAyB;AAC3C;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,sDAAa;AACjC;AACA;AACA,QAAQ,0DAAiB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU,4DAAmB;AAC7B;AACA;AACA;AACA,UAAU;AACV,4BAA4B,6DAAoB;AAChD;AACA;AACA;AACA,QAAQ;AACR;AACA,YAAY,4DAAmB;AAC/B;AACA;AACA,cAAc,uDAAc;AAC5B;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,kBAAkB;AACtC;AACA,UAAU,uDAAc;AACxB;AACA;AACA;AACA,mBAAmB,oDAAW;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,cAAc,4DAAmB;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,oBAAoB,sDAAa;AACjC,MAAM,0DAAiB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,sDAAa;AACjC,MAAM,0DAAiB;AACvB;AACA;AACA;AACA;AACA;AACA,MAAM;AACN,sBAAsB,kBAAkB;AACxC;AACA,YAAY,oDAAW;AACvB,+BAA+B,qEAAqB;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,6DAAoB;AAC9C;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU,2DAAkB,mBAAmB,wDAAe,CAAC,uDAAc;AAC7E;AACA;AACA,UAAU,2DAAkB,kBAAkB,wDAAe,CAAC,uDAAc;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA,IAAI;AACJ;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,sDAAa;AACjC,OAAO,0DAAiB;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,SAAS,oDAAW;AACxB;AACA;AACA,sFAAsF,oDAAW;AACjG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,4DAAmB;AACzB,sBAAsB,6DAAoB;AAC1C;AACA,IAAI;AACJ;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,iBAAiB,yEAAqB;AACtC;AACA,+CAA+C,EAAE;AACjD;AACA;AACA,oBAAoB,yEAAqB;AACzC;AACA,sDAAsD,EAAE;AACxD;AACA;AACA;AACA;;AAEA;AACA,2BAA2B,gDAAW;AACtC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,eAAe,gDAAW;AAC1B,iBAAiB,uDAAc;AAC/B;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,kBAAkB;AACtC;AACA,UAAU,uDAAc;AACxB;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,uDAAc;AACzB;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,6DAAoB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,oCAAoC,yDAAgB;AACpD;AACA;AACA,SAAS,0DAAiB;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,4DAAmB;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,4DAAmB;AACrD;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA,IAAI,oEAA2B;AAC/B;AACA;AACA,IAAI,+DAAsB;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,8DAAqB;AAC9B;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,uBAAuB,gDAAW;AAClC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,eAAe,gDAAW;AAC1B,iBAAiB,uDAAc;AAC/B;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,sDAAa;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,0BAA0B;AAC9C;AACA;AACA;AACA;AACA;AACA,gEAAgE,uDAAc,oDAAoD,wDAAe;AACjJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,WAAW;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,4DAAmB;AAC9C,sBAAsB,iCAAiC;AACvD;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,4DAAmB;AACvD;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA,IAAI,oEAA2B;AAC/B;AACA;AACA,IAAI,+DAAsB;AAC1B;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,kBAAkB;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,sDAAa;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,8DAAqB;AAC9B;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,kCAAkC,sDAAa;;AAE/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,sDAAa;AACtB;AACA;AACA,GAAG,EAAE,yDAAoB,0BAA0B,2DAAsB;AACzE;AACA,GAAG,EAAE,yDAAoB,0BAA0B,yDAAoB;AACvE;AACA,GAAG,EAAE,yDAAoB,0BAA0B,uDAAkB;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,EAAE,yDAAoB,0BAA0B,sDAAiB;AACpE;AACA;AACA;AACA,6BAA6B,mEAA0B;AACvD;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,GAAG,EAAE,yDAAoB,0BAA0B,2DAAsB;AACzE;AACA,wBAAwB,sDAAa;AACrC,UAAU,0DAAiB;AAC3B;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,8BAA8B,4DAAmB,qBAAqB,uDAAc;AACpF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG,EAAE,yDAAoB;AACzB;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,uEAAuE;AACvE;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,OAAO;AACP;AACA;AACA,OAAO;AACP;AACA,GAAG;AACH;AACA;AACA;AACA,OAAO,sDAAa;AACpB;AACA;;AAEA;AACA;AACA,MAAM,sDAAa;AACnB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,eAAe,kEAAkB;AACjC;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,8CAA8C;AAC9C;AACA;AACA,kDAAkD;;AAElD;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,sDAAa;AACrB;AACA,qBAAqB,oEAA2B;AAChD;AACA;AACA,uBAAuB,mEAA0B;AACjD;AACA;AACA,cAAc,sDAAa,CAAC,6DAAwB;AACpD,cAAc,sDAAa,CAAC,2DAAsB;AAClD,cAAc;AACd;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,SAAS,sDAAa;AACtB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,mEAA0B;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,kCAAkC,sDAAa;AAC/C,sCAAsC,sDAAa;AACnD,oCAAoC,sDAAa;AACjD,4BAA4B,sDAAa;AACzC;AACA,yBAAyB,sDAAa;AACtC;AACA;AACA,GAAG,EAAE,yDAAoB;AACzB;AACA;AACA;AACA,MAAM;AACN,qBAAqB,sDAAa;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,EAAE,yDAAoB;AACzB;AACA;AACA,GAAG,EAAE,yDAAoB;AACzB;AACA;AACA,GAAG,EAAE,yDAAoB,0BAA0B,6DAAwB;AAC3E;AACA;AACA,GAAG,EAAE,yDAAoB;AACzB;AACA;AACA,UAAU,oDAAW;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA,wBAAwB,sDAAa;AACrC,UAAU,0DAAiB;AAC3B;AACA;AACA;AACA,GAAG,gCAAgC,6CAAQ;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,4DAAmB;AACpD;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;;AAEA;AACA,oBAAoB,mBAAmB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,oBAAoB,mBAAmB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,eAAe,GAAG,oBAAoB;AACrD;AACA;AACA,sBAAsB,wDAAe;AACrC;AACA,WAAW,gEAAY;AACvB,GAAG;AACH,UAAU,iDAAQ;AAClB;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,WAAW,sDAAa,CAAC,0DAAM;AAC/B;AACA;AACA,OAAO;AACP,KAAK,GAAG,0DAAM;AACd;AACA,CAAC;AACD;AACA,0CAA0C,gBAAgB;AAC1D,IAAI,oBAAoB;AACxB,IAAI,iCAAiC;AACrC;AACA;AACA;AACA,2BAA2B,wDAAe;AAC1C,UAAU,iDAAQ;AAClB;AACA,GAAG;AACH;AACA;AACA;AACA,CAAC;;AAEgb","sources":["/Users/marcmintel/Projects/e-tib.com/node_modules/.pnpm/@lexical+list@0.41.0/node_modules/@lexical/list/LexicalList.dev.mjs"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { effect, namedSignals } from '@lexical/extension';\nimport { $getNearestNodeOfType, removeClassNamesFromElement, addClassNamesToElement, isHTMLElement, mergeRegister, $findMatchingParent, calculateZoomLevel } from '@lexical/utils';\nimport { $getSelection, $isRangeSelection, $isRootOrShadowRoot, $createParagraphNode, $isElementNode, $isLeafNode, $setPointFromCaret, $normalizeCaret, $getChildCaret, $isTextNode, ElementNode, buildImportMap, $isParagraphNode, $applyNodeReplacement, normalizeClassNames, $createTextNode, createCommand, COMMAND_PRIORITY_LOW, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, KEY_ESCAPE_COMMAND, KEY_SPACE_COMMAND, $getNearestNodeFromDOMNode, KEY_ARROW_LEFT_COMMAND, getNearestEditorFromDOMNode, $addUpdateTag, SKIP_SELECTION_FOCUS_TAG, SKIP_DOM_SELECTION_TAG, defineExtension, safeCast, $getNodeByKey, INSERT_PARAGRAPH_COMMAND, TextNode } from 'lexical';\nimport { getStyleObjectFromCSS } from '@lexical/selection';\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n// Do not require this module directly! Use normal `invariant` calls.\n\nfunction formatDevErrorMessage(message) {\n  throw new Error(message);\n}\n\n/**\n * Checks the depth of listNode from the root node.\n * @param listNode - The ListNode to be checked.\n * @returns The depth of the ListNode.\n */\nfunction $getListDepth(listNode) {\n  let depth = 1;\n  let parent = listNode.getParent();\n  while (parent != null) {\n    if ($isListItemNode(parent)) {\n      const parentList = parent.getParent();\n      if ($isListNode(parentList)) {\n        depth++;\n        parent = parentList.getParent();\n        continue;\n      }\n      {\n        formatDevErrorMessage(`A ListItemNode must have a ListNode for a parent.`);\n      }\n    }\n    return depth;\n  }\n  return depth;\n}\n\n/**\n * Finds the nearest ancestral ListNode and returns it, throws an invariant if listItem is not a ListItemNode.\n * @param listItem - The node to be checked.\n * @returns The ListNode found.\n */\nfunction $getTopListNode(listItem) {\n  let list = listItem.getParent();\n  if (!$isListNode(list)) {\n    {\n      formatDevErrorMessage(`A ListItemNode must have a ListNode for a parent.`);\n    }\n  }\n  let parent = list;\n  while (parent !== null) {\n    parent = parent.getParent();\n    if ($isListNode(parent)) {\n      list = parent;\n    }\n  }\n  return list;\n}\n\n/**\n * A recursive Depth-First Search (Postorder Traversal) that finds all of a node's children\n * that are of type ListItemNode and returns them in an array.\n * @param node - The ListNode to start the search.\n * @returns An array containing all nodes of type ListItemNode found.\n */\n// This should probably be $getAllChildrenOfType\nfunction $getAllListItems(node) {\n  let listItemNodes = [];\n  const listChildren = node.getChildren().filter($isListItemNode);\n  for (let i = 0; i < listChildren.length; i++) {\n    const listItemNode = listChildren[i];\n    const firstChild = listItemNode.getFirstChild();\n    if ($isListNode(firstChild)) {\n      listItemNodes = listItemNodes.concat($getAllListItems(firstChild));\n    } else {\n      listItemNodes.push(listItemNode);\n    }\n  }\n  return listItemNodes;\n}\n\n/**\n * Checks to see if the passed node is a ListItemNode and has a ListNode as a child.\n * @param node - The node to be checked.\n * @returns true if the node is a ListItemNode and has a ListNode child, false otherwise.\n */\nfunction isNestedListNode(node) {\n  return $isListItemNode(node) && $isListNode(node.getFirstChild());\n}\n\n/**\n * Takes a deeply nested ListNode or ListItemNode and traverses up the branch to delete the first\n * ancestral ListNode (which could be the root ListNode) or ListItemNode with siblings, essentially\n * bringing the deeply nested node up the branch once. Would remove sublist if it has siblings.\n * Should not break ListItem -> List -> ListItem chain as empty List/ItemNodes should be removed on .remove().\n * @param sublist - The nested ListNode or ListItemNode to be brought up the branch.\n */\nfunction $removeHighestEmptyListParent(sublist) {\n  // Nodes may be repeatedly indented, to create deeply nested lists that each\n  // contain just one bullet.\n  // Our goal is to remove these (empty) deeply nested lists. The easiest\n  // way to do that is crawl back up the tree until we find a node that has siblings\n  // (e.g. is actually part of the list contents) and delete that, or delete\n  // the root of the list (if no list nodes have siblings.)\n  let emptyListPtr = sublist;\n  while (emptyListPtr.getNextSibling() == null && emptyListPtr.getPreviousSibling() == null) {\n    const parent = emptyListPtr.getParent();\n    if (parent == null || !($isListItemNode(parent) || $isListNode(parent))) {\n      break;\n    }\n    emptyListPtr = parent;\n  }\n  emptyListPtr.remove();\n}\n\n/**\n * Wraps a node into a ListItemNode.\n * @param node - The node to be wrapped into a ListItemNode\n * @returns The ListItemNode which the passed node is wrapped in.\n */\nfunction $wrapInListItem(node) {\n  const listItemWrapper = $createListItemNode();\n  return listItemWrapper.append(node);\n}\n\n/**\n * Calculates the start value for a new list created by splitting an existing list.\n */\nfunction $getNewListStart(list, listItem) {\n  return list.getStart() + listItem.getIndexWithinParent();\n}\n\nfunction $isSelectingEmptyListItem(anchorNode, nodes) {\n  return $isListItemNode(anchorNode) && (nodes.length === 0 || nodes.length === 1 && anchorNode.is(nodes[0]) && anchorNode.getChildrenSize() === 0);\n}\n\n/**\n * Inserts a new ListNode. If the selection's anchor node is an empty ListItemNode and is a child of\n * the root/shadow root, it will replace the ListItemNode with a ListNode and the old ListItemNode.\n * Otherwise it will replace its parent with a new ListNode and re-insert the ListItemNode and any previous children.\n * If the selection's anchor node is not an empty ListItemNode, it will add a new ListNode or merge an existing ListNode,\n * unless the the node is a leaf node, in which case it will attempt to find a ListNode up the branch and replace it with\n * a new ListNode, or create a new ListNode at the nearest root/shadow root.\n * @param listType - The type of list, \"number\" | \"bullet\" | \"check\".\n */\nfunction $insertList(listType) {\n  const selection = $getSelection();\n  if (selection !== null) {\n    let nodes = selection.getNodes();\n    if ($isRangeSelection(selection)) {\n      const anchorAndFocus = selection.getStartEndPoints();\n      if (!(anchorAndFocus !== null)) {\n        formatDevErrorMessage(`insertList: anchor should be defined`);\n      }\n      const [anchor] = anchorAndFocus;\n      const anchorNode = anchor.getNode();\n      const anchorNodeParent = anchorNode.getParent();\n      if ($isRootOrShadowRoot(anchorNode)) {\n        const firstChild = anchorNode.getFirstChild();\n        if (firstChild) {\n          nodes = firstChild.selectStart().getNodes();\n        } else {\n          const paragraph = $createParagraphNode();\n          anchorNode.append(paragraph);\n          nodes = paragraph.select().getNodes();\n        }\n      } else if ($isSelectingEmptyListItem(anchorNode, nodes)) {\n        const list = $createListNode(listType);\n        if ($isRootOrShadowRoot(anchorNodeParent)) {\n          anchorNode.replace(list);\n          const listItem = $createListItemNode();\n          if ($isElementNode(anchorNode)) {\n            listItem.setFormat(anchorNode.getFormatType());\n            listItem.setIndent(anchorNode.getIndent());\n          }\n          list.append(listItem);\n        } else if ($isListItemNode(anchorNode)) {\n          const parent = anchorNode.getParentOrThrow();\n          append(list, parent.getChildren());\n          parent.replace(list);\n        }\n        return;\n      }\n    }\n    const handled = new Set();\n    for (let i = 0; i < nodes.length; i++) {\n      const node = nodes[i];\n      if ($isElementNode(node) && node.isEmpty() && !$isListItemNode(node) && !handled.has(node.getKey())) {\n        $createListOrMerge(node, listType);\n        continue;\n      }\n      let parent = $isLeafNode(node) ? node.getParent() : $isListItemNode(node) && node.isEmpty() ? node : null;\n      while (parent != null) {\n        const parentKey = parent.getKey();\n        if ($isListNode(parent)) {\n          if (!handled.has(parentKey)) {\n            const newListNode = $createListNode(listType);\n            append(newListNode, parent.getChildren());\n            parent.replace(newListNode);\n            handled.add(parentKey);\n          }\n          break;\n        } else {\n          const nextParent = parent.getParent();\n          if ($isRootOrShadowRoot(nextParent) && !handled.has(parentKey)) {\n            handled.add(parentKey);\n            $createListOrMerge(parent, listType);\n            break;\n          }\n          parent = nextParent;\n        }\n      }\n    }\n  }\n}\nfunction append(node, nodesToAppend) {\n  node.splice(node.getChildrenSize(), 0, nodesToAppend);\n}\nfunction $createListOrMerge(node, listType) {\n  if ($isListNode(node)) {\n    return node;\n  }\n  const previousSibling = node.getPreviousSibling();\n  const nextSibling = node.getNextSibling();\n  const listItem = $createListItemNode();\n  append(listItem, node.getChildren());\n  let targetList;\n  if ($isListNode(previousSibling) && listType === previousSibling.getListType()) {\n    previousSibling.append(listItem);\n    // if the same type of list is on both sides, merge them.\n    if ($isListNode(nextSibling) && listType === nextSibling.getListType()) {\n      append(previousSibling, nextSibling.getChildren());\n      nextSibling.remove();\n    }\n    targetList = previousSibling;\n  } else if ($isListNode(nextSibling) && listType === nextSibling.getListType()) {\n    nextSibling.getFirstChildOrThrow().insertBefore(listItem);\n    targetList = nextSibling;\n  } else {\n    const list = $createListNode(listType);\n    list.append(listItem);\n    node.replace(list);\n    targetList = list;\n  }\n  // listItem needs to be attached to root prior to setting indent\n  listItem.setFormat(node.getFormatType());\n  listItem.setIndent(node.getIndent());\n\n  // Preserve element-anchored selections by updating them to anchor to the listItem instead of the listNode.\n  const selection = $getSelection();\n  if ($isRangeSelection(selection)) {\n    if (targetList.getKey() === selection.anchor.key) {\n      selection.anchor.set(listItem.getKey(), selection.anchor.offset, 'element');\n    }\n    if (targetList.getKey() === selection.focus.key) {\n      selection.focus.set(listItem.getKey(), selection.focus.offset, 'element');\n    }\n  }\n  node.remove();\n  return targetList;\n}\n\n/**\n * A recursive function that goes through each list and their children, including nested lists,\n * appending list2 children after list1 children and updating ListItemNode values.\n * @param list1 - The first list to be merged.\n * @param list2 - The second list to be merged.\n */\nfunction mergeLists(list1, list2) {\n  const listItem1 = list1.getLastChild();\n  const listItem2 = list2.getFirstChild();\n  if (listItem1 && listItem2 && isNestedListNode(listItem1) && isNestedListNode(listItem2)) {\n    mergeLists(listItem1.getFirstChild(), listItem2.getFirstChild());\n    listItem2.remove();\n  }\n  const toMerge = list2.getChildren();\n  if (toMerge.length > 0) {\n    list1.append(...toMerge);\n  }\n  list2.remove();\n}\n\n/**\n * Searches for the nearest ancestral ListNode and removes it. If selection is an empty ListItemNode\n * it will remove the whole list, including the ListItemNode. For each ListItemNode in the ListNode,\n * removeList will also generate new ParagraphNodes in the removed ListNode's place. Any child node\n * inside a ListItemNode will be appended to the new ParagraphNodes.\n */\nfunction $removeList() {\n  const selection = $getSelection();\n  if ($isRangeSelection(selection)) {\n    const listNodes = new Set();\n    const nodes = selection.getNodes();\n    const anchorNode = selection.anchor.getNode();\n    if ($isSelectingEmptyListItem(anchorNode, nodes)) {\n      listNodes.add($getTopListNode(anchorNode));\n    } else {\n      for (let i = 0; i < nodes.length; i++) {\n        const node = nodes[i];\n        if ($isLeafNode(node)) {\n          const listItemNode = $getNearestNodeOfType(node, ListItemNode);\n          if (listItemNode != null) {\n            listNodes.add($getTopListNode(listItemNode));\n          }\n        }\n      }\n    }\n    for (const listNode of listNodes) {\n      let insertionPoint = listNode;\n      const listItems = $getAllListItems(listNode);\n      for (const listItemNode of listItems) {\n        const paragraph = $createParagraphNode().setTextStyle(selection.style).setTextFormat(selection.format);\n        append(paragraph, listItemNode.getChildren());\n        insertionPoint.insertAfter(paragraph);\n        insertionPoint = paragraph;\n\n        // When the anchor and focus fall on the textNode\n        // we don't have to change the selection because the textNode will be appended to\n        // the newly generated paragraph.\n        // When selection is in empty nested list item, selection is actually on the listItemNode.\n        // When the corresponding listItemNode is deleted and replaced by the newly generated paragraph\n        // we should manually set the selection's focus and anchor to the newly generated paragraph.\n        if (listItemNode.__key === selection.anchor.key) {\n          $setPointFromCaret(selection.anchor, $normalizeCaret($getChildCaret(paragraph, 'next')));\n        }\n        if (listItemNode.__key === selection.focus.key) {\n          $setPointFromCaret(selection.focus, $normalizeCaret($getChildCaret(paragraph, 'next')));\n        }\n        listItemNode.remove();\n      }\n      listNode.remove();\n    }\n  }\n}\n\n/**\n * Takes the value of a child ListItemNode and makes it the value the ListItemNode\n * should be if it isn't already. Also ensures that checked is undefined if the\n * parent does not have a list type of 'check'.\n * @param list - The list whose children are updated.\n */\nfunction updateChildrenListItemValue(list) {\n  const isNotChecklist = list.getListType() !== 'check';\n  let value = list.getStart();\n  for (const child of list.getChildren()) {\n    if ($isListItemNode(child)) {\n      if (child.getValue() !== value) {\n        child.setValue(value);\n      }\n      if (isNotChecklist && child.getLatest().__checked != null) {\n        child.setChecked(undefined);\n      }\n      if (!$isListNode(child.getFirstChild())) {\n        value++;\n      }\n    }\n  }\n}\n\n/**\n * Merge the next sibling list if same type.\n * <ul> will merge with <ul>, but NOT <ul> with <ol>.\n * @param list - The list whose next sibling should be potentially merged\n */\nfunction mergeNextSiblingListIfSameType(list) {\n  const nextSibling = list.getNextSibling();\n  if ($isListNode(nextSibling) && list.getListType() === nextSibling.getListType()) {\n    mergeLists(list, nextSibling);\n  }\n}\n\n/**\n * Adds an empty ListNode/ListItemNode chain at listItemNode, so as to\n * create an indent effect. Won't indent ListItemNodes that have a ListNode as\n * a child, but does merge sibling ListItemNodes if one has a nested ListNode.\n * @param listItemNode - The ListItemNode to be indented.\n */\nfunction $handleIndent(listItemNode) {\n  // go through each node and decide where to move it.\n  const removed = new Set();\n  if (isNestedListNode(listItemNode) || removed.has(listItemNode.getKey())) {\n    return;\n  }\n  const parent = listItemNode.getParent();\n\n  // We can cast both of the below `isNestedListNode` only returns a boolean type instead of a user-defined type guards\n  const nextSibling = listItemNode.getNextSibling();\n  const previousSibling = listItemNode.getPreviousSibling();\n  // if there are nested lists on either side, merge them all together.\n\n  if (isNestedListNode(nextSibling) && isNestedListNode(previousSibling)) {\n    const innerList = previousSibling.getFirstChild();\n    if ($isListNode(innerList)) {\n      innerList.append(listItemNode);\n      const nextInnerList = nextSibling.getFirstChild();\n      if ($isListNode(nextInnerList)) {\n        const children = nextInnerList.getChildren();\n        append(innerList, children);\n        nextSibling.remove();\n        removed.add(nextSibling.getKey());\n      }\n    }\n  } else if (isNestedListNode(nextSibling)) {\n    // if the ListItemNode is next to a nested ListNode, merge them\n    const innerList = nextSibling.getFirstChild();\n    if ($isListNode(innerList)) {\n      const firstChild = innerList.getFirstChild();\n      if (firstChild !== null) {\n        firstChild.insertBefore(listItemNode);\n      }\n    }\n  } else if (isNestedListNode(previousSibling)) {\n    const innerList = previousSibling.getFirstChild();\n    if ($isListNode(innerList)) {\n      innerList.append(listItemNode);\n    }\n  } else {\n    // otherwise, we need to create a new nested ListNode\n\n    if ($isListNode(parent)) {\n      const newListItem = $createListItemNode().setTextFormat(listItemNode.getTextFormat()).setTextStyle(listItemNode.getTextStyle());\n      const newList = $createListNode(parent.getListType()).setTextFormat(parent.getTextFormat()).setTextStyle(parent.getTextStyle());\n      newListItem.append(newList);\n      newList.append(listItemNode);\n      if (previousSibling) {\n        previousSibling.insertAfter(newListItem);\n      } else if (nextSibling) {\n        nextSibling.insertBefore(newListItem);\n      } else {\n        parent.append(newListItem);\n      }\n    }\n  }\n}\n\n/**\n * Removes an indent by removing an empty ListNode/ListItemNode chain. An indented ListItemNode\n * has a great grandparent node of type ListNode, which is where the ListItemNode will reside\n * within as a child.\n * @param listItemNode - The ListItemNode to remove the indent (outdent).\n */\nfunction $handleOutdent(listItemNode) {\n  // go through each node and decide where to move it.\n\n  if (isNestedListNode(listItemNode)) {\n    return;\n  }\n  const parentList = listItemNode.getParent();\n  const grandparentListItem = parentList ? parentList.getParent() : undefined;\n  const greatGrandparentList = grandparentListItem ? grandparentListItem.getParent() : undefined;\n  // If it doesn't have these ancestors, it's not indented.\n\n  if ($isListNode(greatGrandparentList) && $isListItemNode(grandparentListItem) && $isListNode(parentList)) {\n    // if it's the first child in it's parent list, insert it into the\n    // great grandparent list before the grandparent\n    const firstChild = parentList ? parentList.getFirstChild() : undefined;\n    const lastChild = parentList ? parentList.getLastChild() : undefined;\n    if (listItemNode.is(firstChild)) {\n      grandparentListItem.insertBefore(listItemNode);\n      if (parentList.isEmpty()) {\n        grandparentListItem.remove();\n      }\n      // if it's the last child in it's parent list, insert it into the\n      // great grandparent list after the grandparent.\n    } else if (listItemNode.is(lastChild)) {\n      grandparentListItem.insertAfter(listItemNode);\n      if (parentList.isEmpty()) {\n        grandparentListItem.remove();\n      }\n    } else {\n      // otherwise, we need to split the siblings into two new nested lists\n      const listType = parentList.getListType();\n      const previousSiblingsListItem = $createListItemNode();\n      const previousSiblingsList = $createListNode(listType);\n      previousSiblingsListItem.append(previousSiblingsList);\n      listItemNode.getPreviousSiblings().forEach(sibling => previousSiblingsList.append(sibling));\n      const nextSiblingsListItem = $createListItemNode();\n      const nextSiblingsList = $createListNode(listType);\n      nextSiblingsListItem.append(nextSiblingsList);\n      append(nextSiblingsList, listItemNode.getNextSiblings());\n      // put the sibling nested lists on either side of the grandparent list item in the great grandparent.\n      grandparentListItem.insertBefore(previousSiblingsListItem);\n      grandparentListItem.insertAfter(nextSiblingsListItem);\n      // replace the grandparent list item (now between the siblings) with the outdented list item.\n      grandparentListItem.replace(listItemNode);\n    }\n  }\n}\n\n/**\n * Attempts to insert a ParagraphNode at selection and selects the new node. The selection must contain a ListItemNode\n * or a node that does not already contain text. If its grandparent is the root/shadow root, it will get the ListNode\n * (which should be the parent node) and insert the ParagraphNode as a sibling to the ListNode. If the ListNode is\n * nested in a ListItemNode instead, it will add the ParagraphNode after the grandparent ListItemNode.\n * Throws an invariant if the selection is not a child of a ListNode.\n * @returns true if a ParagraphNode was inserted successfully, false if there is no selection\n * or the selection does not contain a ListItemNode or the node already holds text.\n */\nfunction $handleListInsertParagraph(restoreNumbering = false) {\n  const selection = $getSelection();\n  if (!$isRangeSelection(selection) || !selection.isCollapsed()) {\n    return false;\n  }\n  // Only run this code on empty list items (including whitespace-only)\n  const anchor = selection.anchor.getNode();\n  let listItem = null;\n  if ($isListItemNode(anchor) && anchor.getChildrenSize() === 0) {\n    // Truly empty list item (element selection)\n    listItem = anchor;\n  } else if ($isTextNode(anchor)) {\n    // Check if the entire list item contains only whitespace text nodes\n    const parentListItem = anchor.getParent();\n    if ($isListItemNode(parentListItem) && parentListItem.getChildren().every(node => $isTextNode(node) && node.getTextContent().trim() === '')) {\n      listItem = parentListItem;\n    }\n  }\n  if (listItem === null) {\n    return false;\n  }\n  const topListNode = $getTopListNode(listItem);\n  const parent = listItem.getParent();\n  if (!$isListNode(parent)) {\n    formatDevErrorMessage(`A ListItemNode must have a ListNode for a parent.`);\n  }\n  const grandparent = parent.getParent();\n  let replacementNode;\n  if ($isRootOrShadowRoot(grandparent)) {\n    replacementNode = $createParagraphNode();\n    topListNode.insertAfter(replacementNode);\n  } else if ($isListItemNode(grandparent)) {\n    replacementNode = $createListItemNode();\n    grandparent.insertAfter(replacementNode);\n  } else {\n    return false;\n  }\n  replacementNode.setTextStyle(selection.style).setTextFormat(selection.format).select();\n  const nextSiblings = listItem.getNextSiblings();\n  if (nextSiblings.length > 0) {\n    const newStart = restoreNumbering ? $getNewListStart(parent, listItem) : 1;\n    const newList = $createListNode(parent.getListType(), newStart);\n    if ($isListItemNode(replacementNode)) {\n      const newListItem = $createListItemNode();\n      newListItem.append(newList);\n      replacementNode.insertAfter(newListItem);\n    } else {\n      replacementNode.insertAfter(newList);\n    }\n    newList.append(...nextSiblings);\n  }\n\n  // Don't leave hanging nested empty lists\n  $removeHighestEmptyListParent(listItem);\n  return true;\n}\n\nfunction applyMarkerStyles(dom, node, prevNode) {\n  const styles = getStyleObjectFromCSS(node.__textStyle);\n  for (const k in styles) {\n    dom.style.setProperty(`--listitem-marker-${k}`, styles[k]);\n  }\n  if (prevNode) {\n    for (const k in getStyleObjectFromCSS(prevNode.__textStyle)) {\n      if (!(k in styles)) {\n        dom.style.removeProperty(`--listitem-marker-${k}`);\n      }\n    }\n  }\n}\n\n/** @noInheritDoc */\nclass ListItemNode extends ElementNode {\n  /** @internal */\n  __value;\n  /** @internal */\n  __checked;\n\n  /** @internal */\n  $config() {\n    return this.config('listitem', {\n      $transform: node => {\n        if (node.__checked == null) {\n          return;\n        }\n        const parent = node.getParent();\n        if ($isListNode(parent)) {\n          if (parent.getListType() !== 'check' && node.getChecked() != null) {\n            node.setChecked(undefined);\n          }\n        }\n      },\n      extends: ElementNode,\n      importDOM: buildImportMap({\n        li: () => ({\n          conversion: $convertListItemElement,\n          priority: 0\n        })\n      })\n    });\n  }\n  constructor(value = 1, checked = undefined, key) {\n    super(key);\n    this.__value = value === undefined ? 1 : value;\n    this.__checked = checked;\n  }\n  afterCloneFrom(prevNode) {\n    super.afterCloneFrom(prevNode);\n    this.__value = prevNode.__value;\n    this.__checked = prevNode.__checked;\n  }\n  createDOM(config) {\n    const element = document.createElement('li');\n    this.updateListItemDOM(null, element, config);\n    return element;\n  }\n  updateListItemDOM(prevNode, dom, config) {\n    updateListItemChecked(dom, this, prevNode);\n    dom.value = this.__value;\n    $setListItemThemeClassNames(dom, config.theme, this);\n    const prevStyle = prevNode ? prevNode.__style : '';\n    const nextStyle = this.__style;\n    if (prevStyle !== nextStyle) {\n      if (nextStyle === '') {\n        dom.removeAttribute('style');\n      } else {\n        dom.style.cssText = nextStyle;\n      }\n    }\n    applyMarkerStyles(dom, this, prevNode);\n  }\n  updateDOM(prevNode, dom, config) {\n    // @ts-expect-error - this is always HTMLListItemElement\n    const element = dom;\n    this.updateListItemDOM(prevNode, element, config);\n    return false;\n  }\n  updateFromJSON(serializedNode) {\n    return super.updateFromJSON(serializedNode).setValue(serializedNode.value).setChecked(serializedNode.checked);\n  }\n  exportDOM(editor) {\n    const element = this.createDOM(editor._config);\n    const formatType = this.getFormatType();\n    if (formatType) {\n      element.style.textAlign = formatType;\n    }\n    const direction = this.getDirection();\n    if (direction) {\n      element.dir = direction;\n    }\n    return {\n      element\n    };\n  }\n  exportJSON() {\n    return {\n      ...super.exportJSON(),\n      checked: this.getChecked(),\n      value: this.getValue()\n    };\n  }\n  append(...nodes) {\n    for (let i = 0; i < nodes.length; i++) {\n      const node = nodes[i];\n      if ($isElementNode(node) && this.canMergeWith(node)) {\n        const children = node.getChildren();\n        this.append(...children);\n        node.remove();\n      } else {\n        super.append(node);\n      }\n    }\n    return this;\n  }\n  replace(replaceWithNode, includeChildren) {\n    if ($isListItemNode(replaceWithNode)) {\n      return super.replace(replaceWithNode);\n    }\n    this.setIndent(0);\n    const list = this.getParentOrThrow();\n    if (!$isListNode(list)) {\n      return replaceWithNode;\n    }\n    if (list.__first === this.getKey()) {\n      list.insertBefore(replaceWithNode);\n    } else if (list.__last === this.getKey()) {\n      list.insertAfter(replaceWithNode);\n    } else {\n      // Split the list\n      const newList = $createListNode(list.getListType());\n      let nextSibling = this.getNextSibling();\n      while (nextSibling) {\n        const nodeToAppend = nextSibling;\n        nextSibling = nextSibling.getNextSibling();\n        newList.append(nodeToAppend);\n      }\n      list.insertAfter(replaceWithNode);\n      replaceWithNode.insertAfter(newList);\n    }\n    if (includeChildren) {\n      if (!$isElementNode(replaceWithNode)) {\n        formatDevErrorMessage(`includeChildren should only be true for ElementNodes`);\n      }\n      this.getChildren().forEach(child => {\n        replaceWithNode.append(child);\n      });\n    }\n    this.remove();\n    if (list.getChildrenSize() === 0) {\n      list.remove();\n    }\n    return replaceWithNode;\n  }\n  insertAfter(node, restoreSelection = true) {\n    const listNode = this.getParentOrThrow();\n    if (!$isListNode(listNode)) {\n      {\n        formatDevErrorMessage(`insertAfter: list node is not parent of list item node`);\n      }\n    }\n    if ($isListItemNode(node)) {\n      return super.insertAfter(node, restoreSelection);\n    }\n    const siblings = this.getNextSiblings();\n\n    // Split the lists and insert the node in between them\n    listNode.insertAfter(node, restoreSelection);\n    if (siblings.length !== 0) {\n      const newListNode = $createListNode(listNode.getListType());\n      siblings.forEach(sibling => newListNode.append(sibling));\n      node.insertAfter(newListNode, restoreSelection);\n    }\n    return node;\n  }\n  remove(preserveEmptyParent) {\n    const prevSibling = this.getPreviousSibling();\n    const nextSibling = this.getNextSibling();\n    super.remove(preserveEmptyParent);\n    if (prevSibling && nextSibling && isNestedListNode(prevSibling) && isNestedListNode(nextSibling)) {\n      mergeLists(prevSibling.getFirstChild(), nextSibling.getFirstChild());\n      nextSibling.remove();\n    }\n  }\n  insertNewAfter(_, restoreSelection = true) {\n    const newElement = $createListItemNode().updateFromJSON(this.exportJSON()).setChecked(this.getChecked() ? false : undefined);\n    this.insertAfter(newElement, restoreSelection);\n    return newElement;\n  }\n  collapseAtStart(selection) {\n    const paragraph = $createParagraphNode();\n    const children = this.getChildren();\n    children.forEach(child => paragraph.append(child));\n    const listNode = this.getParentOrThrow();\n    const listNodeParent = listNode.getParentOrThrow();\n    const isIndented = $isListItemNode(listNodeParent);\n    if (listNode.getChildrenSize() === 1) {\n      if (isIndented) {\n        // if the list node is nested, we just want to remove it,\n        // effectively unindenting it.\n        listNode.remove();\n        listNodeParent.select();\n      } else {\n        listNode.insertBefore(paragraph);\n        listNode.remove();\n        // If we have selection on the list item, we'll need to move it\n        // to the paragraph\n        const anchor = selection.anchor;\n        const focus = selection.focus;\n        const key = paragraph.getKey();\n        if (anchor.type === 'element' && anchor.getNode().is(this)) {\n          anchor.set(key, anchor.offset, 'element');\n        }\n        if (focus.type === 'element' && focus.getNode().is(this)) {\n          focus.set(key, focus.offset, 'element');\n        }\n      }\n    } else {\n      listNode.insertBefore(paragraph);\n      this.remove();\n    }\n    return true;\n  }\n  getValue() {\n    const self = this.getLatest();\n    return self.__value;\n  }\n  setValue(value) {\n    const self = this.getWritable();\n    self.__value = value;\n    return self;\n  }\n  getChecked() {\n    const self = this.getLatest();\n    let listType;\n    const parent = this.getParent();\n    if ($isListNode(parent)) {\n      listType = parent.getListType();\n    }\n    return listType === 'check' ? Boolean(self.__checked) : undefined;\n  }\n  setChecked(checked) {\n    const self = this.getWritable();\n    self.__checked = checked;\n    return self;\n  }\n  toggleChecked() {\n    const self = this.getWritable();\n    return self.setChecked(!self.__checked);\n  }\n  getIndent() {\n    // If we don't have a parent, we are likely serializing\n    const parent = this.getParent();\n    if (parent === null || !this.isAttached()) {\n      return this.getLatest().__indent;\n    }\n    // ListItemNode should always have a ListNode for a parent.\n    let listNodeParent = parent.getParentOrThrow();\n    let indentLevel = 0;\n    while ($isListItemNode(listNodeParent)) {\n      listNodeParent = listNodeParent.getParentOrThrow().getParentOrThrow();\n      indentLevel++;\n    }\n    return indentLevel;\n  }\n  setIndent(indent) {\n    if (!(typeof indent === 'number')) {\n      formatDevErrorMessage(`Invalid indent value.`);\n    }\n    indent = Math.floor(indent);\n    if (!(indent >= 0)) {\n      formatDevErrorMessage(`Indent value must be non-negative.`);\n    }\n    let currentIndent = this.getIndent();\n    while (currentIndent !== indent) {\n      if (currentIndent < indent) {\n        $handleIndent(this);\n        currentIndent++;\n      } else {\n        $handleOutdent(this);\n        currentIndent--;\n      }\n    }\n    return this;\n  }\n\n  /** @deprecated @internal */\n  canInsertAfter(node) {\n    return $isListItemNode(node);\n  }\n\n  /** @deprecated @internal */\n  canReplaceWith(replacement) {\n    return $isListItemNode(replacement);\n  }\n  canMergeWith(node) {\n    return $isListItemNode(node) || $isParagraphNode(node);\n  }\n  extractWithChild(child, selection) {\n    if (!$isRangeSelection(selection)) {\n      return false;\n    }\n    const anchorNode = selection.anchor.getNode();\n    const focusNode = selection.focus.getNode();\n    return this.isParentOf(anchorNode) && this.isParentOf(focusNode) && this.getTextContent().length === selection.getTextContent().length;\n  }\n  isParentRequired() {\n    return true;\n  }\n  createParentElementNode() {\n    return $createListNode('bullet');\n  }\n  canMergeWhenEmpty() {\n    return true;\n  }\n}\nfunction $setListItemThemeClassNames(dom, editorThemeClasses, node) {\n  const classesToAdd = [];\n  const classesToRemove = [];\n  const listTheme = editorThemeClasses.list;\n  const listItemClassName = listTheme ? listTheme.listitem : undefined;\n  let nestedListItemClassName;\n  if (listTheme && listTheme.nested) {\n    nestedListItemClassName = listTheme.nested.listitem;\n  }\n  if (listItemClassName !== undefined) {\n    classesToAdd.push(...normalizeClassNames(listItemClassName));\n  }\n  if (listTheme) {\n    const parentNode = node.getParent();\n    const isCheckList = $isListNode(parentNode) && parentNode.getListType() === 'check';\n    const checked = node.getChecked();\n    if (!isCheckList || checked) {\n      classesToRemove.push(listTheme.listitemUnchecked);\n    }\n    if (!isCheckList || !checked) {\n      classesToRemove.push(listTheme.listitemChecked);\n    }\n    if (isCheckList) {\n      classesToAdd.push(checked ? listTheme.listitemChecked : listTheme.listitemUnchecked);\n    }\n  }\n  if (nestedListItemClassName !== undefined) {\n    const nestedListItemClasses = normalizeClassNames(nestedListItemClassName);\n    if (node.getChildren().some(child => $isListNode(child))) {\n      classesToAdd.push(...nestedListItemClasses);\n    } else {\n      classesToRemove.push(...nestedListItemClasses);\n    }\n  }\n  if (classesToRemove.length > 0) {\n    removeClassNamesFromElement(dom, ...classesToRemove);\n  }\n  if (classesToAdd.length > 0) {\n    addClassNamesToElement(dom, ...classesToAdd);\n  }\n}\nfunction updateListItemChecked(dom, listItemNode, prevListItemNode) {\n  const parent = listItemNode.getParent();\n  const isCheckbox = $isListNode(parent) && parent.getListType() === 'check' &&\n  // Only add attributes for leaf list items\n  !$isListNode(listItemNode.getFirstChild());\n  if (!isCheckbox) {\n    dom.removeAttribute('role');\n    dom.removeAttribute('tabIndex');\n    dom.removeAttribute('aria-checked');\n  } else {\n    dom.setAttribute('role', 'checkbox');\n    dom.setAttribute('tabIndex', '-1');\n    if (!prevListItemNode || listItemNode.__checked !== prevListItemNode.__checked) {\n      dom.setAttribute('aria-checked', listItemNode.getChecked() ? 'true' : 'false');\n    }\n  }\n}\nfunction $convertListItemElement(domNode) {\n  const isGitHubCheckList = domNode.classList.contains('task-list-item');\n  if (isGitHubCheckList) {\n    for (const child of domNode.children) {\n      if (child.tagName === 'INPUT') {\n        return $convertCheckboxInput(child);\n      }\n    }\n  }\n  const isJoplinCheckList = domNode.classList.contains('joplin-checkbox');\n  if (isJoplinCheckList) {\n    for (const child of domNode.children) {\n      if (child.classList.contains('checkbox-wrapper') && child.children.length > 0 && child.children[0].tagName === 'INPUT') {\n        return $convertCheckboxInput(child.children[0]);\n      }\n    }\n  }\n  const ariaCheckedAttr = domNode.getAttribute('aria-checked');\n  const checked = ariaCheckedAttr === 'true' ? true : ariaCheckedAttr === 'false' ? false : undefined;\n  return {\n    node: $createListItemNode(checked)\n  };\n}\nfunction $convertCheckboxInput(domNode) {\n  const isCheckboxInput = domNode.getAttribute('type') === 'checkbox';\n  if (!isCheckboxInput) {\n    return {\n      node: null\n    };\n  }\n  const checked = domNode.hasAttribute('checked');\n  return {\n    node: $createListItemNode(checked)\n  };\n}\n\n/**\n * Creates a new List Item node, passing true/false will convert it to a checkbox input.\n * @param checked - Is the List Item a checkbox and, if so, is it checked? undefined/null: not a checkbox, true/false is a checkbox and checked/unchecked, respectively.\n * @returns The new List Item.\n */\nfunction $createListItemNode(checked) {\n  return $applyNodeReplacement(new ListItemNode(undefined, checked));\n}\n\n/**\n * Checks to see if the node is a ListItemNode.\n * @param node - The node to be checked.\n * @returns true if the node is a ListItemNode, false otherwise.\n */\nfunction $isListItemNode(node) {\n  return node instanceof ListItemNode;\n}\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n/** @noInheritDoc */\nclass ListNode extends ElementNode {\n  /** @internal */\n  __tag;\n  /** @internal */\n  __start;\n  /** @internal */\n  __listType;\n\n  /** @internal */\n  $config() {\n    return this.config('list', {\n      $transform: node => {\n        mergeNextSiblingListIfSameType(node);\n        updateChildrenListItemValue(node);\n      },\n      extends: ElementNode,\n      importDOM: buildImportMap({\n        ol: () => ({\n          conversion: $convertListNode,\n          priority: 0\n        }),\n        ul: () => ({\n          conversion: $convertListNode,\n          priority: 0\n        })\n      })\n    });\n  }\n  constructor(listType = 'number', start = 1, key) {\n    super(key);\n    const _listType = TAG_TO_LIST_TYPE[listType] || listType;\n    this.__listType = _listType;\n    this.__tag = _listType === 'number' ? 'ol' : 'ul';\n    this.__start = start;\n  }\n  afterCloneFrom(prevNode) {\n    super.afterCloneFrom(prevNode);\n    this.__listType = prevNode.__listType;\n    this.__tag = prevNode.__tag;\n    this.__start = prevNode.__start;\n  }\n  getTag() {\n    return this.getLatest().__tag;\n  }\n  setListType(type) {\n    const writable = this.getWritable();\n    writable.__listType = type;\n    writable.__tag = type === 'number' ? 'ol' : 'ul';\n    return writable;\n  }\n  getListType() {\n    return this.getLatest().__listType;\n  }\n  getStart() {\n    return this.getLatest().__start;\n  }\n  setStart(start) {\n    const self = this.getWritable();\n    self.__start = start;\n    return self;\n  }\n\n  // View\n\n  createDOM(config, _editor) {\n    const tag = this.__tag;\n    const dom = document.createElement(tag);\n    if (this.__start !== 1) {\n      dom.setAttribute('start', String(this.__start));\n    }\n    // @ts-expect-error Internal field.\n    dom.__lexicalListType = this.__listType;\n    $setListThemeClassNames(dom, config.theme, this);\n    return dom;\n  }\n  updateDOM(prevNode, dom, config) {\n    if (prevNode.__tag !== this.__tag || prevNode.__listType !== this.__listType) {\n      return true;\n    }\n    $setListThemeClassNames(dom, config.theme, this);\n    if (prevNode.__start !== this.__start) {\n      dom.setAttribute('start', String(this.__start));\n    }\n    return false;\n  }\n  updateFromJSON(serializedNode) {\n    return super.updateFromJSON(serializedNode).setListType(serializedNode.listType).setStart(serializedNode.start);\n  }\n  exportDOM(editor) {\n    const element = this.createDOM(editor._config, editor);\n    if (isHTMLElement(element)) {\n      if (this.__start !== 1) {\n        element.setAttribute('start', String(this.__start));\n      }\n      if (this.__listType === 'check') {\n        element.setAttribute('__lexicalListType', 'check');\n      }\n    }\n    return {\n      element\n    };\n  }\n  exportJSON() {\n    return {\n      ...super.exportJSON(),\n      listType: this.getListType(),\n      start: this.getStart(),\n      tag: this.getTag()\n    };\n  }\n  canBeEmpty() {\n    return false;\n  }\n  canIndent() {\n    return false;\n  }\n  splice(start, deleteCount, nodesToInsert) {\n    let listItemNodesToInsert = nodesToInsert;\n    for (let i = 0; i < nodesToInsert.length; i++) {\n      const node = nodesToInsert[i];\n      if (!$isListItemNode(node)) {\n        if (listItemNodesToInsert === nodesToInsert) {\n          listItemNodesToInsert = [...nodesToInsert];\n        }\n        listItemNodesToInsert[i] = $createListItemNode().append($isElementNode(node) && !($isListNode(node) || node.isInline()) ? $createTextNode(node.getTextContent()) : node);\n      }\n    }\n    return super.splice(start, deleteCount, listItemNodesToInsert);\n  }\n  extractWithChild(child) {\n    return $isListItemNode(child);\n  }\n}\nfunction $setListThemeClassNames(dom, editorThemeClasses, node) {\n  const classesToAdd = [];\n  const classesToRemove = [];\n  const listTheme = editorThemeClasses.list;\n  if (listTheme !== undefined) {\n    const listLevelsClassNames = listTheme[`${node.__tag}Depth`] || [];\n    const listDepth = $getListDepth(node) - 1;\n    const normalizedListDepth = listDepth % listLevelsClassNames.length;\n    const listLevelClassName = listLevelsClassNames[normalizedListDepth];\n    const listClassName = listTheme[node.__tag];\n    let nestedListClassName;\n    const nestedListTheme = listTheme.nested;\n    const checklistClassName = listTheme.checklist;\n    if (nestedListTheme !== undefined && nestedListTheme.list) {\n      nestedListClassName = nestedListTheme.list;\n    }\n    if (listClassName !== undefined) {\n      classesToAdd.push(listClassName);\n    }\n    if (checklistClassName !== undefined && node.__listType === 'check') {\n      classesToAdd.push(checklistClassName);\n    }\n    if (listLevelClassName !== undefined) {\n      classesToAdd.push(...normalizeClassNames(listLevelClassName));\n      for (let i = 0; i < listLevelsClassNames.length; i++) {\n        if (i !== normalizedListDepth) {\n          classesToRemove.push(node.__tag + i);\n        }\n      }\n    }\n    if (nestedListClassName !== undefined) {\n      const nestedListItemClasses = normalizeClassNames(nestedListClassName);\n      if (listDepth > 1) {\n        classesToAdd.push(...nestedListItemClasses);\n      } else {\n        classesToRemove.push(...nestedListItemClasses);\n      }\n    }\n  }\n  if (classesToRemove.length > 0) {\n    removeClassNamesFromElement(dom, ...classesToRemove);\n  }\n  if (classesToAdd.length > 0) {\n    addClassNamesToElement(dom, ...classesToAdd);\n  }\n}\n\n/*\n * This function normalizes the children of a ListNode after the conversion from HTML,\n * ensuring that they are all ListItemNodes and contain either a single nested ListNode\n * or some other inline content.\n */\nfunction $normalizeChildren(nodes) {\n  const normalizedListItems = [];\n  for (let i = 0; i < nodes.length; i++) {\n    const node = nodes[i];\n    if ($isListItemNode(node)) {\n      normalizedListItems.push(node);\n      const children = node.getChildren();\n      if (children.length > 1) {\n        children.forEach(child => {\n          if ($isListNode(child)) {\n            normalizedListItems.push($wrapInListItem(child));\n          }\n        });\n      }\n    } else {\n      normalizedListItems.push($wrapInListItem(node));\n    }\n  }\n  return normalizedListItems;\n}\nfunction isDomChecklist(domNode) {\n  if (domNode.getAttribute('__lexicallisttype') === 'check' ||\n  // is github checklist\n  domNode.classList.contains('contains-task-list') ||\n  // is joplin checklist\n  domNode.getAttribute('data-is-checklist') === '1') {\n    return true;\n  }\n  // if children are checklist items, the node is a checklist ul. Applicable for googledoc checklist pasting.\n  for (const child of domNode.childNodes) {\n    if (isHTMLElement(child) && child.hasAttribute('aria-checked')) {\n      return true;\n    }\n  }\n  return false;\n}\nfunction $convertListNode(domNode) {\n  const nodeName = domNode.nodeName.toLowerCase();\n  let node = null;\n  if (nodeName === 'ol') {\n    // @ts-ignore\n    const start = domNode.start;\n    node = $createListNode('number', start);\n  } else if (nodeName === 'ul') {\n    if (isDomChecklist(domNode)) {\n      node = $createListNode('check');\n    } else {\n      node = $createListNode('bullet');\n    }\n  }\n  return {\n    after: $normalizeChildren,\n    node\n  };\n}\nconst TAG_TO_LIST_TYPE = {\n  ol: 'number',\n  ul: 'bullet'\n};\n\n/**\n * Creates a ListNode of listType.\n * @param listType - The type of list to be created. Can be 'number', 'bullet', or 'check'.\n * @param start - Where an ordered list starts its count, start = 1 if left undefined.\n * @returns The new ListNode\n */\nfunction $createListNode(listType = 'number', start = 1) {\n  return $applyNodeReplacement(new ListNode(listType, start));\n}\n\n/**\n * Checks to see if the node is a ListNode.\n * @param node - The node to be checked.\n * @returns true if the node is a ListNode, false otherwise.\n */\nfunction $isListNode(node) {\n  return node instanceof ListNode;\n}\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nconst INSERT_CHECK_LIST_COMMAND = createCommand('INSERT_CHECK_LIST_COMMAND');\n\n/**\n * Registers the checklist plugin with the editor.\n * @param editor The LexicalEditor instance.\n * @param options Optional configuration.\n *   - disableTakeFocusOnClick: If true, clicking a checklist item will not focus the editor (useful for mobile).\n */\nfunction registerCheckList(editor, options) {\n  const disableTakeFocusOnClick = options && options.disableTakeFocusOnClick || false;\n  const configHandleClick = event => {\n    handleClick(event, disableTakeFocusOnClick);\n  };\n  const configHandleSelectDefaults = event => {\n    handleSelectDefaults(event, disableTakeFocusOnClick);\n  };\n  return mergeRegister(editor.registerCommand(INSERT_CHECK_LIST_COMMAND, () => {\n    $insertList('check');\n    return true;\n  }, COMMAND_PRIORITY_LOW), editor.registerCommand(KEY_ARROW_DOWN_COMMAND, event => {\n    return handleArrowUpOrDown(event, editor, false);\n  }, COMMAND_PRIORITY_LOW), editor.registerCommand(KEY_ARROW_UP_COMMAND, event => {\n    return handleArrowUpOrDown(event, editor, true);\n  }, COMMAND_PRIORITY_LOW), editor.registerCommand(KEY_ESCAPE_COMMAND, () => {\n    const activeItem = getActiveCheckListItem();\n    if (activeItem != null) {\n      const rootElement = editor.getRootElement();\n      if (rootElement != null) {\n        rootElement.focus();\n      }\n      return true;\n    }\n    return false;\n  }, COMMAND_PRIORITY_LOW), editor.registerCommand(KEY_SPACE_COMMAND, event => {\n    const activeItem = getActiveCheckListItem();\n    if (activeItem != null && editor.isEditable()) {\n      editor.update(() => {\n        const listItemNode = $getNearestNodeFromDOMNode(activeItem);\n        if ($isListItemNode(listItemNode)) {\n          event.preventDefault();\n          listItemNode.toggleChecked();\n        }\n      });\n      return true;\n    }\n    return false;\n  }, COMMAND_PRIORITY_LOW), editor.registerCommand(KEY_ARROW_LEFT_COMMAND, event => {\n    return editor.getEditorState().read(() => {\n      const selection = $getSelection();\n      if ($isRangeSelection(selection) && selection.isCollapsed()) {\n        const {\n          anchor\n        } = selection;\n        const isElement = anchor.type === 'element';\n        if (isElement || anchor.offset === 0) {\n          const anchorNode = anchor.getNode();\n          const elementNode = $findMatchingParent(anchorNode, node => $isElementNode(node) && !node.isInline());\n          if ($isListItemNode(elementNode)) {\n            const parent = elementNode.getParent();\n            if ($isListNode(parent) && parent.getListType() === 'check' && (isElement || elementNode.getFirstDescendant() === anchorNode)) {\n              const domNode = editor.getElementByKey(elementNode.__key);\n              if (domNode != null && document.activeElement !== domNode) {\n                domNode.focus();\n                event.preventDefault();\n                return true;\n              }\n            }\n          }\n        }\n      }\n      return false;\n    });\n  }, COMMAND_PRIORITY_LOW), editor.registerRootListener((rootElement, prevElement) => {\n    if (rootElement !== null) {\n      rootElement.addEventListener('click', configHandleClick);\n      // Use capture so we run before other listeners that might move focus.\n      rootElement.addEventListener('pointerdown', configHandleSelectDefaults, {\n        capture: true\n      });\n      // Some browsers / integrations still generate mousedown events; handle them too.\n      rootElement.addEventListener('mousedown', configHandleSelectDefaults, {\n        capture: true\n      });\n      // Intercept touchstart to stop the mobile browser from placing the caret\n      // and opening the keyboard when tapping the checklist marker.\n      rootElement.addEventListener('touchstart', configHandleSelectDefaults, {\n        capture: true,\n        passive: false\n      });\n    }\n    if (prevElement !== null) {\n      prevElement.removeEventListener('click', configHandleClick);\n      prevElement.removeEventListener('pointerdown', configHandleSelectDefaults, {\n        capture: true\n      });\n      prevElement.removeEventListener('mousedown', configHandleSelectDefaults, {\n        capture: true\n      });\n      prevElement.removeEventListener('touchstart', configHandleSelectDefaults, {\n        capture: true\n      });\n    }\n  }));\n}\nfunction handleCheckItemEvent(event, callback) {\n  const target = event.target;\n  if (!isHTMLElement(target)) {\n    return;\n  }\n\n  // Ignore clicks on LI that have nested lists\n  const firstChild = target.firstChild;\n  if (isHTMLElement(firstChild) && (firstChild.tagName === 'UL' || firstChild.tagName === 'OL')) {\n    return;\n  }\n  const parentNode = target.parentNode;\n\n  // @ts-ignore internal field\n  if (!parentNode || parentNode.__lexicalListType !== 'check') {\n    return;\n  }\n  let clientX = null;\n  let pointerType = null;\n  if ('clientX' in event) {\n    clientX = event.clientX;\n  } else if ('touches' in event) {\n    const touches = event.touches;\n    if (touches.length > 0) {\n      clientX = touches[0].clientX;\n      pointerType = 'touch';\n    }\n  }\n\n  // If we couldn't resolve a clientX (unexpected input), bail out.\n  if (clientX == null) {\n    return;\n  }\n  const rect = target.getBoundingClientRect();\n  const zoom = calculateZoomLevel(target);\n  const clientXInPixels = clientX / zoom;\n\n  // Use getComputedStyle if available, otherwise fallback to 0px width\n  const beforeStyles = window.getComputedStyle ? window.getComputedStyle(target, '::before') : {\n    width: '0px'\n  };\n  const beforeWidthInPixels = parseFloat(beforeStyles.width);\n\n  // Make click area slightly larger for touch devices to improve accessibility\n  // Determine whether this is a touch event; some environments may supply\n  // pointerType on PointerEvent while touch events use the `touches` API above.\n  const isTouchEvent = pointerType === 'touch' || event.pointerType === 'touch';\n  const clickAreaPadding = isTouchEvent ? 32 : 0; // Add 32px padding for touch events\n\n  if (target.dir === 'rtl' ? clientXInPixels < rect.right + clickAreaPadding && clientXInPixels > rect.right - beforeWidthInPixels - clickAreaPadding : clientXInPixels > rect.left - clickAreaPadding && clientXInPixels < rect.left + beforeWidthInPixels + clickAreaPadding) {\n    callback();\n  }\n}\nfunction handleClick(event, disableFocusOnClick) {\n  handleCheckItemEvent(event, () => {\n    if (isHTMLElement(event.target)) {\n      const domNode = event.target;\n      const editor = getNearestEditorFromDOMNode(domNode);\n      if (editor != null && editor.isEditable()) {\n        editor.update(() => {\n          const node = $getNearestNodeFromDOMNode(domNode);\n          if ($isListItemNode(node)) {\n            if (disableFocusOnClick) {\n              $addUpdateTag(SKIP_SELECTION_FOCUS_TAG);\n              $addUpdateTag(SKIP_DOM_SELECTION_TAG);\n            } else {\n              domNode.focus();\n            }\n            node.toggleChecked();\n          }\n        });\n      }\n    }\n  });\n}\n\n/**\n * Prevents default focus switch behavior\n *\n * @param event might be of type PointerEvent, MouseEvent, or TouchEvent, hence the generic Event type\n *\n */\nfunction handleSelectDefaults(event, disableTakeFocusOnClick) {\n  handleCheckItemEvent(event, () => {\n    // Prevents caret moving when clicking on check mark.\n    event.preventDefault();\n    if (disableTakeFocusOnClick) {\n      event.stopPropagation();\n    }\n  });\n}\nfunction getActiveCheckListItem() {\n  const activeElement = document.activeElement;\n  return isHTMLElement(activeElement) && activeElement.tagName === 'LI' && activeElement.parentNode != null &&\n  // @ts-ignore internal field\n  activeElement.parentNode.__lexicalListType === 'check' ? activeElement : null;\n}\nfunction findCheckListItemSibling(node, backward) {\n  let sibling = backward ? node.getPreviousSibling() : node.getNextSibling();\n  let parent = node;\n\n  // Going up in a tree to get non-null sibling\n  while (sibling == null && $isListItemNode(parent)) {\n    // Get li -> parent ul/ol -> parent li\n    parent = parent.getParentOrThrow().getParent();\n    if (parent != null) {\n      sibling = backward ? parent.getPreviousSibling() : parent.getNextSibling();\n    }\n  }\n\n  // Going down in a tree to get first non-nested list item\n  while ($isListItemNode(sibling)) {\n    const firstChild = backward ? sibling.getLastChild() : sibling.getFirstChild();\n    if (!$isListNode(firstChild)) {\n      return sibling;\n    }\n    sibling = backward ? firstChild.getLastChild() : firstChild.getFirstChild();\n  }\n  return null;\n}\nfunction handleArrowUpOrDown(event, editor, backward) {\n  const activeItem = getActiveCheckListItem();\n  if (activeItem != null) {\n    editor.update(() => {\n      const listItem = $getNearestNodeFromDOMNode(activeItem);\n      if (!$isListItemNode(listItem)) {\n        return;\n      }\n      const nextListItem = findCheckListItemSibling(listItem, backward);\n      if (nextListItem != null) {\n        nextListItem.selectStart();\n        const dom = editor.getElementByKey(nextListItem.__key);\n        if (dom != null) {\n          event.preventDefault();\n          setTimeout(() => {\n            dom.focus();\n          }, 0);\n        }\n      }\n    });\n  }\n  return false;\n}\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nconst UPDATE_LIST_START_COMMAND = createCommand('UPDATE_LIST_START_COMMAND');\nconst INSERT_UNORDERED_LIST_COMMAND = createCommand('INSERT_UNORDERED_LIST_COMMAND');\nconst INSERT_ORDERED_LIST_COMMAND = createCommand('INSERT_ORDERED_LIST_COMMAND');\nconst REMOVE_LIST_COMMAND = createCommand('REMOVE_LIST_COMMAND');\nfunction registerList(editor, options) {\n  const removeListener = mergeRegister(editor.registerCommand(INSERT_ORDERED_LIST_COMMAND, () => {\n    $insertList('number');\n    return true;\n  }, COMMAND_PRIORITY_LOW), editor.registerCommand(UPDATE_LIST_START_COMMAND, payload => {\n    const {\n      listNodeKey,\n      newStart\n    } = payload;\n    const listNode = $getNodeByKey(listNodeKey);\n    if (!$isListNode(listNode)) {\n      return false;\n    }\n    if (listNode.getListType() === 'number') {\n      listNode.setStart(newStart);\n      updateChildrenListItemValue(listNode);\n    }\n    return true;\n  }, COMMAND_PRIORITY_LOW), editor.registerCommand(INSERT_UNORDERED_LIST_COMMAND, () => {\n    $insertList('bullet');\n    return true;\n  }, COMMAND_PRIORITY_LOW), editor.registerCommand(REMOVE_LIST_COMMAND, () => {\n    $removeList();\n    return true;\n  }, COMMAND_PRIORITY_LOW), editor.registerCommand(INSERT_PARAGRAPH_COMMAND, () => {\n    const shouldRestore = options && options.restoreNumbering;\n    return $handleListInsertParagraph(!!shouldRestore);\n  }, COMMAND_PRIORITY_LOW), editor.registerNodeTransform(ListItemNode, node => {\n    const firstChild = node.getFirstChild();\n    if (firstChild) {\n      if ($isTextNode(firstChild)) {\n        const style = firstChild.getStyle();\n        const format = firstChild.getFormat();\n        if (node.getTextStyle() !== style) {\n          node.setTextStyle(style);\n        }\n        if (node.getTextFormat() !== format) {\n          node.setTextFormat(format);\n        }\n      }\n    } else {\n      // If it's empty, check the selection\n      const selection = $getSelection();\n      if ($isRangeSelection(selection) && (selection.style !== node.getTextStyle() || selection.format !== node.getTextFormat()) && selection.isCollapsed() && node.is(selection.anchor.getNode())) {\n        node.setTextStyle(selection.style).setTextFormat(selection.format);\n      }\n    }\n  }), editor.registerNodeTransform(TextNode, node => {\n    const listItemParentNode = node.getParent();\n    if ($isListItemNode(listItemParentNode) && node.is(listItemParentNode.getFirstChild())) {\n      const style = node.getStyle();\n      const format = node.getFormat();\n      if (style !== listItemParentNode.getTextStyle() || format !== listItemParentNode.getTextFormat()) {\n        listItemParentNode.setTextStyle(style).setTextFormat(format);\n      }\n    }\n  }));\n  return removeListener;\n}\nfunction registerListStrictIndentTransform(editor) {\n  const $formatListIndentStrict = listItemNode => {\n    const listNode = listItemNode.getParent();\n    if ($isListNode(listItemNode.getFirstChild()) || !$isListNode(listNode)) {\n      return;\n    }\n    const startingListItemNode = $findMatchingParent(listItemNode, node => $isListItemNode(node) && $isListNode(node.getParent()) && $isListItemNode(node.getPreviousSibling()));\n    if (startingListItemNode === null && listItemNode.getIndent() > 0) {\n      listItemNode.setIndent(0);\n    } else if ($isListItemNode(startingListItemNode)) {\n      const prevListItemNode = startingListItemNode.getPreviousSibling();\n      if ($isListItemNode(prevListItemNode)) {\n        const endListItemNode = $findChildrenEndListItemNode(prevListItemNode);\n        const endListNode = endListItemNode.getParent();\n        if ($isListNode(endListNode)) {\n          const prevDepth = $getListDepth(endListNode);\n          const depth = $getListDepth(listNode);\n          if (prevDepth + 1 < depth) {\n            listItemNode.setIndent(prevDepth);\n          }\n        }\n      }\n    }\n  };\n  const $processListWithStrictIndent = listNode => {\n    const queue = [listNode];\n    while (queue.length > 0) {\n      const node = queue.shift();\n      if (!$isListNode(node)) {\n        continue;\n      }\n      for (const child of node.getChildren()) {\n        if ($isListItemNode(child)) {\n          $formatListIndentStrict(child);\n          const firstChild = child.getFirstChild();\n          if ($isListNode(firstChild)) {\n            queue.push(firstChild);\n          }\n        }\n      }\n    }\n  };\n  return editor.registerNodeTransform(ListNode, $processListWithStrictIndent);\n}\nfunction $findChildrenEndListItemNode(listItemNode) {\n  let current = listItemNode;\n  let firstChild = current.getFirstChild();\n  while ($isListNode(firstChild)) {\n    const lastChild = firstChild.getLastChild();\n    if ($isListItemNode(lastChild)) {\n      current = lastChild;\n      firstChild = current.getFirstChild();\n    } else {\n      break;\n    }\n  }\n  return current;\n}\n\n/**\n * @deprecated use {@link $insertList} from an update or command listener.\n *\n * Inserts a new ListNode. If the selection's anchor node is an empty ListItemNode and is a child of\n * the root/shadow root, it will replace the ListItemNode with a ListNode and the old ListItemNode.\n * Otherwise it will replace its parent with a new ListNode and re-insert the ListItemNode and any previous children.\n * If the selection's anchor node is not an empty ListItemNode, it will add a new ListNode or merge an existing ListNode,\n * unless the the node is a leaf node, in which case it will attempt to find a ListNode up the branch and replace it with\n * a new ListNode, or create a new ListNode at the nearest root/shadow root.\n * @param editor - The lexical editor.\n * @param listType - The type of list, \"number\" | \"bullet\" | \"check\".\n */\nfunction insertList(editor, listType) {\n  editor.update(() => $insertList(listType));\n}\n\n/**\n * @deprecated use {@link $removeList} from an update or command listener.\n *\n * Searches for the nearest ancestral ListNode and removes it. If selection is an empty ListItemNode\n * it will remove the whole list, including the ListItemNode. For each ListItemNode in the ListNode,\n * removeList will also generate new ParagraphNodes in the removed ListNode's place. Any child node\n * inside a ListItemNode will be appended to the new ParagraphNodes.\n * @param editor - The lexical editor.\n */\nfunction removeList(editor) {\n  editor.update(() => $removeList());\n}\n/**\n * Configures {@link ListNode}, {@link ListItemNode} and registers\n * the strict indent transform if `hasStrictIndent` is true (default false).\n */\nconst ListExtension = defineExtension({\n  build(editor, config, state) {\n    return namedSignals(config);\n  },\n  config: safeCast({\n    hasStrictIndent: false,\n    shouldPreserveNumbering: false\n  }),\n  name: '@lexical/list/List',\n  nodes: () => [ListNode, ListItemNode],\n  register(editor, config, state) {\n    const stores = state.getOutput();\n    return mergeRegister(effect(() => {\n      return registerList(editor, {\n        restoreNumbering: stores.shouldPreserveNumbering.value\n      });\n    }), effect(() => stores.hasStrictIndent.value ? registerListStrictIndentTransform(editor) : undefined));\n  }\n});\n/**\n * Registers checklist functionality for {@link ListNode} and\n * {@link ListItemNode} with a\n * {@link INSERT_CHECK_LIST_COMMAND} listener and\n * the expected keyboard and mouse interactions for\n * checkboxes.\n */\nconst CheckListExtension = defineExtension({\n  config: safeCast({\n    disableTakeFocusOnClick: false\n  }),\n  dependencies: [ListExtension],\n  name: '@lexical/list/CheckList',\n  register: registerCheckList\n});\n\nexport { $createListItemNode, $createListNode, $getListDepth, $handleListInsertParagraph, $insertList, $isListItemNode, $isListNode, $removeList, CheckListExtension, INSERT_CHECK_LIST_COMMAND, INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND, ListExtension, ListItemNode, ListNode, REMOVE_LIST_COMMAND, UPDATE_LIST_START_COMMAND, insertList, registerCheckList, registerList, registerListStrictIndentTransform, removeList };\n"],"names":[],"ignoreList":[0],"sourceRoot":""}\n//# sourceURL=webpack-internal:///(rsc)/./node_modules/.pnpm/@lexical+list@0.41.0/node_modules/@lexical/list/LexicalList.dev.mjs\n");
/***/ })
};
;
Reference in New Issue View Git Blame Copy Permalink