@aztec/merkle-tree 0.16.1 → 0.16.3

package/dest/standard_indexed_tree/standard_indexed_tree.js

@@ -1,57 +1,39 @@
+var _StandardIndexedTree_snapshotBuilder;
+import { __classPrivateFieldGet } from "tslib";
 import { toBigIntBE, toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { SiblingPath } from '@aztec/types';
+import { IndexedTreeSnapshotBuilder, } from '../index.js';
 import { TreeBase } from '../tree_base.js';
 const log = createDebugLogger('aztec:standard-indexed-tree');
-const indexToKeyLeaf = (name, index) => {
-    return `${name}:leaf:${toBufferBE(index, 32).toString('hex')}`;
+export const buildDbKeyForPreimage = (name, index) => {
+    return `${name}:leaf_by_index:${toBufferBE(index, 32).toString('hex')}`;
 };
-const keyLeafToIndex = (key) => {
-    const index = key.split(':')[2];
-    return toBigIntBE(Buffer.from(index, 'hex'));
-};
-const zeroLeaf = {
-    value: 0n,
-    nextValue: 0n,
-    nextIndex: 0n,
+export const buildDbKeyForLeafIndex = (name, key) => {
+    return `${name}:leaf_index_by_leaf_key:${toBufferBE(key, 32).toString('hex')}`;
 };
 /**
  * Pre-compute empty witness.
  * @param treeHeight - Height of tree for sibling path.
  * @returns An empty witness.
  */
-function getEmptyLowLeafWitness(treeHeight) {
+function getEmptyLowLeafWitness(treeHeight, leafPreimageFactory) {
     return {
-        leafData: zeroLeaf,
+        leafPreimage: leafPreimageFactory.empty(),
         index: 0n,
         siblingPath: new SiblingPath(treeHeight, Array(treeHeight).fill(toBufferBE(0n, 32))),
     };
 }
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const encodeTreeValue = (leafData) => {
-    const valueAsBuffer = toBufferBE(leafData.value, 32);
-    const indexAsBuffer = toBufferBE(leafData.nextIndex, 32);
-    const nextValueAsBuffer = toBufferBE(leafData.nextValue, 32);
-    return Buffer.concat([valueAsBuffer, indexAsBuffer, nextValueAsBuffer]);
-};
-const decodeTreeValue = (buf) => {
-    const value = toBigIntBE(buf.subarray(0, 32));
-    const nextIndex = toBigIntBE(buf.subarray(32, 64));
-    const nextValue = toBigIntBE(buf.subarray(64, 96));
-    return {
-        value,
-        nextIndex,
-        nextValue,
-    };
-};
 /**
- * Indexed merkle tree.
+ * Standard implementation of an indexed tree.
  */
 export class StandardIndexedTree extends TreeBase {
-    constructor() {
-        super(...arguments);
-        this.leaves = [];
-        this.cachedLeaves = {};
+    constructor(db, hasher, name, depth, size = 0n, leafPreimageFactory, leafFactory, root) {
+        super(db, hasher, name, depth, size, root);
+        this.leafPreimageFactory = leafPreimageFactory;
+        this.leafFactory = leafFactory;
+        _StandardIndexedTree_snapshotBuilder.set(this, new IndexedTreeSnapshotBuilder(this.db, this, this.leafPreimageFactory));
+        this.cachedLeafPreimages = {};
     }
     /**
      * Appends the given leaves to the tree.
@@ -84,74 +66,119 @@ export class StandardIndexedTree extends TreeBase {
      * @param includeUncommitted - Indicates whether to include uncommitted leaves in the computation.
      * @returns The value of the leaf at the given index or undefined if the leaf is empty.
      */
-    getLeafValue(index, includeUncommitted) {
-        const leaf = this.getLatestLeafDataCopy(Number(index), includeUncommitted);
-        if (!leaf) {
-            return Promise.resolve(undefined);
-        }
-        return Promise.resolve(toBufferBE(leaf.value, 32));
+    async getLeafValue(index, includeUncommitted) {
+        const preimage = await this.getLatestLeafPreimageCopy(index, includeUncommitted);
+        return preimage && preimage.toBuffer();
     }
     /**
      * Finds the index of the largest leaf whose value is less than or equal to the provided value.
-     * @param newValue - The new value to be inserted into the tree.
+     * @param newKey - The new key to be inserted into the tree.
      * @param includeUncommitted - If true, the uncommitted changes are included in the search.
      * @returns The found leaf index and a flag indicating if the corresponding leaf's value is equal to `newValue`.
      */
-    findIndexOfPreviousValue(newValue, includeUncommitted) {
-        const numLeaves = this.getNumLeaves(includeUncommitted);
-        const diff = [];
-        for (let i = 0; i < numLeaves; i++) {
-            const storedLeaf = this.getLatestLeafDataCopy(i, includeUncommitted);
-            // The stored leaf can be undefined if it addresses an empty leaf
-            // If the leaf is empty we do the same as if the leaf was larger
-            if (storedLeaf === undefined) {
-                diff.push(newValue);
-            }
-            else if (storedLeaf.value > newValue) {
-                diff.push(newValue);
-            }
-            else if (storedLeaf.value === newValue) {
-                return { index: i, alreadyPresent: true };
-            }
-            else {
-                diff.push(newValue - storedLeaf.value);
+    async findIndexOfPreviousKey(newKey, includeUncommitted) {
+        let lowLeafIndex = await this.getDbLowLeafIndex(newKey);
+        let lowLeafPreimage = lowLeafIndex !== undefined ? await this.getDbPreimage(lowLeafIndex) : undefined;
+        if (includeUncommitted) {
+            const cachedLowLeafIndex = this.getCachedLowLeafIndex(newKey);
+            if (cachedLowLeafIndex !== undefined) {
+                const cachedLowLeafPreimage = this.getCachedPreimage(cachedLowLeafIndex);
+                if (!lowLeafPreimage || cachedLowLeafPreimage.getKey() > lowLeafPreimage.getKey()) {
+                    lowLeafIndex = cachedLowLeafIndex;
+                    lowLeafPreimage = cachedLowLeafPreimage;
+                }
             }
         }
-        const minIndex = this.findMinIndex(diff);
-        return { index: minIndex, alreadyPresent: false };
+        if (lowLeafIndex === undefined || !lowLeafPreimage) {
+            return undefined;
+        }
+        return {
+            index: lowLeafIndex,
+            alreadyPresent: lowLeafPreimage.getKey() === newKey,
+        };
+    }
+    getCachedLowLeafIndex(key) {
+        const indexes = Object.getOwnPropertyNames(this.cachedLeafPreimages);
+        const lowLeafIndexes = indexes
+            .map(index => ({
+            index: BigInt(index),
+            key: this.cachedLeafPreimages[index].getKey(),
+        }))
+            .filter(({ key: candidateKey }) => candidateKey <= key)
+            .sort((a, b) => Number(b.key - a.key));
+        return lowLeafIndexes[0]?.index;
+    }
+    getCachedLeafIndex(key) {
+        const index = Object.keys(this.cachedLeafPreimages).find(index => {
+            return this.cachedLeafPreimages[index].getKey() === key;
+        });
+        if (index) {
+            return BigInt(index);
+        }
+        return undefined;
+    }
+    async getDbLowLeafIndex(key) {
+        return await new Promise((resolve, reject) => {
+            let lowLeafIndex;
+            this.db
+                .createReadStream({
+                gte: buildDbKeyForLeafIndex(this.getName(), 0n),
+                lte: buildDbKeyForLeafIndex(this.getName(), key),
+                limit: 1,
+                reverse: true,
+            })
+                .on('data', data => {
+                lowLeafIndex = toBigIntBE(data.value);
+            })
+                .on('close', function () { })
+                .on('end', function () {
+                resolve(lowLeafIndex);
+            })
+                .on('error', function () {
+                log.error('stream error');
+                reject();
+            });
+        });
+    }
+    async getDbPreimage(index) {
+        const dbPreimage = await this.db
+            .get(buildDbKeyForPreimage(this.getName(), index))
+            .then(data => this.leafPreimageFactory.fromBuffer(data))
+            .catch(() => undefined);
+        return dbPreimage;
+    }
+    getCachedPreimage(index) {
+        return this.cachedLeafPreimages[index.toString()];
     }
     /**
-     * Gets the latest LeafData copy.
-     * @param index - Index of the leaf of which to obtain the LeafData copy.
+     * Gets the latest LeafPreimage copy.
+     * @param index - Index of the leaf of which to obtain the LeafPreimage copy.
      * @param includeUncommitted - If true, the uncommitted changes are included in the search.
-     * @returns A copy of the leaf data at the given index or undefined if the leaf was not found.
+     * @returns A copy of the leaf preimage at the given index or undefined if the leaf was not found.
      */
-    getLatestLeafDataCopy(index, includeUncommitted) {
-        const leaf = !includeUncommitted ? this.leaves[index] : this.cachedLeaves[index] ?? this.leaves[index];
-        return leaf
-            ? {
-                value: leaf.value,
-                nextIndex: leaf.nextIndex,
-                nextValue: leaf.nextValue,
-            }
-            : undefined;
+    async getLatestLeafPreimageCopy(index, includeUncommitted) {
+        const preimage = !includeUncommitted
+            ? await this.getDbPreimage(index)
+            : this.getCachedPreimage(index) ?? (await this.getDbPreimage(index));
+        return preimage && this.leafPreimageFactory.clone(preimage);
     }
     /**
-     * Finds the index of the minimum value in an array.
-     * @param values - The collection of values to be searched.
-     * @returns The index of the minimum value in the array.
+     * Returns the index of a leaf given its value, or undefined if no leaf with that value is found.
+     * @param value - The leaf value to look for.
+     * @param includeUncommitted - Indicates whether to include uncommitted data.
+     * @returns The index of the first leaf found with a given value (undefined if not found).
      */
-    findMinIndex(values) {
-        if (!values.length) {
-            return 0;
-        }
-        let minIndex = 0;
-        for (let i = 1; i < values.length; i++) {
-            if (values[minIndex] > values[i]) {
-                minIndex = i;
-            }
+    async findLeafIndex(value, includeUncommitted) {
+        const leaf = this.leafFactory.fromBuffer(value);
+        let index = await this.db
+            .get(buildDbKeyForLeafIndex(this.getName(), leaf.getKey()))
+            .then(data => toBigIntBE(data))
+            .catch(() => undefined);
+        if (includeUncommitted && index === undefined) {
+            const cachedIndex = this.getCachedLeafIndex(leaf.getKey());
+            index = cachedIndex;
         }
-        return minIndex;
+        return index;
     }
     /**
      * Initializes the tree.
@@ -173,59 +200,26 @@ export class StandardIndexedTree extends TreeBase {
         }
         const leaves = [];
         for (let i = 0n; i < prefilledSize; i++) {
-            const newLeaf = {
-                value: toBigIntBE(Buffer.from([Number(i)])),
-                nextIndex: i + 1n,
-                nextValue: i + 1n,
-            };
-            leaves.push(newLeaf);
+            const newLeaf = this.leafFactory.buildDummy(i);
+            const newLeafPreimage = this.leafPreimageFactory.fromLeaf(newLeaf, i + 1n, i + 1n);
+            leaves.push(newLeafPreimage);
         }
-        // Make the first leaf have 0 value
-        leaves[0].value = 0n;
         // Make the last leaf point to the first leaf
-        leaves[prefilledSize - 1].nextIndex = 0n;
-        leaves[prefilledSize - 1].nextValue = 0n;
+        leaves[prefilledSize - 1] = this.leafPreimageFactory.fromLeaf(leaves[prefilledSize - 1].asLeaf(), 0n, 0n);
         await this.encodeAndAppendLeaves(leaves, true);
         await this.commit();
     }
-    /**
-     * Loads Merkle tree data from a database and assigns them to this object.
-     */
-    async initFromDb() {
-        const startingIndex = 0n;
-        const values = [];
-        const promise = new Promise((resolve, reject) => {
-            this.db
-                .createReadStream({
-                gte: indexToKeyLeaf(this.getName(), startingIndex),
-                lte: indexToKeyLeaf(this.getName(), 2n ** BigInt(this.getDepth())),
-            })
-                .on('data', function (data) {
-                const index = keyLeafToIndex(data.key.toString('utf-8'));
-                values[Number(index)] = decodeTreeValue(data.value);
-            })
-                .on('close', function () { })
-                .on('end', function () {
-                resolve();
-            })
-                .on('error', function () {
-                log.error('stream error');
-                reject();
-            });
-        });
-        await promise;
-        this.leaves = values;
-    }
     /**
      * Commits all the leaves to the database and removes them from a cache.
      */
     async commitLeaves() {
         const batch = this.db.batch();
-        const keys = Object.getOwnPropertyNames(this.cachedLeaves);
+        const keys = Object.getOwnPropertyNames(this.cachedLeafPreimages);
         for (const key of keys) {
-            const index = Number(key);
-            batch.put(indexToKeyLeaf(this.getName(), BigInt(index)), encodeTreeValue(this.cachedLeaves[index]));
-            this.leaves[index] = this.cachedLeaves[index];
+            const leaf = this.cachedLeafPreimages[key];
+            const index = BigInt(key);
+            batch.put(buildDbKeyForPreimage(this.getName(), index), leaf.toBuffer());
+            batch.put(buildDbKeyForLeafIndex(this.getName(), leaf.getKey()), toBufferBE(index, 32));
         }
         await batch.write();
         this.clearCachedLeaves();
@@ -234,18 +228,19 @@ export class StandardIndexedTree extends TreeBase {
      * Clears the cache.
      */
     clearCachedLeaves() {
-        this.cachedLeaves = {};
+        this.cachedLeafPreimages = {};
     }
     /**
      * Updates a leaf in the tree.
-     * @param leaf - New contents of the leaf.
+     * @param preimage - New contents of the leaf.
      * @param index - Index of the leaf to be updated.
      */
-    async updateLeaf(leaf, index) {
+    async updateLeaf(preimage, index) {
         if (index > this.maxIndex) {
             throw Error(`Index out of bounds. Index ${index}, max index: ${this.maxIndex}.`);
         }
-        const encodedLeaf = this.encodeLeaf(leaf, true);
+        this.cachedLeafPreimages[index.toString()] = preimage;
+        const encodedLeaf = this.encodeLeaf(preimage, true);
         await this.addLeafToCacheAndHashToRoot(encodedLeaf, index);
         const numLeaves = this.getNumLeaves(true);
         if (index >= numLeaves) {
@@ -262,8 +257,6 @@ export class StandardIndexedTree extends TreeBase {
      *
      * This offers massive circuit performance savings over doing incremental insertions.
      *
-     * A description of the algorithm can be found here: https://colab.research.google.com/drive/1A0gizduSi4FIiIJZ8OylwIpO9-OTqV-R
-     *
      * WARNING: This function has side effects, it will insert values into the tree.
      *
      * Assumptions:
@@ -283,81 +276,78 @@ export class StandardIndexedTree extends TreeBase {
      * roots.
      *
      * This become tricky when two items that are being batch inserted need to update the same low nullifier, or need to use
-     * a value that is part of the same batch insertion as their low nullifier. In this case a zero low nullifier path is given
-     * to the circuit, and it must determine from the set of batch inserted values if the insertion is valid.
+     * a value that is part of the same batch insertion as their low nullifier. What we do to avoid this case is to
+     * update the existing leaves in the tree with the nullifiers in high to low order, ensuring that this case never occurs.
+     * The circuit has to sort the nullifiers (or take a hint of the sorted nullifiers and prove that it's a valid permutation).
+     * Then we just batch insert the new nullifiers in the original order.
      *
      * The following example will illustrate attempting to insert 2,3,20,19 into a tree already containing 0,5,10,15
      *
      * The example will explore two cases. In each case the values low nullifier will exist within the batch insertion,
      * One where the low nullifier comes before the item in the set (2,3), and one where it comes after (20,19).
      *
+     * First, we sort the nullifiers high to low, that's 20,19,3,2
+     *
      * The original tree:                       Pending insertion subtree
      *
-     *  index     0       2       3       4         -       -       -       -
+     *  index     0       1       2       3         -       -       -       -
      *  -------------------------------------      ----------------------------
      *  val       0       5      10      15         -       -       -       -
      *  nextIdx   1       2       3       0         -       -       -       -
      *  nextVal   5      10      15       0         -       -       -       -
      *
      *
-     * Inserting 2: (happy path)
-     * 1. Find the low nullifier (0) - provide inclusion proof
+     * Inserting 20:
+     * 1. Find the low nullifier (3) - provide inclusion proof
      * 2. Update its pointers
-     * 3. Insert 2 into the pending subtree
+     * 3. Insert 20 into the pending subtree
      *
-     *  index     0       2       3       4         5       -       -       -
+     *  index     0       1       2       3         -       -       6       -
      *  -------------------------------------      ----------------------------
-     *  val       0       5      10      15         2       -       -       -
-     *  nextIdx   5       2       3       0         2       -       -       -
-     *  nextVal   2      10      15       0         5       -       -       -
+     *  val       0       5      10      15         -       -      20       -
+     *  nextIdx   1       2       3       6         -       -       0       -
+     *  nextVal   5      10      15      20         -       -       0       -
      *
-     * Inserting 3: The low nullifier exists within the insertion current subtree
-     * 1. When looking for the low nullifier for 3, we will receive 0 again as we have not inserted 2 into the main tree
-     *    This is problematic, as we cannot use either 0 or 2 as our inclusion proof.
-     *    Why cant we?
-     *      - Index 0 has a val 0 and nextVal of 2. This is NOT enough to prove non inclusion of 2.
-     *      - Our existing tree is in a state where we cannot prove non inclusion of 3.
-     *    We do not provide a non inclusion proof to out circuit, but prompt it to look within the insertion subtree.
-     * 2. Update pending insertion subtree
-     * 3. Insert 3 into pending subtree
+     * Inserting 19:
+     * 1. Find the low nullifier (3) - provide inclusion proof
+     * 2. Update its pointers
+     * 3. Insert 19 into the pending subtree
      *
-     * (no inclusion proof provided)
-     *  index     0       2       3       4         5       6       -       -
+     *  index     0       1       2       3         -       -       6       7
      *  -------------------------------------      ----------------------------
-     *  val       0       5      10      15         2       3       -       -
-     *  nextIdx   5       2       3       0         6       2       -       -
-     *  nextVal   2      10      15       0         3       5       -       -
+     *  val       0       5      10      15         -       -      20      19
+     *  nextIdx   1       2       3       7         -       -       0       6
+     *  nextVal   5      10      15      19         -       -       0      20
      *
-     * Inserting 20: (happy path)
-     * 1. Find the low nullifier (15) - provide inclusion proof
+     * Inserting 3:
+     * 1. Find the low nullifier (0) - provide inclusion proof
      * 2. Update its pointers
-     * 3. Insert 20 into the pending subtree
+     * 3. Insert 3 into the pending subtree
      *
-     *  index     0       2       3       4         5       6       7       -
+     *  index     0       1       2       3         -       5       6       7
      *  -------------------------------------      ----------------------------
-     *  val       0       5      10      15         2       3      20       -
-     *  nextIdx   5       2       3       7         6       2       0       -
-     *  nextVal   2      10      15      20         3       5       0       -
+     *  val       0       5      10      15         -       3      20      19
+     *  nextIdx   5       2       3       7         -       1       0       6
+     *  nextVal   3      10      15      19         -       5       0      20
      *
-     * Inserting 19:
-     * 1. In this case we can find a low nullifier, but we are updating a low nullifier that has already been updated
-     *    We can provide an inclusion proof of this intermediate tree state.
+     * Inserting 2:
+     * 1. Find the low nullifier (0) - provide inclusion proof
      * 2. Update its pointers
-     * 3. Insert 19 into the pending subtree
+     * 3. Insert 2 into the pending subtree
      *
-     *  index     0       2       3       4         5       6       7       8
+     *  index     0       1       2       3         4       5       6       7
      *  -------------------------------------      ----------------------------
-     *  val       0       5      10      15         2       3      20       19
-     *  nextIdx   5       2       3       8         6       2       0       7
-     *  nextVal   2      10      15      19         3       5       0       20
+     *  val       0       5      10      15         2       3      20      19
+     *  nextIdx   4       2       3       7         5       1       0       6
+     *  nextVal   2      10      15      19         3       5       0      20
      *
      * Perform subtree insertion
      *
-     *  index     0       2       3       4       5       6       7       8
+     *  index     0       1       2       3       4       5       6       7
      *  ---------------------------------------------------------------------
-     *  val       0       5      10      15       2       3      20       19
-     *  nextIdx   5       2       3       8       6       2       0       7
-     *  nextVal   2      10      15      19       3       5       0       20
+     *  val       0       5      10      15       2       3      20      19
+     *  nextIdx   4       2       3       7       5       1       0       6
+     *  nextVal   2      10      15      19       3       5       0      20
      *
      * TODO: this implementation will change once the zero value is changed from h(0,0,0). Changes incoming over the next sprint
      * @param leaves - Values to insert into the tree.
@@ -365,92 +355,61 @@ export class StandardIndexedTree extends TreeBase {
      * @returns The data for the leaves to be updated when inserting the new ones.
      */
     async batchInsert(leaves, subtreeHeight) {
-        // Keep track of touched low leaves
-        const touched = new Map();
-        const emptyLowLeafWitness = getEmptyLowLeafWitness(this.getDepth());
+        const emptyLowLeafWitness = getEmptyLowLeafWitness(this.getDepth(), this.leafPreimageFactory);
         // Accumulators
-        const lowLeavesWitnesses = [];
-        const pendingInsertionSubtree = [];
+        const lowLeavesWitnesses = leaves.map(() => emptyLowLeafWitness);
+        const pendingInsertionSubtree = leaves.map(() => this.leafPreimageFactory.empty());
         // Start info
         const startInsertionIndex = this.getNumLeaves(true);
+        const leavesToInsert = leaves.map(leaf => this.leafFactory.fromBuffer(leaf));
+        const sortedDescendingLeafTuples = leavesToInsert
+            .map((leaf, index) => ({ leaf, index }))
+            .sort((a, b) => Number(b.leaf.getKey() - a.leaf.getKey()));
+        const sortedDescendingLeaves = sortedDescendingLeafTuples.map(leafTuple => leafTuple.leaf);
         // Get insertion path for each leaf
-        for (let i = 0; i < leaves.length; i++) {
-            const newValue = toBigIntBE(leaves[i]);
-            // Keep space and just insert zero values
-            if (newValue === 0n) {
-                pendingInsertionSubtree.push(zeroLeaf);
-                lowLeavesWitnesses.push(emptyLowLeafWitness);
+        for (let i = 0; i < leavesToInsert.length; i++) {
+            const newLeaf = sortedDescendingLeaves[i];
+            const originalIndex = leavesToInsert.indexOf(newLeaf);
+            if (newLeaf.isEmpty()) {
                 continue;
             }
-            const indexOfPrevious = this.findIndexOfPreviousValue(newValue, true);
-            // If a touched node has a value that is less than the current value
-            const prevNodes = touched.get(indexOfPrevious.index);
-            if (prevNodes && prevNodes.some(v => v < newValue)) {
-                // check the pending low nullifiers for a low nullifier that works
-                // This is the case where the next value is less than the pending
-                for (let j = 0; j < pendingInsertionSubtree.length; j++) {
-                    if (pendingInsertionSubtree[j].value === 0n) {
-                        continue;
-                    }
-                    if (pendingInsertionSubtree[j].value < newValue &&
-                        (pendingInsertionSubtree[j].nextValue > newValue || pendingInsertionSubtree[j].nextValue === 0n)) {
-                        // add the new value to the pending low nullifiers
-                        const currentLowLeaf = {
-                            value: newValue,
-                            nextValue: pendingInsertionSubtree[j].nextValue,
-                            nextIndex: pendingInsertionSubtree[j].nextIndex,
-                        };
-                        pendingInsertionSubtree.push(currentLowLeaf);
-                        // Update the pending low leaf to point at the new value
-                        pendingInsertionSubtree[j].nextValue = newValue;
-                        pendingInsertionSubtree[j].nextIndex = startInsertionIndex + BigInt(i);
-                        break;
-                    }
-                }
-                // Any node updated in this space will need to calculate its low nullifier from a previously inserted value
-                lowLeavesWitnesses.push(emptyLowLeafWitness);
-            }
-            else {
-                // Update the touched mapping
-                if (prevNodes) {
-                    prevNodes.push(newValue);
-                    touched.set(indexOfPrevious.index, prevNodes);
-                }
-                else {
-                    touched.set(indexOfPrevious.index, [newValue]);
-                }
-                // get the low leaf
-                const lowLeaf = this.getLatestLeafDataCopy(indexOfPrevious.index, true);
-                if (lowLeaf === undefined) {
-                    return [undefined, await this.getSubtreeSiblingPath(subtreeHeight, true)];
-                }
-                const siblingPath = await this.getSiblingPath(BigInt(indexOfPrevious.index), true);
-                const witness = {
-                    leafData: { ...lowLeaf },
-                    index: BigInt(indexOfPrevious.index),
-                    siblingPath,
-                };
-                // Update the running paths
-                lowLeavesWitnesses.push(witness);
-                const currentLowLeaf = {
-                    value: newValue,
-                    nextValue: lowLeaf.nextValue,
-                    nextIndex: lowLeaf.nextIndex,
+            const indexOfPrevious = await this.findIndexOfPreviousKey(newLeaf.getKey(), true);
+            if (indexOfPrevious === undefined) {
+                return {
+                    lowLeavesWitnessData: undefined,
+                    sortedNewLeaves: sortedDescendingLeafTuples.map(leafTuple => leafTuple.leaf.toBuffer()),
+                    sortedNewLeavesIndexes: sortedDescendingLeafTuples.map(leafTuple => leafTuple.index),
+                    newSubtreeSiblingPath: await this.getSubtreeSiblingPath(subtreeHeight, true),
                 };
-                pendingInsertionSubtree.push(currentLowLeaf);
-                lowLeaf.nextValue = newValue;
-                lowLeaf.nextIndex = startInsertionIndex + BigInt(i);
-                const lowLeafIndex = indexOfPrevious.index;
-                this.cachedLeaves[lowLeafIndex] = lowLeaf;
-                await this.updateLeaf(lowLeaf, BigInt(lowLeafIndex));
             }
+            // get the low leaf (existence checked in getting index)
+            const lowLeafPreimage = (await this.getLatestLeafPreimageCopy(indexOfPrevious.index, true));
+            const siblingPath = await this.getSiblingPath(BigInt(indexOfPrevious.index), true);
+            const witness = {
+                leafPreimage: lowLeafPreimage,
+                index: BigInt(indexOfPrevious.index),
+                siblingPath,
+            };
+            // Update the running paths
+            lowLeavesWitnesses[i] = witness;
+            const currentPendingPreimageLeaf = this.leafPreimageFactory.fromLeaf(newLeaf, lowLeafPreimage.getNextKey(), lowLeafPreimage.getNextIndex());
+            pendingInsertionSubtree[originalIndex] = currentPendingPreimageLeaf;
+            const newLowLeafPreimage = this.leafPreimageFactory.fromLeaf(lowLeafPreimage.asLeaf(), newLeaf.getKey(), startInsertionIndex + BigInt(originalIndex));
+            const lowLeafIndex = indexOfPrevious.index;
+            this.cachedLeafPreimages[lowLeafIndex.toString()] = newLowLeafPreimage;
+            await this.updateLeaf(newLowLeafPreimage, lowLeafIndex);
         }
         const newSubtreeSiblingPath = await this.getSubtreeSiblingPath(subtreeHeight, true);
         // Perform batch insertion of new pending values
         // Note: In this case we set `hash0Leaf` param to false because batch insertion algorithm use forced null leaf
         // inclusion. See {@link encodeLeaf} for  a more through param explanation.
         await this.encodeAndAppendLeaves(pendingInsertionSubtree, false);
-        return [lowLeavesWitnesses, newSubtreeSiblingPath];
+        return {
+            lowLeavesWitnessData: lowLeavesWitnesses,
+            sortedNewLeaves: sortedDescendingLeafTuples.map(leafTuple => leafTuple.leaf.toBuffer()),
+            sortedNewLeavesIndexes: sortedDescendingLeafTuples.map(leafTuple => leafTuple.index),
+            newSubtreeSiblingPath,
+        };
     }
     async getSubtreeSiblingPath(subtreeHeight, includeUncommitted) {
         const nextAvailableLeafIndex = this.getNumLeaves(includeUncommitted);
@@ -458,19 +417,25 @@ export class StandardIndexedTree extends TreeBase {
         // Drop the first subtreeHeight items since we only care about the path to the subtree root
         return fullSiblingPath.getSubtreeSiblingPath(subtreeHeight);
     }
+    snapshot(blockNumber) {
+        return __classPrivateFieldGet(this, _StandardIndexedTree_snapshotBuilder, "f").snapshot(blockNumber);
+    }
+    getSnapshot(block) {
+        return __classPrivateFieldGet(this, _StandardIndexedTree_snapshotBuilder, "f").getSnapshot(block);
+    }
     /**
      * Encodes leaves and appends them to a tree.
-     * @param leaves - Leaves to encode.
+     * @param preimages - Leaves to encode.
      * @param hash0Leaf - Indicates whether 0 value leaf should be hashed. See {@link encodeLeaf}.
      * @returns Empty promise
      */
-    async encodeAndAppendLeaves(leaves, hash0Leaf) {
-        const startInsertionIndex = Number(this.getNumLeaves(true));
-        const serializedLeaves = leaves.map((leaf, i) => {
-            this.cachedLeaves[startInsertionIndex + i] = leaf;
-            return this.encodeLeaf(leaf, hash0Leaf);
+    async encodeAndAppendLeaves(preimages, hash0Leaf) {
+        const startInsertionIndex = this.getNumLeaves(true);
+        const hashedLeaves = preimages.map((preimage, i) => {
+            this.cachedLeafPreimages[(startInsertionIndex + BigInt(i)).toString()] = preimage;
+            return this.encodeLeaf(preimage, hash0Leaf);
         });
-        await super.appendLeaves(serializedLeaves);
+        await super.appendLeaves(hashedLeaves);
     }
     /**
      * Encode a leaf into a buffer.
@@ -482,13 +447,14 @@ export class StandardIndexedTree extends TreeBase {
      */
     encodeLeaf(leaf, hash0Leaf) {
         let encodedLeaf;
-        if (!hash0Leaf && leaf.value == 0n) {
+        if (!hash0Leaf && leaf.getKey() == 0n) {
             encodedLeaf = toBufferBE(0n, 32);
         }
         else {
-            encodedLeaf = this.hasher.hashInputs([leaf.value, leaf.nextIndex, leaf.nextValue].map(val => toBufferBE(val, 32)));
+            encodedLeaf = this.hasher.hashInputs(leaf.toHashInputs());
         }
         return encodedLeaf;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standard_indexed_tree.js","sourceRoot":"","sources":["../../src/standard_indexed_tree/standard_indexed_tree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAG3C,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3C,MAAM,GAAG,GAAG,iBAAiB,CAAC,6BAA6B,CAAC,CAAC;AAE7D,MAAM,cAAc,GAAG,CAAC,IAAY,EAAE,KAAa,EAAE,EAAE;IACrD,OAAO,GAAG,IAAI,SAAS,UAAU,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;AACjE,CAAC,CAAC;AAEF,MAAM,cAAc,GAAG,CAAC,GAAW,EAAU,EAAE;IAC7C,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAChC,OAAO,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;AAC/C,CAAC,CAAC;AAEF,MAAM,QAAQ,GAAa;IACzB,KAAK,EAAE,EAAE;IACT,SAAS,EAAE,EAAE;IACb,SAAS,EAAE,EAAE;CACd,CAAC;AAoBF;;;;GAIG;AACH,SAAS,sBAAsB,CAAmB,UAAa;IAC7D,OAAO;QACL,QAAQ,EAAE,QAAQ;QAClB,KAAK,EAAE,EAAE;QACT,WAAW,EAAE,IAAI,WAAW,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;KACrF,CAAC;AACJ,CAAC;AAED,6DAA6D;AAC7D,MAAM,eAAe,GAAG,CAAC,QAAkB,EAAE,EAAE;IAC7C,MAAM,aAAa,GAAG,UAAU,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACrD,MAAM,aAAa,GAAG,UAAU,CAAC,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;IACzD,MAAM,iBAAiB,GAAG,UAAU,CAAC,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;IAC7D,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,aAAa,EAAE,aAAa,EAAE,iBAAiB,CAAC,CAAC,CAAC;AAC1E,CAAC,CAAC;AAEF,MAAM,eAAe,GAAG,CAAC,GAAW,EAAE,EAAE;IACtC,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;IAC9C,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACnD,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACnD,OAAO;QACL,KAAK;QACL,SAAS;QACT,SAAS;KACE,CAAC;AAChB,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,OAAO,mBAAoB,SAAQ,QAAQ;IAAjD;;QACY,WAAM,GAAe,EAAE,CAAC;QACxB,iBAAY,GAAgC,EAAE,CAAC;IA+f3D,CAAC;IA7fC;;;;;OAKG;IACI,YAAY,CAAC,OAAiB;QACnC,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACrC,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,MAAM;QACjB,MAAM,KAAK,CAAC,MAAM,EAAE,CAAC;QACrB,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,QAAQ;QACnB,MAAM,KAAK,CAAC,QAAQ,EAAE,CAAC;QACvB,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3B,CAAC;IAED;;;;;OAKG;IACI,YAAY,CAAC,KAAa,EAAE,kBAA2B;QAC5D,MAAM,IAAI,GAAG,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,kBAAkB,CAAC,CAAC;QAC3E,IAAI,CAAC,IAAI,EAAE;YACT,OAAO,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;SACnC;QACD,OAAO,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC;IACrD,CAAC;IAED;;;;;OAKG;IACH,wBAAwB,CACtB,QAAgB,EAChB,kBAA2B;QAW3B,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,CAAC;QACxD,MAAM,IAAI,GAAa,EAAE,CAAC;QAE1B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE;YAClC,MAAM,UAAU,GAAG,IAAI,CAAC,qBAAqB,CAAC,CAAC,EAAE,kBAAkB,CAAE,CAAC;YAEtE,iEAAiE;YACjE,gEAAgE;YAChE,IAAI,UAAU,KAAK,SAAS,EAAE;gBAC5B,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;aACrB;iBAAM,IAAI,UAAU,CAAC,KAAK,GAAG,QAAQ,EAAE;gBACtC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;aACrB;iBAAM,IAAI,UAAU,CAAC,KAAK,KAAK,QAAQ,EAAE;gBACxC,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,cAAc,EAAE,IAAI,EAAE,CAAC;aAC3C;iBAAM;gBACL,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;aACxC;SACF;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QACzC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC;IACpD,CAAC;IAED;;;;;OAKG;IACI,qBAAqB,CAAC,KAAa,EAAE,kBAA2B;QACrE,MAAM,IAAI,GAAG,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACvG,OAAO,IAAI;YACT,CAAC,CAAE;gBACC,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,SAAS,EAAE,IAAI,CAAC,SAAS;gBACzB,SAAS,EAAE,IAAI,CAAC,SAAS;aACb;YAChB,CAAC,CAAC,SAAS,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACK,YAAY,CAAC,MAAgB;QACnC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;YAClB,OAAO,CAAC,CAAC;SACV;QACD,IAAI,QAAQ,GAAG,CAAC,CAAC;QACjB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACtC,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE;gBAChC,QAAQ,GAAG,CAAC,CAAC;aACd;SACF;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;;;;;;;;;;;OAaG;IACI,KAAK,CAAC,IAAI,CAAC,aAAqB;QACrC,IAAI,aAAa,GAAG,CAAC,EAAE;YACrB,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;SACvD;QAED,MAAM,MAAM,GAAe,EAAE,CAAC;QAC9B,KAAK,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,aAAa,EAAE,CAAC,EAAE,EAAE;YACvC,MAAM,OAAO,GAAG;gBACd,KAAK,EAAE,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC3C,SAAS,EAAE,CAAC,GAAG,EAAE;gBACjB,SAAS,EAAE,CAAC,GAAG,EAAE;aAClB,CAAC;YACF,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SACtB;QAED,mCAAmC;QACnC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;QAErB,6CAA6C;QAC7C,MAAM,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC,SAAS,GAAG,EAAE,CAAC;QACzC,MAAM,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC,SAAS,GAAG,EAAE,CAAC;QAEzC,MAAM,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAC/C,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;IACtB,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,UAAU;QACrB,MAAM,aAAa,GAAG,EAAE,CAAC;QACzB,MAAM,MAAM,GAAe,EAAE,CAAC;QAC9B,MAAM,OAAO,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACpD,IAAI,CAAC,EAAE;iBACJ,gBAAgB,CAAC;gBAChB,GAAG,EAAE,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,aAAa,CAAC;gBAClD,GAAG,EAAE,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,EAAE,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;aACnE,CAAC;iBACD,EAAE,CAAC,MAAM,EAAE,UAAU,IAAI;gBACxB,MAAM,KAAK,GAAG,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;gBACzD,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,GAAG,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACtD,CAAC,CAAC;iBACD,EAAE,CAAC,OAAO,EAAE,cAAa,CAAC,CAAC;iBAC3B,EAAE,CAAC,KAAK,EAAE;gBACT,OAAO,EAAE,CAAC;YACZ,CAAC,CAAC;iBACD,EAAE,CAAC,OAAO,EAAE;gBACX,GAAG,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;gBAC1B,MAAM,EAAE,CAAC;YACX,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;QACH,MAAM,OAAO,CAAC;QACd,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,YAAY;QACxB,MAAM,KAAK,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC;QAC9B,MAAM,IAAI,GAAG,MAAM,CAAC,mBAAmB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC3D,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;YACtB,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YAC1B,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACpG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;SAC/C;QACD,MAAM,KAAK,CAAC,KAAK,EAAE,CAAC;QACpB,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3B,CAAC;IAED;;OAEG;IACK,iBAAiB;QACvB,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACO,KAAK,CAAC,UAAU,CAAC,IAAc,EAAE,KAAa;QACtD,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE;YACzB,MAAM,KAAK,CAAC,8BAA8B,KAAK,gBAAgB,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;SAClF;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAChD,MAAM,IAAI,CAAC,2BAA2B,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;QAC3D,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAC1C,IAAI,KAAK,IAAI,SAAS,EAAE;YACtB,IAAI,CAAC,UAAU,GAAG,KAAK,GAAG,EAAE,CAAC;SAC9B;IACH,CAAC;IAED,gEAAgE;IAChE,qFAAqF;IAErF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6GG;IACI,KAAK,CAAC,WAAW,CAKtB,MAAgB,EAChB,aAA4B;QAK5B,mCAAmC;QACnC,MAAM,OAAO,GAAG,IAAI,GAAG,EAAoB,CAAC;QAE5C,MAAM,mBAAmB,GAAG,sBAAsB,CAAC,IAAI,CAAC,QAAQ,EAAgB,CAAC,CAAC;QAClF,eAAe;QACf,MAAM,kBAAkB,GAAqC,EAAE,CAAC;QAChE,MAAM,uBAAuB,GAAe,EAAE,CAAC;QAE/C,aAAa;QACb,MAAM,mBAAmB,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAEpD,mCAAmC;QACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACtC,MAAM,QAAQ,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;YAEvC,yCAAyC;YACzC,IAAI,QAAQ,KAAK,EAAE,EAAE;gBACnB,uBAAuB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBACvC,kBAAkB,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;gBAC7C,SAAS;aACV;YAED,MAAM,eAAe,GAAG,IAAI,CAAC,wBAAwB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;YAEtE,oEAAoE;YACpE,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;YACrD,IAAI,SAAS,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,QAAQ,CAAC,EAAE;gBAClD,kEAAkE;gBAClE,iEAAiE;gBACjE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,uBAAuB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBACvD,IAAI,uBAAuB,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,EAAE,EAAE;wBAC3C,SAAS;qBACV;oBAED,IACE,uBAAuB,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,QAAQ;wBAC3C,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,QAAQ,IAAI,uBAAuB,CAAC,CAAC,CAAC,CAAC,SAAS,KAAK,EAAE,CAAC,EAChG;wBACA,kDAAkD;wBAClD,MAAM,cAAc,GAAa;4BAC/B,KAAK,EAAE,QAAQ;4BACf,SAAS,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC,SAAS;4BAC/C,SAAS,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC,SAAS;yBAChD,CAAC;wBAEF,uBAAuB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;wBAE7C,wDAAwD;wBACxD,uBAAuB,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,QAAQ,CAAC;wBAChD,uBAAuB,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,mBAAmB,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;wBAEvE,MAAM;qBACP;iBACF;gBAED,2GAA2G;gBAC3G,kBAAkB,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;aAC9C;iBAAM;gBACL,6BAA6B;gBAC7B,IAAI,SAAS,EAAE;oBACb,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;oBACzB,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;iBAC/C;qBAAM;oBACL,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;iBAChD;gBAED,mBAAmB;gBACnB,MAAM,OAAO,GAAG,IAAI,CAAC,qBAAqB,CAAC,eAAe,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;gBACxE,IAAI,OAAO,KAAK,SAAS,EAAE;oBACzB,OAAO,CAAC,SAAS,EAAE,MAAM,IAAI,CAAC,qBAAqB,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC,CAAC;iBAC3E;gBACD,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,cAAc,CAAa,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC;gBAE/F,MAAM,OAAO,GAAmC;oBAC9C,QAAQ,EAAE,EAAE,GAAG,OAAO,EAAE;oBACxB,KAAK,EAAE,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC;oBACpC,WAAW;iBACZ,CAAC;gBAEF,2BAA2B;gBAC3B,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBAEjC,MAAM,cAAc,GAAa;oBAC/B,KAAK,EAAE,QAAQ;oBACf,SAAS,EAAE,OAAO,CAAC,SAAS;oBAC5B,SAAS,EAAE,OAAO,CAAC,SAAS;iBAC7B,CAAC;gBAEF,uBAAuB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;gBAE7C,OAAO,CAAC,SAAS,GAAG,QAAQ,CAAC;gBAC7B,OAAO,CAAC,SAAS,GAAG,mBAAmB,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;gBAEpD,MAAM,YAAY,GAAG,eAAe,CAAC,KAAK,CAAC;gBAC3C,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC;gBAC1C,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;aACtD;SACF;QAED,MAAM,qBAAqB,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAC5D,aAAa,EACb,IAAI,CACL,CAAC;QAEF,gDAAgD;QAChD,8GAA8G;QAC9G,2EAA2E;QAC3E,MAAM,IAAI,CAAC,qBAAqB,CAAC,uBAAuB,EAAE,KAAK,CAAC,CAAC;QACjE,OAAO,CAAC,kBAAkB,EAAE,qBAAqB,CAAC,CAAC;IACrD,CAAC;IAED,KAAK,CAAC,qBAAqB,CACzB,aAA4B,EAC5B,kBAA2B;QAE3B,MAAM,sBAAsB,GAAG,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,CAAC;QACrE,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,sBAAsB,EAAE,kBAAkB,CAAC,CAAC;QAE9F,2FAA2F;QAC3F,OAAO,eAAe,CAAC,qBAAqB,CAAC,aAAa,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,qBAAqB,CAAC,MAAkB,EAAE,SAAkB;QACxE,MAAM,mBAAmB,GAAG,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;QAE5D,MAAM,gBAAgB,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE;YAC9C,IAAI,CAAC,YAAY,CAAC,mBAAmB,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;YAClD,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;QAEH,MAAM,KAAK,CAAC,YAAY,CAAC,gBAAgB,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;;;OAOG;IACK,UAAU,CAAC,IAAc,EAAE,SAAkB;QACnD,IAAI,WAAW,CAAC;QAChB,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,KAAK,IAAI,EAAE,EAAE;YAClC,WAAW,GAAG,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;SAClC;aAAM;YACL,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAClC,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAC7E,CAAC;SACH;QACD,OAAO,WAAW,CAAC;IACrB,CAAC;CACF"}
+_StandardIndexedTree_snapshotBuilder = new WeakMap();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standard_indexed_tree.js","sourceRoot":"","sources":["../../src/standard_indexed_tree/standard_indexed_tree.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAU,WAAW,EAAE,MAAM,cAAc,CAAC;AAInD,OAAO,EAIL,0BAA0B,GAE3B,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3C,MAAM,GAAG,GAAG,iBAAiB,CAAC,6BAA6B,CAAC,CAAC;AA6C7D,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,IAAY,EAAE,KAAa,EAAE,EAAE;IACnE,OAAO,GAAG,IAAI,kBAAkB,UAAU,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;AAC1E,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,IAAY,EAAE,GAAW,EAAE,EAAE;IAClE,OAAO,GAAG,IAAI,2BAA2B,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;AACjF,CAAC,CAAC;AAEF;;;;GAIG;AACH,SAAS,sBAAsB,CAC7B,UAAa,EACb,mBAAoC;IAEpC,OAAO;QACL,YAAY,EAAE,mBAAmB,CAAC,KAAK,EAAE;QACzC,KAAK,EAAE,EAAE;QACT,WAAW,EAAE,IAAI,WAAW,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;KACrF,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,OAAO,mBAAoB,SAAQ,QAAQ;IAI/C,YACE,EAAW,EACX,MAAc,EACd,IAAY,EACZ,KAAa,EACb,OAAe,EAAE,EACP,mBAAoC,EACpC,WAAwB,EAClC,IAAa;QAEb,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QAJjC,wBAAmB,GAAnB,mBAAmB,CAAiB;QACpC,gBAAW,GAAX,WAAW,CAAa;QAVpC,+CAAmB,IAAI,0BAA0B,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,mBAAmB,CAAC,EAAC;QACjF,wBAAmB,GAA+C,EAAE,CAAC;IAa/E,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,OAAiB;QAC5B,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACrC,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,MAAM;QACjB,MAAM,KAAK,CAAC,MAAM,EAAE,CAAC;QACrB,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,QAAQ;QACnB,MAAM,KAAK,CAAC,QAAQ,EAAE,CAAC;QACvB,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3B,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,YAAY,CAAC,KAAa,EAAE,kBAA2B;QAClE,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,yBAAyB,CAAC,KAAK,EAAE,kBAAkB,CAAC,CAAC;QACjF,OAAO,QAAQ,IAAI,QAAQ,CAAC,QAAQ,EAAE,CAAC;IACzC,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,sBAAsB,CAC1B,MAAc,EACd,kBAA2B;QAc3B,IAAI,YAAY,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;QACxD,IAAI,eAAe,GAAG,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAEtG,IAAI,kBAAkB,EAAE;YACtB,MAAM,kBAAkB,GAAG,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;YAC9D,IAAI,kBAAkB,KAAK,SAAS,EAAE;gBACpC,MAAM,qBAAqB,GAAG,IAAI,CAAC,iBAAiB,CAAC,kBAAkB,CAAE,CAAC;gBAC1E,IAAI,CAAC,eAAe,IAAI,qBAAqB,CAAC,MAAM,EAAE,GAAG,eAAe,CAAC,MAAM,EAAE,EAAE;oBACjF,YAAY,GAAG,kBAAkB,CAAC;oBAClC,eAAe,GAAG,qBAAqB,CAAC;iBACzC;aACF;SACF;QAED,IAAI,YAAY,KAAK,SAAS,IAAI,CAAC,eAAe,EAAE;YAClD,OAAO,SAAS,CAAC;SAClB;QAED,OAAO;YACL,KAAK,EAAE,YAAY;YACnB,cAAc,EAAE,eAAe,CAAC,MAAM,EAAE,KAAK,MAAM;SACpD,CAAC;IACJ,CAAC;IAEO,qBAAqB,CAAC,GAAW;QACvC,MAAM,OAAO,GAAG,MAAM,CAAC,mBAAmB,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QACrE,MAAM,cAAc,GAAG,OAAO;aAC3B,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YACb,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC;YACpB,GAAG,EAAE,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE;SAC9C,CAAC,CAAC;aACF,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,YAAY,EAAE,EAAE,EAAE,CAAC,YAAY,IAAI,GAAG,CAAC;aACtD,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACzC,OAAO,cAAc,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC;IAClC,CAAC;IAEO,kBAAkB,CAAC,GAAW;QACpC,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;YAC/D,OAAO,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,KAAK,GAAG,CAAC;QAC1D,CAAC,CAAC,CAAC;QACH,IAAI,KAAK,EAAE;YACT,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;SACtB;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAEO,KAAK,CAAC,iBAAiB,CAAC,GAAW;QACzC,OAAO,MAAM,IAAI,OAAO,CAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC/D,IAAI,YAAgC,CAAC;YACrC,IAAI,CAAC,EAAE;iBACJ,gBAAgB,CAAC;gBAChB,GAAG,EAAE,sBAAsB,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,EAAE,CAAC;gBAC/C,GAAG,EAAE,sBAAsB,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,GAAG,CAAC;gBAChD,KAAK,EAAE,CAAC;gBACR,OAAO,EAAE,IAAI;aACd,CAAC;iBACD,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE;gBACjB,YAAY,GAAG,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACxC,CAAC,CAAC;iBACD,EAAE,CAAC,OAAO,EAAE,cAAa,CAAC,CAAC;iBAC3B,EAAE,CAAC,KAAK,EAAE;gBACT,OAAO,CAAC,YAAY,CAAC,CAAC;YACxB,CAAC,CAAC;iBACD,EAAE,CAAC,OAAO,EAAE;gBACX,GAAG,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;gBAC1B,MAAM,EAAE,CAAC;YACX,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,aAAa,CAAC,KAAa;QACvC,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,EAAE;aAC7B,GAAG,CAAC,qBAAqB,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,KAAK,CAAC,CAAC;aACjD,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;aACvD,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QAC1B,OAAO,UAAU,CAAC;IACpB,CAAC;IAEO,iBAAiB,CAAC,KAAa;QACrC,OAAO,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;IACpD,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,yBAAyB,CACpC,KAAa,EACb,kBAA2B;QAE3B,MAAM,QAAQ,GAAG,CAAC,kBAAkB;YAClC,CAAC,CAAC,MAAM,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC;YACjC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;QACvE,OAAO,QAAQ,IAAI,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,aAAa,CAAC,KAAa,EAAE,kBAA2B;QACnE,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAChD,IAAI,KAAK,GAAG,MAAM,IAAI,CAAC,EAAE;aACtB,GAAG,CAAC,sBAAsB,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;aAC1D,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;aAC9B,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QAE1B,IAAI,kBAAkB,IAAI,KAAK,KAAK,SAAS,EAAE;YAC7C,MAAM,WAAW,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;YAC3D,KAAK,GAAG,WAAW,CAAC;SACrB;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;;;;;;;OAaG;IACI,KAAK,CAAC,IAAI,CAAC,aAAqB;QACrC,IAAI,aAAa,GAAG,CAAC,EAAE;YACrB,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;SACvD;QAED,MAAM,MAAM,GAA8B,EAAE,CAAC;QAC7C,KAAK,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,aAAa,EAAE,CAAC,EAAE,EAAE;YACvC,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAC/C,MAAM,eAAe,GAAG,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;YACnF,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;SAC9B;QAED,6CAA6C;QAC7C,MAAM,CAAC,aAAa,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,MAAM,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QAE1G,MAAM,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAC/C,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;IACtB,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,YAAY;QACxB,MAAM,KAAK,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC;QAC9B,MAAM,IAAI,GAAG,MAAM,CAAC,mBAAmB,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QAClE,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;YACtB,MAAM,IAAI,GAAG,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC;YAC3C,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YAC1B,KAAK,CAAC,GAAG,CAAC,qBAAqB,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,KAAK,CAAC,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;YACzE,KAAK,CAAC,GAAG,CAAC,sBAAsB,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,UAAU,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC;SACzF;QACD,MAAM,KAAK,CAAC,KAAK,EAAE,CAAC;QACpB,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3B,CAAC;IAED;;OAEG;IACK,iBAAiB;QACvB,IAAI,CAAC,mBAAmB,GAAG,EAAE,CAAC;IAChC,CAAC;IAED;;;;OAIG;IACO,KAAK,CAAC,UAAU,CAAC,QAAiC,EAAE,KAAa;QACzE,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE;YACzB,MAAM,KAAK,CAAC,8BAA8B,KAAK,gBAAgB,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;SAClF;QAED,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,GAAG,QAAQ,CAAC;QACtD,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QACpD,MAAM,IAAI,CAAC,2BAA2B,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;QAC3D,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAC1C,IAAI,KAAK,IAAI,SAAS,EAAE;YACtB,IAAI,CAAC,UAAU,GAAG,KAAK,GAAG,EAAE,CAAC;SAC9B;IACH,CAAC;IAED,gEAAgE;IAChE,qFAAqF;IAErF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwGG;IACI,KAAK,CAAC,WAAW,CAKtB,MAAgB,EAChB,aAA4B;QAE5B,MAAM,mBAAmB,GAAG,sBAAsB,CAAC,IAAI,CAAC,QAAQ,EAAgB,EAAE,IAAI,CAAC,mBAAmB,CAAC,CAAC;QAC5G,eAAe;QACf,MAAM,kBAAkB,GAAqC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,mBAAmB,CAAC,CAAC;QACnG,MAAM,uBAAuB,GAA8B,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,CAAC,CAAC;QAE9G,aAAa;QACb,MAAM,mBAAmB,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAEpD,MAAM,cAAc,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;QAC7E,MAAM,0BAA0B,GAAG,cAAc;aAC9C,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;aACvC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;QAC7D,MAAM,sBAAsB,GAAG,0BAA0B,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAE3F,mCAAmC;QACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,cAAc,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC9C,MAAM,OAAO,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC;YAC1C,MAAM,aAAa,GAAG,cAAc,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YAEtD,IAAI,OAAO,CAAC,OAAO,EAAE,EAAE;gBACrB,SAAS;aACV;YAED,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,IAAI,CAAC,CAAC;YAClF,IAAI,eAAe,KAAK,SAAS,EAAE;gBACjC,OAAO;oBACL,oBAAoB,EAAE,SAAS;oBAC/B,eAAe,EAAE,0BAA0B,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;oBACvF,sBAAsB,EAAE,0BAA0B,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC;oBACpF,qBAAqB,EAAE,MAAM,IAAI,CAAC,qBAAqB,CAAC,aAAa,EAAE,IAAI,CAAC;iBAC7E,CAAC;aACH;YAED,wDAAwD;YACxD,MAAM,eAAe,GAAG,CAAC,MAAM,IAAI,CAAC,yBAAyB,CAAC,eAAe,CAAC,KAAK,EAAE,IAAI,CAAC,CAAE,CAAC;YAC7F,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,cAAc,CAAa,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC;YAE/F,MAAM,OAAO,GAAmC;gBAC9C,YAAY,EAAE,eAAe;gBAC7B,KAAK,EAAE,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC;gBACpC,WAAW;aACZ,CAAC;YAEF,2BAA2B;YAC3B,kBAAkB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;YAEhC,MAAM,0BAA0B,GAAG,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAClE,OAAO,EACP,eAAe,CAAC,UAAU,EAAE,EAC5B,eAAe,CAAC,YAAY,EAAE,CAC/B,CAAC;YAEF,uBAAuB,CAAC,aAAa,CAAC,GAAG,0BAA0B,CAAC;YAEpE,MAAM,kBAAkB,GAAG,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAC1D,eAAe,CAAC,MAAM,EAAE,EACxB,OAAO,CAAC,MAAM,EAAE,EAChB,mBAAmB,GAAG,MAAM,CAAC,aAAa,CAAC,CAC5C,CAAC;YAEF,MAAM,YAAY,GAAG,eAAe,CAAC,KAAK,CAAC;YAC3C,IAAI,CAAC,mBAAmB,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC,GAAG,kBAAkB,CAAC;YACvE,MAAM,IAAI,CAAC,UAAU,CAAC,kBAAkB,EAAE,YAAY,CAAC,CAAC;SACzD;QAED,MAAM,qBAAqB,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAC5D,aAAa,EACb,IAAI,CACL,CAAC;QAEF,gDAAgD;QAChD,8GAA8G;QAC9G,2EAA2E;QAC3E,MAAM,IAAI,CAAC,qBAAqB,CAAC,uBAAuB,EAAE,KAAK,CAAC,CAAC;QAEjE,OAAO;YACL,oBAAoB,EAAE,kBAAkB;YACxC,eAAe,EAAE,0BAA0B,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACvF,sBAAsB,EAAE,0BAA0B,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC;YACpF,qBAAqB;SACtB,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,qBAAqB,CACzB,aAA4B,EAC5B,kBAA2B;QAE3B,MAAM,sBAAsB,GAAG,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,CAAC;QACrE,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,sBAAsB,EAAE,kBAAkB,CAAC,CAAC;QAE9F,2FAA2F;QAC3F,OAAO,eAAe,CAAC,qBAAqB,CAAC,aAAa,CAAC,CAAC;IAC9D,CAAC;IAED,QAAQ,CAAC,WAAmB;QAC1B,OAAO,uBAAA,IAAI,4CAAiB,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;IACrD,CAAC;IAED,WAAW,CAAC,KAAa;QACvB,OAAO,uBAAA,IAAI,4CAAiB,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IAClD,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,qBAAqB,CAAC,SAAoC,EAAE,SAAkB;QAC1F,MAAM,mBAAmB,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAEpD,MAAM,YAAY,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,CAAC,EAAE,EAAE;YACjD,IAAI,CAAC,mBAAmB,CAAC,CAAC,mBAAmB,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,GAAG,QAAQ,CAAC;YAClF,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;QAEH,MAAM,KAAK,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;IACzC,CAAC;IAED;;;;;;;OAOG;IACK,UAAU,CAAC,IAA6B,EAAE,SAAkB;QAClE,IAAI,WAAW,CAAC;QAChB,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE;YACrC,WAAW,GAAG,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;SAClC;aAAM;YACL,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC;SAC3D;QACD,OAAO,WAAW,CAAC;IACrB,CAAC;CACF"}