From 61e503b88b555eaab7c7171e1ce4f21b14c4ef7f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20Go=C5=82aszewski?= <jodator@jodator.net>
Date: Tue, 6 Aug 2019 13:59:47 +0200
Subject: [PATCH 01/11] Handle invalid nested list in list upcast converter.

---
 src/converters.js    | 43 ++++++++++++++++++++++--
 tests/listediting.js | 80 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 121 insertions(+), 2 deletions(-)

diff --git a/src/converters.js b/src/converters.js
index 5b2ae0e..477077a 100644
--- a/src/converters.js
+++ b/src/converters.js
@@ -347,7 +347,10 @@ export function viewModelConverter( evt, data, conversionApi ) {
 
 		// 2. Handle `listItem` model element attributes.
 		conversionStore.indent = conversionStore.indent || 0;
-		writer.setAttribute( 'listIndent', conversionStore.indent, listItem );
+
+		const modifier = getIndentModifier( data.viewItem, conversionStore );
+
+		writer.setAttribute( 'listIndent', conversionStore.indent + modifier, listItem );
 
 		// Set 'bulleted' as default. If this item is pasted into a context,
 		const type = data.viewItem.parent && data.viewItem.parent.name == 'ol' ? 'numbered' : 'bulleted';
@@ -385,6 +388,40 @@ export function viewModelConverter( evt, data, conversionApi ) {
 	}
 }
 
