{"version":3,"sources":["webpack:///./node_modules/@ckeditor/ckeditor5-link/theme/icons/unlink.svg","webpack:///./node_modules/@ckeditor/ckeditor5-list/src/converters.js","webpack:///./node_modules/@ckeditor/ckeditor5-link/theme/icons/link.svg"],"names":["module","exports","modelViewInsertion","model","evt","data","conversionApi","consumable","test","item","consume","modelItem","viewItem","generateLiInUl","injectViewList","modelViewRemove","viewPosition","mapper","toViewPosition","position","viewStart","getLastMatchingPosition","value","is","nodeAfter","viewWriter","writer","breakContainer","createPositionBefore","createPositionAfter","viewList","parent","viewListPrev","previousSibling","removeRange","createRangeOn","removed","remove","nextSibling","mergeViewLists","toModelElement","hoistNestedLists","getAttribute","start","_step","_iterator","_createForOfIteratorHelper","createRangeIn","getItems","s","n","done","child","unbindViewElement","err","e","f","stop","modelViewChangeType","toViewElement","listName","attributeNewValue","rename","modelViewMergeAfterChangeType","_step2","_iterator2","getChildren","modelViewChangeIndent","attributeOldValue","range","_step3","_iterator3","modelViewSplitOnInsert","name","lists","removeStart","removeEnd","createPositionAt","isEqual","createRange","push","length","i","previousList","nodeBefore","insertedRange","insert","end","mergePos","offset","modelViewMergeAfter","viewItemPrev","viewItemNext","viewModelConverter","listItem","createElement","indent","getIndent","setAttribute","type","safeInsert","modelCursor","nextPosition","viewToModelListItemChildrenConverter","modelRange","updateConversionResult","cleanList","children","Array","from","_i","_children","isWrongElement","isList","_remove","cleanListItem","childCount","_step4","Object","D_Projects_UA_repo_Source_Client_UA_User_Web_node_modules_babel_runtime_helpers_esm_toConsumableArray_js__WEBPACK_IMPORTED_MODULE_7__","foundList","firstNode","_iterator4","_data","trimStart","trimEnd","modelToViewPosition","view","isPhantom","modelPosition","_step5","topmostViewList","getAncestors","find","walker","getWalker","_iterator5","previousPosition","viewToModelPosition","viewPos","viewParent","isAtEnd","modelNode","modelLength","getModelLength","getShiftedBy","modelChangePostFixer","_step6","changes","document","differ","getChanges","itemToListHead","Map","applied","_iterator6","entry","_addListToFix","hasAttribute","removeAttribute","_step8","_iterator8","filter","innerItem","posAfter","attributeKey","_step7","_iterator7","values","listHead","_fixListIndents","_fixListTypes","previousNode","has","set","maxIndent","fixBy","itemIndent","newIndent","typesStack","prev","slice","modelIndentPasteFixer","_ref","selection","_ref2","D_Projects_UA_repo_Source_Client_UA_User_Web_node_modules_babel_runtime_helpers_esm_slicedToArray_js__WEBPACK_IMPORTED_MODULE_3__","content","selectable","getChild","this","createSelection","pos","getFirstPosition","refItem","indentChange","_setAttribute","listItemModel","viewChildren","_step9","schema","_iterator9","convertItem","result","convertedChild","wasSplit","checkChild","findNextListItem","startPosition","treeWalker","TreeWalker","next","nextIndent","modelRemoveStartPosition","viewRemoveStartPosition","viewRemovedItem","insertPosition","prevModelItem","getSiblingListItem","sameIndent","smallerIndent","listIndent","foo","prevIndent","prevViewList","positionAfterUiElements","_i2","_arr","move","viewElement"],"mappings":"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","file":"js/chunk-1aeaa218.c1eb0e30.js","sourcesContent":["module.exports = \"<svg viewBox=\\\"0 0 20 20\\\" xmlns=\\\"http://www.w3.org/2000/svg\\\"><path d=\\\"m11.077 15 .991-1.416a.75.75 0 1 1 1.229.86l-1.148 1.64a.748.748 0 0 1-.217.206 5.251 5.251 0 0 1-8.503-5.955.741.741 0 0 1 .12-.274l1.147-1.639a.75.75 0 1 1 1.228.86L4.933 10.7l.006.003a3.75 3.75 0 0 0 6.132 4.294l.006.004zm5.494-5.335a.748.748 0 0 1-.12.274l-1.147 1.639a.75.75 0 1 1-1.228-.86l.86-1.23a3.75 3.75 0 0 0-6.144-4.301l-.86 1.229a.75.75 0 0 1-1.229-.86l1.148-1.64a.748.748 0 0 1 .217-.206 5.251 5.251 0 0 1 8.503 5.955zm-4.563-2.532a.75.75 0 0 1 .184 1.045l-3.155 4.505a.75.75 0 1 1-1.229-.86l3.155-4.506a.75.75 0 0 1 1.045-.184zm4.919 10.562-1.414 1.414a.75.75 0 1 1-1.06-1.06l1.414-1.415-1.415-1.414a.75.75 0 0 1 1.061-1.06l1.414 1.414 1.414-1.415a.75.75 0 0 1 1.061 1.061l-1.414 1.414 1.414 1.415a.75.75 0 0 1-1.06 1.06l-1.415-1.414z\\\"/></svg>\"","/**\n * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved.\n * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license\n */\n\n/**\n * @module list/converters\n */\n\nimport { TreeWalker } from 'ckeditor5/src/engine';\n\nimport {\n\tgenerateLiInUl,\n\tinjectViewList,\n\tmergeViewLists,\n\tgetSiblingListItem,\n\tpositionAfterUiElements\n} from './utils';\n\n/**\n * A model-to-view converter for the `listItem` model element insertion.\n *\n * It creates a `<ul><li></li><ul>` (or `<ol>`) view structure out of a `listItem` model element, inserts it at the correct\n * position, and merges the list with surrounding lists (if available).\n *\n * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:insert\n * @param {module:engine/model/model~Model} model Model instance.\n * @returns {Function} Returns a conversion callback.\n */\nexport function modelViewInsertion( model ) {\n\treturn ( evt, data, conversionApi ) => {\n\t\tconst consumable = conversionApi.consumable;\n\n\t\tif ( !consumable.test( data.item, 'insert' ) ||\n\t\t\t!consumable.test( data.item, 'attribute:listType' ) ||\n\t\t\t!consumable.test( data.item, 'attribute:listIndent' )\n\t\t) {\n\t\t\treturn;\n\t\t}\n\n\t\tconsumable.consume( data.item, 'insert' );\n\t\tconsumable.consume( data.item, 'attribute:listType' );\n\t\tconsumable.consume( data.item, 'attribute:listIndent' );\n\n\t\tconst modelItem = data.item;\n\t\tconst viewItem = generateLiInUl( modelItem, conversionApi );\n\n\t\tinjectViewList( modelItem, viewItem, conversionApi, model );\n\t};\n}\n\n/**\n * A model-to-view converter for the `listItem` model element removal.\n *\n * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:remove\n * @param {module:engine/model/model~Model} model Model instance.\n * @returns {Function} Returns a conversion callback.\n */\nexport function modelViewRemove( model ) {\n\treturn ( evt, data, conversionApi ) => {\n\t\tconst viewPosition = conversionApi.mapper.toViewPosition( data.position );\n\t\tconst viewStart = viewPosition.getLastMatchingPosition( value => !value.item.is( 'element', 'li' ) );\n\t\tconst viewItem = viewStart.nodeAfter;\n\t\tconst viewWriter = conversionApi.writer;\n\n\t\t// 1. Break the container after and before the list item.\n\t\t// This will create a view list with one view list item - the one to remove.\n\t\tviewWriter.breakContainer( viewWriter.createPositionBefore( viewItem ) );\n\t\tviewWriter.breakContainer( viewWriter.createPositionAfter( viewItem ) );\n\n\t\t// 2. Remove the list with the item to remove.\n\t\tconst viewList = viewItem.parent;\n\t\tconst viewListPrev = viewList.previousSibling;\n\t\tconst removeRange = viewWriter.createRangeOn( viewList );\n\t\tconst removed = viewWriter.remove( removeRange );\n\n\t\t// 3. Merge the whole created by breaking and removing the list.\n\t\tif ( viewListPrev && viewListPrev.nextSibling ) {\n\t\t\tmergeViewLists( viewWriter, viewListPrev, viewListPrev.nextSibling );\n\t\t}\n\n\t\t// 4. Bring back nested list that was in the removed <li>.\n\t\tconst modelItem = conversionApi.mapper.toModelElement( viewItem );\n\n\t\thoistNestedLists( modelItem.getAttribute( 'listIndent' ) + 1, data.position, removeRange.start, viewItem, conversionApi, model );\n\n\t\t// 5. Unbind removed view item and all children.\n\t\tfor ( const child of viewWriter.createRangeIn( removed ).getItems() ) {\n\t\t\tconversionApi.mapper.unbindViewElement( child );\n\t\t}\n\n\t\tevt.stop();\n\t};\n}\n\n/**\n * A model-to-view converter for the `type` attribute change on the `listItem` model element.\n *\n * This change means that the `<li>` element parent changes from `<ul>` to `<ol>` (or vice versa). This is accomplished\n * by breaking view elements and changing their name. The next {@link module:list/converters~modelViewMergeAfterChangeType}\n * converter will attempt to merge split nodes.\n *\n * Splitting this conversion into 2 steps makes it possible to add an additional conversion in the middle.\n * Check {@link module:list/todolistconverters~modelViewChangeType} to see an example of it.\n *\n * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:attribute\n * @param {module:utils/eventinfo~EventInfo} evt An object containing information about the fired event.\n * @param {Object} data Additional information about the change.\n * @param {module:engine/conversion/downcastdispatcher~DowncastConversionApi} conversionApi Conversion interface.\n */\nexport function modelViewChangeType( evt, data, conversionApi ) {\n\tif ( !conversionApi.consumable.consume( data.item, 'attribute:listType' ) ) {\n\t\treturn;\n\t}\n\n\tconst viewItem = conversionApi.mapper.toViewElement( data.item );\n\tconst viewWriter = conversionApi.writer;\n\n\t// Break the container after and before the list item.\n\t// This will create a view list with one view list item -- the one that changed type.\n\tviewWriter.breakContainer( viewWriter.createPositionBefore( viewItem ) );\n\tviewWriter.breakContainer( viewWriter.createPositionAfter( viewItem ) );\n\n\t// Change name of the view list that holds the changed view item.\n\t// We cannot just change name property, because that would not render properly.\n\tconst viewList = viewItem.parent;\n\tconst listName = data.attributeNewValue == 'numbered' ? 'ol' : 'ul';\n\n\tviewWriter.rename( listName, viewList );\n}\n\n/**\n * A model-to-view converter that attempts to merge nodes split by {@link module:list/converters~modelViewChangeType}.\n *\n * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:attribute\n * @param {module:utils/eventinfo~EventInfo} evt An object containing information about the fired event.\n * @param {Object} data Additional information about the change.\n * @param {module:engine/conversion/downcastdispatcher~DowncastConversionApi} conversionApi Conversion interface.\n */\nexport function modelViewMergeAfterChangeType( evt, data, conversionApi ) {\n\tconst viewItem = conversionApi.mapper.toViewElement( data.item );\n\tconst viewList = viewItem.parent;\n\tconst viewWriter = conversionApi.writer;\n\n\t// Merge the changed view list with other lists, if possible.\n\tmergeViewLists( viewWriter, viewList, viewList.nextSibling );\n\tmergeViewLists( viewWriter, viewList.previousSibling, viewList );\n\n\t// Consumable insertion of children inside the item. They are already handled by re-building the item in view.\n\tfor ( const child of data.item.getChildren() ) {\n\t\tconversionApi.consumable.consume( child, 'insert' );\n\t}\n}\n\n/**\n * A model-to-view converter for the `listIndent` attribute change on the `listItem` model element.\n *\n * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:attribute\n * @param {module:engine/model/model~Model} model Model instance.\n * @returns {Function} Returns a conversion callback.\n */\nexport function modelViewChangeIndent( model ) {\n\treturn ( evt, data, conversionApi ) => {\n\t\tif ( !conversionApi.consumable.consume( data.item, 'attribute:listIndent' ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst viewItem = conversionApi.mapper.toViewElement( data.item );\n\t\tconst viewWriter = conversionApi.writer;\n\n\t\t// 1. Break the container after and before the list item.\n\t\t// This will create a view list with one view list item -- the one that changed type.\n\t\tviewWriter.breakContainer( viewWriter.createPositionBefore( viewItem ) );\n\t\tviewWriter.breakContainer( viewWriter.createPositionAfter( viewItem ) );\n\n\t\t// 2. Extract view list with changed view list item and merge \"hole\" possibly created by breaking and removing elements.\n\t\tconst viewList = viewItem.parent;\n\t\tconst viewListPrev = viewList.previousSibling;\n\t\tconst removeRange = viewWriter.createRangeOn( viewList );\n\t\tviewWriter.remove( removeRange );\n\n\t\tif ( viewListPrev && viewListPrev.nextSibling ) {\n\t\t\tmergeViewLists( viewWriter, viewListPrev, viewListPrev.nextSibling );\n\t\t}\n\n\t\t// 3. Bring back nested list that was in the removed <li>.\n\t\thoistNestedLists( data.attributeOldValue + 1, data.range.start, removeRange.start, viewItem, conversionApi, model );\n\n\t\t// 4. Inject view list like it is newly inserted.\n\t\tinjectViewList( data.item, viewItem, conversionApi, model );\n\n\t\t// 5. Consume insertion of children inside the item. They are already handled by re-building the item in view.\n\t\tfor ( const child of data.item.getChildren() ) {\n\t\t\tconversionApi.consumable.consume( child, 'insert' );\n\t\t}\n\t};\n}\n\n/**\n * A special model-to-view converter introduced by the {@link module:list/list~List list feature}. This converter is fired for\n * insert change of every model item, and should be fired before the actual converter. The converter checks whether the inserted\n * model item is a non-`listItem` element. If it is, and it is inserted inside a view list, the converter breaks the\n * list so the model element is inserted to the view parent element corresponding to its model parent element.\n *\n * The converter prevents such situations:\n *\n *\t\t// Model:                        // View:\n *\t\t<listItem>foo</listItem>         <ul>\n *\t\t<listItem>bar</listItem>             <li>foo</li>\n *\t\t                                     <li>bar</li>\n *\t\t                                 </ul>\n *\n *\t\t// After change:                 // Correct view guaranteed by this converter:\n *\t\t<listItem>foo</listItem>         <ul><li>foo</li></ul><p>xxx</p><ul><li>bar</li></ul>\n *\t\t<paragraph>xxx</paragraph>       // Instead of this wrong view state:\n *\t\t<listItem>bar</listItem>         <ul><li>foo</li><p>xxx</p><li>bar</li></ul>\n *\n * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:insert\n * @param {module:utils/eventinfo~EventInfo} evt An object containing information about the fired event.\n * @param {Object} data Additional information about the change.\n * @param {module:engine/conversion/downcastdispatcher~DowncastConversionApi} conversionApi Conversion interface.\n */\nexport function modelViewSplitOnInsert( evt, data, conversionApi ) {\n\tif ( data.item.name != 'listItem' ) {\n\t\tlet viewPosition = conversionApi.mapper.toViewPosition( data.range.start );\n\n\t\tconst viewWriter = conversionApi.writer;\n\t\tconst lists = [];\n\n\t\t// Break multiple ULs/OLs if there are.\n\t\t//\n\t\t// Imagine following list:\n\t\t//\n\t\t// 1 --------\n\t\t//   1.1 --------\n\t\t//     1.1.1 --------\n\t\t//     1.1.2 --------\n\t\t//     1.1.3 --------\n\t\t//       1.1.3.1 --------\n\t\t//   1.2 --------\n\t\t//     1.2.1 --------\n\t\t// 2 --------\n\t\t//\n\t\t// Insert paragraph after item 1.1.1:\n\t\t//\n\t\t// 1 --------\n\t\t//   1.1 --------\n\t\t//     1.1.1 --------\n\t\t//\n\t\t// Lorem ipsum.\n\t\t//\n\t\t//     1.1.2 --------\n\t\t//     1.1.3 --------\n\t\t//       1.1.3.1 --------\n\t\t//   1.2 --------\n\t\t//     1.2.1 --------\n\t\t// 2 --------\n\t\t//\n\t\t// In this case 1.1.2 has to become beginning of a new list.\n\t\t// We need to break list before 1.1.2 (obvious), then we need to break list also before 1.2.\n\t\t// Then we need to move those broken pieces one after another and merge:\n\t\t//\n\t\t// 1 --------\n\t\t//   1.1 --------\n\t\t//     1.1.1 --------\n\t\t//\n\t\t// Lorem ipsum.\n\t\t//\n\t\t// 1.1.2 --------\n\t\t//   1.1.3 --------\n\t\t//     1.1.3.1 --------\n\t\t// 1.2 --------\n\t\t//   1.2.1 --------\n\t\t// 2 --------\n\t\t//\n\t\twhile ( viewPosition.parent.name == 'ul' || viewPosition.parent.name == 'ol' ) {\n\t\t\tviewPosition = viewWriter.breakContainer( viewPosition );\n\n\t\t\tif ( viewPosition.parent.name != 'li' ) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\t// Remove lists that are after inserted element.\n\t\t\t// They will be brought back later, below the inserted element.\n\t\t\tconst removeStart = viewPosition;\n\t\t\tconst removeEnd = viewWriter.createPositionAt( viewPosition.parent, 'end' );\n\n\t\t\t// Don't remove if there is nothing to remove.\n\t\t\tif ( !removeStart.isEqual( removeEnd ) ) {\n\t\t\t\tconst removed = viewWriter.remove( viewWriter.createRange( removeStart, removeEnd ) );\n\t\t\t\tlists.push( removed );\n\t\t\t}\n\n\t\t\tviewPosition = viewWriter.createPositionAfter( viewPosition.parent );\n\t\t}\n\n\t\t// Bring back removed lists.\n\t\tif ( lists.length > 0 ) {\n\t\t\tfor ( let i = 0; i < lists.length; i++ ) {\n\t\t\t\tconst previousList = viewPosition.nodeBefore;\n\t\t\t\tconst insertedRange = viewWriter.insert( viewPosition, lists[ i ] );\n\t\t\t\tviewPosition = insertedRange.end;\n\n\t\t\t\t// Don't merge first list! We want a split in that place (this is why this converter is introduced).\n\t\t\t\tif ( i > 0 ) {\n\t\t\t\t\tconst mergePos = mergeViewLists( viewWriter, previousList, previousList.nextSibling );\n\n\t\t\t\t\t// If `mergePos` is in `previousList` it means that the lists got merged.\n\t\t\t\t\t// In this case, we need to fix insert position.\n\t\t\t\t\tif ( mergePos && mergePos.parent == previousList ) {\n\t\t\t\t\t\tviewPosition.offset--;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Merge last inserted list with element after it.\n\t\t\tmergeViewLists( viewWriter, viewPosition.nodeBefore, viewPosition.nodeAfter );\n\t\t}\n\t}\n}\n\n/**\n * A special model-to-view converter introduced by the {@link module:list/list~List list feature}. This converter takes care of\n * merging view lists after something is removed or moved from near them.\n *\n * Example:\n *\n *\t\t// Model:                        // View:\n *\t\t<listItem>foo</listItem>         <ul><li>foo</li></ul>\n *\t\t<paragraph>xxx</paragraph>       <p>xxx</p>\n *\t\t<listItem>bar</listItem>         <ul><li>bar</li></ul>\n *\n *\t\t// After change:                 // Correct view guaranteed by this converter:\n *\t\t<listItem>foo</listItem>         <ul>\n *\t\t<listItem>bar</listItem>             <li>foo</li>\n *\t\t                                     <li>bar</li>\n *\t\t                                 </ul>\n *\n * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:remove\n * @param {module:utils/eventinfo~EventInfo} evt An object containing information about the fired event.\n * @param {Object} data Additional information about the change.\n * @param {module:engine/conversion/downcastdispatcher~DowncastConversionApi} conversionApi Conversion interface.\n */\nexport function modelViewMergeAfter( evt, data, conversionApi ) {\n\tconst viewPosition = conversionApi.mapper.toViewPosition( data.position );\n\tconst viewItemPrev = viewPosition.nodeBefore;\n\tconst viewItemNext = viewPosition.nodeAfter;\n\n\t// Merge lists if something (remove, move) was done from inside of list.\n\t// Merging will be done only if both items are view lists of the same type.\n\t// The check is done inside the helper function.\n\tmergeViewLists( conversionApi.writer, viewItemPrev, viewItemNext );\n}\n\n/**\n * A view-to-model converter that converts the `<li>` view elements into the `listItem` model elements.\n *\n * To set correct values of the `listType` and `listIndent` attributes the converter:\n * * checks `<li>`'s parent,\n * * stores and increases the `conversionApi.store.indent` value when `<li>`'s sub-items are converted.\n *\n * @see module:engine/conversion/upcastdispatcher~UpcastDispatcher#event:element\n * @param {module:utils/eventinfo~EventInfo} evt An object containing information about the fired event.\n * @param {Object} data An object containing conversion input and a placeholder for conversion output and possibly other values.\n * @param {module:engine/conversion/upcastdispatcher~UpcastConversionApi} conversionApi Conversion interface to be used by the callback.\n */\nexport function viewModelConverter( evt, data, conversionApi ) {\n\tif ( conversionApi.consumable.consume( data.viewItem, { name: true } ) ) {\n\t\tconst writer = conversionApi.writer;\n\n\t\t// 1. Create `listItem` model element.\n\t\tconst listItem = writer.createElement( 'listItem' );\n\n\t\t// 2. Handle `listItem` model element attributes.\n\t\tconst indent = getIndent( data.viewItem );\n\n\t\twriter.setAttribute( 'listIndent', indent, listItem );\n\n\t\t// Set 'bulleted' as default. If this item is pasted into a context,\n\t\tconst type = data.viewItem.parent && data.viewItem.parent.name == 'ol' ? 'numbered' : 'bulleted';\n\t\twriter.setAttribute( 'listType', type, listItem );\n\n\t\tif ( !conversionApi.safeInsert( listItem, data.modelCursor ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst nextPosition = viewToModelListItemChildrenConverter( listItem, data.viewItem.getChildren(), conversionApi );\n\n\t\t// Result range starts before the first item and ends after the last.\n\t\tdata.modelRange = writer.createRange( data.modelCursor, nextPosition );\n\n\t\tconversionApi.updateConversionResult( listItem, data );\n\t}\n}\n\n/**\n * A view-to-model converter for the `<ul>` and `<ol>` view elements that cleans the input view of garbage.\n * This is mostly to clean whitespaces from between the `<li>` view elements inside the view list element, however, also\n * incorrect data can be cleared if the view was incorrect.\n *\n * @see module:engine/conversion/upcastdispatcher~UpcastDispatcher#event:element\n * @param {module:utils/eventinfo~EventInfo} evt An object containing information about the fired event.\n * @param {Object} data An object containing conversion input and a placeholder for conversion output and possibly other values.\n * @param {module:engine/conversion/upcastdispatcher~UpcastConversionApi} conversionApi Conversion interface to be used by the callback.\n */\nexport function cleanList( evt, data, conversionApi ) {\n\tif ( conversionApi.consumable.test( data.viewItem, { name: true } ) ) {\n\t\t// Caching children because when we start removing them iterating fails.\n\t\tconst children = Array.from( data.viewItem.getChildren() );\n\n\t\tfor ( const child of children ) {\n\t\t\tconst isWrongElement = !( child.is( 'element', 'li' ) || isList( child ) );\n\n\t\t\tif ( isWrongElement ) {\n\t\t\t\tchild._remove();\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * A view-to-model converter for the `<li>` elements that cleans whitespace formatting from the input view.\n *\n * @see module:engine/conversion/upcastdispatcher~UpcastDispatcher#event:element\n * @param {module:utils/eventinfo~EventInfo} evt An object containing information about the fired event.\n * @param {Object} data An object containing conversion input and a placeholder for conversion output and possibly other values.\n * @param {module:engine/conversion/upcastdispatcher~UpcastConversionApi} conversionApi Conversion interface to be used by the callback.\n */\nexport function cleanListItem( evt, data, conversionApi ) {\n\tif ( conversionApi.consumable.test( data.viewItem, { name: true } ) ) {\n\t\tif ( data.viewItem.childCount === 0 ) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst children = [ ...data.viewItem.getChildren() ];\n\n\t\tlet foundList = false;\n\t\tlet firstNode = true;\n\n\t\tfor ( const child of children ) {\n\t\t\tif ( foundList && !isList( child ) ) {\n\t\t\t\tchild._remove();\n\t\t\t}\n\n\t\t\tif ( child.is( '$text' ) ) {\n\t\t\t\t// If this is the first node and it's a text node, left-trim it.\n\t\t\t\tif ( firstNode ) {\n\t\t\t\t\tchild._data = child.data.trimStart();\n\t\t\t\t}\n\n\t\t\t\t// If this is the last text node before <ul> or <ol>, right-trim it.\n\t\t\t\tif ( !child.nextSibling || isList( child.nextSibling ) ) {\n\t\t\t\t\tchild._data = child.data.trimEnd();\n\t\t\t\t}\n\t\t\t} else if ( isList( child ) ) {\n\t\t\t\t// If this is a <ul> or <ol>, do not process it, just mark that we already visited list element.\n\t\t\t\tfoundList = true;\n\t\t\t}\n\n\t\t\tfirstNode = false;\n\t\t}\n\t}\n}\n\n/**\n * Returns a callback for model position to view position mapping for {@link module:engine/conversion/mapper~Mapper}. The callback fixes\n * positions between the `listItem` elements that would be incorrectly mapped because of how list items are represented in the model\n * and in the view.\n *\n * @see module:engine/conversion/mapper~Mapper#event:modelToViewPosition\n * @param {module:engine/view/view~View} view A view instance.\n * @returns {Function}\n */\nexport function modelToViewPosition( view ) {\n\treturn ( evt, data ) => {\n\t\tif ( data.isPhantom ) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst modelItem = data.modelPosition.nodeBefore;\n\n\t\tif ( modelItem && modelItem.is( 'element', 'listItem' ) ) {\n\t\t\tconst viewItem = data.mapper.toViewElement( modelItem );\n\t\t\tconst topmostViewList = viewItem.getAncestors().find( isList );\n\t\t\tconst walker = view.createPositionAt( viewItem, 0 ).getWalker();\n\n\t\t\tfor ( const value of walker ) {\n\t\t\t\tif ( value.type == 'elementStart' && value.item.is( 'element', 'li' ) ) {\n\t\t\t\t\tdata.viewPosition = value.previousPosition;\n\n\t\t\t\t\tbreak;\n\t\t\t\t} else if ( value.type == 'elementEnd' && value.item == topmostViewList ) {\n\t\t\t\t\tdata.viewPosition = value.nextPosition;\n\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\n/**\n * The callback for view position to model position mapping for {@link module:engine/conversion/mapper~Mapper}. The callback fixes\n * positions between the `<li>` elements that would be incorrectly mapped because of how list items are represented in the model\n * and in the view.\n *\n * @see module:engine/conversion/mapper~Mapper#event:viewToModelPosition\n * @param {module:engine/model/model~Model} model Model instance.\n * @returns {Function} Returns a conversion callback.\n */\nexport function viewToModelPosition( model ) {\n\treturn ( evt, data ) => {\n\t\tconst viewPos = data.viewPosition;\n\t\tconst viewParent = viewPos.parent;\n\t\tconst mapper = data.mapper;\n\n\t\tif ( viewParent.name == 'ul' || viewParent.name == 'ol' ) {\n\t\t\t// Position is directly in <ul> or <ol>.\n\t\t\tif ( !viewPos.isAtEnd ) {\n\t\t\t\t// If position is not at the end, it must be before <li>.\n\t\t\t\t// Get that <li>, map it to `listItem` and set model position before that `listItem`.\n\t\t\t\tconst modelNode = mapper.toModelElement( viewPos.nodeAfter );\n\n\t\t\t\tdata.modelPosition = model.createPositionBefore( modelNode );\n\t\t\t} else {\n\t\t\t\t// Position is at the end of <ul> or <ol>, so there is no <li> after it to be mapped.\n\t\t\t\t// There is <li> before the position, but we cannot just map it to `listItem` and set model position after it,\n\t\t\t\t// because that <li> may contain nested items.\n\t\t\t\t// We will check \"model length\" of that <li>, in other words - how many `listItem`s are in that <li>.\n\t\t\t\tconst modelNode = mapper.toModelElement( viewPos.nodeBefore );\n\t\t\t\tconst modelLength = mapper.getModelLength( viewPos.nodeBefore );\n\n\t\t\t\t// Then we get model position before mapped `listItem` and shift it accordingly.\n\t\t\t\tdata.modelPosition = model.createPositionBefore( modelNode ).getShiftedBy( modelLength );\n\t\t\t}\n\n\t\t\tevt.stop();\n\t\t} else if (\n\t\t\tviewParent.name == 'li' &&\n\t\t\tviewPos.nodeBefore &&\n\t\t\t( viewPos.nodeBefore.name == 'ul' || viewPos.nodeBefore.name == 'ol' )\n\t\t) {\n\t\t\t// In most cases when view position is in <li> it is in text and this is a correct position.\n\t\t\t// However, if position is after <ul> or <ol> we have to fix it -- because in model <ul>/<ol> are not in the `listItem`.\n\t\t\tconst modelNode = mapper.toModelElement( viewParent );\n\n\t\t\t// Check all <ul>s and <ol>s that are in the <li> but before mapped position.\n\t\t\t// Get model length of those elements and then add it to the offset of `listItem` mapped to the original <li>.\n\t\t\tlet modelLength = 1; // Starts from 1 because the original <li> has to be counted in too.\n\t\t\tlet viewList = viewPos.nodeBefore;\n\n\t\t\twhile ( viewList && isList( viewList ) ) {\n\t\t\t\tmodelLength += mapper.getModelLength( viewList );\n\n\t\t\t\tviewList = viewList.previousSibling;\n\t\t\t}\n\n\t\t\tdata.modelPosition = model.createPositionBefore( modelNode ).getShiftedBy( modelLength );\n\n\t\t\tevt.stop();\n\t\t}\n\t};\n}\n\n/**\n * Post-fixer that reacts to changes on document and fixes incorrect model states.\n *\n * In the example below, there is a correct list structure.\n * Then the middle element is removed so the list structure will become incorrect:\n *\n *\t\t<listItem listType=\"bulleted\" listIndent=0>Item 1</listItem>\n *\t\t<listItem listType=\"bulleted\" listIndent=1>Item 2</listItem>   <--- this is removed.\n *\t\t<listItem listType=\"bulleted\" listIndent=2>Item 3</listItem>\n *\n * The list structure after the middle element is removed:\n *\n * \t\t<listItem listType=\"bulleted\" listIndent=0>Item 1</listItem>\n *\t\t<listItem listType=\"bulleted\" listIndent=2>Item 3</listItem>\n *\n * Should become:\n *\n *\t\t<listItem listType=\"bulleted\" listIndent=0>Item 1</listItem>\n *\t\t<listItem listType=\"bulleted\" listIndent=1>Item 3</listItem>   <--- note that indent got post-fixed.\n *\n * @param {module:engine/model/model~Model} model The data model.\n * @param {module:engine/model/writer~Writer} writer The writer to do changes with.\n * @returns {Boolean} `true` if any change has been applied, `false` otherwise.\n */\nexport function modelChangePostFixer( model, writer ) {\n\tconst changes = model.document.differ.getChanges();\n\tconst itemToListHead = new Map();\n\n\tlet applied = false;\n\n\tfor ( const entry of changes ) {\n\t\tif ( entry.type == 'insert' && entry.name == 'listItem' ) {\n\t\t\t_addListToFix( entry.position );\n\t\t} else if ( entry.type == 'insert' && entry.name != 'listItem' ) {\n\t\t\tif ( entry.name != '$text' ) {\n\t\t\t\t// In case of renamed element.\n\t\t\t\tconst item = entry.position.nodeAfter;\n\n\t\t\t\tif ( item.hasAttribute( 'listIndent' ) ) {\n\t\t\t\t\twriter.removeAttribute( 'listIndent', item );\n\n\t\t\t\t\tapplied = true;\n\t\t\t\t}\n\n\t\t\t\tif ( item.hasAttribute( 'listType' ) ) {\n\t\t\t\t\twriter.removeAttribute( 'listType', item );\n\n\t\t\t\t\tapplied = true;\n\t\t\t\t}\n\n\t\t\t\tif ( item.hasAttribute( 'listStyle' ) ) {\n\t\t\t\t\twriter.removeAttribute( 'listStyle', item );\n\n\t\t\t\t\tapplied = true;\n\t\t\t\t}\n\n\t\t\t\tfor ( const innerItem of Array.from( model.createRangeIn( item ) ).filter( e => e.item.is( 'element', 'listItem' ) ) ) {\n\t\t\t\t\t_addListToFix( innerItem.previousPosition );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tconst posAfter = entry.position.getShiftedBy( entry.length );\n\n\t\t\t_addListToFix( posAfter );\n\t\t} else if ( entry.type == 'remove' && entry.name == 'listItem' ) {\n\t\t\t_addListToFix( entry.position );\n\t\t} else if ( entry.type == 'attribute' && entry.attributeKey == 'listIndent' ) {\n\t\t\t_addListToFix( entry.range.start );\n\t\t} else if ( entry.type == 'attribute' && entry.attributeKey == 'listType' ) {\n\t\t\t_addListToFix( entry.range.start );\n\t\t}\n\t}\n\n\tfor ( const listHead of itemToListHead.values() ) {\n\t\t_fixListIndents( listHead );\n\t\t_fixListTypes( listHead );\n\t}\n\n\treturn applied;\n\n\tfunction _addListToFix( position ) {\n\t\tconst previousNode = position.nodeBefore;\n\n\t\tif ( !previousNode || !previousNode.is( 'element', 'listItem' ) ) {\n\t\t\tconst item = position.nodeAfter;\n\n\t\t\tif ( item && item.is( 'element', 'listItem' ) ) {\n\t\t\t\titemToListHead.set( item, item );\n\t\t\t}\n\t\t} else {\n\t\t\tlet listHead = previousNode;\n\n\t\t\tif ( itemToListHead.has( listHead ) ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tfor (\n\t\t\t\t// Cache previousSibling and reuse for performance reasons. See #6581.\n\t\t\t\tlet previousSibling = listHead.previousSibling;\n\t\t\t\tpreviousSibling && previousSibling.is( 'element', 'listItem' );\n\t\t\t\tpreviousSibling = listHead.previousSibling\n\t\t\t) {\n\t\t\t\tlistHead = previousSibling;\n\n\t\t\t\tif ( itemToListHead.has( listHead ) ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\titemToListHead.set( previousNode, listHead );\n\t\t}\n\t}\n\n\tfunction _fixListIndents( item ) {\n\t\tlet maxIndent = 0;\n\t\tlet fixBy = null;\n\n\t\twhile ( item && item.is( 'element', 'listItem' ) ) {\n\t\t\tconst itemIndent = item.getAttribute( 'listIndent' );\n\n\t\t\tif ( itemIndent > maxIndent ) {\n\t\t\t\tlet newIndent;\n\n\t\t\t\tif ( fixBy === null ) {\n\t\t\t\t\tfixBy = itemIndent - maxIndent;\n\t\t\t\t\tnewIndent = maxIndent;\n\t\t\t\t} else {\n\t\t\t\t\tif ( fixBy > itemIndent ) {\n\t\t\t\t\t\tfixBy = itemIndent;\n\t\t\t\t\t}\n\n\t\t\t\t\tnewIndent = itemIndent - fixBy;\n\t\t\t\t}\n\n\t\t\t\twriter.setAttribute( 'listIndent', newIndent, item );\n\n\t\t\t\tapplied = true;\n\t\t\t} else {\n\t\t\t\tfixBy = null;\n\t\t\t\tmaxIndent = item.getAttribute( 'listIndent' ) + 1;\n\t\t\t}\n\n\t\t\titem = item.nextSibling;\n\t\t}\n\t}\n\n\tfunction _fixListTypes( item ) {\n\t\tlet typesStack = [];\n\t\tlet prev = null;\n\n\t\twhile ( item && item.is( 'element', 'listItem' ) ) {\n\t\t\tconst itemIndent = item.getAttribute( 'listIndent' );\n\n\t\t\tif ( prev && prev.getAttribute( 'listIndent' ) > itemIndent ) {\n\t\t\t\ttypesStack = typesStack.slice( 0, itemIndent + 1 );\n\t\t\t}\n\n\t\t\tif ( itemIndent != 0 ) {\n\t\t\t\tif ( typesStack[ itemIndent ] ) {\n\t\t\t\t\tconst type = typesStack[ itemIndent ];\n\n\t\t\t\t\tif ( item.getAttribute( 'listType' ) != type ) {\n\t\t\t\t\t\twriter.setAttribute( 'listType', type, item );\n\n\t\t\t\t\t\tapplied = true;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\ttypesStack[ itemIndent ] = item.getAttribute( 'listType' );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tprev = item;\n\t\t\titem = item.nextSibling;\n\t\t}\n\t}\n}\n\n/**\n * A fixer for pasted content that includes list items.\n *\n * It fixes indentation of pasted list items so the pasted items match correctly to the context they are pasted into.\n *\n * Example:\n *\n *\t\t<listItem listType=\"bulleted\" listIndent=0>A</listItem>\n *\t\t<listItem listType=\"bulleted\" listIndent=1>B^</listItem>\n *\t\t// At ^ paste:  <listItem listType=\"bulleted\" listIndent=4>X</listItem>\n *\t\t//              <listItem listType=\"bulleted\" listIndent=5>Y</listItem>\n *\t\t<listItem listType=\"bulleted\" listIndent=2>C</listItem>\n *\n * Should become:\n *\n *\t\t<listItem listType=\"bulleted\" listIndent=0>A</listItem>\n *\t\t<listItem listType=\"bulleted\" listIndent=1>BX</listItem>\n *\t\t<listItem listType=\"bulleted\" listIndent=2>Y/listItem>\n *\t\t<listItem listType=\"bulleted\" listIndent=2>C</listItem>\n *\n * @param {module:utils/eventinfo~EventInfo} evt An object containing information about the fired event.\n * @param {Array} args Arguments of {@link module:engine/model/model~Model#insertContent}.\n */\nexport function modelIndentPasteFixer( evt, [ content, selectable ] ) {\n\t// Check whether inserted content starts from a `listItem`. If it does not, it means that there are some other\n\t// elements before it and there is no need to fix indents, because even if we insert that content into a list,\n\t// that list will be broken.\n\t// Note: we also need to handle singular elements because inserting item with indent 0 into 0,1,[],2\n\t// would create incorrect model.\n\tlet item = content.is( 'documentFragment' ) ? content.getChild( 0 ) : content;\n\n\tlet selection;\n\n\tif ( !selectable ) {\n\t\tselection = this.document.selection;\n\t} else {\n\t\tselection = this.createSelection( selectable );\n\t}\n\n\tif ( item && item.is( 'element', 'listItem' ) ) {\n\t\t// Get a reference list item. Inserted list items will be fixed according to that item.\n\t\tconst pos = selection.getFirstPosition();\n\t\tlet refItem = null;\n\n\t\tif ( pos.parent.is( 'element', 'listItem' ) ) {\n\t\t\trefItem = pos.parent;\n\t\t} else if ( pos.nodeBefore && pos.nodeBefore.is( 'element', 'listItem' ) ) {\n\t\t\trefItem = pos.nodeBefore;\n\t\t}\n\n\t\t// If there is `refItem` it means that we do insert list items into an existing list.\n\t\tif ( refItem ) {\n\t\t\t// First list item in `data` has indent equal to 0 (it is a first list item). It should have indent equal\n\t\t\t// to the indent of reference item. We have to fix the first item and all of it's children and following siblings.\n\t\t\t// Indent of all those items has to be adjusted to reference item.\n\t\t\tconst indentChange = refItem.getAttribute( 'listIndent' );\n\n\t\t\t// Fix only if there is anything to fix.\n\t\t\tif ( indentChange > 0 ) {\n\t\t\t\t// Adjust indent of all \"first\" list items in inserted data.\n\t\t\t\twhile ( item && item.is( 'element', 'listItem' ) ) {\n\t\t\t\t\titem._setAttribute( 'listIndent', item.getAttribute( 'listIndent' ) + indentChange );\n\n\t\t\t\t\titem = item.nextSibling;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\n// Helper function that converts children of a given `<li>` view element into corresponding model elements.\n// The function maintains proper order of elements if model `listItem` is split during the conversion\n// due to block children conversion.\n//\n// @param {module:engine/model/element~Element} listItemModel List item model element to which converted children will be inserted.\n// @param {Iterable.<module:engine/view/node~Node>} viewChildren View elements which will be converted.\n// @param {module:engine/conversion/upcastdispatcher~UpcastConversionApi} conversionApi Conversion interface to be used by the callback.\n// @returns {module:engine/model/position~Position} Position on which next elements should be inserted after children conversion.\nfunction viewToModelListItemChildrenConverter( listItemModel, viewChildren, conversionApi ) {\n\tconst { writer, schema } = conversionApi;\n\n\t// A position after the last inserted `listItem`.\n\tlet nextPosition = writer.createPositionAfter( listItemModel );\n\n\t// Check all children of the converted `<li>`. At this point we assume there are no \"whitespace\" view text nodes\n\t// in view list, between view list items. This should be handled by `<ul>` and `<ol>` converters.\n\tfor ( const child of viewChildren ) {\n\t\tif ( child.name == 'ul' || child.name == 'ol' ) {\n\t\t\t// If the children is a list, we will insert its conversion result after currently handled `listItem`.\n\t\t\t// Then, next insertion position will be set after all the new list items (and maybe other elements if\n\t\t\t// something split list item).\n\t\t\t//\n\t\t\t// If this is a list, we expect that some `listItem`s and possibly other blocks will be inserted, however `.modelCursor`\n\t\t\t// should be set after last `listItem` (or block). This is why it feels safe to use it as `nextPosition`\n\t\t\tnextPosition = conversionApi.convertItem( child, nextPosition ).modelCursor;\n\t\t} else {\n\t\t\t// If this is not a list, try inserting content at the end of the currently handled `listItem`.\n\t\t\tconst result = conversionApi.convertItem( child, writer.createPositionAt( listItemModel, 'end' ) );\n\n\t\t\t// It may end up that the current `listItem` becomes split (if that content cannot be inside `listItem`). For example:\n\t\t\t//\n\t\t\t// <li><p>Foo</p></li>\n\t\t\t//\n\t\t\t// will be converted to:\n\t\t\t//\n\t\t\t// <listItem></listItem><paragraph>Foo</paragraph><listItem></listItem>\n\t\t\t//\n\t\t\tconst convertedChild = result.modelRange.start.nodeAfter;\n\t\t\tconst wasSplit = convertedChild && convertedChild.is( 'element' ) && !schema.checkChild( listItemModel, convertedChild.name );\n\n\t\t\tif ( wasSplit ) {\n\t\t\t\t// As `lastListItem` got split, we need to update it to the second part of the split `listItem` element.\n\t\t\t\t//\n\t\t\t\t// `modelCursor` should be set to a position where the conversion should continue. There are multiple possible scenarios\n\t\t\t\t// that may happen. Usually, `modelCursor` (marked as `#` below) would point to the second list item after conversion:\n\t\t\t\t//\n\t\t\t\t//\t\t`<li><p>Foo</p></li>` -> `<listItem></listItem><paragraph>Foo</paragraph><listItem>#</listItem>`\n\t\t\t\t//\n\t\t\t\t// However, in some cases, like auto-paragraphing, the position is placed at the end of the block element:\n\t\t\t\t//\n\t\t\t\t//\t\t`<li><div>Foo</div></li>` -> `<listItem></listItem><paragraph>Foo#</paragraph><listItem></listItem>`\n\t\t\t\t//\n\t\t\t\t// or after an element if another element broken auto-paragraphed element:\n\t\t\t\t//\n\t\t\t\t//\t\t`<li><div><h2>Foo</h2></div></li>` -> `<listItem></listItem><heading1>Foo</heading1>#<listItem></listItem>`\n\t\t\t\t//\n\t\t\t\t// We need to check for such cases and use proper list item and position based on it.\n\t\t\t\t//\n\t\t\t\tif ( result.modelCursor.parent.is( 'element', 'listItem' ) ) {\n\t\t\t\t\t// (1).\n\t\t\t\t\tlistItemModel = result.modelCursor.parent;\n\t\t\t\t} else {\n\t\t\t\t\t// (2), (3).\n\t\t\t\t\tlistItemModel = findNextListItem( result.modelCursor );\n\t\t\t\t}\n\n\t\t\t\tnextPosition = writer.createPositionAfter( listItemModel );\n\t\t\t}\n\t\t}\n\t}\n\n\treturn nextPosition;\n}\n\n// Helper function that seeks for a next list item starting from given `startPosition`.\nfunction findNextListItem( startPosition ) {\n\tconst treeWalker = new TreeWalker( { startPosition } );\n\n\tlet value;\n\n\tdo {\n\t\tvalue = treeWalker.next();\n\t} while ( !value.value.item.is( 'element', 'listItem' ) );\n\n\treturn value.value.item;\n}\n\n// Helper function that takes all children of given `viewRemovedItem` and moves them in a correct place, according\n// to other given parameters.\nfunction hoistNestedLists( nextIndent, modelRemoveStartPosition, viewRemoveStartPosition, viewRemovedItem, conversionApi, model ) {\n\t// Find correct previous model list item element.\n\t// The element has to have either same or smaller indent than given reference indent.\n\t// This will be the model element which will get nested items (if it has smaller indent) or sibling items (if it has same indent).\n\t// Keep in mind that such element might not be found, if removed item was the first item.\n\tconst prevModelItem = getSiblingListItem( modelRemoveStartPosition.nodeBefore, {\n\t\tsameIndent: true,\n\t\tsmallerIndent: true,\n\t\tlistIndent: nextIndent,\n\t\tfoo: 'b'\n\t} );\n\n\tconst mapper = conversionApi.mapper;\n\tconst viewWriter = conversionApi.writer;\n\n\t// Indent of found element or `null` if the element has not been found.\n\tconst prevIndent = prevModelItem ? prevModelItem.getAttribute( 'listIndent' ) : null;\n\n\tlet insertPosition;\n\n\tif ( !prevModelItem ) {\n\t\t// If element has not been found, simply insert lists at the position where the removed item was:\n\t\t//\n\t\t// Lorem ipsum.\n\t\t// 1 --------           <--- this is removed, no previous list item, put nested items in place of removed item.\n\t\t//   1.1 --------       <--- this is reference indent.\n\t\t//     1.1.1 --------\n\t\t//     1.1.2 --------\n\t\t//   1.2 --------\n\t\t//\n\t\t// Becomes:\n\t\t//\n\t\t// Lorem ipsum.\n\t\t// 1.1 --------\n\t\t//   1.1.1 --------\n\t\t//   1.1.2 --------\n\t\t// 1.2 --------\n\t\tinsertPosition = viewRemoveStartPosition;\n\t} else if ( prevIndent == nextIndent ) {\n\t\t// If element has been found and has same indent as reference indent it means that nested items should\n\t\t// become siblings of found element:\n\t\t//\n\t\t// 1 --------\n\t\t//   1.1 --------\n\t\t//   1.2 --------       <--- this is `prevModelItem`.\n\t\t// 2 --------           <--- this is removed, previous list item has indent same as reference indent.\n\t\t//   2.1 --------       <--- this is reference indent, this and 2.2 should become siblings of 1.2.\n\t\t//   2.2 --------\n\t\t//\n\t\t// Becomes:\n\t\t//\n\t\t// 1 --------\n\t\t//   1.1 --------\n\t\t//   1.2 --------\n\t\t//   2.1 --------\n\t\t//   2.2 --------\n\t\tconst prevViewList = mapper.toViewElement( prevModelItem ).parent;\n\t\tinsertPosition = viewWriter.createPositionAfter( prevViewList );\n\t} else {\n\t\t// If element has been found and has smaller indent as reference indent it means that nested items\n\t\t// should become nested items of found item:\n\t\t//\n\t\t// 1 --------           <--- this is `prevModelItem`.\n\t\t//   1.1 --------       <--- this is removed, previous list item has indent smaller than reference indent.\n\t\t//     1.1.1 --------   <--- this is reference indent, this and 1.1.1 should become nested items of 1.\n\t\t//     1.1.2 --------\n\t\t//   1.2 --------\n\t\t//\n\t\t// Becomes:\n\t\t//\n\t\t// 1 --------\n\t\t//   1.1.1 --------\n\t\t//   1.1.2 --------\n\t\t//   1.2 --------\n\t\t//\n\t\t// Note: in this case 1.1.1 have indent 2 while 1 have indent 0. In model that should not be possible,\n\t\t// because following item may have indent bigger only by one. But this is fixed by postfixer.\n\t\tconst modelPosition = model.createPositionAt( prevModelItem, 'end' );\n\t\tinsertPosition = mapper.toViewPosition( modelPosition );\n\t}\n\n\tinsertPosition = positionAfterUiElements( insertPosition );\n\n\t// Handle multiple lists. This happens if list item has nested numbered and bulleted lists. Following lists\n\t// are inserted after the first list (no need to recalculate insertion position for them).\n\tfor ( const child of [ ...viewRemovedItem.getChildren() ] ) {\n\t\tif ( isList( child ) ) {\n\t\t\tinsertPosition = viewWriter.move( viewWriter.createRangeOn( child ), insertPosition ).end;\n\n\t\t\tmergeViewLists( viewWriter, child, child.nextSibling );\n\t\t\tmergeViewLists( viewWriter, child.previousSibling, child );\n\t\t}\n\t}\n}\n\n// Checks if view element is a list type (ul or ol).\n//\n// @param {module:engine/view/element~Element} viewElement\n// @returns {Boolean}\nfunction isList( viewElement ) {\n\treturn viewElement.is( 'element', 'ol' ) || viewElement.is( 'element', 'ul' );\n}\n\n// Calculates the indent value for a list item. Handles HTML compliant and non-compliant lists.\n//\n// Also, fixes non HTML compliant lists indents:\n//\n//\t\tbefore:                                     fixed list:\n//\t\tOL                                          OL\n//\t\t|-> LI (parent LIs: 0)                      |-> LI     (indent: 0)\n//\t\t    |-> OL                                  |-> OL\n//\t\t        |-> OL                                  |\n//\t\t        |   |-> OL                              |\n//\t\t        |       |-> OL                          |\n//\t\t        |           |-> LI (parent LIs: 1)      |-> LI (indent: 1)\n//\t\t        |-> LI (parent LIs: 1)                  |-> LI (indent: 1)\n//\n//\t\tbefore:                                     fixed list:\n//\t\tOL                                          OL\n//\t\t|-> OL                                      |\n//\t\t    |-> OL                                  |\n//\t\t         |-> OL                             |\n//\t\t             |-> LI (parent LIs: 0)         |-> LI        (indent: 0)\n//\n//\t\tbefore:                                     fixed list:\n//\t\tOL                                          OL\n//\t\t|-> LI (parent LIs: 0)                      |-> LI         (indent: 0)\n//\t\t|-> OL                                          |-> OL\n//\t\t    |-> LI (parent LIs: 0)                          |-> LI (indent: 1)\n//\n// @param {module:engine/view/element~Element} listItem\n// @param {Object} conversionStore\n// @returns {Number}\nfunction getIndent( listItem ) {\n\tlet indent = 0;\n\n\tlet parent = listItem.parent;\n\n\twhile ( parent ) {\n\t\t// Each LI in the tree will result in an increased indent for HTML compliant lists.\n\t\tif ( parent.is( 'element', 'li' ) ) {\n\t\t\tindent++;\n\t\t} else {\n\t\t\t// If however the list is nested in other list we should check previous sibling of any of the list elements...\n\t\t\tconst previousSibling = parent.previousSibling;\n\n\t\t\t// ...because the we might need increase its indent:\n\t\t\t//\t\tbefore:                           fixed list:\n\t\t\t//\t\tOL                                OL\n\t\t\t//\t\t|-> LI (parent LIs: 0)            |-> LI         (indent: 0)\n\t\t\t//\t\t|-> OL                                |-> OL\n\t\t\t//\t\t    |-> LI (parent LIs: 0)                |-> LI (indent: 1)\n\t\t\tif ( previousSibling && previousSibling.is( 'element', 'li' ) ) {\n\t\t\t\tindent++;\n\t\t\t}\n\t\t}\n\n\t\tparent = parent.parent;\n\t}\n\n\treturn indent;\n}\n","module.exports = \"<svg viewBox=\\\"0 0 20 20\\\" xmlns=\\\"http://www.w3.org/2000/svg\\\"><path d=\\\"m11.077 15 .991-1.416a.75.75 0 1 1 1.229.86l-1.148 1.64a.748.748 0 0 1-.217.206 5.251 5.251 0 0 1-8.503-5.955.741.741 0 0 1 .12-.274l1.147-1.639a.75.75 0 1 1 1.228.86L4.933 10.7l.006.003a3.75 3.75 0 0 0 6.132 4.294l.006.004zm5.494-5.335a.748.748 0 0 1-.12.274l-1.147 1.639a.75.75 0 1 1-1.228-.86l.86-1.23a3.75 3.75 0 0 0-6.144-4.301l-.86 1.229a.75.75 0 0 1-1.229-.86l1.148-1.64a.748.748 0 0 1 .217-.206 5.251 5.251 0 0 1 8.503 5.955zm-4.563-2.532a.75.75 0 0 1 .184 1.045l-3.155 4.505a.75.75 0 1 1-1.229-.86l3.155-4.506a.75.75 0 0 1 1.045-.184z\\\"/></svg>\""],"sourceRoot":""}