{"mappings":"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","names":["findWrapping","ReplaceAroundStep","canSplit","liftTarget","canJoin","NodeRange","Fragment","Slice","NodeType","Selection","olDOM","ulDOM","liDOM","orderedList","dom","node","bulletList","listItem","add","obj","props","copy","prop","addListNodes","nodes","itemContent","listGroup","wrapInList","listType","attrs","state","dispatch","$from","$to","range","tr","wrapRangeInList","doJoin","outerRange","doc","$insert","wrap","doWrapInList","wrappers","joinBefore","content","i","found","splitDepth","splitPos","parent","e","first","isItem","itemType","type","splitListItem","itemAttrs","grandParent","depthBefore","d","depthAfter","start","sel","pos","nextType","types","splitListItemKeepMarks","split","marks","liftListItem","liftToOuterList","liftOutOfList","end","endOfList","target","$after","list","$start","item","atStart","atEnd","indexBefore","sinkListItem","startIndex","nodeBefore","nestedBefore","inner","slice","before","after"],"sources":["../esm/npm/prosemirror-schema-list@1.6.0/node_modules/prosemirror-schema-list/dist/index.js"],"sourcesContent":["import { findWrapping, ReplaceAroundStep, canSplit, liftTarget, canJoin } from 'prosemirror-transform';\nimport { NodeRange, Fragment, Slice, NodeType } from 'prosemirror-model';\nimport { Selection } from 'prosemirror-state';\n\nconst olDOM = [\"ol\", 0], ulDOM = [\"ul\", 0], liDOM = [\"li\", 0];\n/**\nAn ordered list [node spec](https://prosemirror.net/docs/ref/#model.NodeSpec). Has a single\nattribute, `order`, which determines the number at which the list\nstarts counting, and defaults to 1. Represented as an `\u003col\u003e`\nelement.\n*/\nconst orderedList = {\n    attrs: { order: { default: 1, validate: \"number\" } },\n    parseDOM: [{ tag: \"ol\", getAttrs(dom) {\n                return { order: dom.hasAttribute(\"start\") ? +dom.getAttribute(\"start\") : 1 };\n            } }],\n    toDOM(node) {\n        return node.attrs.order == 1 ? olDOM : [\"ol\", { start: node.attrs.order }, 0];\n    }\n};\n/**\nA bullet list node spec, represented in the DOM as `\u003cul\u003e`.\n*/\nconst bulletList = {\n    parseDOM: [{ tag: \"ul\" }],\n    toDOM() { return ulDOM; }\n};\n/**\nA list item (`\u003cli\u003e`) spec.\n*/\nconst listItem = {\n    parseDOM: [{ tag: \"li\" }],\n    toDOM() { return liDOM; },\n    defining: true\n};\nfunction add(obj, props) {\n    let copy = {};\n    for (let prop in obj)\n        copy[prop] = obj[prop];\n    for (let prop in props)\n        copy[prop] = props[prop];\n    return copy;\n}\n/**\nConvenience function for adding list-related node types to a map\nspecifying the nodes for a schema. Adds\n[`orderedList`](https://prosemirror.net/docs/ref/#schema-list.orderedList) as `\"ordered_list\"`,\n[`bulletList`](https://prosemirror.net/docs/ref/#schema-list.bulletList) as `\"bullet_list\"`, and\n[`listItem`](https://prosemirror.net/docs/ref/#schema-list.listItem) as `\"list_item\"`.\n\n`itemContent` determines the content expression for the list items.\nIf you want the commands defined in this module to apply to your\nlist structure, it should have a shape like `\"paragraph block*\"` or\n`\"paragraph (ordered_list | bullet_list)*\"`. `listGroup` can be\ngiven to assign a group name to the list node types, for example\n`\"block\"`.\n*/\nfunction addListNodes(nodes, itemContent, listGroup) {\n    return nodes.append({\n        ordered_list: add(orderedList, { content: \"list_item+\", group: listGroup }),\n        bullet_list: add(bulletList, { content: \"list_item+\", group: listGroup }),\n        list_item: add(listItem, { content: itemContent })\n    });\n}\n/**\nReturns a command function that wraps the selection in a list with\nthe given type an attributes. If `dispatch` is null, only return a\nvalue to indicate whether this is possible, but don't actually\nperform the change.\n*/\nfunction wrapInList(listType, attrs = null) {\n    return function (state, dispatch) {\n        let { $from, $to } = state.selection;\n        let range = $from.blockRange($to);\n        if (!range)\n            return false;\n        let tr = dispatch ? state.tr : null;\n        if (!wrapRangeInList(tr, range, listType, attrs))\n            return false;\n        if (dispatch)\n            dispatch(tr.scrollIntoView());\n        return true;\n    };\n}\n/**\nTry to wrap the given node range in a list of the given type.\nReturn `true` when this is possible, `false` otherwise. When `tr`\nis non-null, the wrapping is added to that transaction. When it is\n`null`, the function only queries whether the wrapping is\npossible.\n*/\nfunction wrapRangeInList(tr, range, listType, attrs = null) {\n    let doJoin = false, outerRange = range, doc = range.$from.doc;\n    // This is at the top of an existing list item\n    if (range.depth \u003e= 2 \u0026\u0026 range.$from.node(range.depth - 1).type.compatibleContent(listType) \u0026\u0026 range.startIndex == 0) {\n        // Don't do anything if this is the top of the list\n        if (range.$from.index(range.depth - 1) == 0)\n            return false;\n        let $insert = doc.resolve(range.start - 2);\n        outerRange = new NodeRange($insert, $insert, range.depth);\n        if (range.endIndex \u003c range.parent.childCount)\n            range = new NodeRange(range.$from, doc.resolve(range.$to.end(range.depth)), range.depth);\n        doJoin = true;\n    }\n    let wrap = findWrapping(outerRange, listType, attrs, range);\n    if (!wrap)\n        return false;\n    if (tr)\n        doWrapInList(tr, range, wrap, doJoin, listType);\n    return true;\n}\nfunction doWrapInList(tr, range, wrappers, joinBefore, listType) {\n    let content = Fragment.empty;\n    for (let i = wrappers.length - 1; i \u003e= 0; i--)\n        content = Fragment.from(wrappers[i].type.create(wrappers[i].attrs, content));\n    tr.step(new ReplaceAroundStep(range.start - (joinBefore ? 2 : 0), range.end, range.start, range.end, new Slice(content, 0, 0), wrappers.length, true));\n    let found = 0;\n    for (let i = 0; i \u003c wrappers.length; i++)\n        if (wrappers[i].type == listType)\n            found = i + 1;\n    let splitDepth = wrappers.length - found;\n    let splitPos = range.start + wrappers.length - (joinBefore ? 2 : 0), parent = range.parent;\n    for (let i = range.startIndex, e = range.endIndex, first = true; i \u003c e; i++, first = false) {\n        if (!first \u0026\u0026 splitDepth \u0026\u0026 canSplit(tr.doc, splitPos, splitDepth)) {\n            tr.split(splitPos, splitDepth);\n            splitPos += 2 * splitDepth;\n        }\n        splitPos += parent.child(i).nodeSize;\n    }\n    return tr;\n}\nfunction isItem(itemType, type) {\n    return itemType instanceof NodeType ? type == itemType : itemType.indexOf(type) \u003e -1;\n}\n/**\nBuild a command that splits a non-empty textblock at the top level\nof a list item by also splitting that list item. `itemType` may be\nan array, when there are multiple node types that act as list\nitems. The new item gets the same type as the item that was split.\n*/\nfunction splitListItem(itemType, itemAttrs) {\n    return function (state, dispatch) {\n        let { $from, $to, node } = state.selection;\n        if ((node \u0026\u0026 node.isBlock) || $from.depth \u003c 2 || !$from.sameParent($to))\n            return false;\n        let grandParent = $from.node(-1);\n        if (!isItem(itemType, grandParent.type))\n            return false;\n        if ($from.parent.content.size == 0 \u0026\u0026 $from.node(-1).childCount == $from.indexAfter(-1)) {\n            // In an empty block. If this is a nested list, the wrapping\n            // list item should be split. Otherwise, bail out and let next\n            // command handle lifting.\n            if ($from.depth == 3 || !isItem(itemType, $from.node(-3).type) ||\n                $from.index(-2) != $from.node(-2).childCount - 1)\n                return false;\n            if (dispatch) {\n                let wrap = Fragment.empty;\n                let depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3;\n                // Build a fragment containing empty versions of the structure\n                // from the outer list item to the parent node of the cursor\n                for (let d = $from.depth - depthBefore; d \u003e= $from.depth - 3; d--)\n                    wrap = Fragment.from($from.node(d).copy(wrap));\n                let depthAfter = $from.indexAfter(-1) \u003c $from.node(-2).childCount ? 1\n                    : $from.indexAfter(-2) \u003c $from.node(-3).childCount ? 2 : 3;\n                // Add a second list item with an empty default start node\n                wrap = wrap.append(Fragment.from($from.node(-3).type.createAndFill()));\n                let start = $from.before($from.depth - (depthBefore - 1));\n                let tr = state.tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0));\n                let sel = -1;\n                tr.doc.nodesBetween(start, tr.doc.content.size, (node, pos) =\u003e {\n                    if (sel \u003e -1)\n                        return false;\n                    if (node.isTextblock \u0026\u0026 node.content.size == 0)\n                        sel = pos + 1;\n                });\n                if (sel \u003e -1)\n                    tr.setSelection(Selection.near(tr.doc.resolve(sel)));\n                dispatch(tr.scrollIntoView());\n            }\n            return true;\n        }\n        let nextType = $to.pos == $from.end() ? grandParent.contentMatchAt(0).defaultType : null;\n        let tr = state.tr.delete($from.pos, $to.pos);\n        let types = nextType ? [itemAttrs ? { type: grandParent.type, attrs: itemAttrs } : null, { type: nextType }] : undefined;\n        if (!canSplit(tr.doc, $from.pos, 2, types))\n            return false;\n        if (dispatch)\n            dispatch(tr.split($from.pos, 2, types).scrollIntoView());\n        return true;\n    };\n}\n/**\nActs like [`splitListItem`](https://prosemirror.net/docs/ref/#schema-list.splitListItem), but\nwithout resetting the set of active marks at the cursor.\n*/\nfunction splitListItemKeepMarks(itemType, itemAttrs) {\n    let split = splitListItem(itemType, itemAttrs);\n    return (state, dispatch) =\u003e {\n        return split(state, dispatch \u0026\u0026 (tr =\u003e {\n            let marks = state.storedMarks || (state.selection.$to.parentOffset \u0026\u0026 state.selection.$from.marks());\n            if (marks)\n                tr.ensureMarks(marks);\n            dispatch(tr);\n        }));\n    };\n}\n/**\nCreate a command to lift the list item around the selection up into\na wrapping list. `itemType` may be an array of list item types.\n*/\nfunction liftListItem(itemType) {\n    return function (state, dispatch) {\n        let { $from, $to } = state.selection;\n        let range = $from.blockRange($to, node =\u003e node.childCount \u003e 0 \u0026\u0026 isItem(itemType, node.firstChild.type));\n        if (!range)\n            return false;\n        if (!dispatch)\n            return true;\n        if (isItem(itemType, $from.node(range.depth - 1).type)) // Inside a parent list\n            return liftToOuterList(state, dispatch, range);\n        else // Outer list node\n            return liftOutOfList(state, dispatch, range);\n    };\n}\nfunction liftToOuterList(state, dispatch, range) {\n    let tr = state.tr, end = range.end, endOfList = range.$to.end(range.depth);\n    let itemType = range.parent.child(range.endIndex - 1).type;\n    if (end \u003c endOfList) {\n        // There are siblings after the lifted items, which must become\n        // children of the last item\n        tr.step(new ReplaceAroundStep(end - 1, endOfList, end, endOfList, new Slice(Fragment.from(itemType.create(null, range.parent.copy())), 1, 0), 1, true));\n        range = new NodeRange(tr.doc.resolve(range.$from.pos), tr.doc.resolve(endOfList), range.depth);\n    }\n    const target = liftTarget(range);\n    if (target == null)\n        return false;\n    tr.lift(range, target);\n    let $after = tr.doc.resolve(tr.mapping.map(end, -1) - 1);\n    if (canJoin(tr.doc, $after.pos) \u0026\u0026 $after.nodeBefore.type == $after.nodeAfter.type)\n        tr.join($after.pos);\n    dispatch(tr.scrollIntoView());\n    return true;\n}\nfunction liftOutOfList(state, dispatch, range) {\n    let tr = state.tr, list = range.parent;\n    // Merge the list items into a single big item\n    for (let pos = range.end, i = range.endIndex - 1, e = range.startIndex; i \u003e e; i--) {\n        pos -= list.child(i).nodeSize;\n        tr.delete(pos - 1, pos + 1);\n    }\n    let $start = tr.doc.resolve(range.start), item = $start.nodeAfter;\n    if (tr.mapping.map(range.end) != range.start + $start.nodeAfter.nodeSize)\n        return false;\n    let atStart = range.startIndex == 0, atEnd = range.endIndex == list.childCount;\n    let parent = $start.node(-1), indexBefore = $start.index(-1);\n    if (!parent.canReplace(indexBefore + (atStart ? 0 : 1), indexBefore + 1, item.content.append(atEnd ? Fragment.empty : Fragment.from(list))))\n        return false;\n    let start = $start.pos, end = start + item.nodeSize;\n    // Strip off the surrounding list. At the sides where we're not at\n    // the end of the list, the existing list is closed. At sides where\n    // this is the end, it is overwritten to its end.\n    tr.step(new ReplaceAroundStep(start - (atStart ? 1 : 0), end + (atEnd ? 1 : 0), start + 1, end - 1, new Slice((atStart ? Fragment.empty : Fragment.from(list.copy(Fragment.empty)))\n        .append(atEnd ? Fragment.empty : Fragment.from(list.copy(Fragment.empty))), atStart ? 0 : 1, atEnd ? 0 : 1), atStart ? 0 : 1));\n    dispatch(tr.scrollIntoView());\n    return true;\n}\n/**\nCreate a command to sink the list item around the selection down\ninto an inner list. `itemType` may be an array of list item types.\n*/\nfunction sinkListItem(itemType) {\n    return function (state, dispatch) {\n        let { $from, $to } = state.selection;\n        let range = $from.blockRange($to, node =\u003e node.childCount \u003e 0 \u0026\u0026 isItem(itemType, node.firstChild.type));\n        if (!range)\n            return false;\n        let startIndex = range.startIndex;\n        if (startIndex == 0)\n            return false;\n        let parent = range.parent, nodeBefore = parent.child(startIndex - 1);\n        if (!isItem(itemType, nodeBefore.type))\n            return false;\n        if (dispatch) {\n            let nestedBefore = nodeBefore.lastChild \u0026\u0026 nodeBefore.lastChild.type == parent.type;\n            let inner = Fragment.from(nestedBefore ? nodeBefore.lastChild.lastChild.type.create() : null);\n            let slice = new Slice(Fragment.from(nodeBefore.type.create(null, Fragment.from(parent.type.create(null, inner)))), nestedBefore ? 3 : 1, 0);\n            let before = range.start, after = range.end;\n            dispatch(state.tr.step(new ReplaceAroundStep(before - (nestedBefore ? 3 : 1), after, before, after, slice, 1, true))\n                .scrollIntoView());\n        }\n        return true;\n    };\n}\n\nexport { addListNodes, bulletList, liftListItem, listItem, orderedList, sinkListItem, splitListItem, splitListItemKeepMarks, wrapInList, wrapRangeInList };\n"],"version":3}