+function getIndentModifier( listItem, conversionStore ) {
+	// Ensure proper conversion store value.
+	conversionStore.indentModifiers = conversionStore.indentModifiers || new WeakMap();
+
+	const viewItem = listItem.parent;
+
+	// View
+	if ( !viewItem || !viewItem.parent ) {
+		return 0;
+	}
+
+	const parent = viewItem.parent;
+	const parentName = parent && parent.name;
+
+	let modifier = 0;
+
+	if ( parentName == 'ul' ) {
+		const previousSibling = viewItem.previousSibling;
+
+		if ( previousSibling ) {
+			if ( previousSibling.is( 'li' ) ) {
+				modifier = 1;
+			} else {
+				modifier = conversionStore.indentModifiers.get( previousSibling );
+			}
+		}
+	}
+
+	// Update the stored modifiers info.
+	conversionStore.indentModifiers.set( viewItem, modifier );
+
+	return modifier;
+}
+
 /**
  * A view-to-model converter for `<ul>` and `<ol>` view elements that cleans the input view of garbage.
  * This is mostly to clean whitespaces from between `<li>` view elements inside the view list element, however, also
@@ -401,7 +438,9 @@ export function cleanList( evt, data, conversionApi ) {
 		const children = Array.from( data.viewItem.getChildren() );
 
 		for ( const child of children ) {
-			if ( !child.is( 'li' ) ) {
+			const isWrongElement = !( child.is( 'li' ) || child.is( 'ul' ) || child.is( 'ol' ) );
+
+			if ( isWrongElement ) {
 				child._remove();
 			}
 		}
diff --git a/tests/listediting.js b/tests/listediting.js
index 4c6523f..f6b1f73 100644
--- a/tests/listediting.js
+++ b/tests/listediting.js
@@ -1290,6 +1290,86 @@ describe( 'ListEditing', () => {
 				} );
 			}
 
+			describe( 'fixing nested list in list', () => {
+				test( 'fixing list - ul in ul',
+					'<ul>' +
+						'<ul>' +
+							'<li>1.1</li>' +
+						'</ul>' +
+					'</ul>',
+					'<ul>' +
+						'<li>1.1</li>' +
+					'</ul>'
+				);
+
+				test( 'fixing list - ul in ul (prev is li)',
+					'<ul>' +
+						'<li>1</li>' +
+						'<ul>' +
+							'<li>2.1</li>' +
+						'</ul>' +
+					'</ul>',
+					'<ul>' +
+						'<li>1' +
+							'<ul>' +
+								'<li>2.1</li>' +
+							'</ul>' +
+						'</li>' +
+					'</ul>'
+				);
+
+				test( 'fixing list - ul in deeply nested ul',
+					'<ul>' +
+						'<ul>' +
+							'<ul>' +
+								'<ul>' +
+									'<li>2.1</li>' +
+								'</ul>' +
+							'</ul>' +
+						'</ul>' +
+					'</ul>',
+					'<ul>' +
+					'<li>2.1</li>' +
+					'</ul>'
+				);
+
+				test( 'fixing list - ul in deeply nested ul',
+					'<ul>' +
+						'<li>A' +
+							'<ul>' +
+								'<ul>' +
+									'<ul>' +
+										'<ul>' +
+											'<li>B</li>' +
+										'</ul>' +
+									'</ul>' +
+								'</ul>' +
+								'<li>C</li>' +
+							'</ul>' +
+						'</li>' +
+					'</ul>',
+					'<ul>' +
+					'<li>A' +
+						'<ul>' +
+							'<li>B</li>' +
+							'<li>C</li>' +
+						'</ul>' +
+					'</li>' +
+					'</ul>'
+				);
+			} );
+
+			test( 'fixing list - ul in ul',
+				'<ul>' +
+					'<ul>' +
+						'<li>1.1</li>' +
+					'</ul>' +
+				'</ul>',
+				'<ul>' +
+					'<li>1.1</li>' +
+				'</ul>'
+			);
+
 			test( 'bullet list simple structure',
 				'<p>foo</p>' +
 				'<ul>' +

From b38ee0d702d36f5d509b1413d1b76b0952602cf6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20Go=C5=82aszewski?= <jodator@jodator.net>
Date: Tue, 6 Aug 2019 14:39:06 +0200
Subject: [PATCH 02/11] Support mixed nested list in list normalization.

---
 src/converters.js    | 14 +++++-------
 tests/listediting.js | 51 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 56 insertions(+), 9 deletions(-)

diff --git a/src/converters.js b/src/converters.js
index 477077a..b943e9c 100644
--- a/src/converters.js
+++ b/src/converters.js
@@ -392,20 +392,16 @@ function getIndentModifier( listItem, conversionStore ) {
 	// Ensure proper conversion store value.
 	conversionStore.indentModifiers = conversionStore.indentModifiers || new WeakMap();
 
-	const viewItem = listItem.parent;
+	const list = listItem.parent;
 
-	// View
-	if ( !viewItem || !viewItem.parent ) {
+	if ( !list || !list.parent ) {
 		return 0;
 	}
 
-	const parent = viewItem.parent;
-	const parentName = parent && parent.name;
-
 	let modifier = 0;
 
-	if ( parentName == 'ul' ) {
-		const previousSibling = viewItem.previousSibling;
+	if ( list.parent.is( 'ol' ) || list.parent.is( 'ul' ) ) {
+		const previousSibling = list.previousSibling;
 
 		if ( previousSibling ) {
 			if ( previousSibling.is( 'li' ) ) {
@@ -417,7 +413,7 @@ function getIndentModifier( listItem, conversionStore ) {
 	}
 
 	// Update the stored modifiers info.
-	conversionStore.indentModifiers.set( viewItem, modifier );
+	conversionStore.indentModifiers.set( list, modifier );
 
 	return modifier;
 }
diff --git a/tests/listediting.js b/tests/listediting.js
index f6b1f73..5921806 100644
--- a/tests/listediting.js
+++ b/tests/listediting.js
@@ -1302,6 +1302,17 @@ describe( 'ListEditing', () => {
 					'</ul>'
 				);
 
+				test( 'fixing list - ul in ol',
+					'<ol>' +
+						'<ul>' +
+							'<li>1.1</li>' +
+						'</ul>' +
+					'</ol>',
+					'<ul>' +
+					'<li>1.1</li>' +
+					'</ul>'
+				);
+
 				test( 'fixing list - ul in ul (prev is li)',
 					'<ul>' +
 						'<li>1</li>' +
@@ -1333,6 +1344,21 @@ describe( 'ListEditing', () => {
 					'</ul>'
 				);
 
+				test( 'fixing list - ul in deeply nested ul/ol',
+					'<ol>' +
+						'<ul>' +
+							'<ol>' +
+								'<ul>' +
+									'<li>2.1</li>' +
+								'</ul>' +
+							'</ol>' +
+						'</ul>' +
+					'</ol>',
+					'<ul>' +
+					'<li>2.1</li>' +
+					'</ul>'
+				);
+
 				test( 'fixing list - ul in deeply nested ul',
 					'<ul>' +
 						'<li>A' +
@@ -1357,6 +1383,31 @@ describe( 'ListEditing', () => {
 					'</li>' +
 					'</ul>'
 				);
+
+				test( 'fixing list - ul in deeply nested ul/ol',
+					'<ul>' +
+						'<li>A' +
+							'<ol>' +
+								'<ul>' +
+									'<ol>' +
+										'<ul>' +
+											'<li>B</li>' +
+										'</ul>' +
+									'</ol>' +
+								'</ul>' +
+								'<li>C</li>' +
+							'</ol>' +
+						'</li>' +
+					'</ul>',
+					'<ul>' +
+						'<li>A' +
+						'<ul>' +
+							'<li>B</li>' +
+							'<li>C</li>' +
+						'</ul>' +
+						'</li>' +
+					'</ul>'
+				);
 			} );
 
 			test( 'fixing list - ul in ul',

From eae26cde82716a8f0d95437ca09ac8a26ad0e58d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20Go=C5=82aszewski?= <jodator@jodator.net>
Date: Mon, 12 Aug 2019 11:59:19 +0200
Subject: [PATCH 03/11] Fix deeply nested list in list.

---
 src/converters.js    |  16 ++++--
 tests/listediting.js | 115 ++++++++++++++++++++++++++++++++++++-------
 2 files changed, 110 insertions(+), 21 deletions(-)

diff --git a/src/converters.js b/src/converters.js
index b943e9c..b578c7a 100644
--- a/src/converters.js
+++ b/src/converters.js
@@ -348,8 +348,8 @@ export function viewModelConverter( evt, data, conversionApi ) {
 		// 2. Handle `listItem` model element attributes.
 		conversionStore.indent = conversionStore.indent || 0;
 
+		const text = data.viewItem.childCount && data.viewItem.getChild( 0 ).data;
 		const modifier = getIndentModifier( data.viewItem, conversionStore );
-
 		writer.setAttribute( 'listIndent', conversionStore.indent + modifier, listItem );
 
 		// Set 'bulleted' as default. If this item is pasted into a context,
@@ -388,6 +388,7 @@ export function viewModelConverter( evt, data, conversionApi ) {
 	}
 }
 
+// TODO: refactor this ugly piece of code...
 function getIndentModifier( listItem, conversionStore ) {
 	// Ensure proper conversion store value.
 	conversionStore.indentModifiers = conversionStore.indentModifiers || new WeakMap();
@@ -405,10 +406,19 @@ function getIndentModifier( listItem, conversionStore ) {
 
 		if ( previousSibling ) {
 			if ( previousSibling.is( 'li' ) ) {
-				modifier = 1;
+				modifier = ( conversionStore.indentModifiers.get( previousSibling.parent ) || 0 ) + 1;
 			} else {
-				modifier = conversionStore.indentModifiers.get( previousSibling );
+				modifier = conversionStore.indentModifiers.get( previousSibling.parent );
 			}
+		} else {
+			let par = list.parent;
+
+			while ( par.is( 'ol' ) || par.is( 'ul' ) && modifier === undefined ) {
+				modifier = conversionStore.indentModifiers.get( par );
+				par = par.parent;
+			}
+
+			modifier = modifier === undefined ? 0 : modifier + 1;
 		}
 	}
 
diff --git a/tests/listediting.js b/tests/listediting.js
index 5921806..e7d8df0 100644
--- a/tests/listediting.js
+++ b/tests/listediting.js
@@ -1290,8 +1290,8 @@ describe( 'ListEditing', () => {
 				} );
 			}
 
-			describe( 'fixing nested list in list', () => {
-				test( 'fixing list - ul in ul',
+			describe( 'non HTML compliant list fixing', () => {
+				test( 'ul in ul',
 					'<ul>' +
 						'<ul>' +
 							'<li>1.1</li>' +
@@ -1302,7 +1302,7 @@ describe( 'ListEditing', () => {
 					'</ul>'
 				);
 
-				test( 'fixing list - ul in ol',
+				test( 'ul in ol',
 					'<ol>' +
 						'<ul>' +
 							'<li>1.1</li>' +
@@ -1313,7 +1313,7 @@ describe( 'ListEditing', () => {
 					'</ul>'
 				);
 
-				test( 'fixing list - ul in ul (prev is li)',
+				test( 'ul in ul (previous sibling is li)',
 					'<ul>' +
 						'<li>1</li>' +
 						'<ul>' +
@@ -1329,7 +1329,7 @@ describe( 'ListEditing', () => {
 					'</ul>'
 				);
 
-				test( 'fixing list - ul in deeply nested ul',
+				test( 'ul in deeply nested ul',
 					'<ul>' +
 						'<ul>' +
 							'<ul>' +
@@ -1344,7 +1344,7 @@ describe( 'ListEditing', () => {
 					'</ul>'
 				);
 
-				test( 'fixing list - ul in deeply nested ul/ol',
+				test( 'ul in deeply nested ul/ol',
 					'<ol>' +
 						'<ul>' +
 							'<ol>' +
@@ -1359,7 +1359,7 @@ describe( 'ListEditing', () => {
 					'</ul>'
 				);
 
-				test( 'fixing list - ul in deeply nested ul',
+				test( 'ul in deeply nested ul inside li',
 					'<ul>' +
 						'<li>A' +
 							'<ul>' +
@@ -1384,7 +1384,7 @@ describe( 'ListEditing', () => {
 					'</ul>'
 				);
 
-				test( 'fixing list - ul in deeply nested ul/ol',
+				test( 'ul in deeply nested ul/ol',
 					'<ul>' +
 						'<li>A' +
 							'<ol>' +
@@ -1408,18 +1408,97 @@ describe( 'ListEditing', () => {
 						'</li>' +
 					'</ul>'
 				);
-			} );
 
-			test( 'fixing list - ul in ul',
-				'<ul>' +
+				test( 'ul in ul (complex case)',
+					'<ol>' +
+						'<li>1</li>' +
+						'<ul>' +
+							'<li>A</li>' +
+							'<ol>' +
+								'<li>1</li>' +
+							'</ol>' +
+						'</ul>' +
+						'<li>2</li>' +
+						'<li>3</li>' +
+						'<ul>' +
+							'<li>A</li>' +
+							'<li>B</li>' +
+						'</ul>' +
+					'</ol>' +
 					'<ul>' +
-						'<li>1.1</li>' +
-					'</ul>' +
-				'</ul>',
-				'<ul>' +
-					'<li>1.1</li>' +
-				'</ul>'
-			);
+						'<li>A</li>' +
+						'<ol>' +
+							'<li>1</li>' +
+							'<li>2</li>' +
+						'</ol>' +
+					'</ul>',
+					'<ol>' +
+						'<li>1' +
+							'<ul>' +
+								'<li>A' +
+									'<ol>' +
+										'<li>1</li>' +
+									'</ol>' +
+								'</li>' +
+							'</ul>' +
+						'</li>' +
+						'<li>2</li>' +
+						'<li>3' +
+							'<ul>' +
+								'<li>A</li>' +
+								'<li>B</li>' +
+							'</ul>' +
+						'</li>' +
+					'</ol>' +
+					'<ul>' +
+						'<li>A' +
+							'<ol>' +
+								'<li>1</li>' +
+								'<li>2</li>' +
+							'</ol>' +
+						'</li>' +
+					'</ul>'
+				);
+
+				test( 'ol in ol (deep structure)',
+					'<ol>' +
+						'<li>A1</li>' +
+						'<ol>' +
+							'<ol>' +
+								'<ol>' +
+									'<ol>' +
+										'<ol>' +
+											'<ol>' +
+												'<ol>' +
+													'<li>B8</li>' +
+												'</ol>' +
+											'</ol>' +
+										'</ol>' +
+									'</ol>' +
+								'</ol>' +
+								'<li>C3</li>' +
+								'<ol>' +
+									'<li>D4</li>' +
+								'</ol>' +
+							'</ol>' +
+							'<li>E2</li>' +
+						'</ol>' +
+					'</ol>',
+					'<ol>' +
+						'<li>A1' +
+							'<ol>' +
+								'<li>B8</li>' +
+								'<li>C3' +
+									'<ol>' +
+										'<li>D4</li>' +
+									'</ol>' +
+								'</li>' +
+								'<li>E2</li>' +
+							'</ol>' +
+						'</li>' +
+					'</ol>'
+				);
+			} );
 
 			test( 'bullet list simple structure',
 				'<p>foo</p>' +

From 1135262170de1d5590ac0eed15d7a240af68c4d8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20Go=C5=82aszewski?= <jodator@jodator.net>
Date: Tue, 13 Aug 2019 19:26:59 +0200
Subject: [PATCH 04/11] Introduce isList() helper in list converters.

---
 src/converters.js | 50 ++++++++++++++++++++++++++---------------------
 1 file changed, 28 insertions(+), 22 deletions(-)

diff --git a/src/converters.js b/src/converters.js
index b01c20b..95e481d 100644
--- a/src/converters.js
+++ b/src/converters.js
@@ -426,24 +426,13 @@ function getIndentModifier( listItem, conversionStore ) {
 
 	let modifier = 0;
 
-	if ( list.parent.is( 'ol' ) || list.parent.is( 'ul' ) ) {
+	if ( isList( list.parent ) ) {
 		const previousSibling = list.previousSibling;
 
-		if ( previousSibling ) {
-			if ( previousSibling.is( 'li' ) ) {
-				modifier = ( conversionStore.indentModifiers.get( previousSibling.parent ) || 0 ) + 1;
-			} else {
-				modifier = conversionStore.indentModifiers.get( previousSibling.parent );
-			}
+		if ( previousSibling && previousSibling.is( 'li' ) ) {
+			modifier = ( conversionStore.indentModifiers.get( previousSibling.parent ) || 0 ) + 1;
 		} else {
-			let par = list.parent;
-
-			while ( par.is( 'ol' ) || par.is( 'ul' ) && modifier === undefined ) {
-				modifier = conversionStore.indentModifiers.get( par );
-				par = par.parent;
-			}
-
-			modifier = modifier === undefined ? 0 : modifier + 1;
+			modifier = getNestedListModifier( list, conversionStore );
 		}
 	}
 
@@ -453,6 +442,18 @@ function getIndentModifier( listItem, conversionStore ) {
 	return modifier;
 }
 
+function getNestedListModifier( list, conversionStore ) {
+	let listParent = list.parent;
+	let modifier;
+
+	while ( ( isList( listParent ) ) && modifier === undefined ) {
+		modifier = conversionStore.indentModifiers.get( listParent );
+		listParent = listParent.parent;
+	}
+
+	return modifier === undefined ? 0 : modifier + 1;
+}
+
 /**
  * A view-to-model converter for the `<ul>` and `<ol>` view elements that cleans the input view of garbage.
  * This is mostly to clean whitespaces from between the `<li>` view elements inside the view list element, however, also
@@ -469,7 +470,7 @@ export function cleanList( evt, data, conversionApi ) {
 		const children = Array.from( data.viewItem.getChildren() );
 
 		for ( const child of children ) {
-			const isWrongElement = !( child.is( 'li' ) || child.is( 'ul' ) || child.is( 'ol' ) );
+			const isWrongElement = !( child.is( 'li' ) || isList( child ) );
 
 			if ( isWrongElement ) {
 				child._remove();
@@ -498,7 +499,7 @@ export function cleanListItem( evt, data, conversionApi ) {
 		let firstNode = true;
 
 		for ( const child of children ) {
-			if ( foundList && !child.is( 'ul' ) && !child.is( 'ol' ) ) {
+			if ( foundList && !isList( child ) ) {
 				child._remove();
 			}
 
@@ -509,10 +510,10 @@ export function cleanListItem( evt, data, conversionApi ) {
 				}
 
 				// If this is the last text node before <ul> or <ol>, right-trim it.
-				if ( !child.nextSibling || ( child.nextSibling.is( 'ul' ) || child.nextSibling.is( 'ol' ) ) ) {
+				if ( !child.nextSibling || isList( child.nextSibling ) ) {
 					child._data = child.data.replace( /\s+$/, '' );
 				}
-			} else if ( child.is( 'ul' ) || child.is( 'ol' ) ) {
+			} else if ( isList( child ) ) {
 				// If this is a <ul> or <ol>, do not process it, just mark that we already visited list element.
 				foundList = true;
 			}
@@ -541,7 +542,7 @@ export function modelToViewPosition( view ) {
 
 		if ( modelItem && modelItem.is( 'listItem' ) ) {
 			const viewItem = data.mapper.toViewElement( modelItem );
-			const topmostViewList = viewItem.getAncestors().find( element => element.is( 'ul' ) || element.is( 'ol' ) );
+			const topmostViewList = viewItem.getAncestors().find( isList );
 			const walker = view.createPositionAt( viewItem, 0 ).getWalker();
 
 			for ( const value of walker ) {
@@ -609,7 +610,7 @@ export function viewToModelPosition( model ) {
 			let modelLength = 1; // Starts from 1 because the original <li> has to be counted in too.
 			let viewList = viewPos.nodeBefore;
 
-			while ( viewList && ( viewList.is( 'ul' ) || viewList.is( 'ol' ) ) ) {
+			while ( viewList && ( isList( viewList ) ) ) {
 				modelLength += mapper.getModelLength( viewList );
 
 				viewList = viewList.previousSibling;
@@ -1029,7 +1030,7 @@ function hoistNestedLists( nextIndent, modelRemoveStartPosition, viewRemoveStart
 	// Handle multiple lists. This happens if list item has nested numbered and bulleted lists. Following lists
 	// are inserted after the first list (no need to recalculate insertion position for them).
 	for ( const child of [ ...viewRemovedItem.getChildren() ] ) {
-		if ( child.is( 'ul' ) || child.is( 'ol' ) ) {
+		if ( isList( child ) ) {
 			insertPosition = viewWriter.move( viewWriter.createRangeOn( child ), insertPosition ).end;
 
 			mergeViewLists( viewWriter, child, child.nextSibling );
@@ -1037,3 +1038,8 @@ function hoistNestedLists( nextIndent, modelRemoveStartPosition, viewRemoveStart
 		}
 	}
 }
+
+// Checks if view element is a list type (ul or ol).
+function isList( viewElement ) {
+	return viewElement.is( 'ol' ) || viewElement.is( 'ul' );
+}

From 1f6a940ec5ca65443983b725c57447f8564d8959 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20Go=C5=82aszewski?= <jodator@jodator.net>
Date: Tue, 13 Aug 2019 19:46:15 +0200
Subject: [PATCH 05/11] Refactor getIndentModifier() in list converters.

---
 src/converters.js | 89 +++++++++++++++++++++++++----------------------
 1 file changed, 47 insertions(+), 42 deletions(-)

diff --git a/src/converters.js b/src/converters.js
index 95e481d..6711710 100644
--- a/src/converters.js
+++ b/src/converters.js
@@ -413,47 +413,6 @@ export function viewModelConverter( evt, data, conversionApi ) {
 	}
 }
 
-// TODO: refactor this ugly piece of code...
-function getIndentModifier( listItem, conversionStore ) {
-	// Ensure proper conversion store value.
-	conversionStore.indentModifiers = conversionStore.indentModifiers || new WeakMap();
-
-	const list = listItem.parent;
-
-	if ( !list || !list.parent ) {
-		return 0;
-	}
-
-	let modifier = 0;
-
-	if ( isList( list.parent ) ) {
-		const previousSibling = list.previousSibling;
-
-		if ( previousSibling && previousSibling.is( 'li' ) ) {
-			modifier = ( conversionStore.indentModifiers.get( previousSibling.parent ) || 0 ) + 1;
-		} else {
-			modifier = getNestedListModifier( list, conversionStore );
-		}
-	}
-
-	// Update the stored modifiers info.
-	conversionStore.indentModifiers.set( list, modifier );
-
-	return modifier;
-}
-
-function getNestedListModifier( list, conversionStore ) {
-	let listParent = list.parent;
-	let modifier;
-
-	while ( ( isList( listParent ) ) && modifier === undefined ) {
-		modifier = conversionStore.indentModifiers.get( listParent );
-		listParent = listParent.parent;
-	}
-
-	return modifier === undefined ? 0 : modifier + 1;
-}
-
 /**
  * A view-to-model converter for the `<ul>` and `<ol>` view elements that cleans the input view of garbage.
  * This is mostly to clean whitespaces from between the `<li>` view elements inside the view list element, however, also
@@ -610,7 +569,7 @@ export function viewToModelPosition( model ) {
 			let modelLength = 1; // Starts from 1 because the original <li> has to be counted in too.
 			let viewList = viewPos.nodeBefore;
 
-			while ( viewList && ( isList( viewList ) ) ) {
+			while ( viewList && isList( viewList ) ) {
 				modelLength += mapper.getModelLength( viewList );
 
 				viewList = viewList.previousSibling;
@@ -1043,3 +1002,49 @@ function hoistNestedLists( nextIndent, modelRemoveStartPosition, viewRemoveStart
 function isList( viewElement ) {
 	return viewElement.is( 'ol' ) || viewElement.is( 'ul' );
 }
+
+// Return list item indent modifier - used to fix lists that are not properly nested according to HTML rules.
+function getIndentModifier( listItem, conversionStore ) {
+	// Ensure proper conversion store value.
+	// Indent modifiers stores already calculated indentation modifiers.
+	conversionStore.indentModifiers = conversionStore.indentModifiers || new WeakMap();
+
+	const list = listItem.parent;
+
+	// List item might be pasted without parent list or be directly in pasted content - no need to calculate or store anything.
+	if ( !list || !list.parent ) {
+		return 0;
+	}
+
+	let modifier = 0;
+
+	if ( isList( list.parent ) ) {
+		// Only consider list nested directly in other list so when not wrapped by LI element.
+		const previousSibling = list.previousSibling;
+
+		if ( previousSibling && previousSibling.is( 'li' ) ) {
+			// List is nested in other list but after other list item.
+			modifier = ( conversionStore.indentModifiers.get( previousSibling.parent ) || 0 ) + 1;
+		} else {
+			// List is nested directly in other list as a first item.
+			modifier = getNestedListModifier( list, conversionStore );
+		}
+	}
+
+	// Store the indent modifier of parent list.
+	conversionStore.indentModifiers.set( list, modifier );
+
+	return modifier;
+}
+
+function getNestedListModifier( list, conversionStore ) {
+	let listParent = list.parent;
+	let modifier;
+
+	while ( isList( listParent ) && modifier === undefined ) {
+		modifier = conversionStore.indentModifiers.get( listParent );
+		listParent = listParent.parent;
+	}
+
+	return modifier === undefined ? 0 : modifier + 1;
+}

From c622df44d3759369b1d155a731127aad32d35b99 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20Go=C5=82aszewski?= <jodator@jodator.net>
Date: Wed, 14 Aug 2019 11:25:39 +0200
Subject: [PATCH 06/11] Refactor how list indent offset are calculated.

---
 src/converters.js    | 84 +++++++++++++++++++++++++++++++++++---------
 tests/listediting.js | 43 ++++++++---------------
 2 files changed, 82 insertions(+), 45 deletions(-)

diff --git a/src/converters.js b/src/converters.js
index 6711710..22d84aa 100644
--- a/src/converters.js
+++ b/src/converters.js
@@ -373,9 +373,13 @@ export function viewModelConverter( evt, data, conversionApi ) {
 		// 2. Handle `listItem` model element attributes.
 		conversionStore.indent = conversionStore.indent || 0;
 
-		const text = data.viewItem.childCount && data.viewItem.getChild( 0 ).data;
-		const modifier = getIndentModifier( data.viewItem, conversionStore );
-		writer.setAttribute( 'listIndent', conversionStore.indent + modifier, listItem );
+		// The offset is used if list is not nested according to rules from HTML specification, e.g. directly in other list.
+		// We calculate offset here as the indent increment is done when converting children of other list items
+		// and it might be set incorrectly.
+		const offset = getIncompatibleListOffset( data.viewItem, conversionStore );
+		const resultingIndent = conversionStore.indent + offset;
+
+		writer.setAttribute( 'listIndent', resultingIndent, listItem );
 
 		// Set 'bulleted' as default. If this item is pasted into a context,
 		const type = data.viewItem.parent && data.viewItem.parent.name == 'ol' ? 'numbered' : 'bulleted';
@@ -999,15 +1003,55 @@ function hoistNestedLists( nextIndent, modelRemoveStartPosition, viewRemoveStart
 }
 
 // Checks if view element is a list type (ul or ol).
+//
+// @param {module:engine/view/element~Element} viewElement
+// @returns {Boolean}
 function isList( viewElement ) {
 	return viewElement.is( 'ol' ) || viewElement.is( 'ul' );
 }
 
-// Return list item indent modifier - used to fix lists that are not properly nested according to HTML rules.
-function getIndentModifier( listItem, conversionStore ) {
+// Return list item indent offset - used to fix lists that are not properly nested according to HTML rules.
+//
+// Returning offset will change the indent from normal flow of a conversion process.
+//
+// 1. List item in a wrongly nested list (previous sibling is a list item)
+//
+//		before:                           fixed list:
+//		OL                                OL
+//		|-> LI                            |-> LI         (indent: 0)
+//		|-> OL                                |-> OL
+//		    |-> LI (offset: +1)                   |-> LI (indent: 1)
+//
+// 2. List nested directly in other list as a first child.
+//
+//  The offset will be 0 if one of the ancestors is nested in li so the indent is already properly calculated.
+//
+//		before:                           fixed list:
+//		OL                                OL
+//		|-> LI                            |-> LI         (indent: 0)
+//		    |-> OL                            |-> OL
+//		        |-> OL                            |-> LI (indent: 1)
+//		        |   |-> OL                        |-> LI (indent: 1)
+//		        |       |-> OL
+//		        |           |-> LI (offset: 0)
+//		        |-> LI (offset: 0)
+//
+//  The offset will be 0 if list is not nested in any other list item:
+//
+//		before:                           fixed list:
+//		OL                                OL
+//		|-> OL                             |-> LI        (indent: 0)
+//		    |-> OL
+//		         |-> OL
+//		             |-> LI (offset: 0)
+//
+// @param {module:engine/view/element~Element} listItem
+// @param {Object} conversionStore
+// @returns {Number}
+function getIncompatibleListOffset( listItem, conversionStore ) {
 	// Ensure proper conversion store value.
 	// Indent modifiers stores already calculated indentation modifiers.
-	conversionStore.indentModifiers = conversionStore.indentModifiers || new WeakMap();
+	conversionStore.indentOffsets = conversionStore.indentOffsets || new WeakMap();
 
 	const list = listItem.parent;
 
@@ -1016,7 +1060,7 @@ function getIndentModifier( listItem, conversionStore ) {
 		return 0;
 	}
 
-	let modifier = 0;
+	let offset = 0;
 
 	if ( isList( list.parent ) ) {
 		// Only consider list nested directly in other list so when not wrapped by LI element.
@@ -1024,27 +1068,35 @@ function getIndentModifier( listItem, conversionStore ) {
 
 		if ( previousSibling && previousSibling.is( 'li' ) ) {
 			// List is nested in other list but after other list item.
-			modifier = ( conversionStore.indentModifiers.get( previousSibling.parent ) || 0 ) + 1;
+			offset = ( conversionStore.indentOffsets.get( previousSibling.parent ) || 0 ) + 1;
 		} else {
 			// List is nested directly in other list as a first item.
-			modifier = getNestedListModifier( list, conversionStore );
+			offset = getNestedListOffset( list, conversionStore );
 		}
 	}
 
 	// Store the indent modifier of parent list.
-	conversionStore.indentModifiers.set( list, modifier );
+	conversionStore.indentOffsets.set( list, offset );
 
-	return modifier;
+	return offset;
 }
 
-function getNestedListModifier( list, conversionStore ) {
+// Return list item indent offset - used to fix lists that are not properly nested according to HTML rules.
+//
+// @param {module:engine/view/element~Element} listItem
+// @param {Object} conversionStore
+// @returns {Number}
+function getNestedListOffset( list, conversionStore ) {
 	let listParent = list.parent;
-	let modifier;
 
-	while ( isList( listParent ) && modifier === undefined ) {
-		modifier = conversionStore.indentModifiers.get( listParent );
+	while ( isList( listParent ) && !conversionStore.indentOffsets.has( listParent ) ) {
 		listParent = listParent.parent;
 	}
 
-	return modifier === undefined ? 0 : modifier + 1;
+	// If there was a list ancestor with offset we must return greater offset.
+	if ( conversionStore.indentOffsets.has( listParent ) ) {
+		return conversionStore.indentOffsets.get( listParent ) + 1;
+	}
+
+	return 0;
 }
diff --git a/tests/listediting.js b/tests/listediting.js
index d6bd9fb..7831257 100644
--- a/tests/listediting.js
+++ b/tests/listediting.js
@@ -1333,35 +1333,20 @@ describe( 'ListEditing', () => {
 					'</ul>'
 				);
 
-				test( 'ul in deeply nested ul',
-					'<ul>' +
-						'<ul>' +
-							'<ul>' +
-								'<ul>' +
-									'<li>2.1</li>' +
-								'</ul>' +
-							'</ul>' +
-						'</ul>' +
-					'</ul>',
-					'<ul>' +
-					'<li>2.1</li>' +
-					'</ul>'
-				);
-
-				test( 'ul in deeply nested ul/ol',
-					'<ol>' +
-						'<ul>' +
-							'<ol>' +
-								'<ul>' +
-									'<li>2.1</li>' +
-								'</ul>' +
-							'</ol>' +
-						'</ul>' +
-					'</ol>',
-					'<ul>' +
-					'<li>2.1</li>' +
-					'</ul>'
-				);
+				// test( 'ul in deeply nested ul/ol 2',
+				// 	'<ol>' +
+				// 		'<ul>' +
+				// 			'<ol>' +
+				// 				'<ul>' +
+				// 					'<li>2.1</li>' +
+				// 				'</ul>' +
+				// 			'</ol>' +
+				// 		'</ul>' +
+				// 	'</ol>',
+				// 	'<ul>' +
+				// 	'<li>2.1</li>' +
+				// 	'</ul>'
+				// );
 
 				test( 'ul in deeply nested ul inside li',
 					'<ul>' +

From 69befbc8564272218fc01c07580fd9bc3ef7cab5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20Go=C5=82aszewski?= <jodator@jodator.net>
Date: Tue, 10 Sep 2019 09:47:01 +0200
Subject: [PATCH 07/11] Add more test cases.

---
 tests/listediting.js | 70 +++++++++++++++++++++++++++++++++++---------
 1 file changed, 56 insertions(+), 14 deletions(-)

diff --git a/tests/listediting.js b/tests/listediting.js
index c69bdf2..44d2deb 100644
--- a/tests/listediting.js
+++ b/tests/listediting.js
@@ -1333,20 +1333,62 @@ describe( 'ListEditing', () => {
 					'</ul>'
 				);
 
-				// test( 'ul in deeply nested ul/ol 2',
-				// 	'<ol>' +
-				// 		'<ul>' +
-				// 			'<ol>' +
-				// 				'<ul>' +
-				// 					'<li>2.1</li>' +
-				// 				'</ul>' +
-				// 			'</ol>' +
-				// 		'</ul>' +
-				// 	'</ol>',
-				// 	'<ul>' +
-				// 	'<li>2.1</li>' +
-				// 	'</ul>'
-				// );
+				test( 'ul in deeply nested ul - base index > 0 #1',
+					'<ul>' +
+						'<li>1.1</li>' +
+						'<li>1.2' +
+							'<ul>' +
+								'<ul>' +
+									'<ul>' +
+										'<ul>' +
+											'<li>2.1</li>' +
+										'</ul>' +
+									'</ul>' +
+								'</ul>' +
+							'</ul>' +
+						'</li>' +
+					'</ul>',
+					'<ul>' +
+						'<li>1.1</li>' +
+						'<li>1.2' +
+							'<ul>' +
+								'<li>2.1</li>' +
+							'</ul>' +
+						'</li>' +
+					'</ul>'
+				);
+
+				test( 'ul in deeply nested ul - base index > 0 #2',
+					'<ul>' +
+						'<li>1.1</li>' +
+						'<li>1.2' +
+							'<ul>' +
+								'<li>2.1</li>' +
+								'<ul>' +
+									'<ul>' +
+										'<ul>' +
+											'<li>3.1</li>' +
+										'</ul>' +
+									'</ul>' +
+								'</ul>' +
+								'<li>2.2</li>' +
+							'</ul>' +
+						'</li>' +
+					'</ul>',
+					'<ul>' +
+						'<li>1.1</li>' +
+						'<li>1.2' +
+							'<ul>' +
+								'<li>2.1' +
+									'<ul>' +
+										'<li>3.1</li>' +
+									'</ul>' +
+								'</li>' +
+								'<li>2.2</li>' +
+							'</ul>' +
+						'</li>' +
+					'</ul>'
+				);
 
 				test( 'ul in deeply nested ul inside li',
 					'<ul>' +

From 6c5a9aaca51fde8ccb75f7a42da2246e96ec255b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20Go=C5=82aszewski?= <jodator@jodator.net>
Date: Tue, 10 Sep 2019 17:10:53 +0200
Subject: [PATCH 08/11] Rewrite list item indent calculation.

---
 src/converters.js | 181 +++++++++++++++++++++++++---------------------
 1 file changed, 98 insertions(+), 83 deletions(-)

diff --git a/src/converters.js b/src/converters.js
index 18bbe5f..c4b7f38 100644
--- a/src/converters.js
+++ b/src/converters.js
@@ -371,23 +371,14 @@ export function viewModelConverter( evt, data, conversionApi ) {
 		const listItem = writer.createElement( 'listItem' );
 
 		// 2. Handle `listItem` model element attributes.
-		conversionStore.indent = conversionStore.indent || 0;
+		const indent = getIndent( data.viewItem, conversionStore );
 
-		// The offset is used if list is not nested according to rules from HTML specification, e.g. directly in other list.
-		// We calculate offset here as the indent increment is done when converting children of other list items
-		// and it might be set incorrectly.
-		const offset = getIncompatibleListOffset( data.viewItem, conversionStore );
-		const resultingIndent = conversionStore.indent + offset;
-
-		writer.setAttribute( 'listIndent', resultingIndent, listItem );
+		writer.setAttribute( 'listIndent', indent, listItem );
 
 		// Set 'bulleted' as default. If this item is pasted into a context,
 		const type = data.viewItem.parent && data.viewItem.parent.name == 'ol' ? 'numbered' : 'bulleted';
 		writer.setAttribute( 'listType', type, listItem );
 
-		// `listItem`s created recursively should have bigger indent.
-		conversionStore.indent++;
-
 		// Try to find allowed parent for list item.
 		const splitResult = conversionApi.splitToAllowedParent( listItem, data.modelCursor );
 
@@ -401,8 +392,6 @@ export function viewModelConverter( evt, data, conversionApi ) {
 
 		const nextPosition = viewToModelListItemChildrenConverter( listItem, data.viewItem.getChildren(), conversionApi );
 
-		conversionStore.indent--;
-
 		// Result range starts before the first item and ends after the last.
 		data.modelRange = writer.createRange( data.modelCursor, nextPosition );
 
@@ -1007,96 +996,122 @@ function hoistNestedLists( nextIndent, modelRemoveStartPosition, viewRemoveStart
 // @param {module:engine/view/element~Element} viewElement
 // @returns {Boolean}
 function isList( viewElement ) {
-	return viewElement.is( 'ol' ) || viewElement.is( 'ul' );
+	return viewElement && ( viewElement.is( 'ol' ) || viewElement.is( 'ul' ) );
 }
 
-// Return list item indent offset - used to fix lists that are not properly nested according to HTML rules.
-//
-// Returning offset will change the indent from normal flow of a conversion process.
-//
-// 1. List item in a wrongly nested list (previous sibling is a list item)
-//
-//		before:                           fixed list:
-//		OL                                OL
-//		|-> LI                            |-> LI         (indent: 0)
-//		|-> OL                                |-> OL
-//		    |-> LI (offset: +1)                   |-> LI (indent: 1)
-//
-// 2. List nested directly in other list as a first child.
-//
-//  The offset will be 0 if one of the ancestors is nested in li so the indent is already properly calculated.
-//
-//		before:                           fixed list:
-//		OL                                OL
-//		|-> LI                            |-> LI         (indent: 0)
-//		    |-> OL                            |-> OL
-//		        |-> OL                            |-> LI (indent: 1)
-//		        |   |-> OL                        |-> LI (indent: 1)
-//		        |       |-> OL
-//		        |           |-> LI (offset: 0)
-//		        |-> LI (offset: 0)
-//
-//  The offset will be 0 if list is not nested in any other list item:
-//
-//		before:                           fixed list:
-//		OL                                OL
-//		|-> OL                             |-> LI        (indent: 0)
-//		    |-> OL
-//		         |-> OL
-//		             |-> LI (offset: 0)
+// Calculates list item indent. Handles HTML compliant and non-compliant lists.
 //
 // @param {module:engine/view/element~Element} listItem
 // @param {Object} conversionStore
 // @returns {Number}
-function getIncompatibleListOffset( listItem, conversionStore ) {
-	// Ensure proper conversion store value.
-	// Indent modifiers stores already calculated indentation modifiers.
-	conversionStore.indentOffsets = conversionStore.indentOffsets || new WeakMap();
+function getIndent( listItem, conversionStore ) {
+	const indentsMap = conversionStore.__indents = conversionStore.__indents || new WeakMap();
+
+	const parentList = listItem.parent;
 
-	const list = listItem.parent;
+	let indent;
 
-	// List item might be pasted without parent list or be directly in pasted content - no need to calculate or store anything.
-	if ( !list || !list.parent ) {
-		return 0;
+	if ( !parentList || !isList( parentList ) ) {
+		indent = 0;
 	}
 
-	let offset = 0;
+	if ( indent === undefined && indentsMap.has( parentList ) ) {
+		indent = indentsMap.get( parentList );
+	}
 
-	if ( isList( list.parent ) ) {
-		// Only consider list nested directly in other list so when not wrapped by LI element.
-		const previousSibling = list.previousSibling;
+	// Semantic list.
+	if ( indent === undefined && parentList.parent && parentList.parent.is( 'li' ) ) {
+		let prevIndent;
 
-		if ( previousSibling && previousSibling.is( 'li' ) ) {
-			// List is nested in other list but after other list item.
-			offset = ( conversionStore.indentOffsets.get( previousSibling.parent ) || 0 ) + 1;
-		} else {
-			// List is nested directly in other list as a first item.
-			offset = getNestedListOffset( list, conversionStore );
+		// In most cases this would be true as when li is nested in ul.
+		if ( indentsMap.has( parentList.parent.parent ) ) {
+			prevIndent = indentsMap.get( parentList.parent.parent );
+		}
+		// Edge case - when pasted li with ul inside. LI already checked above.
+		else {
+			prevIndent = indentsMap.get( parentList.parent );
 		}
+
+		indent = prevIndent + 1;
 	}
 
-	// Store the indent modifier of parent list.
-	conversionStore.indentOffsets.set( list, offset );
+	// Non semantic list.
+	if ( indent === undefined && isList( parentList.parent ) ) {
+		const previousSibling = parentList.previousSibling;
 
-	return offset;
-}
+		// Return list item indent offset - used to fix lists that are not properly nested according to HTML rules.
+		//
+		// Returning offset will change the indent from normal flow of a conversion process.
+		//
+		// 1. List item in a wrongly nested list (previous sibling is a list item)
+		//
+		//		before:                           fixed list:
+		//		OL                                OL
+		//		|-> LI                            |-> LI         (indent: 0)
+		//		|-> OL                                |-> OL
+		//		    |-> LI (offset: +1)                   |-> LI (indent: 1)
+		//
+		// 2. List nested directly in other list as a first child.
+		//
+		//  The offset will be 0 if one of the ancestors is nested in li so the indent is already properly calculated.
+		//
+		//		before:                           fixed list:
+		//		OL                                OL
+		//		|-> LI                            |-> LI         (indent: 0)
+		//		    |-> OL                            |-> OL
+		//		        |-> OL                            |-> LI (indent: 1)
+		//		        |   |-> OL                        |-> LI (indent: 1)
+		//		        |       |-> OL
+		//		        |           |-> LI (offset: 0)
+		//		        |-> LI (offset: 0)
+		//
+		//  The offset will be 0 if list is not nested in any other list item:
+		//
+		//		before:                           fixed list:
+		//		OL                                OL
+		//		|-> OL                             |-> LI        (indent: 0)
+		//		    |-> OL
+		//		         |-> OL
+		//		             |-> LI (offset: 0)
+		//
+		// @param {module:engine/view/element~Element} listItem
+		// @param {Object} conversionStore
+		// @returns {Number}
 
-// Return list item indent offset - used to fix lists that are not properly nested according to HTML rules.
-//
-// @param {module:engine/view/element~Element} listItem
-// @param {Object} conversionStore
-// @returns {Number}
-function getNestedListOffset( list, conversionStore ) {
-	let listParent = list.parent;
+		if ( previousSibling && previousSibling.is( 'li' ) ) {
+			indent = indentsMap.get( previousSibling.parent ) + 1;
+		} else {
+			let parent = parentList.parent;
 
-	while ( isList( listParent ) && !conversionStore.indentOffsets.has( listParent ) ) {
-		listParent = listParent.parent;
+			while ( isList( parent ) && !indentsMap.has( parent ) ) {
+				parent = parent.parent;
+			}
+
+			if ( indentsMap.has( parent ) ) {
+				indent = indentsMap.get( parent ) + 1;
+			} else {
+				if ( parent.is( 'li' ) && indentsMap.has( parent.parent ) ) {
+					indent = indentsMap.get( parent.parent ) + 1;
+				} else {
+					// Wrong if
+					indent = 0;
+				}
+			}
+			// List is nested directly in other list as a first item.
+			// offset = getNestedListOffset( list, conversionStore );
+		}
 	}
 
-	// If there was a list ancestor with offset we must return greater offset.
-	if ( conversionStore.indentOffsets.has( listParent ) ) {
-		return conversionStore.indentOffsets.get( listParent ) + 1;
+	if ( indent === undefined ) {
+		indent = 0;
+	}
+
+	if ( parentList ) {
+		indentsMap.set( parentList, indent );
+	} else {
+		// For edge cases.
+		indentsMap.set( listItem, indent );
 	}
 
-	return 0;
+	return indent;
 }

From 0784b5163e9e0d9546e5cba2607d8bba99c79707 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20Go=C5=82aszewski?= <jodator@jodator.net>
Date: Tue, 10 Sep 2019 18:36:49 +0200
Subject: [PATCH 09/11] Improve indent calculation readability and improve its
 inline docs.

---
 src/converters.js    | 121 +++++++++++++++++++++----------------------
 tests/listediting.js |   6 +--
 2 files changed, 63 insertions(+), 64 deletions(-)

diff --git a/src/converters.js b/src/converters.js
index c4b7f38..4ef1b7b 100644
--- a/src/converters.js
+++ b/src/converters.js
@@ -996,64 +996,74 @@ function hoistNestedLists( nextIndent, modelRemoveStartPosition, viewRemoveStart
 // @param {module:engine/view/element~Element} viewElement
 // @returns {Boolean}
 function isList( viewElement ) {
-	return viewElement && ( viewElement.is( 'ol' ) || viewElement.is( 'ul' ) );
+	return viewElement.is( 'ol' ) || viewElement.is( 'ul' );
 }
 
-// Calculates list item indent. Handles HTML compliant and non-compliant lists.
+// Returns the indent value for a list item. Handles HTML compliant and non-compliant lists.
 //
 // @param {module:engine/view/element~Element} listItem
 // @param {Object} conversionStore
 // @returns {Number}
 function getIndent( listItem, conversionStore ) {
+	// Indents map caches the indent for the same list (ul/ol).
 	const indentsMap = conversionStore.__indents = conversionStore.__indents || new WeakMap();
 
 	const parentList = listItem.parent;
 
-	let indent;
-
+	// The indent is always 0 for list items without a parent or placed direclty in root.
 	if ( !parentList || !isList( parentList ) ) {
-		indent = 0;
+		return 0;
 	}
 
-	if ( indent === undefined && indentsMap.has( parentList ) ) {
-		indent = indentsMap.get( parentList );
+	// List have been already processed - no need to calculate anything.
+	if ( indentsMap.has( parentList ) ) {
+		return indentsMap.get( parentList );
 	}
 
-	// Semantic list.
-	if ( indent === undefined && parentList.parent && parentList.parent.is( 'li' ) ) {
-		let prevIndent;
+	const indent = calculateIndent( parentList, indentsMap );
+
+	indentsMap.set( parentList, indent );
+
+	return indent;
+}
+
+// Calculates indent for parent list.
+function calculateIndent( parentList, indentsMap ) {
+	const wrappingParent = parentList.parent;
 
-		// In most cases this would be true as when li is nested in ul.
-		if ( indentsMap.has( parentList.parent.parent ) ) {
-			prevIndent = indentsMap.get( parentList.parent.parent );
+	if ( !wrappingParent ) {
+		return 0;
+	}
+
+	// HTML compliant list - ul/ol has li parent.
+	if ( wrappingParent.is( 'li' ) ) {
+		// Standard case: ul > li > ul > li - Get the wrapping li parent's (ul/ol) indent.
+		if ( indentsMap.has( wrappingParent.parent ) ) {
+			return indentsMap.get( wrappingParent.parent ) + 1;
 		}
-		// Edge case - when pasted li with ul inside. LI already checked above.
+		// Edge case: li > ul > li. List item placed directly in root has nested list.
 		else {
-			prevIndent = indentsMap.get( parentList.parent );
+			return 1;
 		}
-
-		indent = prevIndent + 1;
 	}
 
-	// Non semantic list.
-	if ( indent === undefined && isList( parentList.parent ) ) {
+	// Non HTML compliant list - ul/ol has ul/ol parent.
+	if ( isList( wrappingParent ) ) {
 		const previousSibling = parentList.previousSibling;
 
-		// Return list item indent offset - used to fix lists that are not properly nested according to HTML rules.
+		// Resulting offset depends of the nesting condition.
 		//
-		// Returning offset will change the indent from normal flow of a conversion process.
-		//
-		// 1. List item in a wrongly nested list (previous sibling is a list item)
+		// 1. Previous sibling is a list item.
 		//
 		//		before:                           fixed list:
 		//		OL                                OL
 		//		|-> LI                            |-> LI         (indent: 0)
 		//		|-> OL                                |-> OL
-		//		    |-> LI (offset: +1)                   |-> LI (indent: 1)
+		//		    |-> LI                                |-> LI (indent: 1)
 		//
 		// 2. List nested directly in other list as a first child.
 		//
-		//  The offset will be 0 if one of the ancestors is nested in li so the indent is already properly calculated.
+		//  a) The indent will not be offset if one of the ancestors is nested in li so the indent is already properly calculated.
 		//
 		//		before:                           fixed list:
 		//		OL                                OL
@@ -1062,56 +1072,45 @@ function getIndent( listItem, conversionStore ) {
 		//		        |-> OL                            |-> LI (indent: 1)
 		//		        |   |-> OL                        |-> LI (indent: 1)
 		//		        |       |-> OL
-		//		        |           |-> LI (offset: 0)
-		//		        |-> LI (offset: 0)
+		//		        |           |-> LI
+		//		        |-> LI
 		//
-		//  The offset will be 0 if list is not nested in any other list item:
+		//  b) The indent will not be offset if list is not nested in any other list item:
 		//
 		//		before:                           fixed list:
 		//		OL                                OL
 		//		|-> OL                             |-> LI        (indent: 0)
 		//		    |-> OL
 		//		         |-> OL
-		//		             |-> LI (offset: 0)
-		//
-		// @param {module:engine/view/element~Element} listItem
-		// @param {Object} conversionStore
-		// @returns {Number}
+		//		             |-> LI
 
+		// Case 1 - previous sibling is li so we nest this list inside.
 		if ( previousSibling && previousSibling.is( 'li' ) ) {
-			indent = indentsMap.get( previousSibling.parent ) + 1;
-		} else {
-			let parent = parentList.parent;
+			return indentsMap.get( previousSibling.parent ) + 1;
+		}
 
-			while ( isList( parent ) && !indentsMap.has( parent ) ) {
-				parent = parent.parent;
-			}
+		// Case 2: The list item is nested directly in other list - find the best indent for this scenario.
+		let parent = wrappingParent;
 
-			if ( indentsMap.has( parent ) ) {
-				indent = indentsMap.get( parent ) + 1;
-			} else {
-				if ( parent.is( 'li' ) && indentsMap.has( parent.parent ) ) {
-					indent = indentsMap.get( parent.parent ) + 1;
-				} else {
-					// Wrong if
-					indent = 0;
-				}
-			}
-			// List is nested directly in other list as a first item.
-			// offset = getNestedListOffset( list, conversionStore );
+		// Find first ul/ol parent that has mapped indent.
+		while ( isList( parent ) && !indentsMap.has( parent ) ) {
+			parent = parent.parent;
 		}
-	}
 
-	if ( indent === undefined ) {
-		indent = 0;
-	}
+		// We always nest one lever deeper than...
+		// ...already processed list - if found - or...
+		if ( indentsMap.has( parent ) ) {
+			return indentsMap.get( parent ) + 1;
+		}
 
-	if ( parentList ) {
-		indentsMap.set( parentList, indent );
-	} else {
-		// For edge cases.
-		indentsMap.set( listItem, indent );
+		// ...HTML compliant list (if present).
+		if ( parent.is( 'li' ) && indentsMap.has( parent.parent ) ) {
+			return indentsMap.get( parent.parent ) + 1;
+		}
 	}
 
-	return indent;
+	// Will fallback to base indent in other cases:
+	// - wrapping parent is neither list nor list item
+	// - the indent should be zero for non-compliant list if li is deeply nested in other lists (case 2b.)
+	return 0;
 }
diff --git a/tests/listediting.js b/tests/listediting.js
index 44d2deb..aa515e3 100644
--- a/tests/listediting.js
+++ b/tests/listediting.js
@@ -22,7 +22,7 @@ import IndentEditing from '@ckeditor/ckeditor5-indent/src/indentediting';
 
 import { getCode } from '@ckeditor/ckeditor5-utils/src/keyboard';
 
-describe( 'ListEditing', () => {
+describe.only( 'ListEditing', () => {
 	let editor, model, modelDoc, modelRoot, view, viewDoc, viewRoot;
 
 	beforeEach( () => {
@@ -1285,7 +1285,7 @@ describe( 'ListEditing', () => {
 		} );
 	} );
 
-	describe( 'nested lists', () => {
+	describe.only( 'nested lists', () => {
 		describe( 'setting data', () => {
 			function test( testName, string, expectedString = null ) {
 				it( testName, () => {
@@ -3750,7 +3750,7 @@ describe( 'ListEditing', () => {
 		} );
 	} );
 
-	describe( 'paste and insertContent integration', () => {
+	describe.only( 'paste and insertContent integration', () => {
 		it( 'should be triggered on DataController#insertContent()', () => {
 			setModelData( model,
 				'<listItem listType="bulleted" listIndent="0">A</listItem>' +

From 1a701a08dfa419e875bd15313d36559cab91fbeb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20Go=C5=82aszewski?= <jodator@jodator.net>
Date: Tue, 10 Sep 2019 18:37:08 +0200
Subject: [PATCH 10/11] Remove .only from tests.

---
 tests/listediting.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/listediting.js b/tests/listediting.js
index aa515e3..44d2deb 100644
--- a/tests/listediting.js
+++ b/tests/listediting.js
@@ -22,7 +22,7 @@ import IndentEditing from '@ckeditor/ckeditor5-indent/src/indentediting';
 
 import { getCode } from '@ckeditor/ckeditor5-utils/src/keyboard';
 
-describe.only( 'ListEditing', () => {
+describe( 'ListEditing', () => {
 	let editor, model, modelDoc, modelRoot, view, viewDoc, viewRoot;
 
 	beforeEach( () => {
@@ -1285,7 +1285,7 @@ describe.only( 'ListEditing', () => {
 		} );
 	} );
 
-	describe.only( 'nested lists', () => {
+	describe( 'nested lists', () => {
 		describe( 'setting data', () => {
 			function test( testName, string, expectedString = null ) {
 				it( testName, () => {
@@ -3750,7 +3750,7 @@ describe.only( 'ListEditing', () => {
 		} );
 	} );
 
-	describe.only( 'paste and insertContent integration', () => {
+	describe( 'paste and insertContent integration', () => {
 		it( 'should be triggered on DataController#insertContent()', () => {
 			setModelData( model,
 				'<listItem listType="bulleted" listIndent="0">A</listItem>' +

From c5f3e8ca1073998c3a9e22814a53587aadab9df6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20Go=C5=82aszewski?= <jodator@jodator.net>
Date: Tue, 10 Sep 2019 18:55:56 +0200
Subject: [PATCH 11/11] Calculate indent solely relying on the view tree
 structure.

---
 src/converters.js | 123 +++++++---------------------------------------
 1 file changed, 18 insertions(+), 105 deletions(-)

diff --git a/src/converters.js b/src/converters.js
index 4ef1b7b..634a858 100644
--- a/src/converters.js
+++ b/src/converters.js
@@ -365,13 +365,12 @@ export function modelViewMergeAfter( evt, data, conversionApi ) {
 export function viewModelConverter( evt, data, conversionApi ) {
 	if ( conversionApi.consumable.consume( data.viewItem, { name: true } ) ) {
 		const writer = conversionApi.writer;
-		const conversionStore = this.conversionApi.store;
 
 		// 1. Create `listItem` model element.
 		const listItem = writer.createElement( 'listItem' );
 
 		// 2. Handle `listItem` model element attributes.
-		const indent = getIndent( data.viewItem, conversionStore );
+		const indent = getIndent( data.viewItem );
 
 		writer.setAttribute( 'listIndent', indent, listItem );
 
@@ -999,118 +998,32 @@ function isList( viewElement ) {
 	return viewElement.is( 'ol' ) || viewElement.is( 'ul' );
 }
 
-// Returns the indent value for a list item. Handles HTML compliant and non-compliant lists.
+// Calculates the indent value for a list item. Handles HTML compliant and non-compliant lists.
 //
 // @param {module:engine/view/element~Element} listItem
 // @param {Object} conversionStore
 // @returns {Number}
-function getIndent( listItem, conversionStore ) {
-	// Indents map caches the indent for the same list (ul/ol).
-	const indentsMap = conversionStore.__indents = conversionStore.__indents || new WeakMap();
+function getIndent( listItem ) {
+	let indent = 0;
 
-	const parentList = listItem.parent;
+	let parent = listItem.parent;
 
-	// The indent is always 0 for list items without a parent or placed direclty in root.
-	if ( !parentList || !isList( parentList ) ) {
-		return 0;
-	}
-
-	// List have been already processed - no need to calculate anything.
-	if ( indentsMap.has( parentList ) ) {
-		return indentsMap.get( parentList );
-	}
-
-	const indent = calculateIndent( parentList, indentsMap );
-
-	indentsMap.set( parentList, indent );
-
-	return indent;
-}
-
-// Calculates indent for parent list.
-function calculateIndent( parentList, indentsMap ) {
-	const wrappingParent = parentList.parent;
-
-	if ( !wrappingParent ) {
-		return 0;
-	}
-
-	// HTML compliant list - ul/ol has li parent.
-	if ( wrappingParent.is( 'li' ) ) {
-		// Standard case: ul > li > ul > li - Get the wrapping li parent's (ul/ol) indent.
-		if ( indentsMap.has( wrappingParent.parent ) ) {
-			return indentsMap.get( wrappingParent.parent ) + 1;
-		}
-		// Edge case: li > ul > li. List item placed directly in root has nested list.
-		else {
-			return 1;
-		}
-	}
-
-	// Non HTML compliant list - ul/ol has ul/ol parent.
-	if ( isList( wrappingParent ) ) {
-		const previousSibling = parentList.previousSibling;
-
-		// Resulting offset depends of the nesting condition.
-		//
-		// 1. Previous sibling is a list item.
-		//
-		//		before:                           fixed list:
-		//		OL                                OL
-		//		|-> LI                            |-> LI         (indent: 0)
-		//		|-> OL                                |-> OL
-		//		    |-> LI                                |-> LI (indent: 1)
-		//
-		// 2. List nested directly in other list as a first child.
-		//
-		//  a) The indent will not be offset if one of the ancestors is nested in li so the indent is already properly calculated.
-		//
-		//		before:                           fixed list:
-		//		OL                                OL
-		//		|-> LI                            |-> LI         (indent: 0)
-		//		    |-> OL                            |-> OL
-		//		        |-> OL                            |-> LI (indent: 1)
-		//		        |   |-> OL                        |-> LI (indent: 1)
-		//		        |       |-> OL
-		//		        |           |-> LI
-		//		        |-> LI
-		//
-		//  b) The indent will not be offset if list is not nested in any other list item:
-		//
-		//		before:                           fixed list:
-		//		OL                                OL
-		//		|-> OL                             |-> LI        (indent: 0)
-		//		    |-> OL
-		//		         |-> OL
-		//		             |-> LI
-
-		// Case 1 - previous sibling is li so we nest this list inside.
-		if ( previousSibling && previousSibling.is( 'li' ) ) {
-			return indentsMap.get( previousSibling.parent ) + 1;
-		}
-
-		// Case 2: The list item is nested directly in other list - find the best indent for this scenario.
-		let parent = wrappingParent;
-
-		// Find first ul/ol parent that has mapped indent.
-		while ( isList( parent ) && !indentsMap.has( parent ) ) {
-			parent = parent.parent;
-		}
+	while ( parent && ( parent.is( 'li' ) || isList( parent ) ) ) {
+		// Each LI in the tree will result in an increased indent for HTML compliant lists.
+		if ( parent.is( 'li' ) ) {
+			indent++;
+		} else {
+			// If however the list is nested in other list we should check previous sibling of any of the list elements...
+			const previousSibling = parent.previousSibling;
 
-		// We always nest one lever deeper than...
-		// ...already processed list - if found - or...
-		if ( indentsMap.has( parent ) ) {
-			return indentsMap.get( parent ) + 1;
+			// ..,because the we might need increase its indent.
+			if ( previousSibling && previousSibling.is( 'li' ) ) {
+				indent++;
+			}
 		}
 
-		// ...HTML compliant list (if present).
-		if ( parent.is( 'li' ) && indentsMap.has( parent.parent ) ) {
-			return indentsMap.get( parent.parent ) + 1;
-		}
+		parent = parent.parent;
 	}
 
-	// Will fallback to base indent in other cases:
-	// - wrapping parent is neither list nor list item
-	// - the indent should be zero for non-compliant list if li is deeply nested in other lists (case 2b.)
-	return 0;
+	return indent;
 }