aberdeen 0.4.0 → 0.5.0

package/dist/aberdeen.js

@@ -1,2012 +1,1199 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-let queueArray = []; // When not empty, a runQueue is scheduled or currently running.
-let queueIndex = 0; // This first element in queueArray that still needs to be processed.
-let queueSet = new Set(); // Contains the subset of queueArray at index >= queueIndex.
-let queueOrdered = true; // Set to `false` when `queue()` appends a runner to `queueArray` that should come before the previous last item in the array. Will trigger a sort.
-let runQueueDepth = 0; // Incremented when a queue event causes another queue event to be added. Reset when queue is empty. Throw when >= 42 to break (infinite) recursion.
-let showCreateTransitions = false; // Set to `true` only when creating top level elements in response to `Store` changes, triggering `create` transitions.
-function queue(runner) {
-    if (queueSet.has(runner))
-        return;
-    if (runQueueDepth > 42) {
-        throw new Error("Too many recursive updates from observes");
-    }
-    if (!queueArray.length) {
-        setTimeout(runQueue, 0);
-    }
-    else if (runner._queueOrder < queueArray[queueArray.length - 1]._queueOrder) {
-        queueOrdered = false;
+// src/helpers/reverseSortedSet.ts
+class ReverseSortedSet {
+  keyProp;
+  tail;
+  symbols;
+  constructor(keyProp) {
+    this.keyProp = keyProp;
+    this.tail = {};
+    this.symbols = [Symbol(0)];
+  }
+  add(item) {
+    if (this.symbols[0] in item)
+      return false;
+    const level = 1 + (Math.clz32(Math.random() * 4294967295) >> 2);
+    for (let l = this.symbols.length;l < level; l++)
+      this.symbols.push(Symbol(l));
+    const keyProp = this.keyProp;
+    const key = item[keyProp];
+    let prev;
+    let current = this.tail;
+    for (let l = this.symbols.length - 1;l >= 0; l--) {
+      const symbol = this.symbols[l];
+      while ((prev = current[symbol]) && prev[keyProp] > key)
+        current = prev;
+      if (l < level) {
+        item[symbol] = current[symbol];
+        current[symbol] = item;
+      }
     }
-    queueArray.push(runner);
-    queueSet.add(runner);
+    return true;
+  }
+  has(item) {
+    return this.symbols[0] in item;
+  }
+  fetchLast() {
+    let item = this.tail[this.symbols[0]];
+    if (item) {
+      this.remove(item);
+      return item;
+    }
+  }
+  isEmpty() {
+    return this.tail[this.symbols[0]] === undefined;
+  }
+  get(indexValue) {
+    const keyProp = this.keyProp;
+    let current = this.tail;
+    let prev;
+    for (let l = this.symbols.length - 1;l >= 0; l--) {
+      const symbol = this.symbols[l];
+      while ((prev = current[symbol]) && prev[keyProp] > indexValue)
+        current = prev;
+    }
+    return current[this.symbols[0]]?.[keyProp] === indexValue ? current[this.symbols[0]] : undefined;
+  }
+  *[Symbol.iterator]() {
+    let symbol = this.symbols[0];
+    let node = this.tail[symbol];
+    while (node) {
+      yield node;
+      node = node[symbol];
+    }
+  }
+  prev(item) {
+    return item[this.symbols[0]];
+  }
+  remove(item) {
+    if (!(this.symbols[0] in item))
+      return false;
+    const keyProp = this.keyProp;
+    const prop = item[keyProp];
+    let prev;
+    let current = this.tail;
+    for (let l = this.symbols.length - 1;l >= 0; l--) {
+      const symbol = this.symbols[l];
+      while ((prev = current[symbol]) && prev[keyProp] >= prop && prev !== item)
+        current = prev;
+      if (prev === item) {
+        current[symbol] = prev[symbol];
+        delete prev[symbol];
+      }
+    }
+    return prev === item;
+  }
+  clear() {
+    const symbol = this.symbols[0];
+    let current = this.tail;
+    while (current) {
+      const prev = current[symbol];
+      for (const symbol2 of this.symbols) {
+        if (!(symbol2 in current))
+          break;
+        delete current[symbol2];
+      }
+      current = prev;
+    }
+    this.tail = {};
+  }
 }
-/**
- * Normally, changes to `Store`s are reacted to asynchronously, in an (optimized)
- * batch, after a timeout of 0s. Calling `runQueue()` will do so immediately
- * and synchronously. Doing so may be helpful in cases where you need some DOM
- * modification to be done synchronously.
- *
- * This function is re-entrant, meaning it is safe to call `runQueue` from a
- * function that is called due to another (automatic) invocation of `runQueue`.
- */
-export function runQueue() {
-    showCreateTransitions = true;
-    for (; queueIndex < queueArray.length;) {
-        // Sort queue if new unordered items have been added since last time.
-        if (!queueOrdered) {
-            queueArray.splice(0, queueIndex);
-            queueIndex = 0;
-            // Order queued observers by depth, lowest first.
-            queueArray.sort((a, b) => a._queueOrder - b._queueOrder);
-            queueOrdered = true;
-        }
-        // Process the rest of what's currently in the queue.
-        let batchEndIndex = queueArray.length;
-        while (queueIndex < batchEndIndex && queueOrdered) {
-            let runner = queueArray[queueIndex++];
-            queueSet.delete(runner);
-            runner._queueRun();
-        }
-        // If new items have been added to the queue while processing the previous
-        // batch, we'll need to run this loop again.
-        runQueueDepth++;
-    }
-    queueIndex = 0;
-    queueArray.length = 0;
-    runQueueDepth = 0;
-    showCreateTransitions = false;
+
+// src/aberdeen.ts
+var sortedQueue;
+var runQueueDepth = 0;
+var topRedrawScope;
+function queue(runner) {
+  if (!sortedQueue) {
+    sortedQueue = new ReverseSortedSet("prio");
+    setTimeout(runQueue, 0);
+  } else if (!(runQueueDepth & 1)) {
+    runQueueDepth++;
+    if (runQueueDepth > 98) {
+      throw new Error("Too many recursive updates from observes");
+    }
+  }
+  sortedQueue.add(runner);
 }
-let domWaiters = [];
-let domInReadPhase = false;
-/**
- * A promise-like object that you can `await`. It will resolve *after* the current batch
- * of DOM-write operations has completed. This is the best time to retrieve DOM properties
- * that dependent on a layout being completed, such as `offsetHeight`.
- *
- * By batching DOM reads separately from DOM writes, this prevents the browser from
- * interleaving layout reads and writes, which can force additional layout recalculations.
- * This helps reduce visual glitches and flashes by ensuring the browser doesn't render
- * intermediate DOM states during updates.
- *
- * Unlike `setTimeout` or `requestAnimationFrame`, this mechanism ensures that DOM read
- * operations happen before any DOM writes in the same queue cycle, minimizing layout thrashing.
- *
- * See `transitions.js` for some examples.
- */
-export const DOM_READ_PHASE = {
-    then: function (fulfilled) {
-        if (domInReadPhase)
-            fulfilled();
-        else {
-            if (!domWaiters.length)
-                queue(DOM_PHASE_RUNNER);
-            domWaiters.push(fulfilled);
-        }
-        return this;
-    }
-};
-/**
- * A promise-like object that you can `await`. It will resolve *after* the current
- * DOM_READ_PHASE has completed (if any) and after any DOM triggered by Aberdeen
- * have completed. This is a good time to do little manual DOM tweaks that depend
- * on a *read phase* first, like triggering transitions.
- *
- * By batching DOM writes separately from DOM reads, this prevents the browser from
- * interleaving layout reads and writes, which can force additional layout recalculations.
- * This helps reduce visual glitches and flashes by ensuring the browser doesn't render
- * intermediate DOM states during updates.
- *
- * Unlike `setTimeout` or `requestAnimationFrame`, this mechanism ensures that DOM write
- * operations happen after all DOM reads in the same queue cycle, minimizing layout thrashing.
- *
- * See `transitions.js` for some examples.
- */
-export const DOM_WRITE_PHASE = {
-    then: function (fulfilled) {
-        if (!domInReadPhase)
-            fulfilled();
-        else {
-            if (!domWaiters.length)
-                queue(DOM_PHASE_RUNNER);
-            domWaiters.push(fulfilled);
-        }
-        return this;
-    }
-};
-const DOM_PHASE_RUNNER = {
-    _queueOrder: 99999,
-    _queueRun: function () {
-        let waiters = domWaiters;
-        domWaiters = [];
-        domInReadPhase = !domInReadPhase;
-        for (let waiter of waiters) {
-            try {
-                waiter();
-            }
-            catch (e) {
-                console.error(e);
-            }
-        }
-    }
-};
-/**
- * Given an integer number, a string or an array of these, this function returns a string that can be used
- * to compare items in a natural sorting order. So `[3, 'ab']` should be smaller than `[3, 'ac']`.
- * The resulting string is guaranteed to never be empty.
- */
-function sortKeyToString(key) {
-    if (key instanceof Array) {
-        return key.map(partToStr).join('');
-    }
-    else {
-        return partToStr(key);
-    }
+function runQueue() {
+  let time = Date.now();
+  while (sortedQueue) {
+    const runner = sortedQueue.fetchLast();
+    if (!runner)
+      break;
+    if (runQueueDepth & 1)
+      runQueueDepth++;
+    runner.queueRun();
+  }
+  sortedQueue = undefined;
+  runQueueDepth = 0;
+  time = Date.now() - time;
+  if (time > 1)
+    console.debug(`Aberdeen queue took ${time}ms`);
 }
 function partToStr(part) {
-    if (typeof part === 'string') {
-        return part + '\x01';
-    }
-    else {
-        let result = numToString(Math.abs(Math.round(part)), part < 0);
-        // Prefix the number of digits, counting down from 128 for negative and up for positive
-        return String.fromCharCode(128 + (part > 0 ? result.length : -result.length)) + result;
-    }
+  if (typeof part === "string") {
+    return part + "\x01";
+  }
+  let result = "";
+  let num = Math.abs(Math.round(part));
+  const negative = part < 0;
+  while (num > 0) {
+    result += String.fromCharCode(negative ? 65534 - num % 65533 : 2 + num % 65533);
+    num = Math.floor(num / 65533);
+  }
+  return String.fromCharCode(128 + (negative ? -result.length : result.length)) + result;
 }
-function numToString(num, neg) {
-    let result = '';
-    while (num > 0) {
-        /*
-        * We're reserving a few character codes:
-        * 0 - for compatibility
-        * 1 - separator between array items
-        * 65535 - for compatibility
-        */
-        result += String.fromCharCode(neg ? 65535 - (num % 65533) : 2 + (num % 65533));
-        num = Math.floor(num / 65533);
-    }
-    return result;
+function invertString(input) {
+  let result = "";
+  for (let i = 0;i < input.length; i++) {
+    result += String.fromCodePoint(65535 - input.charCodeAt(i));
+  }
+  return result;
 }
-/*
- * 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
- * DOM elements that is given a `render` function for its contents has its own scope.
- * The `Scope` manages the position in the DOM tree elements created by `render`
- * are inserted at. Before a rerender, all previously created elements are removed
- * and the `clean` functions for the scope and all sub-scopes are called.
- */
+var lastPrio = 0;
+
 class Scope {
-    constructor(_parentElement, 
-    // The node or scope right before this scope that has the same `parentElement`
-    _precedingSibling, 
-    // How deep is this scope nested in other scopes; we use this to make sure events
-    // at lower depths are handled before events at higher depths.
-    _queueOrder) {
-        this._parentElement = _parentElement;
-        this._precedingSibling = _precedingSibling;
-        this._queueOrder = _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 = [];
-        // Set to true after the scope has been cleaned, causing any spurious reruns to
-        // be ignored.
-        this._isDead = false;
-    }
-    // Get a reference to the last Node preceding this Scope, or undefined if there is none
-    _findPrecedingNode(stopAt = undefined) {
-        let cur = this;
-        let pre;
-        while ((pre = cur._precedingSibling) && pre !== stopAt) {
-            if (pre instanceof Node)
-                return pre;
-            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;
-            else
-                return this._lastChild._findLastNode() || this._lastChild._findPrecedingNode(this._precedingSibling);
-        }
-    }
-    _addNode(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();
-            if (lastNode) {
-                // at least one DOM node to be removed
-                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) {
-                    /* c8 ignore next */
-                    if (!nextNode)
-                        return internalError(1);
-                    const node = nextNode;
-                    nextNode = node.nextSibling || undefined;
-                    let onDestroy = onDestroyMap.get(node);
-                    if (onDestroy && node instanceof Element) {
-                        if (onDestroy !== true) {
-                            if (typeof onDestroy === 'function') {
-                                onDestroy(node);
-                            }
-                            else {
-                                destroyWithClass(node, onDestroy);
-                            }
-                            // This causes the element to be ignored from this function from now on:
-                            onDestroyMap.set(node, true);
-                        }
-                        // Ignore the deleting element
-                    }
-                    else {
-                        this._parentElement.removeChild(node);
-                    }
-                    if (node === lastNode)
-                        break;
-                }
-            }
-        }
-        // run cleaners
-        this._clean();
-    }
-    _clean() {
-        this._isDead = true;
-        for (let cleaner of this._cleaners) {
-            cleaner._clean(this);
-        }
-        this._cleaners.length = 0;
-    }
-    _onChange(index, newData, oldData) {
-        queue(this);
-    }
+  prio = --lastPrio;
+  remove() {
+    const lastNode = this.getLastNode();
+    if (lastNode)
+      removeNodes(lastNode, this.getPrecedingNode());
+    this.delete();
+  }
 }
-class SimpleScope extends Scope {
-    constructor(parentElement, precedingSibling, queueOrder, renderer) {
-        super(parentElement, precedingSibling, queueOrder);
-        if (renderer)
-            this._renderer = renderer;
-    }
-    /* c8 ignore start */
-    _renderer() {
-        // Should be overriden by a subclass or the constructor
-        internalError(14);
-    }
-    /* c8 ignore stop */
-    _queueRun() {
-        /* c8 ignore next */
-        if (currentScope)
-            internalError(2);
-        if (this._isDead)
-            return;
-        this._remove();
-        this._isDead = false;
-        this._update();
-    }
-    _update() {
-        let savedScope = currentScope;
-        currentScope = this;
-        try {
-            this._renderer();
-        }
-        catch (e) {
-            // Throw the error async, so the rest of the rendering can continue
-            handleError(e, true);
-        }
-        currentScope = savedScope;
-    }
-    _install() {
-        if (showCreateTransitions) {
-            showCreateTransitions = false;
-            this._update();
-            showCreateTransitions = true;
-        }
-        else {
-            this._update();
-        }
-        // Add it to our list of cleaners. Even if `childScope` currently has
-        // no cleaners, it may get them in a future refresh.
-        currentScope._cleaners.push(this);
-    }
+
+class ContentScope extends Scope {
+  cleaners;
+  constructor(cleaners = []) {
+    super();
+    this.cleaners = cleaners;
+  }
+  lastChild;
+  redraw() {}
+  getLastNode() {
+    return findLastNodeInPrevSiblings(this.lastChild);
+  }
+  delete() {
+    for (let cleaner of this.cleaners) {
+      if (typeof cleaner === "function")
+        cleaner();
+      else
+        cleaner.delete(this);
+    }
+    this.cleaners.length = 0;
+    sortedQueue?.remove(this);
+    this.lastChild = undefined;
+  }
+  queueRun() {
+    this.remove();
+    topRedrawScope = this;
+    this.redraw();
+    topRedrawScope = undefined;
+  }
+  getInsertAfterNode() {
+    return this.getLastNode() || this.getPrecedingNode();
+  }
+  onChange(index, newData, oldData) {
+    queue(this);
+  }
+  getChildPrevSibling() {
+    return this.lastChild;
+  }
 }
-/**
- * This could have been done with a SimpleScope, but then we'd have to draw along an instance of
- * that as well as a renderer function that closes over quite a few variables, which probably
- * wouldn't be great for the performance of this common feature.
- */
-class SetArgScope extends SimpleScope {
-    constructor(parentElement, precedingSibling, queueOrder, _key, _value) {
-        super(parentElement, precedingSibling, queueOrder);
-        this._key = _key;
-        this._value = _value;
-    }
-    _renderer() {
-        applyArg(this._parentElement, this._key, this._value.get());
-    }
+
+class ChainedScope extends ContentScope {
+  parentElement;
+  prevSibling;
+  constructor(parentElement, useParentCleaners = false) {
+    super(useParentCleaners ? currentScope.cleaners : []);
+    this.parentElement = parentElement;
+    if (parentElement === currentScope.parentElement) {
+      this.prevSibling = currentScope.getChildPrevSibling();
+      currentScope.lastChild = this;
+    }
+    if (!useParentCleaners)
+      currentScope.cleaners.push(this);
+  }
+  getPrecedingNode() {
+    return findLastNodeInPrevSiblings(this.prevSibling);
+  }
+  getChildPrevSibling() {
+    return this.lastChild || this.prevSibling;
+  }
 }
-let immediateQueue = new Set();
-class ImmediateScope extends SimpleScope {
-    _onChange(index, newData, oldData) {
-        immediateQueue.add(this);
+
+class RegularScope extends ChainedScope {
+  renderer;
+  constructor(parentElement, renderer) {
+    super(parentElement);
+    this.renderer = renderer;
+    this.redraw();
+  }
+  redraw() {
+    let savedScope = currentScope;
+    currentScope = this;
+    try {
+      this.renderer();
+    } catch (e) {
+      handleError(e, true);
     }
+    currentScope = savedScope;
+  }
 }
-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 RootScope extends ContentScope {
+  parentElement = document.body;
+  getPrecedingNode() {
+    return;
+  }
 }
-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);
-    }
-    _onChange(index, newData, oldData) {
-        if (newData === undefined) {
-            // oldData is guaranteed not to be undefined
-            if (this.triggerCount || !--this.count)
-                queue(this.scope);
-        }
-        else if (oldData === undefined) {
-            if (this.triggerCount || !this.count++)
-                queue(this.scope);
-        }
-    }
-    _clean() {
-        this.collection._removeObserver(ANY_INDEX, this);
-    }
+
+class MountScope extends ContentScope {
+  parentElement;
+  renderer;
+  constructor(parentElement, renderer) {
+    super();
+    this.parentElement = parentElement;
+    this.renderer = renderer;
+    this.redraw();
+    currentScope.cleaners.push(this);
+  }
+  redraw() {
+    RegularScope.prototype.redraw.call(this);
+  }
+  getPrecedingNode() {
+    return;
+  }
+  delete() {
+    removeNodes(this.getLastNode(), this.getPrecedingNode());
+    super.delete();
+  }
+  remove() {
+    this.delete();
+  }
 }
-/** @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 = [];
-        /** The item scopes in a Map by index */
-        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;
-    }
-    // toString(): string {
-    // 	return `OnEachScope(collection=${this.collection})`
-    // }
-    _onChange(index, newData, oldData) {
-        if (oldData === undefined) {
-            if (this._removedIndexes.has(index)) {
-                this._removedIndexes.delete(index);
-            }
-            else {
-                this._newIndexes.add(index);
-                queue(this);
-            }
-        }
-        else if (newData === undefined) {
-            if (this._newIndexes.has(index)) {
-                this._newIndexes.delete(index);
-            }
-            else {
-                this._removedIndexes.add(index);
-                queue(this);
-            }
-        }
-    }
-    _queueRun() {
-        if (this._isDead)
-            return;
-        let indexes = this._removedIndexes;
-        this._removedIndexes = new Set();
-        indexes.forEach(index => {
-            this._removeChild(index);
-        });
-        indexes = this._newIndexes;
-        this._newIndexes = new Set();
-        indexes.forEach(index => {
-            this._addChild(index);
-        });
-    }
-    _clean() {
-        super._clean();
-        this._collection._observers.delete(this);
-        for (const [index, scope] of this._byIndex) {
-            scope._clean();
-        }
-        // Help garbage collection:
-        this._byPosition.length = 0;
-        this._byIndex.clear();
-    }
-    _renderInitial() {
-        /* c8 ignore next */
-        if (!currentScope)
-            return internalError(3);
-        let parentScope = currentScope;
-        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();
-        // 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);
-        /* c8 ignore next */
-        if (!scope)
-            return internalError(6);
-        scope._remove();
-        this._byIndex.delete(itemIndex);
-        this._removeFromPosition(scope);
-    }
-    _findPosition(sortStr) {
-        // In case of duplicate `sortStr`s, this will return the first match.
-        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)
-            return max;
-        // Binary search for the insert position		
-        while (min < max) {
-            let mid = (min + max) >> 1;
-            if (items[mid]._sortStr < sortStr) {
-                min = mid + 1;
-            }
-            else {
-                max = mid;
-            }
-        }
-        return min;
-    }
-    _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];
-        if (nextSibling) {
-            child._precedingSibling = nextSibling._precedingSibling;
-            nextSibling._precedingSibling = child;
-        }
-        else {
-            child._precedingSibling = this._lastChild || this._precedingSibling;
-            this._lastChild = child;
-        }
-    }
-    _removeFromPosition(child) {
-        if (child._sortStr === '')
-            return;
-        let pos = this._findPosition(child._sortStr);
-        while (true) {
-            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];
-                    /* c8 ignore next */
-                    if (!nextSibling)
-                        return internalError(8);
-                    /* c8 ignore next */
-                    if (nextSibling._precedingSibling !== child)
-                        return internalError(13);
-                    nextSibling._precedingSibling = child._precedingSibling;
-                }
-                else {
-                    /* c8 ignore next */
-                    if (child !== this._lastChild)
-                        return internalError(12);
-                    this._lastChild = child._precedingSibling === this._precedingSibling ? undefined : child._precedingSibling;
-                }
-                return;
-            }
-            // There may be another Scope with the same sortStr
-            /* c8 ignore next */
-            if (++pos >= this._byPosition.length || this._byPosition[pos]._sortStr !== child._sortStr)
-                return internalError(5);
-        }
-    }
+function removeNodes(node, preNode) {
+  while (node && node !== preNode) {
+    const prevNode = node.previousSibling;
+    let onDestroy = onDestroyMap.get(node);
+    if (onDestroy && node instanceof Element) {
+      if (onDestroy !== true) {
+        if (typeof onDestroy === "function") {
+          onDestroy(node);
+        } else {
+          destroyWithClass(node, onDestroy);
+        }
+        onDestroyMap.set(node, true);
+      }
+    } else {
+      node.remove();
+    }
+    node = prevNode;
+  }
 }
