       sections = list.sections
       subject.next(Observable2DArrayEvent(change: .deleteSections(IndexSet(sectionDeletes)), source: self))
       subject.next(Observable2DArrayEvent(change: .deleteItems(deletesIndexPaths), source: self))
+      
+      for entry in sectionMoves {
+        subject.next(Observable2DArrayEvent(change: .moveSection(entry.from, entry.to), source: self))
+      }
+      
+      for entry in movesIndexPaths {
+        subject.next(Observable2DArrayEvent(change: .moveItem(entry.from, entry.to), source: self))
+      }
+      
+      
       subject.next(Observable2DArrayEvent(change: .insertSections(IndexSet(sectionInserts)), source: self))
       subject.next(Observable2DArrayEvent(change: .insertItems(insertsIndexPaths), source: self))
       subject.next(Observable2DArrayEvent(change: .endBatchEditing, source: self))
       lock.unlock()
     } else {
-      replace(with: list)
-    }
-  }
-  
-}
-
-
+      replace2D(with: list)
+    }
+  }
+  
+}
+
+

        
        // insertions should alwyas happen to the new section's place
        insertsIndexPaths.append(contentsOf: inserts.map { IndexPath(item: $0, section: entry.new) })
      }
      
      

      
      var deletesIndexPaths: [IndexPath] = []
      var insertsIndexPaths: [IndexPath] = []
      var movesIndexPaths: [(from: IndexPath, to: IndexPath)] = []
      
      // perform diff on sectionsSame items to get indecies that where deleted, inserted and moved inside those sections
      for entry in sectionsSame {
        
        // the diff should happen between old section's items and new section's items on their corresponding indecies
        let diff = sections[entry.old].items.extendedDiff(list[entry.new].items)
        let patch = diff.patch(from: sections[entry.old].items, to: list[entry.new].items)

        //let diff = Array.diff(sections[entry.old].items, list[entry.new].items)
        
        var deletes: [Int] = []
        var inserts: [Int] = []
        deletes.reserveCapacity(diff.count)
        inserts.reserveCapacity(diff.count)

        
        for diffStep in patch {
          switch diffStep {
          case .insertion(let index, _):
            inserts.append(index)
          case .deletion(let index):
            deletes.append(index)
          case .move(let from, let to):
            movesIndexPaths.append((IndexPath(item: from, section: entry.new), IndexPath(item: to, section: entry.new)))
          }
        }
        
