aberdeen 0.1.2 → 0.2.2

package/dist/aberdeen.js

@@ -3,7 +3,6 @@ let queueSet = new Set();
 let queueOrdered = true;
 let runQueueDepth = 0;
 let queueIndex;
-let recordingPatch;
 function queue(runner) {
     if (queueSet.has(runner))
         return;
@@ -13,7 +12,7 @@ function queue(runner) {
     if (!queueArray.length) {
         setTimeout(runQueue, 0);
     }
-    else if (runner.queueOrder < queueArray[queueArray.length - 1].queueOrder) {
+    else if (runner._queueOrder < queueArray[queueArray.length - 1]._queueOrder) {
         queueOrdered = false;
     }
     queueArray.push(runner);
@@ -27,7 +26,7 @@ function runQueue() {
             queueArray.splice(0, queueIndex);
             queueIndex = 0;
             // Order queued observers by depth, lowest first.
-            queueArray.sort((a, b) => a.queueOrder - b.queueOrder);
+            queueArray.sort((a, b) => a._queueOrder - b._queueOrder);
             queueOrdered = true;
         }
         // Process the rest of what's currently in the queue.
@@ -35,7 +34,7 @@ function runQueue() {
         for (; queueIndex < batchEndIndex && queueOrdered; queueIndex++) {
             let runner = queueArray[queueIndex];
             queueSet.delete(runner);
-            runner.queueRun();
+            runner._queueRun();
         }
         // If new items have been added to the queue while processing the previous
         // batch, we'll need to run this loop again.
@@ -46,7 +45,6 @@ function runQueue() {
     runQueueDepth = 0;
     onCreateEnabled = false;
 }
-let scheduleOrder = 1000;
 /**
  * Schedule a DOM read operation to be executed in Aberdeen's internal task queue.
  *
@@ -65,8 +63,8 @@ let scheduleOrder = 1000;
  * @param func The function to be executed as a DOM read operation.
  */
 export function scheduleDomReader(func) {
-    let order = (queueIndex != null && queueIndex < queueArray.length && queueArray[queueIndex].queueOrder >= 1000) ? ((queueArray[queueIndex].queueOrder + 1) & (~1)) : 1000;
-    queue({ queueOrder: order, queueRun: func });
+    let order = (queueIndex != null && queueIndex < queueArray.length && queueArray[queueIndex]._queueOrder >= 1000) ? ((queueArray[queueIndex]._queueOrder + 1) & (~1)) : 1000;
+    queue({ _queueOrder: order, _queueRun: func });
 }
 /**
  * Schedule a DOM write operation to be executed in Aberdeen's internal task queue.
@@ -86,8 +84,8 @@ export function scheduleDomReader(func) {
  * @param func The function to be executed as a DOM write operation.
  */
 export function scheduleDomWriter(func) {
-    let order = (queueIndex != null && queueIndex < queueArray.length && queueArray[queueIndex].queueOrder >= 1000) ? (queueArray[queueIndex].queueOrder | 1) : 1001;
-    queue({ queueOrder: order, queueRun: func });
+    let order = (queueIndex != null && queueIndex < queueArray.length && queueArray[queueIndex]._queueOrder >= 1000) ? (queueArray[queueIndex]._queueOrder | 1) : 1001;
+    queue({ _queueOrder: order, _queueRun: func });
 }
 /**
  * Given an integer number, a string or an array of these, this function returns a string that can be used
@@ -128,6 +126,7 @@ function numToString(num, neg) {
 }
 /*
  * Scope
+ * @internal
  *
  * A `Scope` is created with a `render` function that is run initially,
  * and again when any of the `Store`s that this function reads are changed. Any
@@ -140,54 +139,54 @@ class Scope {
     constructor(parentElement, precedingSibling, queueOrder) {
         // The list of clean functions to be called when this scope is cleaned. These can
         // be for child scopes, subscriptions as well as `clean(..)` hooks.
-        this.cleaners = [];
+        this._cleaners = [];
         // Set to true after the scope has been cleaned, causing any spurious reruns to
         // be ignored.
-        this.isDead = false;
-        this.parentElement = parentElement;
-        this.precedingSibling = precedingSibling;
-        this.queueOrder = queueOrder;
+        this._isDead = false;
+        this._parentElement = parentElement;
+        this._precedingSibling = precedingSibling;
+        this._queueOrder = queueOrder;
     }
     // Get a reference to the last Node preceding this Scope, or undefined if there is none
-    findPrecedingNode(stopAt = undefined) {
+    _findPrecedingNode(stopAt = undefined) {
         let cur = this;
         let pre;
-        while ((pre = cur.precedingSibling) && pre !== stopAt) {
+        while ((pre = cur._precedingSibling) && pre !== stopAt) {
             if (pre instanceof Node)
                 return pre;
-            let node = pre.findLastNode();
+            let node = pre._findLastNode();
             if (node)
                 return node;
             cur = pre;
         }
     }
     // Get a reference to the last Node within this scope and parentElement
-    findLastNode() {
-        if (this.lastChild) {
-            if (this.lastChild instanceof Node)
-                return this.lastChild;
+    _findLastNode() {
+        if (this._lastChild) {
+            if (this._lastChild instanceof Node)
+                return this._lastChild;
             else
-                return this.lastChild.findLastNode() || this.lastChild.findPrecedingNode(this.precedingSibling);
+                return this._lastChild._findLastNode() || this._lastChild._findPrecedingNode(this._precedingSibling);
         }
     }
-    addNode(node) {
-        if (!this.parentElement)
+    _addNode(node) {
+        if (!this._parentElement)
             throw new ScopeError(true);
-        let prevNode = this.findLastNode() || this.findPrecedingNode();
-        this.parentElement.insertBefore(node, prevNode ? prevNode.nextSibling : this.parentElement.firstChild);
-        this.lastChild = node;
+        let prevNode = this._findLastNode() || this._findPrecedingNode();
+        this._parentElement.insertBefore(node, prevNode ? prevNode.nextSibling : this._parentElement.firstChild);
+        this._lastChild = node;
     }
-    remove() {
-        if (this.parentElement) {
-            let lastNode = this.findLastNode();
+    _remove() {
+        if (this._parentElement) {
+            let lastNode = this._findLastNode();
             if (lastNode) {
                 // at least one DOM node to be removed
-                let nextNode = this.findPrecedingNode();
-                nextNode = (nextNode ? nextNode.nextSibling : this.parentElement.firstChild);
-                this.lastChild = undefined;
+                let nextNode = this._findPrecedingNode();
+                nextNode = (nextNode ? nextNode.nextSibling : this._parentElement.firstChild);
+                this._lastChild = undefined;
                 // Keep removing DOM nodes starting at our first node, until we encounter the last node
                 while (true) {
-                    /* istanbul ignore next */
+                    /* c8 ignore next */
                     if (!nextNode)
                         return internalError(1);
                     const node = nextNode;
@@ -207,7 +206,7 @@ class Scope {
                         // Ignore the deleting element
                     }
                     else {
-                        this.parentElement.removeChild(node);
+                        this._parentElement.removeChild(node);
                     }
                     if (node === lastNode)
                         break;
@@ -218,37 +217,36 @@ class Scope {
         this._clean();
     }
     _clean() {
-        this.isDead = true;
-        for (let cleaner of this.cleaners) {
+        this._isDead = true;
+        for (let cleaner of this._cleaners) {
             cleaner._clean(this);
         }
-        this.cleaners.length = 0;
+        this._cleaners.length = 0;
     }
-    onChange(index, newData, oldData) {
+    _onChange(index, newData, oldData) {
         queue(this);
     }
 }
 class SimpleScope extends Scope {
     constructor(parentElement, precedingSibling, queueOrder, renderer) {
         super(parentElement, precedingSibling, queueOrder);
-        this.renderer = renderer;
+        this._renderer = renderer;
     }
-    queueRun() {
-        /* istanbul ignore next */
-        if (currentScope) {
+    _queueRun() {
+        /* c8 ignore next */
+        if (currentScope)
             internalError(2);
-        }
-        if (this.isDead)
+        if (this._isDead)
             return;
-        this.remove();
-        this.isDead = false;
-        this.update();
+        this._remove();
+        this._isDead = false;
+        this._update();
     }
-    update() {
+    _update() {
         let savedScope = currentScope;
         currentScope = this;
         try {
-            this.renderer();
+            this._renderer();
         }
         catch (e) {
             // Throw the error async, so the rest of the rendering can continue
@@ -257,16 +255,47 @@ class SimpleScope extends Scope {
         currentScope = savedScope;
     }
 }
+let immediateQueue = new Set();
+class ImmediateScope extends SimpleScope {
+    _onChange(index, newData, oldData) {
+        immediateQueue.add(this);
+    }
+}
+let immediateQueuerRunning = false;
+function runImmediateQueue() {
+    if (immediateQueuerRunning)
+        return;
+    for (let count = 0; immediateQueue.size; count++) {
+        if (count > 42) {
+            immediateQueue.clear();
+            throw new Error("Too many recursive updates from immediate-mode observes");
+        }
+        immediateQueuerRunning = true;
+        let copy = immediateQueue;
+        immediateQueue = new Set();
+        let savedScope = currentScope;
+        currentScope = undefined;
+        try {
+            for (const scope of copy) {
+                scope._queueRun();
+            }
+        }
+        finally {
+            currentScope = savedScope;
+            immediateQueuerRunning = false;
+        }
+    }
+}
 class IsEmptyObserver {
     constructor(scope, collection, triggerCount) {
         this.scope = scope;
         this.collection = collection;
         this.triggerCount = triggerCount;
-        this.count = collection.getCount();
-        collection.addObserver(ANY_INDEX, this);
-        scope.cleaners.push(this);
+        this.count = collection._getCount();
+        collection._addObserver(ANY_INDEX, this);
+        scope._cleaners.push(this);
     }
-    onChange(index, newData, oldData) {
+    _onChange(index, newData, oldData) {
         if (newData === undefined) {
             // oldData is guaranteed not to be undefined
             if (this.triggerCount || !--this.count)
@@ -278,106 +307,105 @@ class IsEmptyObserver {
         }
     }
     _clean() {
-        this.collection.removeObserver(ANY_INDEX, this);
+        this.collection._removeObserver(ANY_INDEX, this);
     }
 }
+/** @internal */
 class OnEachScope extends Scope {
     constructor(parentElement, precedingSibling, queueOrder, collection, renderer, makeSortKey) {
         super(parentElement, precedingSibling, queueOrder);
         /** The ordered list of currently item scopes */
-        this.byPosition = [];
+        this._byPosition = [];
         /** The item scopes in a Map by index */
-        this.byIndex = new Map();
+        this._byIndex = new Map();
         /** Indexes that have been created/removed and need to be handled in the next `queueRun` */
-        this.newIndexes = new Set();
-        this.removedIndexes = new Set();
-        this.collection = collection;
-        this.renderer = renderer;
-        this.makeSortKey = makeSortKey;
+        this._newIndexes = new Set();
+        this._removedIndexes = new Set();
+        this._collection = collection;
+        this._renderer = renderer;
+        this._makeSortKey = makeSortKey;
     }
     // toString(): string {
     // 	return `OnEachScope(collection=${this.collection})`
     // }
-    onChange(index, newData, oldData) {
+    _onChange(index, newData, oldData) {
         if (oldData === undefined) {
-            if (this.removedIndexes.has(index)) {
-                this.removedIndexes.delete(index);
+            if (this._removedIndexes.has(index)) {
+                this._removedIndexes.delete(index);
             }
             else {
-                this.newIndexes.add(index);
+                this._newIndexes.add(index);
                 queue(this);
             }
         }
         else if (newData === undefined) {
-            if (this.newIndexes.has(index)) {
-                this.newIndexes.delete(index);
+            if (this._newIndexes.has(index)) {
+                this._newIndexes.delete(index);
             }
             else {
-                this.removedIndexes.add(index);
+                this._removedIndexes.add(index);
                 queue(this);
             }
         }
     }
-    queueRun() {
-        if (this.isDead)
+    _queueRun() {
+        if (this._isDead)
             return;
-        let indexes = this.removedIndexes;
-        this.removedIndexes = new Set();
+        let indexes = this._removedIndexes;
+        this._removedIndexes = new Set();
         indexes.forEach(index => {
-            this.removeChild(index);
+            this._removeChild(index);
         });
-        indexes = this.newIndexes;
-        this.newIndexes = new Set();
+        indexes = this._newIndexes;
+        this._newIndexes = new Set();
         indexes.forEach(index => {
-            this.addChild(index);
+            this._addChild(index);
         });
     }
     _clean() {
         super._clean();
-        this.collection.observers.delete(this);
-        for (const [index, scope] of this.byIndex) {
+        this._collection._observers.delete(this);
+        for (const [index, scope] of this._byIndex) {
             scope._clean();
         }
         // Help garbage collection:
-        this.byPosition.length = 0;
-        this.byIndex.clear();
+        this._byPosition.length = 0;
+        this._byIndex.clear();
     }
-    renderInitial() {
-        /* istanbul ignore next */
-        if (!currentScope) {
+    _renderInitial() {
+        /* c8 ignore next */
+        if (!currentScope)
             return internalError(3);
-        }
         let parentScope = currentScope;
-        this.collection.iterateIndexes(this);
+        this._collection._iterateIndexes(this);
         currentScope = parentScope;
     }
-    addChild(itemIndex) {
-        let scope = new OnEachItemScope(this.parentElement, undefined, this.queueOrder + 1, this, itemIndex);
-        this.byIndex.set(itemIndex, scope);
-        scope.update();
+    _addChild(itemIndex) {
+        let scope = new OnEachItemScope(this._parentElement, undefined, this._queueOrder + 1, this, itemIndex);
+        this._byIndex.set(itemIndex, scope);
+        scope._update();
         // We're not adding a cleaner here, as we'll be calling them from our _clean function
     }
-    removeChild(itemIndex) {
-        let scope = this.byIndex.get(itemIndex);
-        /* istanbul ignore next */
-        if (!scope) {
+    _removeChild(itemIndex) {
+        let scope = this._byIndex.get(itemIndex);
+        /* c8 ignore next */
+        if (!scope)
             return internalError(6);
-        }
-        scope.remove();
-        this.byIndex.delete(itemIndex);
-        this.removeFromPosition(scope);
+        scope._remove();
+        this._byIndex.delete(itemIndex);
+        this._removeFromPosition(scope);
     }
-    findPosition(sortStr) {
+    _findPosition(sortStr) {
         // In case of duplicate `sortStr`s, this will return the first match.
-        let items = this.byPosition;
+        let items = this._byPosition;
         let min = 0, max = items.length;
         // Fast-path for elements that are already ordered (as is the case when working with arrays ordered by index)
-        if (!max || sortStr > items[max - 1].sortStr)
+        if (!max || sortStr > items[max - 1]._sortStr)
             return max;
         // Binary search for the insert position		
         while (min < max) {
             let mid = (min + max) >> 1;
-            if (items[mid].sortStr < sortStr) {
+            if (items[mid]._sortStr < sortStr) {
                 min = mid + 1;
             }
             else {
@@ -386,101 +414,100 @@ class OnEachScope extends Scope {
         }
         return min;
     }
-    insertAtPosition(child) {
-        let pos = this.findPosition(child.sortStr);
-        this.byPosition.splice(pos, 0, child);
+    _insertAtPosition(child) {
+        let pos = this._findPosition(child._sortStr);
+        this._byPosition.splice(pos, 0, child);
         // Based on the position in the list, set the precedingSibling for the new Scope
         // and for the next sibling.
-        let nextSibling = this.byPosition[pos + 1];
+        let nextSibling = this._byPosition[pos + 1];
         if (nextSibling) {
-            child.precedingSibling = nextSibling.precedingSibling;
-            nextSibling.precedingSibling = child;
+            child._precedingSibling = nextSibling._precedingSibling;
+            nextSibling._precedingSibling = child;
         }
         else {
-            child.precedingSibling = this.lastChild || this.precedingSibling;
-            this.lastChild = child;
+            child._precedingSibling = this._lastChild || this._precedingSibling;
+            this._lastChild = child;
         }
     }
-    removeFromPosition(child) {
-        if (child.sortStr === '')
+    _removeFromPosition(child) {
+        if (child._sortStr === '')
             return;
-        let pos = this.findPosition(child.sortStr);
+        let pos = this._findPosition(child._sortStr);
         while (true) {
-            if (this.byPosition[pos] === child) {
+            if (this._byPosition[pos] === child) {
                 // Yep, this is the right scope
-                this.byPosition.splice(pos, 1);
-                if (pos < this.byPosition.length) {
-                    let nextSibling = this.byPosition[pos];
-                    /* istanbul ignore next */
+                this._byPosition.splice(pos, 1);
+                if (pos < this._byPosition.length) {
+                    let nextSibling = this._byPosition[pos];
+                    /* c8 ignore next */
                     if (!nextSibling)
                         return internalError(8);
-                    /* istanbul ignore next */
-                    if (nextSibling.precedingSibling !== child)
+                    /* c8 ignore next */
+                    if (nextSibling._precedingSibling !== child)
                         return internalError(13);
-                    nextSibling.precedingSibling = child.precedingSibling;
+                    nextSibling._precedingSibling = child._precedingSibling;
                 }
                 else {
-                    /* istanbul ignore next */
-                    if (child !== this.lastChild)
+                    /* c8 ignore next */
+                    if (child !== this._lastChild)
                         return internalError(12);
-                    this.lastChild = child.precedingSibling === this.precedingSibling ? undefined : child.precedingSibling;
+                    this._lastChild = child._precedingSibling === this._precedingSibling ? undefined : child._precedingSibling;
                 }
                 return;
             }
             // There may be another Scope with the same sortStr
-            /* istanbul ignore next */
-            if (++pos >= this.byPosition.length || this.byPosition[pos].sortStr !== child.sortStr) {
+            /* c8 ignore next */
+            if (++pos >= this._byPosition.length || this._byPosition[pos]._sortStr !== child._sortStr)
                 return internalError(5);
-            }
         }
     }
 }
+/** @internal */
 class OnEachItemScope extends Scope {
     constructor(parentElement, precedingSibling, queueOrder, parent, itemIndex) {
         super(parentElement, precedingSibling, queueOrder);
-        this.sortStr = "";
-        this.parent = parent;
-        this.itemIndex = itemIndex;
+        this._sortStr = "";
+        this._parent = parent;
+        this._itemIndex = itemIndex;
     }
     // toString(): string {
     // 	return `OnEachItemScope(itemIndex=${this.itemIndex} parentElement=${this.parentElement} parent=${this.parent} precedingSibling=${this.precedingSibling} lastChild=${this.lastChild})`
     // }
-    queueRun() {
-        /* istanbul ignore next */
-        if (currentScope) {
+    _queueRun() {
+        /* c8 ignore next */
+        if (currentScope)
             internalError(4);
-        }
-        if (this.isDead)
+        if (this._isDead)
             return;
-        this.remove();
-        this.isDead = false;
-        this.update();
+        this._remove();
+        this._isDead = false;
+        this._update();
     }
-    update() {
+    _update() {
         // Have the makeSortKey function return an ordering int/string/array.
         // Since makeSortKey may get() the Store, we'll need to set currentScope first.
         let savedScope = currentScope;
         currentScope = this;
-        let itemStore = new Store(this.parent.collection, this.itemIndex);
+        let itemStore = new Store(this._parent._collection, this._itemIndex);
         let sortKey;
         try {
-            sortKey = this.parent.makeSortKey(itemStore);
+            sortKey = this._parent._makeSortKey(itemStore);
         }
         catch (e) {
             handleError(e);
         }
-        let oldSortStr = this.sortStr;
+        let oldSortStr = this._sortStr;
         let newSortStr = sortKey == null ? '' : sortKeyToString(sortKey);
         if (oldSortStr !== '' && oldSortStr !== newSortStr) {
-            this.parent.removeFromPosition(this);
+            this._parent._removeFromPosition(this);
         }
-        this.sortStr = newSortStr;
+        this._sortStr = newSortStr;
         if (newSortStr !== '') {
             if (newSortStr !== oldSortStr) {
-                this.parent.insertAtPosition(this);
+                this._parent._insertAtPosition(this);
             }
             try {
-                this.parent.renderer(itemStore);
+                this._parent._renderer(itemStore);
             }
             catch (e) {
                 handleError(e);
@@ -498,49 +525,45 @@ let currentScope;
  * A special Node observer index to subscribe to any value in the map changing.
  */
 const ANY_INDEX = {};
-class ObsCollection {
+/** @internal */
+export class ObsCollection {
     constructor() {
-        this.observers = new Map();
+        this._observers = new Map();
     }
     // toString(): string {
     // 	return JSON.stringify(peek(() => this.getRecursive(3)))
     // }
-    addObserver(index, observer) {
+    _addObserver(index, observer) {
         observer = observer;
-        let obsSet = this.observers.get(index);
+        let obsSet = this._observers.get(index);
         if (obsSet) {
             if (obsSet.has(observer))
                 return false;
             obsSet.add(observer);
         }
         else {
-            this.observers.set(index, new Set([observer]));
+            this._observers.set(index, new Set([observer]));
         }
         return true;
     }
-    removeObserver(index, observer) {
-        let obsSet = this.observers.get(index);
+    _removeObserver(index, observer) {
+        let obsSet = this._observers.get(index);
         obsSet.delete(observer);
     }
     emitChange(index, newData, oldData) {
-        if (recordingPatch) {
-            addToPatch(recordingPatch, this, index, newData, oldData);
-        }
-        else {
-            let obsSet = this.observers.get(index);
-            if (obsSet)
-                obsSet.forEach(observer => observer.onChange(index, newData, oldData));
-            obsSet = this.observers.get(ANY_INDEX);
-            if (obsSet)
-                obsSet.forEach(observer => observer.onChange(index, newData, oldData));
-        }
+        let obsSet = this._observers.get(index);
+        if (obsSet)
+            obsSet.forEach(observer => observer._onChange(index, newData, oldData));
+        obsSet = this._observers.get(ANY_INDEX);
+        if (obsSet)
+            obsSet.forEach(observer => observer._onChange(index, newData, oldData));
     }
     _clean(observer) {
-        this.removeObserver(ANY_INDEX, observer);
+        this._removeObserver(ANY_INDEX, observer);
     }
-    setIndex(index, newValue, deleteMissing) {
+    _setIndex(index, newValue, deleteMissing) {
         const curData = this.rawGet(index);
-        if (!(curData instanceof ObsCollection) || newValue instanceof Store || !curData.merge(newValue, deleteMissing)) {
+        if (!(curData instanceof ObsCollection) || newValue instanceof Store || !curData._merge(newValue, deleteMissing)) {
             let newData = valueToData(newValue);
             if (newData !== curData) {
                 this.rawSet(index, newData);
@@ -549,67 +572,71 @@ class ObsCollection {
         }
     }
 }
+/** @internal */
 class ObsArray extends ObsCollection {
     constructor() {
         super(...arguments);
-        this.data = [];
+        this._data = [];
     }
-    getType() {
+    _getType() {
         return "array";
     }
-    getRecursive(depth) {
+    _getRecursive(depth) {
         if (currentScope) {
-            if (this.addObserver(ANY_INDEX, currentScope)) {
-                currentScope.cleaners.push(this);
+            if (this._addObserver(ANY_INDEX, currentScope)) {
+                currentScope._cleaners.push(this);
             }
         }
         let result = [];
-        for (let i = 0; i < this.data.length; i++) {
-            let v = this.data[i];
-            result.push(v instanceof ObsCollection ? (depth ? v.getRecursive(depth - 1) : new Store(this, i)) : v);
+        for (let i = 0; i < this._data.length; i++) {
+            let v = this._data[i];
+            result.push(v instanceof ObsCollection ? (depth ? v._getRecursive(depth - 1) : new Store(this, i)) : v);
         }
         return result;
     }
     rawGet(index) {
-        return this.data[index];
+        return this._data[index];
     }
     rawSet(index, newData) {
         if (index !== (0 | index) || index < 0 || index > 999999) {
             throw new Error(`Invalid array index ${JSON.stringify(index)}`);
         }
-        this.data[index] = newData;
+        this._data[index] = newData;
         // Remove trailing `undefined`s
-        while (this.data.length > 0 && this.data[this.data.length - 1] === undefined) {
-            this.data.pop();
+        while (this._data.length > 0 && this._data[this._data.length - 1] === undefined) {
+            this._data.pop();
         }
     }
-    merge(newValue, deleteMissing) {
+    _merge(newValue, deleteMissing) {
         if (!(newValue instanceof Array)) {
             return false;
         }
         // newValue is an array
         for (let i = 0; i < newValue.length; i++) {
-            this.setIndex(i, newValue[i], deleteMissing);
-        }
-        if (deleteMissing && this.data.length > newValue.length) {
-            for (let i = newValue.length; i < this.data.length; i++) {
-                let old = this.data[i];
+            this._setIndex(i, newValue[i], deleteMissing);
+        }
+        // Overwriting just the first elements of an array and leaving the rest of
+        // the old data in place is just weird and unexpected, so we'll always use
+        // 'replace' behavior for arrays.
+        if ( /*deleteMissing &&*/this._data.length > newValue.length) {
+            for (let i = newValue.length; i < this._data.length; i++) {
+                let old = this._data[i];
                 if (old !== undefined) {
                     this.emitChange(i, undefined, old);
                 }
             }
-            this.data.length = newValue.length;
+            this._data.length = newValue.length;
         }
         return true;
     }
-    iterateIndexes(scope) {
-        for (let i = 0; i < this.data.length; i++) {
-            if (this.data[i] !== undefined) {
-                scope.addChild(i);
+    _iterateIndexes(scope) {
+        for (let i = 0; i < this._data.length; i++) {
+            if (this._data[i] !== undefined) {
+                scope._addChild(i);
             }
         }
     }
-    normalizeIndex(index) {
+    _normalizeIndex(index) {
         if (typeof index === 'number')
             return index;
         if (typeof index === 'string') {
@@ -621,27 +648,28 @@ class ObsArray extends ObsCollection {
         }
         throw new Error(`Invalid array index ${JSON.stringify(index)}`);
     }
-    getCount() {
-        return this.data.length;
+    _getCount() {
+        return this._data.length;
     }
 }
+/** @internal */
 class ObsMap extends ObsCollection {
     constructor() {
         super(...arguments);
         this.data = new Map();
     }
-    getType() {
+    _getType() {
         return "map";
     }
-    getRecursive(depth) {
+    _getRecursive(depth) {
         if (currentScope) {
-            if (this.addObserver(ANY_INDEX, currentScope)) {
-                currentScope.cleaners.push(this);
+            if (this._addObserver(ANY_INDEX, currentScope)) {
+                currentScope._cleaners.push(this);
             }
         }
         let result = new Map();
         this.data.forEach((v, k) => {
-            result.set(k, (v instanceof ObsCollection) ? (depth ? v.getRecursive(depth - 1) : new Store(this, k)) : v);
+            result.set(k, (v instanceof ObsCollection) ? (depth ? v._getRecursive(depth - 1) : new Store(this, k)) : v);
         });
         return result;
     }
@@ -656,67 +684,68 @@ class ObsMap extends ObsCollection {
             this.data.set(index, newData);
         }
     }
-    merge(newValue, deleteMissing) {
+    _merge(newValue, deleteMissing) {
         if (!(newValue instanceof Map)) {
             return false;
         }
         // Walk the pairs of the new value map
         newValue.forEach((v, k) => {
-            this.setIndex(k, v, deleteMissing);
+            this._setIndex(k, v, deleteMissing);
         });
         if (deleteMissing) {
             this.data.forEach((v, k) => {
                 if (!newValue.has(k))
-                    this.setIndex(k, undefined, false);
+                    this._setIndex(k, undefined, false);
             });
         }
         return true;
     }
-    iterateIndexes(scope) {
+    _iterateIndexes(scope) {
         this.data.forEach((_, itemIndex) => {
-            scope.addChild(itemIndex);
+            scope._addChild(itemIndex);
         });
     }
-    normalizeIndex(index) {
+    _normalizeIndex(index) {
         return index;
     }
-    getCount() {
+    _getCount() {
         return this.data.size;
     }
 }
+/** @internal */
 class ObsObject extends ObsMap {
-    getType() {
+    _getType() {
         return "object";
     }
-    getRecursive(depth) {
+    _getRecursive(depth) {
         if (currentScope) {
-            if (this.addObserver(ANY_INDEX, currentScope)) {
-                currentScope.cleaners.push(this);
+            if (this._addObserver(ANY_INDEX, currentScope)) {
+                currentScope._cleaners.push(this);
             }
         }
         let result = {};
         this.data.forEach((v, k) => {
-            result[k] = (v instanceof ObsCollection) ? (depth ? v.getRecursive(depth - 1) : new Store(this, k)) : v;
+            result[k] = (v instanceof ObsCollection) ? (depth ? v._getRecursive(depth - 1) : new Store(this, k)) : v;
         });
         return result;
     }
-    merge(newValue, deleteMissing) {
+    _merge(newValue, deleteMissing) {
         if (!newValue || newValue.constructor !== Object) {
             return false;
         }
         // Walk the pairs of the new value object
         for (let k in newValue) {
-            this.setIndex(k, newValue[k], deleteMissing);
+            this._setIndex(k, newValue[k], deleteMissing);
         }
         if (deleteMissing) {
             this.data.forEach((v, k) => {
                 if (!newValue.hasOwnProperty(k))
-                    this.setIndex(k, undefined, false);
+                    this._setIndex(k, undefined, false);
             });
         }
         return true;
     }
-    normalizeIndex(index) {
+    _normalizeIndex(index) {
         let type = typeof index;
         if (type === 'string')
             return index;
@@ -724,7 +753,7 @@ class ObsObject extends ObsMap {
             return '' + index;
         throw new Error(`Invalid object index ${JSON.stringify(index)}`);
     }
-    getCount() {
+    _getCount() {
         let cnt = 0;
         for (let key of this.data)
             cnt++;
@@ -742,18 +771,18 @@ class ObsObject extends ObsMap {
 export class Store {
     constructor(value = undefined, index = undefined) {
         if (index === undefined) {
-            this.collection = new ObsArray();
-            this.idx = 0;
+            this._collection = new ObsArray();
+            this._idx = 0;
             if (value !== undefined) {
-                this.collection.rawSet(0, valueToData(value));
+                this._collection.rawSet(0, valueToData(value));
             }
         }
         else {
             if (!(value instanceof ObsCollection)) {
                 throw new Error("1st parameter should be an ObsCollection if the 2nd is also given");
             }
-            this.collection = value;
-            this.idx = index;
+            this._collection = value;
+            this._idx = index;
         }
     }
     /**
@@ -771,11 +800,11 @@ export class Store {
      * ```
      */
     index() {
-        return this.idx;
+        return this._idx;
     }
     /** @internal */
     _clean(scope) {
-        this.collection.removeObserver(this.idx, scope);
+        this._collection._removeObserver(this._idx, scope);
     }
     /**
      * @returns Resolves `path` and then retrieves the value that is there, subscribing
@@ -871,12 +900,12 @@ export class Store {
         let store = opts.path && opts.path.length ? this.ref(...opts.path) : this;
         let value = store._observe();
         if (opts.type && (value !== undefined || opts.defaultValue === undefined)) {
-            let type = (value instanceof ObsCollection) ? value.getType() : (value === null ? "null" : typeof value);
+            let type = (value instanceof ObsCollection) ? value._getType() : (value === null ? "null" : typeof value);
             if (type !== opts.type)
                 throw new TypeError(`Expecting ${opts.type} but got ${type}`);
         }
         if (value instanceof ObsCollection) {
-            return value.getRecursive(opts.depth == null ? -1 : opts.depth - 1);
+            return value._getRecursive(opts.depth == null ? -1 : opts.depth - 1);
         }
         return value === undefined ? opts.defaultValue : value;
     }
@@ -896,7 +925,7 @@ export class Store {
                 return !observer.count;
             }
             else {
-                return !value.getCount();
+                return !value._getCount();
             }
         }
         else if (value === undefined) {
@@ -922,7 +951,7 @@ export class Store {
                 return observer.count;
             }
             else {
-                return value.getCount();
+                return value._getCount();
             }
         }
         else if (value === undefined) {
@@ -944,7 +973,7 @@ export class Store {
     getType(...path) {
         let store = this.ref(...path);
         let value = store._observe();
-        return (value instanceof ObsCollection) ? value.getType() : (value === null ? "null" : typeof value);
+        return (value instanceof ObsCollection) ? value._getType() : (value === null ? "null" : typeof value);
     }
     /**
      * Sets the value to the last given argument. Any earlier argument are a Store-path that is first
@@ -978,7 +1007,8 @@ export class Store {
     set(...pathAndValue) {
         let newValue = pathAndValue.pop();
         let store = this.makeRef(...pathAndValue);
-        store.collection.setIndex(store.idx, newValue, true);
+        store._collection._setIndex(store._idx, newValue, true);
+        runImmediateQueue();
     }
     /**
      * Sets the `Store` to the given `mergeValue`, but without deleting any pre-existing
@@ -995,7 +1025,8 @@ export class Store {
     merge(...pathAndValue) {
         let mergeValue = pathAndValue.pop();
         let store = this.makeRef(...pathAndValue);
-        store.collection.setIndex(store.idx, mergeValue, false);
+        store._collection._setIndex(store._idx, mergeValue, false);
+        runImmediateQueue();
     }
     /**
      * Sets the value for the store to `undefined`, which causes it to be omitted from the map (or array, if it's at the end)
@@ -1015,7 +1046,8 @@ export class Store {
      */
     delete(...path) {
         let store = this.makeRef(...path);
-        store.collection.setIndex(store.idx, undefined, true);
+        store._collection._setIndex(store._idx, undefined, true);
+        runImmediateQueue();
     }
     /**
      * Pushes a value to the end of the Array that is at the specified path in the store.
@@ -1037,18 +1069,19 @@ export class Store {
     push(...pathAndValue) {
         let newValue = pathAndValue.pop();
         let store = this.makeRef(...pathAndValue);
-        let obsArray = store.collection.rawGet(store.idx);
+        let obsArray = store._collection.rawGet(store._idx);
         if (obsArray === undefined) {
             obsArray = new ObsArray();
-            store.collection.setIndex(store.idx, obsArray, true);
+            store._collection._setIndex(store._idx, obsArray, true);
         }
         else if (!(obsArray instanceof ObsArray)) {
             throw new Error(`push() is only allowed for an array or undefined (which would become an array)`);
         }
         let newData = valueToData(newValue);
-        let pos = obsArray.data.length;
-        obsArray.data.push(newData);
+        let pos = obsArray._data.length;
+        obsArray._data.push(newData);
         obsArray.emitChange(pos, newData, undefined);
+        runImmediateQueue();
         return pos;
     }
     /**
@@ -1072,7 +1105,7 @@ export class Store {
         for (let i = 0; i < path.length; i++) {
             let value = store._observe();
             if (value instanceof ObsCollection) {
-                store = new Store(value, value.normalizeIndex(path[i]));
+                store = new Store(value, value._normalizeIndex(path[i]));
             }
             else {
                 if (value !== undefined)
@@ -1105,26 +1138,27 @@ export class Store {
     makeRef(...path) {
         let store = this;
         for (let i = 0; i < path.length; i++) {
-            let value = store.collection.rawGet(store.idx);
+            let value = store._collection.rawGet(store._idx);
             if (!(value instanceof ObsCollection)) {
                 if (value !== undefined)
                     throw new Error(`Value ${JSON.stringify(value)} is not a collection (nor undefined) in step ${i} of $(${JSON.stringify(path)})`);
                 value = new ObsObject();
-                store.collection.rawSet(store.idx, value);
-                store.collection.emitChange(store.idx, value, undefined);
+                store._collection.rawSet(store._idx, value);
+                store._collection.emitChange(store._idx, value, undefined);
             }
-            store = new Store(value, value.normalizeIndex(path[i]));
+            store = new Store(value, value._normalizeIndex(path[i]));
         }
+        runImmediateQueue();
         return store;
     }
     /** @internal */
     _observe() {
         if (currentScope) {
-            if (this.collection.addObserver(this.idx, currentScope)) {
-                currentScope.cleaners.push(this);
+            if (this._collection._addObserver(this._idx, currentScope)) {
+                currentScope._cleaners.push(this);
             }
         }
-        return this.collection.rawGet(this.idx);
+        return this._collection.rawGet(this._idx);
     }
     /**
      * Iterate the specified collection (Array, Map or object), running the given code block for each item.
@@ -1151,11 +1185,11 @@ export class Store {
         let val = store._observe();
         if (val instanceof ObsCollection) {
             // Subscribe to changes using the specialized OnEachScope
-            let onEachScope = new OnEachScope(currentScope.parentElement, currentScope.lastChild || currentScope.precedingSibling, currentScope.queueOrder + 1, val, renderer, makeSortKey);
-            val.addObserver(ANY_INDEX, onEachScope);
-            currentScope.cleaners.push(onEachScope);
-            currentScope.lastChild = onEachScope;
-            onEachScope.renderInitial();
+            let onEachScope = new OnEachScope(currentScope._parentElement, currentScope._lastChild || currentScope._precedingSibling, currentScope._queueOrder + 1, val, renderer, makeSortKey);
+            val._addObserver(ANY_INDEX, onEachScope);
+            currentScope._cleaners.push(onEachScope);
+            currentScope._lastChild = onEachScope;
+            onEachScope._renderInitial();
         }
         else if (val !== undefined) {
             throw new Error(`onEach() attempted on a value that is neither a collection nor undefined`);
@@ -1240,7 +1274,7 @@ export class Store {
      * does not exist.
      */
     isDetached() { return false; }
-    /*
+    /**
     * Dump a live view of the `Store` tree as HTML text, `ul` and `li` nodes at
     * the current mount position. Meant for debugging purposes.
     */
@@ -1306,22 +1340,22 @@ export function node(tag = "", ...rest) {
             el.className = classes.replaceAll('.', ' ');
         }
     }
-    currentScope.addNode(el);
+    currentScope._addNode(el);
     for (let item of rest) {
         let type = typeof item;
         if (type === 'function') {
-            let scope = new SimpleScope(el, undefined, currentScope.queueOrder + 1, item);
+            let scope = new SimpleScope(el, undefined, currentScope._queueOrder + 1, item);
             if (onCreateEnabled) {
                 onCreateEnabled = false;
-                scope.update();
+                scope._update();
                 onCreateEnabled = true;
             }
             else {
-                scope.update();
+                scope._update();
             }
             // Add it to our list of cleaners. Even if `scope` currently has
             // no cleaners, it may get them in a future refresh.
-            currentScope.cleaners.push(scope);
+            currentScope._cleaners.push(scope);
         }
         else if (type === 'string' || type === 'number') {
             el.textContent = item;
@@ -1344,12 +1378,12 @@ export function node(tag = "", ...rest) {
  * @param html - The HTML string. For example `"<section><h2>Test</h2><p>Info..</p></section>"`.
  */
 export function html(html) {
-    if (!currentScope || !currentScope.parentElement)
+    if (!currentScope || !currentScope._parentElement)
         throw new ScopeError(true);
-    let tmpParent = document.createElement(currentScope.parentElement.tagName);
+    let tmpParent = document.createElement(currentScope._parentElement.tagName);
     tmpParent.innerHTML = '' + html;
     while (tmpParent.firstChild) {
-        currentScope.addNode(tmpParent.firstChild);
+        currentScope._addNode(tmpParent.firstChild);
     }
 }
 function bindInput(el, store) {
@@ -1397,18 +1431,18 @@ export function text(text) {
         throw new ScopeError(true);
     if (text == null)
         return;
-    currentScope.addNode(document.createTextNode(text));
+    currentScope._addNode(document.createTextNode(text));
 }
 export function prop(name, value = undefined) {
-    if (!currentScope || !currentScope.parentElement)
+    if (!currentScope || !currentScope._parentElement)
         throw new ScopeError(true);
     if (typeof name === 'object') {
         for (let k in name) {
-            applyProp(currentScope.parentElement, k, name[k]);
+            applyProp(currentScope._parentElement, k, name[k]);
         }
     }
     else {
-        applyProp(currentScope.parentElement, name, value);
+        applyProp(currentScope._parentElement, name, value);
     }
 }
 /**
@@ -1419,9 +1453,9 @@ export function prop(name, value = undefined) {
  * terribly surprising. Be careful within the parent element of onEach() though.
  */
 export function getParentElement() {
-    if (!currentScope || !currentScope.parentElement)
+    if (!currentScope || !currentScope._parentElement)
         throw new ScopeError(true);
-    return currentScope.parentElement;
+    return currentScope._parentElement;
 }
 /**
  * Register a function that is to be executed right before the current reactive scope
@@ -1431,7 +1465,7 @@ export function getParentElement() {
 export function clean(clean) {
     if (!currentScope)
         throw new ScopeError(false);
-    currentScope.cleaners.push({ _clean: clean });
+    currentScope._cleaners.push({ _clean: clean });
 }
 /**
  * Reactively run a function, meaning the function will rerun when any `Store` that was read
@@ -1440,6 +1474,7 @@ export function clean(clean) {
  * no cause the outer function to rerun.
  *
  * @param func - The function to be (repeatedly) executed.
+ * @returns The mount id (usable for `unmount`) if this is a top-level observe.
  * @example
  * ```
  * let number = new Store(0)
@@ -1455,13 +1490,26 @@ export function clean(clean) {
  * })
  */
 export function observe(func) {
-    mount(undefined, func);
+    return _mount(undefined, func, SimpleScope);
+}
+/**
+ * Like `observe`, but instead of deferring running the observer function until
+ * a setTimeout 0, run it immediately and synchronously when a change to one of
+ * the observed  `Store`s is made. Use this sparingly, as this prevents Aberdeen
+ * from doing the usual batching and smart ordering of observers, leading to
+ * performance problems and observing of 'weird' partial states.
+ * @param func The function to be (repeatedly) executed.
+ * @returns The mount id (usable for `unmount`) if this is a top-level observe.
+ */
+export function immediateObserve(func) {
+    return _mount(undefined, func, ImmediateScope);
 }
 /**
  * Like {@link Store.observe}, but allow the function to create DOM elements using {@link Store.node}.
 
  * @param func - The function to be (repeatedly) executed, possibly adding DOM elements to `parentElement`.
  * @param parentElement - A DOM element that will be used as the parent element for calls to `node`.
+ * @returns The mount id (usable for `unmount`) if this is a top-level mount.
  *
  * @example
  * ```
@@ -1498,20 +1546,47 @@ export function observe(func) {
  * ```
 */
 export function mount(parentElement, func) {
+    return _mount(parentElement, func, SimpleScope);
+}
+let maxTopScopeId = 0;
+const topScopes = new Map();
+function _mount(parentElement, func, MountScope) {
     let scope;
     if (parentElement || !currentScope) {
-        scope = new SimpleScope(parentElement, undefined, 0, func);
+        scope = new MountScope(parentElement, undefined, 0, func);
     }
     else {
-        scope = new SimpleScope(currentScope.parentElement, currentScope.lastChild || currentScope.precedingSibling, currentScope.queueOrder + 1, func);
-        currentScope.lastChild = scope;
+        scope = new MountScope(currentScope._parentElement, currentScope._lastChild || currentScope._precedingSibling, currentScope._queueOrder + 1, func);
+        currentScope._lastChild = scope;
     }
     // Do the initial run
-    scope.update();
+    scope._update();
     // Add it to our list of cleaners. Even if `scope` currently has
     // no cleaners, it may get them in a future refresh.
     if (currentScope) {
-        currentScope.cleaners.push(scope);
+        currentScope._cleaners.push(scope);
+    }
+    else {
+        topScopes.set(++maxTopScopeId, scope);
+        return maxTopScopeId;
+    }
+}
+/**
+ * Unmount one specific or all top-level mounts or observes, meaning those that were created outside of the scope
+ * of any other mount or observe.
+ * @param id Optional mount number (as returned by `mount`, `observe` or `immediateObserve`). If `undefined`, unmount all.
+ */
+export function unmount(id) {
+    if (id == null) {
+        for (let scope of topScopes.values())
+            scope._remove();
+        topScopes.clear();
+    }
+    else {
+        let scope = topScopes.get(id);
+        if (!scope)
+            throw new Error("No such mount " + id);
+        scope._remove();
     }
 }
 /** Runs the given function, while not subscribing the current scope when reading {@link Store.Store} values.
@@ -1641,11 +1716,12 @@ function valueToData(value) {
 function defaultMakeSortKey(store) {
     return store.index();
 }
-/* istanbul ignore next */
+/* c8 ignore start */
 function internalError(code) {
     let error = new Error("Aberdeen internal error " + code);
     setTimeout(() => { throw error; }, 0);
 }
+/* c8 ignore end */
 function handleError(e) {
     // Throw the error async, so the rest of the rendering can continue
     setTimeout(() => { throw e; }, 0);
@@ -1655,188 +1731,26 @@ class ScopeError extends Error {
         super(`Operation not permitted outside of ${mount ? "a mount" : "an observe"}() scope`);
     }
 }
-const FADE_TIME = 400;
-const GROW_SHRINK_TRANSITION = `margin ${FADE_TIME}ms ease-out, transform ${FADE_TIME}ms ease-out`;
-function getGrowShrinkProps(el) {
-    const parentStyle = el.parentElement ? getComputedStyle(el.parentElement) : {};
-    const isHorizontal = parentStyle.display === 'flex' && (parentStyle.flexDirection || '').startsWith('row');
-    return isHorizontal ?
-        { marginLeft: `-${el.offsetWidth / 2}px`, marginRight: `-${el.offsetWidth / 2}px`, transform: "scaleX(0)" } :
-        { marginBottom: `-${el.offsetHeight / 2}px`, marginTop: `-${el.offsetHeight / 2}px`, transform: "scaleY(0)" };
-}
-/** Do a grow transition for the given element. This is meant to be used as a
-* handler for the `create` property.
-*
-* @param el The element to transition.
-*
-* The transition doesn't look great for table elements, and may have problems
-* for other specific cases as well.
-*/
-export function grow(el) {
-    // This timeout is to await all other elements having been added to the Dom
-    scheduleDomReader(() => {
-        // Make the element size 0 using transforms and negative margins.
-        // This causes a browser layout, as we're querying el.offset<>.
-        let props = getGrowShrinkProps(el);
-        // The timeout is in order to batch all reads and then all writes when there
-        // are multiple simultaneous grow transitions.
-        scheduleDomWriter(() => {
-            Object.assign(el.style, props);
-            // This timeout is to combine multiple transitions into a single browser layout
-            scheduleDomReader(() => {
-                // Make sure the layouting has been performed, to cause transitions to trigger
-                el.offsetHeight;
-                scheduleDomWriter(() => {
-                    // Do the transitions
-                    el.style.transition = GROW_SHRINK_TRANSITION;
-                    for (let prop in props)
-                        el.style[prop] = "";
-                    setTimeout(() => {
-                        // Reset the element to a clean state
-                        el.style.transition = "";
-                    }, FADE_TIME);
-                });
-            });
-        });
-    });
-}
-/** Do a shrink transition for the given element, and remove it from the DOM
-* afterwards. This is meant to be used as a handler for the `destroy` property.
-*
-* @param el The element to transition and remove.
-*
-* The transition doesn't look great for table elements, and may have problems
-* for other specific cases as well.
-*/
-export function shrink(el) {
-    scheduleDomReader(() => {
-        const props = getGrowShrinkProps(el);
-        // The timeout is in order to batch all reads and then all writes when there
-        // are multiple simultaneous shrink transitions.
-        scheduleDomWriter(() => {
-            el.style.transition = GROW_SHRINK_TRANSITION;
-            Object.assign(el.style, props);
-            setTimeout(() => el.remove(), FADE_TIME);
-        });
-    });
-}
-function recordPatch(func) {
-    if (recordingPatch)
-        throw new Error(`already recording a patch`);
-    recordingPatch = new Map();
+/** @internal */
+export function withEmitHandler(handler, func) {
+    const oldEmitHandler = ObsCollection.prototype.emitChange;
+    ObsCollection.prototype.emitChange = handler;
     try {
         func();
     }
-    catch (e) {
-        recordingPatch = undefined;
-        throw e;
-    }
-    const result = recordingPatch;
-    recordingPatch = undefined;
-    return result;
-}
-function addToPatch(patch, collection, index, newData, oldData) {
-    let collectionMap = patch.get(collection);
-    if (!collectionMap) {
-        collectionMap = new Map();
-        patch.set(collection, collectionMap);
-    }
-    let prev = collectionMap.get(index);
-    if (prev)
-        oldData = prev[1];
-    if (newData === oldData)
-        collectionMap.delete(index);
-    else
-        collectionMap.set(index, [newData, oldData]);
-}
-function emitPatch(patch) {
-    for (let [collection, collectionMap] of patch) {
-        for (let [index, [newData, oldData]] of collectionMap) {
-            collection.emitChange(index, newData, oldData);
-        }
-    }
-}
-function mergePatch(target, source, reverse = false) {
-    for (let [collection, collectionMap] of source) {
-        for (let [index, [newData, oldData]] of collectionMap) {
-            addToPatch(target, collection, index, reverse ? oldData : newData, reverse ? newData : oldData);
-        }
-    }
-}
-function silentlyApplyPatch(patch, force = false) {
-    for (let [collection, collectionMap] of patch) {
-        for (let [index, [newData, oldData]] of collectionMap) {
-            let actualData = collection.rawGet(index);
-            if (actualData !== oldData) {
-                if (force)
-                    handleError(new Error(`Applying invalid patch: data ${actualData} is unequal to expected old data ${oldData} for index ${index}`));
-                else
-                    return false;
-            }
-        }
-    }
-    for (let [collection, collectionMap] of patch) {
-        for (let [index, [newData, oldData]] of collectionMap) {
-            collection.rawSet(index, newData);
-        }
+    finally {
+        ObsCollection.prototype.emitChange = oldEmitHandler;
     }
-    return true;
 }
-const appliedPredictions = [];
 /**
- * Run the provided function, while treating all changes to Observables as predictions,
- * meaning they will be reverted when changes come back from the server (or some other
- * async source).
- * @param predictFunc The function to run. It will generally modify some Observables
- * 	to immediately reflect state (as closely as possible) that we expect the server
- *  to communicate back to us later on.
- * @returns A `Patch` object. Don't modify it. This is only meant to be passed to `applyCanon`.
+ * Run a function, while *not* causing reactive effects for any changes it makes to `Store`s.
+ * @param func The function to be executed once immediately.
  */
-export function applyPrediction(predictFunc) {
-    let patch = recordPatch(predictFunc);
-    appliedPredictions.push(patch);
-    emitPatch(patch);
-    return patch;
-}
-/**
- * Temporarily revert all outstanding predictions, optionally run the provided function
- * (which will generally make authoritative changes to the data based on a server response),
- * and then attempt to reapply the predictions on top of the new canonical state, dropping
- * any predictions that can no longer be applied cleanly (the data has been modified) or
- * that were specified in `dropPredictions`.
- *
- * All of this is done such that redraws are only triggered if the overall effect is an
- * actual change to an `Observable`.
- * @param canonFunc The function to run without any predictions applied. This will typically
- *  make authoritative changes to the data, based on a server response.
- * @param dropPredictions An optional list of predictions (as returned by `applyPrediction`)
- *  to undo. Typically, when a server response for a certain request is being handled,
- *  you'd want to drop the prediction that was done for that request.
- */
-export function applyCanon(canonFunc, dropPredictions = []) {
-    let resultPatch = new Map();
-    for (let prediction of appliedPredictions)
-        mergePatch(resultPatch, prediction, true);
-    silentlyApplyPatch(resultPatch, true);
-    for (let prediction of dropPredictions) {
-        let pos = appliedPredictions.indexOf(prediction);
-        if (pos >= 0)
-            appliedPredictions.splice(pos, 1);
-    }
-    if (canonFunc)
-        mergePatch(resultPatch, recordPatch(canonFunc));
-    for (let idx = 0; idx < appliedPredictions.length; idx++) {
-        if (silentlyApplyPatch(appliedPredictions[idx])) {
-            mergePatch(resultPatch, appliedPredictions[idx]);
-        }
-        else {
-            appliedPredictions.splice(idx, 1);
-            idx--;
-        }
-    }
-    emitPatch(resultPatch);
+export function inhibitEffects(func) {
+    withEmitHandler(() => { }, func);
 }
 // @ts-ignore
-// istanbul ignore next
+// c8 ignore next
 if (!String.prototype.replaceAll)
     String.prototype.replaceAll = function (from, to) { return this.split(from).join(to); };
+//# sourceMappingURL=aberdeen.js.map