-/** @internal */
-class OnEachItemScope extends Scope {
-    constructor(parentElement, precedingSibling, queueOrder, parent, itemIndex) {
-        super(parentElement, precedingSibling, queueOrder);
-        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() {
-        /* c8 ignore next */
-        if (currentScope)
-            internalError(4);
-        if (this._isDead)
-            return;
-        this._remove();
-        this._isDead = false;
-        this._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 sortKey;
-        try {
-            sortKey = this._parent._makeSortKey(itemStore);
-        }
-        catch (e) {
-            handleError(e, false);
-        }
-        let oldSortStr = this._sortStr;
-        let newSortStr = sortKey == null ? '' : sortKeyToString(sortKey);
-        if (oldSortStr !== '' && oldSortStr !== newSortStr) {
-            this._parent._removeFromPosition(this);
-        }
-        this._sortStr = newSortStr;
-        if (newSortStr !== '') {
-            if (newSortStr !== oldSortStr) {
-                this._parent._insertAtPosition(this);
-            }
-            try {
-                this._parent._renderer(itemStore);
-            }
-            catch (e) {
-                handleError(e, true);
-            }
-        }
-        currentScope = savedScope;
-    }
+function findLastNodeInPrevSiblings(sibling) {
+  if (!sibling || sibling instanceof Node)
+    return sibling;
+  return sibling.getLastNode() || sibling.getPrecedingNode();
 }
-/**
- * This global is set during the execution of a `Scope.render`. It is used by
- * functions like `$` and `clean`.
- */
-let currentScope;
-/**
- * A special Node observer index to subscribe to any value in the map changing.
- */
-const ANY_INDEX = {};
-/** @internal */
-export class ObsCollection {
-    constructor() {
-        this._observers = new Map();
-    }
-    // toString(): string {
-    // 	return JSON.stringify(peek(() => this.getRecursive(3)))
-    // }
-    _addObserver(index, observer) {
-        observer = observer;
-        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]));
-        }
-        return true;
-    }
-    _removeObserver(index, observer) {
-        let obsSet = this._observers.get(index);
-        obsSet.delete(observer);
-    }
-    emitChange(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);
-    }
-    _setIndex(index, newValue, deleteMissing) {
-        const curData = this.rawGet(index);
-        if (!(curData instanceof ObsCollection) || newValue instanceof Store || !curData._merge(newValue, deleteMissing)) {
-            let newData = valueToData(newValue);
-            if (newData !== curData) {
-                this.rawSet(index, newData);
-                this.emitChange(index, newData, curData);
-            }
-        }
+
+class ResultScope extends ChainedScope {
+  renderer;
+  result = optProxy({ value: undefined });
+  constructor(parentElement, renderer) {
+    super(parentElement);
+    this.renderer = renderer;
+    this.redraw();
+  }
+  redraw() {
+    let savedScope = currentScope;
+    currentScope = this;
+    try {
+      this.result.value = this.renderer();
+    } catch (e) {
+      handleError(e, true);
     }
+    currentScope = savedScope;
+  }
 }
-/** @internal */
-class ObsArray extends ObsCollection {
-    constructor() {
-        super(...arguments);
-        this._data = [];
-    }
-    _getType() {
-        return "array";
-    }
-    _getRecursive(depth) {
-        if (currentScope) {
-            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);
-        }
-        return result;
-    }
-    rawGet(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;
-        // Remove trailing `undefined`s
-        while (this._data.length > 0 && this._data[this._data.length - 1] === undefined) {
-            this._data.pop();
-        }
-    }
-    _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);
-        }
-        // 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;
-        }
-        return true;
-    }
-    _iterateIndexes(scope) {
-        for (let i = 0; i < this._data.length; i++) {
-            if (this._data[i] !== undefined) {
-                scope._addChild(i);
-            }
-        }
-    }
-    _normalizeIndex(index) {
-        if (typeof index === 'number')
-            return index;
-        if (typeof index === 'string') {
-            // Convert to int
-            let num = 0 | index;
-            // Check if the number is still the same after conversion
-            if (index.length && num == index)
-                return index;
-        }
-        throw new Error(`Invalid array index ${JSON.stringify(index)}`);
-    }
-    _getCount() {
-        return this._data.length;
-    }
+
+class SetArgScope extends ChainedScope {
+  key;
+  target;
+  constructor(parentElement, key, target) {
+    super(parentElement);
+    this.key = key;
+    this.target = target;
+    this.redraw();
+  }
+  redraw() {
+    let savedScope = currentScope;
+    currentScope = this;
+    applyArg(this.key, this.target.value);
+    currentScope = savedScope;
+  }
 }
-/** @internal */
-class ObsMap extends ObsCollection {
-    constructor() {
-        super(...arguments);
-        this.data = new Map();
-    }
-    _getType() {
-        return "map";
-    }
-    _getRecursive(depth) {
-        if (currentScope) {
-            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);
-        });
-        return result;
-    }
-    rawGet(index) {
-        return this.data.get(index);
-    }
-    rawSet(index, newData) {
-        if (newData === undefined) {
-            this.data.delete(index);
-        }
-        else {
-            this.data.set(index, newData);
-        }
-    }
-    _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);
-        });
-        if (deleteMissing) {
-            this.data.forEach((v, k) => {
-                if (!newValue.has(k))
-                    this._setIndex(k, undefined, false);
-            });
-        }
-        return true;
-    }
-    _iterateIndexes(scope) {
-        this.data.forEach((_, itemIndex) => {
-            scope._addChild(itemIndex);
-        });
-    }
-    _normalizeIndex(index) {
-        return index;
-    }
-    _getCount() {
-        return this.data.size;
-    }
+var immediateQueue = new ReverseSortedSet("prio");
+
+class ImmediateScope extends RegularScope {
+  onChange(index, newData, oldData) {
+    immediateQueue.add(this);
+  }
 }
-/** @internal */
-class ObsObject extends ObsMap {
-    _getType() {
-        return "object";
-    }
-    _getRecursive(depth) {
-        if (currentScope) {
-            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;
-        });
-        return result;
-    }
-    _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);
-        }
-        if (deleteMissing) {
-            this.data.forEach((v, k) => {
-                if (!newValue.hasOwnProperty(k))
-                    this._setIndex(k, undefined, false);
-            });
-        }
-        return true;
-    }
-    _normalizeIndex(index) {
-        let type = typeof index;
-        if (type === 'string')
-            return index;
-        if (type === 'number')
-            return '' + index;
-        throw new Error(`Invalid object index ${JSON.stringify(index)}`);
-    }
-    _getCount() {
-        let cnt = 0;
-        for (let key of this.data)
-            cnt++;
-        return cnt;
+var immediateQueueRunning = false;
+function runImmediateQueue() {
+  for (let count = 0;!immediateQueue.isEmpty() && !immediateQueueRunning; count++) {
+    if (count > 42) {
+      immediateQueue.clear();
+      throw new Error("Too many immediate-mode recursive updates");
+    }
+    immediateQueueRunning = true;
+    let copy = immediateQueue;
+    immediateQueue = new ReverseSortedSet("prio");
+    try {
+      for (const scope of copy) {
+        scope.queueRun();
+      }
+    } finally {
+      immediateQueueRunning = false;
     }
+  }
 }
-const DETACHED_KEY = {};
-export class Store {
-    /** @internal */
-    constructor(value = undefined, index = undefined) {
-        /**
-         * Create and return a new `Store` that represents the subtree at `path` of
-         * the current `Store`.
-         *
-         * The `path` is only actually resolved when this new `Store` is first used,
-         * and how this is done depends on whether a read or a write operation is
-         * performed. Read operations will just use an `undefined` value when a
-         * subtree that we're diving into does not exist. Also, they'll subscribe
-         * to changes at each level of the tree indexed by `path`.
-         *
-         * Write operations will create any missing subtrees as objects. They don't
-         * subscribe to changes (as they are the ones causing the changes).
-         *
-         * Both read and write operations will throw an error if, while resolving
-         * `path`, they encounters a non-collection data type (such as a number)
-         */
-        const ref = function (...path) {
-            const result = new Store(ref._collection, ref._idx);
-            if (path.length || ref._virtual) {
-                result._virtual = ref._virtual ? ref._virtual.concat(path) : path;
-            }
-            return result;
-        };
-        Object.setPrototypeOf(ref, Store.prototype);
-        if (index === undefined) {
-            ref._collection = new ObsArray();
-            ref._idx = 0;
-            if (value !== undefined) {
-                ref._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");
-            }
-            ref._collection = value;
-            ref._idx = index;
-        }
-        // @ts-ignore
-        return ref;
-    }
-    /**
-     * @returns The index for this Store within its parent collection. This will be a `number`
-     * when the parent collection is an array, a `string` when it's an object, or any data type
-     * when it's a `Map`.
-     *
-     * @example
-     * ```
-     * let store = new Store({x: 123})
-     * let subStore = store.ref('x')
-     * subStore.get() // 123
-     * subStore.index() // 'x'
-     * ```
-     */
-    index() {
-        return this._idx;
-    }
-    /** @internal */
-    _clean(scope) {
-        this._collection._removeObserver(this._idx, scope);
-    }
-    /**
-     * Retrieve the value for store, subscribing the observe scope to changes.
-     *
-     * @param depth Limit the depth of the retrieved data structure to this positive integer.
-     *    When `depth` is `1`, only a single level of the value at `path` is unpacked. This
-     *    makes no difference for primitive values (like strings), but for objects, maps and
-     *    arrays, it means that each *value* in the resulting data structure will be a
-     *    reference to the `Store` for that value.
-     *
-     * @returns The resulting value (or `undefined` if the `Store` does not exist).
-     */
-    get(depth = 0) {
-        let value = this._observe();
-        return value instanceof ObsCollection ? value._getRecursive(depth - 1) : value;
-    }
-    /**
-     * Exactly like {@link Store.get}, except that when executed from an observe scope,
-     * we will not subscribe to changes in the data retrieved data.
-     */
-    peek(depth = 0) {
-        let savedScope = currentScope;
-        currentScope = undefined;
-        let result = this.get(depth);
-        currentScope = savedScope;
-        return result;
-    }
-    /**
-     * Like {@link Store.get}, but with return type checking.
-     *
-     * @param expectType A string specifying what type the.get is expected to return. Options are:
-     *    "undefined", "null", "boolean", "number", "string", "function", "array", "map"
-     *    and "object". If the store holds a different type of value, a `TypeError`
-     *    exception is thrown.
-     * @returns
-     */
-    getTyped(expectType, depth = 0) {
-        let value = this._observe();
-        let type = (value instanceof ObsCollection) ? value._getType() : (value === null ? "null" : typeof value);
-        if (type !== expectType)
-            throw new TypeError(`Expecting ${expectType} but got ${type}`);
-        return value instanceof ObsCollection ? value._getRecursive(depth - 1) : value;
-    }
-    /**
-     * @returns Like {@link Store.get}, but throws a `TypeError` if the resulting value is not of type `number`.
-     * Using this instead of just {@link Store.get} is especially useful from within TypeScript.
-     */
-    getNumber() { return this.getTyped('number'); }
-    /**
-     * @returns Like {@link Store.get}, but throws a `TypeError` if the resulting value is not of type `string`.
-     * Using this instead of just {@link Store.get} is especially useful from within TypeScript.
-     */
-    getString() { return this.getTyped('string'); }
-    /**
-     * @returns Like {@link Store.get}, but throws a `TypeError` if the resulting value is not of type `boolean`.
-     * Using this instead of just {@link Store.get} is especially useful from within TypeScript.
-     */
-    getBoolean() { return this.getTyped('boolean'); }
-    /**
-     * @returns Like {@link Store.get}, but throws a `TypeError` if the resulting value is not of type `function`.
-     * Using this instead of just {@link Store.get} is especially useful from within TypeScript.
-     */
-    getFunction() { return this.getTyped('function'); }
-    /**
-     * @returns Like {@link Store.get}, but throws a `TypeError` if the resulting value is not of type `array`.
-     * Using this instead of just {@link Store.get} is especially useful from within TypeScript.
-     */
-    getArray(depth = 0) { return this.getTyped('array', depth); }
-    /**
-     * @returns Like {@link Store.get}, but throws a `TypeError` if the resulting value is not of type `object`.
-     * Using this instead of just {@link Store.get} is especially useful from within TypeScript.
-     */
-    getObject(depth = 0) { return this.getTyped('object', depth); }
-    /**
-     * @returns Like {@link Store.get}, but throws a `TypeError` if the resulting value is not of type `map`.
-     * Using this instead of just {@link Store.get} is especially useful from within TypeScript.
-     */
-    getMap(depth = 0) { return this.getTyped('map', depth); }
-    /**
-     * Like {@link Store.get}, but with a default value (returned when the Store
-     * contains `undefined`). This default value is also used to determine the expected type,
-     * and to throw otherwise.
-     *
-     * @example
-     * ```
-     * let store = new Store({x: 42})
-     * store('x').getOr(99) // 42
-     * store('y').getOr(99) // 99
-     * store('x').getOr('hello') // throws TypeError (because 42 is not a string)
-     * ```
-     */
-    getOr(defaultValue) {
-        let value = this._observe();
-        if (value === undefined)
-            return defaultValue;
-        let expectType = typeof defaultValue;
-        if (expectType === 'object') {
-            if (defaultValue instanceof Map)
-                expectType = 'map';
-            else if (defaultValue instanceof Array)
-                expectType = 'array';
-            else if (defaultValue === null)
-                expectType = 'null';
-        }
-        let type = (value instanceof ObsCollection) ? value._getType() : (value === null ? "null" : typeof value);
-        if (type !== expectType)
-            throw new TypeError(`Expecting ${expectType} but got ${type}`);
-        return (value instanceof ObsCollection ? value._getRecursive(-1) : value);
-    }
-    /**
-     * Checks if the collection held in `Store` is empty, and subscribes the current scope to changes of the emptiness of this collection.
-     *
-     * @returns When the collection is not empty `true` is returned. If it is empty or if the value is undefined, `false` is returned.
-     * @throws When the value is not a collection and not undefined, an Error will be thrown.
-     */
-    isEmpty() {
-        let value = this._observe();
-        if (value instanceof ObsCollection) {
-            if (currentScope) {
-                let observer = new IsEmptyObserver(currentScope, value, false);
-                return !observer.count;
-            }
-            else {
-                return !value._getCount();
-            }
-        }
-        else if (value === undefined) {
-            return true;
-        }
-        else {
-            throw new Error(`isEmpty() expects a collection or undefined, but got ${JSON.stringify(value)}`);
-        }
-    }
-    /**
-     * Returns the number of items in the collection held in Store, and subscribes the current scope to changes in this count.
-     *
-     * @returns The number of items contained in the collection, or 0 if the value is undefined.
-     * @throws When the value is not a collection and not undefined, an Error will be thrown.
-     */
-    count() {
-        let value = this._observe();
-        if (value instanceof ObsCollection) {
-            if (currentScope) {
-                let observer = new IsEmptyObserver(currentScope, value, true);
-                return observer.count;
-            }
-            else {
-                return value._getCount();
-            }
-        }
-        else if (value === undefined) {
-            return 0;
-        }
-        else {
-            throw new Error(`count() expects a collection or undefined, but got ${JSON.stringify(value)}`);
-        }
-    }
-    /**
-     * Returns a strings describing the type of the `Store` value, subscribing to changes of this type.
-     * Note: this currently also subscribes to changes of primitive values, so changing a value from 3 to 4
-     * would cause the scope to be rerun. This is not great, and may change in the future. This caveat does
-     * not apply to changes made *inside* an object, `Array` or `Map`.
-     *
-     * @returns Possible options: "undefined", "null", "boolean", "number", "string", "function", "array", "map" or "object".
-     */
-    getType() {
-        let value = this._observe();
-        return (value instanceof ObsCollection) ? value._getType() : (value === null ? "null" : typeof value);
-    }
-    /**
-     * Returns a new `Store` that will always hold either the value of `whenTrue` or the value
-     * of `whenFalse` depending on whether the original `Store` is truthy or not.
-     *
-     * @param whenTrue The value set to the return-`Store` while `this` is truthy. This can be
-     *     any type of value. If it's a `Store`, the return-`Store` will reference the same
-     *     data (so *no* deep copy will be made).
-     * @param whenFalse Like `whenTrue`, but for falsy values (false, undefined, null, 0, "").
-     * @returns A store holding the result value. The value will keep getting updated while
-     * the observe context from which `if()` was called remains active.
-     */
-    if(whenTrue, whenFalse) {
-        const result = new Store();
-        observe(() => {
-            const value = this.get() ? whenTrue : whenFalse;
-            result.set(value);
-        });
-        return result;
-    }
-    /**
-     * Sets the `Store` value to the given argument.
-     *
-     * When a `Store` is passed in as the value, its value will be copied (subscribing to changes). In
-     * case the value is an object, an `Array` or a `Map`, a *reference* to that data structure will
-     * be created, so that changes made through one `Store` will be reflected through the other. Be
-     * carefull not to create loops in your `Store` tree that way, as that would cause any future
-     * call to {@link Store.get} to throw a `RangeError` (Maximum call stack size exceeded.)
-     *
-     * If you intent to make a copy instead of a reference, call {@link Store.get} on the origin `Store`.
-     *
-     * @returns The `Store` itself, for chaining other methods.
-     *
-     * @example
-     * ```
-     * let store = new Store() // Value is `undefined`
-     *
-     * store.set(6)
-     * store.get() // 6
-     *
-     * store.set({}) // Change  value to an empty object
-     * store('a', 'b', 'c').set('d') // Create parent path as objects
-     * store.get() // {x: 6, a: {b: {c: 'd'}}}
-     *
-     * store.set(42) // Overwrites all of the above
-     * store.get() // 42
-     *
-     * store('x').set(6) // Throw Error (42 is not a collection)
-     * ```
-     */
-    set(newValue) {
-        this._materialize(true);
-        this._collection._setIndex(this._idx, newValue, true);
-        runImmediateQueue();
-        return this;
-    }
-    /** @internal */
-    _materialize(forWriting) {
-        if (!this._virtual)
-            return true;
-        let collection = this._collection;
-        let idx = this._idx;
-        for (let i = 0; i < this._virtual.length; i++) {
-            if (!forWriting && currentScope) {
-                if (collection._addObserver(idx, currentScope)) {
-                    currentScope._cleaners.push(this);
-                }
-            }
-            let value = collection.rawGet(idx);
-            if (!(value instanceof ObsCollection)) {
-                // Throw an error if trying to index a primitive type
-                if (value !== undefined)
-                    throw new Error(`While resolving ${JSON.stringify(this._virtual)}, found ${JSON.stringify(value)} at index ${i} instead of a collection.`);
-                // For reads, we'll just give up. We might reactively get another shot at this.
-                if (!forWriting)
-                    return false;
-                // For writes, create a new collection.
-                value = new ObsObject();
-                collection.rawSet(idx, value);
-                collection.emitChange(idx, value, undefined);
-            }
-            collection = value;
-            const prop = this._virtual[i];
-            idx = collection._normalizeIndex(prop);
-        }
-        this._collection = collection;
-        this._idx = idx;
-        delete this._virtual;
-        return true;
-    }
-    /**
-     * Sets the `Store` to the given `mergeValue`, but without deleting any pre-existing
-     * items when a collection overwrites a similarly typed collection. This results in
-     * a deep merge.
-     *
-     * @returns The `Store` itself, for chaining other methods.
-     *
-     * @example
-     * ```
-     * let store = new Store({a: {x: 1}})
-     * store.merge({a: {y: 2}, b: 3})
-     * store.get() // {a: {x: 1, y: 2}, b: 3}
-     * ```
-     */
-    merge(mergeValue) {
-        this._materialize(true);
-        this._collection._setIndex(this._idx, mergeValue, false);
-        runImmediateQueue();
-        return this;
-    }
-    /**
-     * 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)
-     *
-     * @returns The `Store` itself, for chaining other methods.
-     *
-     * @example
-     * ```
-     * let store = new Store({a: 1, b: 2})
-     * store('a').delete()
-     * store.get() // {b: 2}
-     *
-     * store = new Store(['a','b','c'])
-     * store(1).delete()
-     * store.get() // ['a', undefined, 'c']
-     * store(2).delete()
-     * store.get() // ['a']
-     * store.delete()
-     * store.get() // undefined
-     * ```
-     */
-    delete() {
-        this._materialize(true);
-        this._collection._setIndex(this._idx, undefined, true);
-        runImmediateQueue();
-        return this;
-    }
-    /**
-     * Pushes a value to the end of the Array that is at the specified path in the store.
-     * If that store path is `undefined`, an Array is created first.
-     * The last argument is the value to be added, any earlier arguments indicate the path.
-     *
-     * @returns The index at which the item was appended.
-     * @throws TypeError when the store contains a primitive data type.
-     *
-     * @example
-     * ```
-     * let store = new Store()
-     * store.push(3) // Creates the array
-     * store.push(6)
-     * store.get() // [3,6]
-     *
-     * store = new Store({myArray: [1,2]})
-     * store('myArray').push(3)
-     * store.get() // {myArray: [1,2,3]}
-     * ```
-     */
-    push(newValue) {
-        this._materialize(true);
-        let obsArray = this._collection.rawGet(this._idx);
-        if (obsArray === undefined) {
-            obsArray = new ObsArray();
-            this._collection._setIndex(this._idx, obsArray, true);
-        }
-        else if (!(obsArray instanceof ObsArray)) {
-            throw new TypeError(`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);
-        obsArray.emitChange(pos, newData, undefined);
-        runImmediateQueue();
-        return pos;
-    }
-    /**
-     * {@link Store.peek} the current value, pass it through `func`, and {@link Store.set} the resulting
-     * value.
-     * @param func The function transforming the value.
-     * @returns The `Store` itself, for chaining other methods.
-     */
-    modify(func) {
-        this.set(func(this.peek()));
-        return this;
-    }
-    /** @internal */
-    _observe() {
-        if (!this._materialize(false))
-            return undefined;
-        if (currentScope) {
-            if (this._collection._addObserver(this._idx, currentScope)) {
-                currentScope._cleaners.push(this);
-            }
-        }
-        return this._collection.rawGet(this._idx);
-    }
-    /**
-     * Iterate the specified collection (Array, Map or object), running the given code block for each item.
-     * When items are added to the collection at some later point, the code block will be ran for them as well.
-     * When an item is removed, the {@link Store.clean} handlers left by its code block are executed.
-     *
-     * @param renderer The function to be called for each item. It receives the item's `Store` object as its only argument.
-     * @param makeSortKey An optional function that, given an items `Store` object, returns a value to be sorted on.
-     *   This value can be a number, a string, or an array containing a combination of both. When undefined is returned,
-     *   the item is *not* rendered. If `makeSortKey` is not specified, the output will be sorted by `index()`.
-     */
-    onEach(renderer, makeSortKey = defaultMakeSortKey) {
-        if (!currentScope) { // Do this in a new top-level scope
-            _mount(undefined, () => this.onEach(renderer, makeSortKey), SimpleScope);
-            return;
-        }
-        let val = this._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();
-        }
-        else if (val !== undefined) {
-            throw new Error(`onEach() attempted on a value that is neither a collection nor undefined`);
-        }
-    }
-    /**
-     * Derive a new `Store` from this `Store`, by reactively passing its value
-     * through the specified function.
-     * @param func Your function. It should accept a the input store's value, and return
-     *   a result to be reactively set to the output store.
-     * @returns The output `Store`.
-     * @example
-     * ```javascript
-     * const store = new Store(21)
-     * const double = store.derive(v => v*2)
-     * double.get() // 42
-     *
-     * store.set(100)
-     * runQueue() // Or after a setTimeout 0, due to batching
-     * double.get() // 200
-     * ```
-     */
-    derive(func) {
-        let out = new Store();
-        observe(() => {
-            out.set(func(this.get()));
-        });
-        return out;
-    }
-    /**
-     * Applies a filter/map function on each item within the `Store`'s collection,
-     * and reactively manages the returned `Map` `Store` to hold any results.
-     *
-     * @param func - Function that transform the given store into an output value or
-     * `undefined` in case this value should be skipped:
-     *
-     * @returns - A array/map/object `Store` with the values returned by `func` and the
-     * corresponding keys from the original map, array or object `Store`.
-     *
-     * When items disappear from the `Store` or are changed in a way that `func` depends
-     * upon, the resulting items are removed from the output `Store` as well. When multiple
-     * input items produce the same output keys, this may lead to unexpected results.
-     */
-    map(func) {
-        let out = new Store();
-        observe(() => {
-            let t = this.getType();
-            out.set(t === 'array' ? [] : (t === 'object' ? {} : new Map()));
-            this.onEach((item) => {
-                let value = func(item);
-                if (value !== undefined) {
-                    let key = item.index();
-                    const ref = out(key);
-                    ref.set(value);
-                    clean(() => {
-                        ref.delete();
-                    });
-                }
-            });
-        });
-        return out;
-    }
-    /**
-     * Applies a filter/map function on each item within the `Store`'s collection,
-     * each of which can deliver any number of key/value pairs, and reactively manages the
-     * returned map `Store` to hold any results.
-     *
-     * @param func - Function that transform the given store into output values
-     * that can take one of the following forms:
-     * - an `Object` or a `Map`: Each key/value pair will be added to the output `Store`.
-     * - anything else: No key/value pairs are added to the output `Store`.
-     *
-     * @returns - A map `Store` with the key/value pairs returned by all `func` invocations.
-     *
-     * When items disappear from the `Store` or are changed in a way that `func` depends
-     * upon, the resulting items are removed from the output `Store` as well. When multiple
-     * input items produce the same output keys, this may lead to unexpected results.
-     */
-    multiMap(func) {
-        let out = new Store(new Map());
-        this.onEach((item) => {
-            let result = func(item);
-            let refs = [];
-            if (result.constructor === Object) {
-                for (let key in result) {
-                    const ref = out(key);
-                    ref.set(result[key]);
-                    refs.push(ref);
-                }
-            }
-            else if (result instanceof Map) {
-                result.forEach((value, key) => {
-                    const ref = out(key);
-                    ref.set(value);
-                    refs.push(ref);
-                });
-            }
-            else {
-                return;
-            }
-            if (refs.length) {
-                clean(() => {
-                    for (let ref of refs) {
-                        ref.delete();
-                    }
-                });
-            }
-        });
-        return out;
-    }
-    /**
-    * Dump a live view of the `Store` tree as HTML text, `ul` and `li` nodes at
-    * the current mount position. Meant for debugging purposes.
-    * @returns The `Store` itself, for chaining other methods.
-    */
-    dump() {
-        let type = this.getType();
-        if (type === 'array' || type === 'object' || type === 'map') {
-            $({ text: `<${type}>` });
-            $('ul', () => {
-                this.onEach((sub) => {
-                    $('li:' + JSON.stringify(sub.index()) + ": ", () => {
-                        sub.dump();
-                    });
-                });
-            });
-        }
-        else {
-            $({ text: JSON.stringify(this.get()) });
-        }
-        return this;
-    }
+
+class OnEachScope extends Scope {
+  renderer;
+  makeSortKey;
+  parentElement = currentScope.parentElement;
+  prevSibling;
+  target;
+  byIndex = new Map;
+  sortedSet = new ReverseSortedSet("sortKey");
+  changedIndexes = new Set;
+  constructor(proxy, renderer, makeSortKey) {
+    super();
+    this.renderer = renderer;
+    this.makeSortKey = makeSortKey;
+    const target = this.target = proxy[TARGET_SYMBOL] || proxy;
+    subscribe(target, ANY_SYMBOL, this);
+    this.prevSibling = currentScope.getChildPrevSibling();
+    currentScope.lastChild = this;
+    currentScope.cleaners.push(this);
+    if (target instanceof Array) {
+      for (let i = 0;i < target.length; i++) {
+        if (target[i] !== undefined) {
+          new OnEachItemScope(this, i, false);
+        }
+      }
+    } else {
+      for (const key in target) {
+        if (target[key] !== undefined) {
+          new OnEachItemScope(this, key, false);
+        }
+      }
+    }
+  }
+  getPrecedingNode() {
+    return findLastNodeInPrevSiblings(this.prevSibling);
+  }
+  onChange(index, newData, oldData) {
+    if (!(this.target instanceof Array) || typeof index === "number")
+      this.changedIndexes.add(index);
+    queue(this);
+  }
+  queueRun() {
+    let indexes = this.changedIndexes;
+    this.changedIndexes = new Set;
+    for (let index of indexes) {
+      const oldScope = this.byIndex.get(index);
+      if (oldScope)
+        oldScope.remove();
+      if (this.target[index] === undefined) {
+        this.byIndex.delete(index);
+      } else {
+        new OnEachItemScope(this, index, true);
+      }
+    }
+    topRedrawScope = undefined;
+  }
+  delete() {
+    for (const scope of this.byIndex.values()) {
+      scope.delete();
+    }
+    this.byIndex.clear();
+    setTimeout(() => {
+      this.sortedSet.clear();
+    }, 1);
+  }
+  getLastNode() {
+    for (let scope of this.sortedSet) {
+      const node = scope.getActualLastNode();
+      if (node)
+        return node;
+    }
+  }
 }
-let onDestroyMap = new WeakMap();
-function destroyWithClass(element, cls) {
-    element.classList.add(cls);
-    setTimeout(() => element.remove(), 2000);
+
+class OnEachItemScope extends ContentScope {
+  parent;
+  itemIndex;
+  sortKey;
+  parentElement;
+  constructor(parent, itemIndex, topRedraw) {
+    super();
+    this.parent = parent;
+    this.itemIndex = itemIndex;
+    this.parentElement = parent.parentElement;
+    this.parent.byIndex.set(this.itemIndex, this);
+    this.lastChild = this;
+    if (topRedraw)
+      topRedrawScope = this;
+    this.redraw();
+  }
+  getPrecedingNode() {
+    this.parent.sortedSet.add(this);
+    const preScope = this.parent.sortedSet.prev(this);
+    if (preScope)
+      return findLastNodeInPrevSiblings(preScope.lastChild);
+    return this.parent.getPrecedingNode();
+  }
+  getLastNode() {
+    return this.getPrecedingNode();
+  }
+  getActualLastNode() {
+    let child = this.lastChild;
+    while (child && child !== this) {
+      if (child instanceof Node)
+        return child;
+      const node = child.getLastNode();
+      if (node)
+        return node;
+      child = child.getPrecedingNode();
+    }
+  }
+  queueRun() {
+    if (currentScope !== ROOT_SCOPE)
+      internalError(4);
+    if (this.sortKey !== undefined) {
+      const lastNode = this.getActualLastNode();
+      if (lastNode)
+        removeNodes(lastNode, this.getPrecedingNode());
+    }
+    this.delete();
+    this.lastChild = this;
+    topRedrawScope = this;
+    this.redraw();
+    topRedrawScope = undefined;
+  }
+  redraw() {
+    const value = optProxy(this.parent.target[this.itemIndex]);
+    let savedScope = currentScope;
+    currentScope = this;
+    let sortKey;
+    try {
+      if (this.parent.makeSortKey) {
+        let rawSortKey = this.parent.makeSortKey(value, this.itemIndex);
+        if (rawSortKey != null)
+          sortKey = rawSortKey instanceof Array ? rawSortKey.map(partToStr).join("") : rawSortKey;
+      } else {
+        sortKey = this.itemIndex;
+      }
+      if (typeof sortKey === "number")
+        sortKey = partToStr(sortKey);
+      if (this.sortKey !== sortKey) {
+        this.parent.sortedSet.remove(this);
+        this.sortKey = sortKey;
+      }
+      if (sortKey != null)
+        this.parent.renderer(value, this.itemIndex);
+    } catch (e) {
+      handleError(e, sortKey != null);
+    }
+    currentScope = savedScope;
+  }
+  getInsertAfterNode() {
+    if (this.sortKey == null)
+      internalError(1);
+    return findLastNodeInPrevSiblings(this.lastChild);
+  }
+  remove() {
+    if (this.sortKey !== undefined) {
+      const lastNode = this.getActualLastNode();
+      if (lastNode)
+        removeNodes(lastNode, this.getPrecedingNode());
+      this.parent.sortedSet.remove(this);
+      this.sortKey = undefined;
+    }
+    this.delete();
+  }
 }
-function addLeafNode(deepEl, node) {
-    if (deepEl === currentScope._parentElement) {
-        currentScope._addNode(node);
-    }
-    else {
-        deepEl.appendChild(node);
-    }
+function addNode(node) {
+  const parentEl = currentScope.parentElement;
+  const prevNode = currentScope.getInsertAfterNode();
+  parentEl.insertBefore(node, prevNode ? prevNode.nextSibling : parentEl.firstChild);
+  currentScope.lastChild = node;
 }
-function applyBinding(_el, _key, store) {
-    if (store == null)
-        return;
-    if (!(store instanceof Store))
-        throw new Error(`Unexpect bind-argument: ${JSON.parse(store)}`);
-    const el = _el;
-    let onStoreChange;
-    let onInputChange;
-    let type = el.getAttribute('type');
-    let value = store.peek();
-    if (type === 'checkbox') {
-        if (value === undefined)
-            store.set(el.checked);
-        onStoreChange = value => el.checked = value;
-        onInputChange = () => store.set(el.checked);
-    }
-    else if (type === 'radio') {
-        if (value === undefined && el.checked)
-            store.set(el.value);
-        onStoreChange = value => el.checked = (value === el.value);
-        onInputChange = () => {
-            if (el.checked)
-                store.set(el.value);
-        };
-    }
-    else {
-        onInputChange = () => store.set(type === 'number' || type === 'range' ? (el.value === '' ? null : +el.value) : el.value);
-        if (value === undefined)
-            onInputChange();
-        onStoreChange = value => {
-            if (el.value !== value)
-                el.value = value;
-        };
-    }
-    observe(() => {
-        onStoreChange(store.get());
+var ROOT_SCOPE = new RootScope;
+var currentScope = ROOT_SCOPE;
+var ANY_SYMBOL = Symbol("any");
+var TARGET_SYMBOL = Symbol("target");
+var subscribers = new WeakMap;
+var peeking = 0;
+function subscribe(target, index, observer = currentScope) {
+  if (observer === ROOT_SCOPE || peeking)
+    return;
+  let byTarget = subscribers.get(target);
+  if (!byTarget)
+    subscribers.set(target, byTarget = new Map);
+  if (index !== ANY_SYMBOL && byTarget.get(ANY_SYMBOL)?.has(observer))
+    return;
+  let byIndex = byTarget.get(index);
+  if (!byIndex)
+    byTarget.set(index, byIndex = new Set);
+  if (byIndex.has(observer))
+    return;
+  byIndex.add(observer);
+  if (observer === currentScope) {
+    currentScope.cleaners.push(byIndex);
+  } else {
+    currentScope.cleaners.push(function() {
+      byIndex.delete(observer);
+    });
+  }
+}
+function onEach(target, render, makeKey) {
+  if (!target || typeof target !== "object")
+    throw new Error("onEach requires an object");
+  target = target[TARGET_SYMBOL] || target;
+  new OnEachScope(target, render, makeKey);
+}
+function isObjEmpty(obj) {
+  for (let k in obj)
+    return false;
+  return true;
+}
+function isEmpty(proxied) {
+  const target = proxied[TARGET_SYMBOL] || proxied;
+  const scope = currentScope;
+  if (target instanceof Array) {
+    subscribe(target, "length", function(index, newData, oldData) {
+      if (!newData !== !oldData)
+        queue(scope);
     });
-    el.addEventListener('input', onInputChange);
-    clean(() => {
-        el.removeEventListener('input', onInputChange);
+    return !target.length;
+  } else {
+    const result = isObjEmpty(target);
+    subscribe(target, ANY_SYMBOL, function(index, newData, oldData) {
+      if (result ? oldData === undefined : newData === undefined)
+        queue(scope);
     });
+    return result;
+  }
 }
-const SPECIAL_PROPS = {
-    create: function (el, value) {
-        if (!showCreateTransitions)
-            return;
-        if (typeof value === 'function') {
-            value(el);
-        }
-        else {
-            el.classList.add(value);
-            (function () {
-                return __awaiter(this, void 0, void 0, function* () {
-                    yield DOM_READ_PHASE;
-                    el.offsetHeight;
-                    yield DOM_WRITE_PHASE;
-                    el.classList.remove(value);
-                });
-            })();
-        }
-    },
-    destroy: function (deepEl, value) {
-        onDestroyMap.set(deepEl, value);
-    },
-    html: function (deepEl, value) {
-        if (!value)
-            return;
-        let tmpParent = document.createElement(deepEl.tagName);
-        tmpParent.innerHTML = '' + value;
-        while (tmpParent.firstChild)
-            addLeafNode(deepEl, tmpParent.firstChild);
-    },
-    text: function (deepEl, value) {
-        if (value != null)
-            addLeafNode(deepEl, document.createTextNode(value));
-    },
-    element: function (deepEl, value) {
-        if (value == null)
-            return;
-        if (!(value instanceof Node))
-            throw new Error(`Unexpect element-argument: ${JSON.parse(value)}`);
-        addLeafNode(deepEl, value);
-    },
-};
-/**
- * Modifies the *parent* DOM element in the current reactive scope, or adds
- * new DOM elements to it.
- *
- * @param args - Arguments that define how to modify/create elements.
- *
- * ### String arguments
- * Create new elements with optional classes and text content:
- * ```js
- * $('div.myClass')              // <div class="myClass"></div>
- * $('span.c1.c2:Hello')         // <span class="c1 c2">Hello</span>
- * $('p:Some text')              // <p>Some text</p>
- * $('.my-thing')                // <div class="my-thing"></div>
- * $('div', 'span', 'p.cls')     // <div><span<p class="cls"></p></span></div>
- * $(':Just some text!')		 // Just some text! (No new element, just a text node)
- * ```
- *
- * ### Object arguments
- * Set properties, attributes, events and special features:
- * ```js
- * // Classes (dot prefix)
- * $('div', {'.active': true})           // Add class
- * $('div', {'.hidden': false})          // Remove (or don't add) class
- * $('div', {'.selected': myStore})      // Reactively add/remove class
- *
- * // Styles (dollar prefixed and camel-cased CSS properties)
- * $('div', {$color: 'red'})             // style.color = 'red'
- * $('div', {$marginTop: '10px'})        // style.marginTop = '10px'
- * $('div', {$color: myColorStore})      // Reactively change color
- *
- * // Events (function values)
- * $('button', {click: () => alert()})   // Add click handler
- *
- * // Properties (boolean values, `selectedIndex`, `value`)
- * $('input', {disabled: true})          // el.disabled = true
- * $('input', {value: 'test'})           // el.value = 'test'
- * $('select', {selectedIndex: 2})       // el.selectedIndex = 2
- *
- * // Transitions
- * $('div', {create: 'fade-in'})         // Add class on create
- * $('div', {create: el => {...}})       // Run function on create
- * $('div', {destroy: 'fade-out'})       // Add class before remove
- * $('div', {destroy: el => {...}})      // Run function before remove
- *
- * // Content
- * $('div', {html: '<b>Bold</b>'})       // Set innerHTML
- * $('div', {text: 'Plain text'})        // Add text node
- * const myElement = document.createElement('video')
- * $('div', {element: myElement})        // Add existing DOM element
- *
- * // Regular attributes (everything else)
- * $('div', {title: 'Info'})             // el.setAttribute('title', 'info')
- * ```
- *
- * When a `Store` is passed as a value, a seperate observe-scope will
- * be created for it, such that when the `Store` changes, only *that*
- * UI property will need to be updated.
- * So in the following example, when `colorStore` changes, only the
- * `color` CSS property will be updated.
- * ```js
- * $('div', {
- *   '.active': activeStore,             // Reactive class
- *   $color: colorStore,                 // Reactive style
- *   text: textStore                     // Reactive text
- * })
- * ```
- *
- * ### Two-way input binding
- * Set the initial value of an <input> <textarea> or <select> to that
- * of a `Store`, and then start reflecting user changes to the former
- * in the latter.
- * ```js
- * $('input', {bind: myStore})           // Binds input.value
- * ```
- * This is a special case, as changes to the `Store` will *not* be
- * reflected in the UI.
- *
- * ### Function arguments
- * Create child scopes that re-run on observed `Store` changes:
- * ```js
- * $('div', () => {
- *   $(myStore.get() ? 'span' : 'p')     // Reactive element type
- * })
- * ```
- * When *only* a function is given, `$` behaves exactly like {@link Store.observe},
- * except that it will only work when we're inside a `mount`.
- *
- * @throws {ScopeError} If called outside an observable scope.
- * @throws {Error} If invalid arguments are provided.
- */
-export function $(...args) {
-    if (!currentScope || !currentScope._parentElement)
-        throw new ScopeError(true);
-    let deepEl = currentScope._parentElement;
-    for (let arg of args) {
-        if (arg == null || arg === false)
-            continue;
-        if (typeof arg === 'string') {
-            let text, classes;
-            const textPos = arg.indexOf(':');
-            if (textPos >= 0) {
-                text = arg.substring(textPos + 1);
-                if (textPos === 0) { // Just a string to add as text, no new node
-                    addLeafNode(deepEl, document.createTextNode(text));
-                    continue;
-                }
-                arg = arg.substring(0, textPos);
-            }
-            const classPos = arg.indexOf('.');
-            if (classPos >= 0) {
-                classes = arg.substring(classPos + 1).replaceAll('.', ' ');
-                arg = arg.substring(0, classPos);
-            }
-            if (arg.indexOf(' ') >= 0)
-                throw new Error(`Tag '${arg}' cannot contain space`);
-            const el = document.createElement(arg || 'div');
-            if (classes)
-                el.className = classes;
-            if (text)
-                el.textContent = text;
-            addLeafNode(deepEl, el);
-            deepEl = el;
-        }
-        else if (typeof arg === 'object') {
-            if (arg.constructor !== Object)
-                throw new Error(`Unexpected argument: ${arg}`);
-            for (const key in arg) {
-                const val = arg[key];
-                if (key === 'bind') { // Special case, as for this prop we *don't* want to resolve the Store to a value first.
-                    applyBinding(deepEl, key, val);
-                }
-                else if (val instanceof Store) {
-                    let childScope = new SetArgScope(deepEl, deepEl.lastChild, currentScope._queueOrder + 1, key, val);
-                    childScope._install();
-                }
-                else {
-                    applyArg(deepEl, key, val);
-                }
-            }
-        }
-        else if (typeof arg === 'function') {
-            if (deepEl === currentScope._parentElement) { // do what observe does
-                _mount(undefined, args[0], SimpleScope);
-            }
-            else { // new scope for a new node without any scope attached yet
-                let childScope = new SimpleScope(deepEl, deepEl.lastChild, currentScope._queueOrder + 1, arg);
-                childScope._install();
-            }
-        }
-        else {
-            throw new Error(`Unexpected argument: ${JSON.stringify(arg)}`);
-        }
-    }
+function count(proxied) {
+  if (proxied instanceof Array)
+    return ref(proxied, "length");
+  const target = proxied[TARGET_SYMBOL] || proxied;
+  let cnt = 0;
+  for (let k in target)
+    if (target[k] !== undefined)
+      cnt++;
+  const result = proxy(cnt);
+  subscribe(target, ANY_SYMBOL, function(index, newData, oldData) {
+    if (oldData === newData) {} else if (oldData === undefined)
+      result.value = ++cnt;
+    else if (newData === undefined)
+      result.value = --cnt;
+  });
+  return result;
 }
-function applyArg(deepEl, key, value) {
-    if (key[0] === '.') { // CSS class(es)
-        const classes = key.substring(1).split('.');
-        if (value)
-            deepEl.classList.add(...classes);
+function defaultEmitHandler(target, index, newData, oldData) {
+  if (newData === oldData && newData !== undefined)
+    return;
+  const byTarget = subscribers.get(target);
+  if (byTarget === undefined)
+    return;
+  for (const what of [index, ANY_SYMBOL]) {
+    let byIndex = byTarget.get(what);
+    if (byIndex) {
+      for (let observer of byIndex) {
+        if (typeof observer === "function")
+          observer(index, newData, oldData);
         else
-            deepEl.classList.remove(...classes);
+          observer.onChange(index, newData, oldData);
+      }
     }
-    else if (key[0] === '$') { // Style
-        const name = key.substring(1);
-        if (value == null || value === false)
-            deepEl.style[name] = '';
-        else
-            deepEl.style[name] = '' + value;
-    }
-    else if (key in SPECIAL_PROPS) { // Special property
-        SPECIAL_PROPS[key](deepEl, value);
-    }
-    else if (typeof value === 'function') { // Event listener
-        deepEl.addEventListener(key, value);
-        clean(() => deepEl.removeEventListener(key, value));
-    }
-    else if (value === true || value === false || key === 'value' || key === 'selectedIndex') { // DOM property
-        deepEl[key] = value;
-    }
-    else { // HTML attribute
-        deepEl.setAttribute(key, value);
+  }
+}
+var emit = defaultEmitHandler;
+var objectHandler = {
+  get(target, prop) {
+    if (prop === TARGET_SYMBOL)
+      return target;
+    subscribe(target, prop);
+    return optProxy(target[prop]);
+  },
+  set(target, prop, newData) {
+    if (typeof newData === "object" && newData)
+      newData = newData[TARGET_SYMBOL] || newData;
+    const oldData = target[prop];
+    if (newData !== oldData) {
+      target[prop] = newData;
+      emit(target, prop, newData, oldData);
+      runImmediateQueue();
     }
+    return true;
+  },
+  deleteProperty(target, prop) {
+    const old = target[prop];
+    delete target[prop];
+    emit(target, prop, undefined, old);
+    runImmediateQueue();
+    return true;
+  },
+  has(target, prop) {
+    const result = prop in target;
+    subscribe(target, prop);
+    return result;
+  },
+  ownKeys(target) {
+    subscribe(target, ANY_SYMBOL);
+    return Reflect.ownKeys(target);
+  }
+};
+function arraySet(target, prop, newData) {
+  if (typeof newData === "object" && newData)
+    newData = newData[TARGET_SYMBOL] || newData;
+  const oldData = target[prop];
+  if (newData !== oldData) {
+    let oldLength = target.length;
+    if (prop === "length") {
+      target.length = newData;
+      for (let i = newData;i < oldLength; i++) {
+        emit(target, i, undefined, target[i]);
+      }
+    } else {
+      const intProp = parseInt(prop);
+      if (intProp.toString() === prop)
+        prop = intProp;
+      target[prop] = newData;
+      emit(target, prop, newData, oldData);
+    }
+    if (target.length !== oldLength) {
+      emit(target, "length", target.length, oldLength);
+    }
+    runImmediateQueue();
+  }
+  return true;
+}
+var arrayHandler = {
+  get(target, prop) {
+    if (prop === TARGET_SYMBOL)
+      return target;
+    let subProp = prop;
+    if (typeof prop !== "symbol") {
+      const intProp = parseInt(prop);
+      if (intProp.toString() === prop)
+        subProp = intProp;
+    }
+    subscribe(target, subProp);
+    return optProxy(target[prop]);
+  },
+  set: arraySet,
+  deleteProperty(target, prop) {
+    return arraySet(target, prop, undefined);
+  }
+};
+var proxyMap = new WeakMap;
+function optProxy(value) {
+  if (typeof value !== "object" || !value || value[TARGET_SYMBOL] !== undefined) {
+    return value;
+  }
+  let proxied = proxyMap.get(value);
+  if (proxied)
+    return proxied;
+  proxied = new Proxy(value, value instanceof Array ? arrayHandler : objectHandler);
+  proxyMap.set(value, proxied);
+  return proxied;
+}
+function proxy(target) {
+  return optProxy(typeof target === "object" && target !== null ? target : { value: target });
+}
+function unproxy(target) {
+  return target ? target[TARGET_SYMBOL] || target : target;
+}
+var onDestroyMap = new WeakMap;
+function destroyWithClass(element, cls) {
+  const classes = cls.split(".").filter((c) => c);
+  element.classList.add(...classes);
+  setTimeout(() => element.remove(), 2000);
+}
+function copy(dst, src, flags = 0) {
+  copyRecurse(dst, src, flags);
+  runImmediateQueue();
+}
+var MERGE = 1;
+var SHALLOW = 2;
+var COPY_SUBSCRIBE = 32;
+var COPY_EMIT = 64;
+function clone(src, flags = 0) {
+  const dst = Object.create(Object.getPrototypeOf(src));
+  copyRecurse(dst, src, flags);
+  return dst;
+}
+function copyRecurse(dst, src, flags) {
+  let unproxied = dst[TARGET_SYMBOL];
+  if (unproxied) {
+    dst = unproxied;
+    flags |= COPY_EMIT;
+  }
+  unproxied = src[TARGET_SYMBOL];
+  if (unproxied) {
+    src = unproxied;
+    if (currentScope !== ROOT_SCOPE && !peeking)
+      flags |= COPY_SUBSCRIBE;
+  }
+  if (flags & COPY_SUBSCRIBE)
+    subscribe(src, ANY_SYMBOL);
+  if (src instanceof Array) {
+    if (!(dst instanceof Array))
+      throw new Error("Cannot copy array into object");
+    const dstLen = dst.length;
+    const srcLen = src.length;
+    for (let i = 0;i < srcLen; i++) {
+      copyValue(dst, src, i, flags);
+    }
+    if (srcLen !== dstLen) {
+      if (flags & COPY_EMIT) {
+        for (let i = srcLen;i < dstLen; i++) {
+          const old = dst[i];
+          dst[i] = undefined;
+          emit(dst, i, undefined, old);
+        }
+        dst.length = srcLen;
+        emit(dst, "length", srcLen, dstLen);
+      } else {
+        dst.length = srcLen;
+      }
+    }
+  } else {
+    for (let k in src) {
+      copyValue(dst, src, k, flags);
+    }
+    if (!(flags & MERGE)) {
+      for (let k in dst) {
+        if (!(k in src)) {
+          const old = dst[k];
+          delete dst[k];
+          if (flags & COPY_EMIT && old !== undefined) {
+            emit(dst, k, undefined, old);
+          }
+        }
+      }
+    }
+  }
+}
+function copyValue(dst, src, index, flags) {
+  let dstValue = dst[index];
+  let srcValue = src[index];
+  if (srcValue !== dstValue) {
+    if (srcValue && dstValue && typeof srcValue === "object" && typeof dstValue === "object" && (srcValue.constructor === dstValue.constructor || flags & MERGE && dstValue instanceof Array)) {
+      copyRecurse(dstValue, srcValue, flags);
+      return;
+    }
+    if (!(flags & SHALLOW) && srcValue && typeof srcValue === "object") {
+      let copy2 = Object.create(Object.getPrototypeOf(srcValue));
+      copyRecurse(copy2, srcValue, 0);
+      srcValue = copy2;
+    }
+    const old = dst[index];
+    if (flags & MERGE && srcValue == null)
+      delete dst[index];
+    else
+      dst[index] = srcValue;
+    if (flags & COPY_EMIT)
+      emit(dst, index, srcValue, old);
+  }
+}
+var refHandler = {
+  get(target, prop) {
+    if (prop === TARGET_SYMBOL) {
+      return ref(unproxy(target.proxy), target.index);
+    }
+    if (prop === "value") {
+      return target.proxy[target.index];
+    }
+  },
+  set(target, prop, value) {
+    if (prop === "value") {
+      target.proxy[target.index] = value;
+      return true;
+    }
+    return false;
+  }
+};
+function ref(target, index) {
+  return new Proxy({ proxy: target, index }, refHandler);
+}
+function applyBind(_el, target) {
+  const el = _el;
+  let onProxyChange;
+  let onInputChange;
+  let type = el.getAttribute("type");
+  let value = unproxy(target).value;
+  if (type === "checkbox") {
+    if (value === undefined)
+      target.value = el.checked;
+    onProxyChange = () => el.checked = target.value;
+    onInputChange = () => target.value = el.checked;
+  } else if (type === "radio") {
+    if (value === undefined && el.checked)
+      target.value = el.value;
+    onProxyChange = () => el.checked = target.value === el.value;
+    onInputChange = () => {
+      if (el.checked)
+        target.value = el.value;
+    };
+  } else {
+    onInputChange = () => target.value = type === "number" || type === "range" ? el.value === "" ? null : +el.value : el.value;
+    if (value === undefined)
+      onInputChange();
+    onProxyChange = () => el.value = target.value;
+  }
+  observe(onProxyChange);
+  el.addEventListener("input", onInputChange);
+  clean(() => {
+    el.removeEventListener("input", onInputChange);
+  });
+}
+var SPECIAL_PROPS = {
+  create: function(value) {
+    const el = currentScope.parentElement;
+    if (currentScope !== topRedrawScope)
+      return;
+    if (typeof value === "function") {
+      value(el);
+    } else {
+      const classes = value.split(".").filter((c) => c);
+      el.classList.add(...classes);
+      (async function() {
+        el.offsetHeight;
+        el.classList.remove(...classes);
+      })();
+    }
+  },
+  destroy: function(value) {
+    const el = currentScope.parentElement;
+    onDestroyMap.set(el, value);
+  },
+  html: function(value) {
+    let tmpParent = document.createElement(currentScope.parentElement.tagName);
+    tmpParent.innerHTML = "" + value;
+    while (tmpParent.firstChild)
+      addNode(tmpParent.firstChild);
+  },
+  text: function(value) {
+    addNode(document.createTextNode(value));
+  },
+  element: function(value) {
+    if (!(value instanceof Node))
+      throw new Error(`Unexpected element-argument: ${JSON.parse(value)}`);
+    addNode(value);
+  }
+};
+function $(...args) {
+  let savedCurrentScope;
+  let err;
+  for (let arg of args) {
+    if (arg == null || arg === false)
+      continue;
+    if (typeof arg === "string") {
+      let text, classes;
+      const textPos = arg.indexOf(":");
+      if (textPos >= 0) {
+        text = arg.substring(textPos + 1);
+        arg = arg.substring(0, textPos);
+      }
+      const classPos = arg.indexOf(".");
+      if (classPos >= 0) {
+        classes = arg.substring(classPos + 1);
+        arg = arg.substring(0, classPos);
+      }
+      if (arg === "") {
+        if (text)
+          addNode(document.createTextNode(text));
+        if (classes) {
+          const el = currentScope.parentElement;
+          el.classList.add(...classes.split("."));
+          if (!savedCurrentScope) {
+            clean(() => el.classList.remove(...classes.split(".")));
+          }
+        }
+      } else if (arg.indexOf(" ") >= 0) {
+        err = `Tag '${arg}' cannot contain space`;
+        break;
+      } else {
+        const el = document.createElement(arg);
+        if (classes)
+          el.className = classes.replaceAll(".", " ");
+        if (text)
+          el.textContent = text;
+        addNode(el);
+        if (!savedCurrentScope) {
+          savedCurrentScope = currentScope;
+        }
+        let newScope = new ChainedScope(el, true);
+        newScope.lastChild = el.lastChild || undefined;
+        if (topRedrawScope === currentScope)
+          topRedrawScope = newScope;
+        currentScope = newScope;
+      }
+    } else if (typeof arg === "object") {
+      if (arg.constructor !== Object) {
+        err = `Unexpected argument: ${arg}`;
+        break;
+      }
+      for (const key in arg) {
+        const val = arg[key];
+        applyArg(key, val);
+      }
+    } else if (typeof arg === "function") {
+      new RegularScope(currentScope.parentElement, arg);
+    } else {
+      err = `Unexpected argument: ${arg}`;
+      break;
+    }
+  }
+  if (savedCurrentScope) {
+    currentScope = savedCurrentScope;
+  }
+  if (err)
+    throw new Error(err);
+}
+var cssCount = 0;
+function insertCss(style, global = false) {
+  const prefix = global ? "" : ".AbdStl" + ++cssCount;
+  let css = styleToCss(style, prefix);
+  if (css)
+    $("style:" + css);
+  return prefix;
+}
+function styleToCss(style, prefix) {
+  let props = "";
+  let rules = "";
+  for (const kOr in style) {
+    const v = style[kOr];
+    for (const k of kOr.split(/, ?/g)) {
+      if (v && typeof v === "object") {
+        if (k.startsWith("@")) {
+          rules += k + `{
+` + styleToCss(v, prefix) + `}
+`;
+        } else {
+          rules += styleToCss(v, k.includes("&") ? k.replace(/&/g, prefix) : prefix + " " + k);
+        }
+      } else {
+        props += k.replace(/[A-Z]/g, (letter) => "-" + letter.toLowerCase()) + ":" + v + ";";
+      }
+    }
+  }
+  if (props)
+    rules = (prefix.trimStart() || "*") + "{" + props + `}
+` + rules;
+  return rules;
+}
+function applyArg(key, value) {
+  const el = currentScope.parentElement;
+  if (typeof value === "object" && value !== null && value[TARGET_SYMBOL]) {
+    if (key === "bind") {
+      applyBind(el, value);
+    } else {
+      new SetArgScope(el, key, value);
+    }
+  } else if (key[0] === ".") {
+    const classes = key.substring(1).split(".");
+    if (value)
+      el.classList.add(...classes);
+    else
+      el.classList.remove(...classes);
+  } else if (key[0] === "$") {
+    const name = key.substring(1);
+    if (value == null || value === false)
+      el.style[name] = "";
+    else
+      el.style[name] = "" + value;
+  } else if (value == null) {} else if (key in SPECIAL_PROPS) {
+    SPECIAL_PROPS[key](value);
+  } else if (typeof value === "function") {
+    el.addEventListener(key, value);
+    clean(() => el.removeEventListener(key, value));
+  } else if (value === true || value === false || key === "value" || key === "selectedIndex") {
+    el[key] = value;
+  } else {
+    el.setAttribute(key, value);
+  }
 }
 function defaultOnError(error) {
-    console.error('Error while in Aberdeen render:', error);
-    return true;
+  console.error("Error while in Aberdeen render:", error);
+  return true;
 }
-let onError = defaultOnError;
-/**
- * Set a custome error handling function, thast is called when an error occurs during rendering
- * while in a reactive scope. The default implementation logs the error to the console, and then
- * just returns `true`, which causes an 'Error' message to be displayed in the UI. When this function
- * returns `false`, the error is suppressed. This mechanism exists because rendering errors can occur
- * at any time, not just synchronous when making a call to Aberdeen, thus normal exception handling
- * is not always possible.
- *
- * @param handler The handler function, getting an `Error` as its argument, and returning `false`
- *    if it does *not* want an error message to be added to the DOM.
- *    When `handler is `undefined`, the default error handling will be reinstated.
- *
- * @example
- * ```javascript
- * //
- * setErrorHandler(error => {
- *    // Tell our developers about the problem.
- * 	  fancyErrorLogger(error)
- *    // Add custom error message to the DOM.
- *    try {
- *        $('.error:Sorry, something went wrong!')
- *    } catch() {} // In case there is no parent element.
- *    // Don't add default error message to the DOM.
- * 	  return false
- * })
- * ```
- */
-export function setErrorHandler(handler) {
-    onError = handler || defaultOnError;
+var onError = defaultOnError;
+function setErrorHandler(handler) {
+  onError = handler || defaultOnError;
 }
-/**
- * Return the browser Element that nodes would be rendered to at this point.
- * NOTE: Manually changing the DOM is not recommended in most cases. There is
- * usually a better, declarative way. Although there are no hard guarantees on
- * how your changes interact with Aberdeen, in most cases results will not be
- * terribly surprising. Be careful within the parent element of onEach() though.
- */
-export function getParentElement() {
-    if (!currentScope || !currentScope._parentElement)
-        throw new ScopeError(true);
-    return currentScope._parentElement;
+function getParentElement() {
+  return currentScope.parentElement;
 }
-/**
- * Register a function that is to be executed right before the current reactive scope
- * disappears or redraws.
- * @param clean - The function to be executed.
- */
-export function clean(clean) {
-    if (!currentScope)
-        throw new ScopeError(false);
-    currentScope._cleaners.push({ _clean: clean });
+function clean(cleaner) {
+  currentScope.cleaners.push(cleaner);
 }
-/**
- * Reactively run a function, meaning the function will rerun when any `Store` that was read
- * during its execution is updated.
- * Calls to `observe` can be nested, such that changes to `Store`s read by the inner function do
- * 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)
- * let doubled = new Store()
- * setInterval(() => number.set(0|Math.random()*100)), 1000)
- *
- * observe(() => {
- *   doubled.set(number.get() * 2)
- * })
- *
- * observe(() => {
- *   console.log(doubled.get())
- * })
- */
-export function observe(func) {
-    return _mount(undefined, func, SimpleScope);
+function observe(func) {
+  return new ResultScope(currentScope.parentElement, func).result;
 }
-/**
- * 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);
+function immediateObserve(func) {
+  new ImmediateScope(currentScope.parentElement, func);
 }
-/**
- * Reactively run the function, adding any DOM-elements created using {@link $} to the given parent element.
-
- * @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 `$`.
- * @returns The mount id (usable for `unmount`) if this is a top-level mount.
- *
- * @example
- * ```
- * let store = new Store(0)
- * setInterval(() => store.modify(v => v+1), 1000)
- *
- * mount(document.body, () => {
- * 	   $(`h2:${store.get()} seconds have passed`)
- * })
- * ```
- *
- * An example nesting {@link Store.observe} within `mount`:
- * ```
- * let selected = new Store(0)
- * let colors = new Store(new Map())
- *
- * mount(document.body, () => {
- *   // This function will never rerun (as it does not read any `Store`s)
- *   $('button:<<', {click: () => selected.modify(n => n-1)})
- *   $('button:>>', {click: () => selected.modify(n => n+1)})
- *
- *   observe(() => {
- *     // This will rerun whenever `selected` changes, recreating the <h2> and <input>.
- *     $('h2', {text: '#' + selected.get()})
- *     $('input', {type: 'color', value: '#ffffff' bind: colors(selected.get())})
- *   })
- *
- *   observe(() => {
- *     // This function will rerun when `selected` or the selected color changes.
- *     // It will change the <body> background-color.
- *     $({$backgroundColor: colors.get(selected.get()) || 'white'})
- *   })
- * })
- * ```
-*/
-export function mount(parentElement, func) {
-    for (let scope of topScopes.values()) {
-        if (parentElement === scope._parentElement) {
-            throw new Error("Only a single mount per parent element");
-        }
-    }
-    return _mount(parentElement, func, SimpleScope);
+function mount(parentElement, func) {
+  new MountScope(parentElement, func);
 }
-let maxTopScopeId = 0;
-const topScopes = new Map();
-function _mount(parentElement, func, MountScope) {
-    let scope;
-    if (parentElement || !currentScope) {
-        scope = new MountScope(parentElement, undefined, 0, func);
-    }
-    else {
-        scope = new MountScope(currentScope._parentElement, currentScope._lastChild || currentScope._precedingSibling, currentScope._queueOrder + 1, func);
-        currentScope._lastChild = scope;
-    }
-    // Do the initial run
-    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);
-    }
-    else {
-        topScopes.set(++maxTopScopeId, scope);
-        return maxTopScopeId;
-    }
+function unmountAll() {
+  ROOT_SCOPE.remove();
+  cssCount = 0;
 }
-/**
- * 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);
-        topScopes.delete(id);
-        scope._remove();
-    }
+function peek(func) {
+  peeking++;
+  try {
+    return func();
+  } finally {
+    peeking--;
+  }
 }
-/** Runs the given function, while not subscribing the current scope when reading {@link Store.Store} values.
- *
- * @param func Function to be executed immediately.
- * @returns Whatever `func()` returns.
- * @example
- * ```
- * import {Store, peek, text} from aberdeen
- *
- * let store = new Store(['a', 'b', 'c'])
- *
- * mount(document.body, () => {
- *     // Prevent rerender when store changes
- *     let msg = peek(() => `Store has ${store.count()} elements, and the first is ${store.get(0)}`))
- *     text(msg)
- * })
- * ```
- *
- * In the above example `store.get(0)` could be replaced with `store.peek(0)` to achieve the
- * same result without `peek()` wrapping everything. There is no non-subscribing equivalent
- * for `count()` however.
- */
-export function peek(func) {
-    let savedScope = currentScope;
-    currentScope = undefined;
-    try {
-        return func();
-    }
-    finally {
-        currentScope = savedScope;
-    }
+function map(source, func) {
+  let out = optProxy(source instanceof Array ? [] : {});
+  onEach(source, (item, key) => {
+    let value = func(item, key);
+    if (value !== undefined) {
+      out[key] = value;
+      clean(() => {
+        delete out[key];
+      });
+    }
+  });
+  return out;
 }
-/*
- * Helper functions
- */
-function valueToData(value) {
-    if (value instanceof Store) {
-        // When a Store is passed pointing at a collection, a reference
-        // is made to that collection.
-        return value._observe();
-    }
-    else if (typeof value !== "object" || !value) {
-        // Simple data types
-        return value;
-    }
-    else if (value instanceof Map) {
-        let result = new ObsMap();
-        value.forEach((v, k) => {
-            let d = valueToData(v);
-            if (d !== undefined)
-                result.rawSet(k, d);
+function multiMap(source, func) {
+  let out = optProxy({});
+  onEach(source, (item, key) => {
+    let pairs = func(item, key);
+    if (pairs) {
+      for (let key2 in pairs)
+        out[key2] = pairs[key2];
+      clean(() => {
+        for (let key2 in pairs)
+          delete out[key2];
+      });
+    }
+  });
+  return out;
+}
+function partition(source, func) {
+  const unproxiedOut = {};
+  const out = proxy(unproxiedOut);
+  onEach(source, (item, key) => {
+    let rsp = func(item, key);
+    if (rsp != null) {
+      const buckets = rsp instanceof Array ? rsp : [rsp];
+      if (buckets.length) {
+        for (let bucket of buckets) {
+          if (unproxiedOut[bucket])
+            out[bucket][key] = item;
+          else
+            out[bucket] = { [key]: item };
+        }
+        clean(() => {
+          for (let bucket of buckets) {
+            delete out[bucket][key];
+            if (isObjEmpty(unproxiedOut[bucket]))
+              delete out[bucket];
+          }
         });
-        return result;
-    }
-    else if (value instanceof Array) {
-        let result = new ObsArray();
-        for (let i = 0; i < value.length; i++) {
-            let d = valueToData(value[i]);
-            if (d !== undefined)
-                result.rawSet(i, d);
-        }
-        return result;
-    }
-    else if (value.constructor === Object) {
-        // A plain (literal) object
-        let result = new ObsObject();
-        for (let k in value) {
-            let d = valueToData(value[k]);
-            if (d !== undefined)
-                result.rawSet(k, d);
-        }
-        return result;
-    }
-    else {
-        // Any other type of object (including ObsCollection)
-        return value;
+      }
     }
+  });
+  return out;
 }
-function defaultMakeSortKey(store) {
-    return store.index();
+function dump(data) {
+  if (data && typeof data === "object") {
+    $({ text: data instanceof Array ? "<array>" : "<object>" });
+    $("ul", () => {
+      onEach(data, (value, key) => {
+        $("li:" + JSON.stringify(key) + ": ", () => {
+          dump(value);
+        });
+      });
+    });
+  } else {
+    $({ text: JSON.stringify(data) });
+  }
+  return data;
 }
-/* c8 ignore start */
 function internalError(code) {
-    throw new Error("Aberdeen internal error " + code);
+  throw new Error("Aberdeen internal error " + code);
 }
-/* c8 ignore end */
 function handleError(e, showMessage) {
-    try {
-        if (onError(e) === false)
-            showMessage = false;
-    }
-    catch (_a) { }
-    if (showMessage && (currentScope === null || currentScope === void 0 ? void 0 : currentScope._parentElement))
-        $('.aberdeen-error:Error');
-}
-class ScopeError extends Error {
-    constructor(mount) {
-        super(`Operation not permitted outside of ${mount ? "a mount" : "an observe"}() scope`);
-    }
+  try {
+    if (onError(e) === false)
+      showMessage = false;
+  } catch (e2) {
+    console.error(e2);
+  }
+  try {
+    if (showMessage)
+      $("div.aberdeen-error:Error");
+  } catch {}
 }
-/** @internal */
-export function withEmitHandler(handler, func) {
-    const oldEmitHandler = ObsCollection.prototype.emitChange;
-    ObsCollection.prototype.emitChange = handler;
-    try {
-        func();
-    }
-    finally {
-        ObsCollection.prototype.emitChange = oldEmitHandler;
-    }
+function withEmitHandler(handler, func) {
+  const oldEmitHandler = emit;
+  emit = handler;
+  try {
+    func();
+  } finally {
+    emit = oldEmitHandler;
+  }
 }
-// @ts-ignore
-// c8 ignore next
 if (!String.prototype.replaceAll)
-    String.prototype.replaceAll = function (from, to) { return this.split(from).join(to); };
-//# sourceMappingURL=aberdeen.js.map
+  String.prototype.replaceAll = function(from, to) {
+    return this.split(from).join(to);
+  };
+export {
+  withEmitHandler,
+  unproxy,
+  unmountAll,
+  setErrorHandler,
+  runQueue,
+  ref,
+  proxy,
+  peek,
+  partition,
+  onEach,
+  observe,
+  multiMap,
+  mount,
+  map,
+  isEmpty,
+  invertString,
+  insertCss,
+  immediateObserve,
+  getParentElement,
+  dump,
+  defaultEmitHandler,
+  count,
+  copy,
+  clone,
+  clean,
+  SHALLOW,
+  MERGE,
+  $
+};
+
+//# debugId=DE860A8F16A3286C64756E2164756E21
+//# sourceMappingURL=aberdeen.js.map