@aztec-labs/foundation 6.0.0-nightly.20260829

package/dest/trees/sibling_path.d.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { Fr } from '../curves/bn254/index.js';
+import { type Tuple } from '../serialize/index.js';
+import type { Hasher } from './hasher.js';
+/**
+ * Upper bound on the elements a serialized sibling path may declare. The deepest protocol tree is 42 levels,
+ * and the stacked path proving L2-to-L1 message inclusion spans four unbalanced trees, so this leaves room to
+ * spare while keeping a malformed length prefix from driving a large allocation. `stdlib` asserts that it stays
+ * above every protocol tree height, which this package cannot check itself without depending on `@aztec-labs/constants`.
+ */
+export declare const MAX_SIBLING_PATH_LENGTH = 128;
+/**
+ * Contains functionality to compute and serialize/deserialize a sibling path.
+ * E.g. Sibling path for a leaf at index 3 in a tree of depth 3 consists of:
+ *      d0:                                            [ root ]
+ *      d1:                      [ ]                                               [*]
+ *      d2:         [*]                      [ ]                       [ ]                     [ ]
+ *      d3:   [ ]         [ ]          [*]         [ ]           [ ]         [ ]          [ ]        [ ].
+ *
+ *      And the elements would be ordered as: [ leaf_at_index_2, node_at_level_2_index_0, node_at_level_1_index_1 ].
+ */
+export declare class SiblingPath<N extends number> {
+    /** Size of the sibling path (number of fields it contains). */
+    pathSize: N;
+    private data;
+    /**
+     * Constructor.
+     * @param pathSize - The size of the sibling path.
+     * @param path - The sibling path data.
+     */
+    constructor(
+    /** Size of the sibling path (number of fields it contains). */
+    pathSize: N, 
+    /** The sibling path data. */
+    path: Buffer[]);
+    static get schema(): z.ZodPipe<import("../schemas/types.js").ZodFor<Buffer<ArrayBufferLike>>, z.ZodTransform<SiblingPath<number>, Buffer<ArrayBufferLike>>>;
+    static schemaFor<N extends number>(size: N): z.ZodPipe<import("../schemas/types.js").ZodFor<Buffer<ArrayBufferLike>>, z.ZodTransform<SiblingPath<N>, Buffer<ArrayBufferLike>>>;
+    toJSON(): Buffer<ArrayBufferLike>;
+    /**
+     * Returns sibling path hashed up from the a element.
+     * @param size - The number of elements in a given path.
+     * @param zeroElement - Value of the zero element.
+     * @param hasher - Implementation of a hasher interface.
+     * @returns A sibling path hashed up from a zero element.
+     */
+    static ZERO<N extends number>(size: N, zeroElement: Buffer, hasher: Hasher): SiblingPath<N>;
+    static random<N extends number>(number: N): SiblingPath<N>;
+    /**
+     * Serializes this SiblingPath object to a buffer.
+     * @returns The buffer representation of this object.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Returns the path buffer underlying the sibling path.
+     * @returns The Buffer array representation of this object.
+     */
+    toBufferArray(): Buffer[];
+    /**
+     * Convert the Sibling Path object into an array of field elements.
+     * @returns The field array representation of this object.
+     */
+    toFields(): Fr[];
+    /**
+     * Convert Sibling Path object into a tuple of field elements.
+     * @returns A tuple representation of the sibling path.
+     */
+    toTuple(): Tuple<Fr, N>;
+    /**
+     * Deserializes a SiblingPath from a buffer.
+     * @param buf - A buffer containing the buffer representation of SiblingPath.
+     * @param offset - An offset to start deserializing from.
+     * @returns A SiblingPath object.
+     * @throws If the length prefix exceeds MAX_SIBLING_PATH_LENGTH or the buffer holds fewer elements than it declares.
+     */
+    static fromBuffer<N extends number>(buf: Buffer, offset?: number): SiblingPath<N>;
+    /**
+     * Serializes this SiblingPath object to a hex string representation.
+     * @returns A hex string representation of the sibling path.
+     */
+    toString(): string;
+    /**
+     * Deserializes a SiblingPath object from a hex string representation.
+     * @param repr - A hex string representation of the sibling path.
+     * @returns A SiblingPath object.
+     */
+    static fromString<N extends number>(repr: string): SiblingPath<N>;
+    /**
+     * Generate a subtree path from the current sibling path.
+     * @param subtreeHeight - The size of the subtree that we are getting the path for.
+     * @returns A new sibling path that is the for the requested subtree.
+     */
+    getSubtreeSiblingPath<SubtreeHeight extends number, SubtreeSiblingPathHeight extends number>(subtreeHeight: SubtreeHeight): SiblingPath<SubtreeSiblingPathHeight>;
+}
+/** Computes the expected root of a merkle tree given a leaf and its sibling path. */
+export declare function computeRootFromSiblingPath(leaf: Buffer, siblingPath: Buffer[], index: number, hasher: (left: Buffer, right: Buffer) => Promise<Buffer>): Promise<Buffer<ArrayBufferLike>>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2libGluZ19wYXRoLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJlZXMvc2libGluZ19wYXRoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFHeEIsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRTlDLE9BQU8sRUFBZ0IsS0FBSyxLQUFLLEVBQW9ELE1BQU0sdUJBQXVCLENBQUM7QUFFbkgsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRTFDOzs7OztHQUtHO0FBQ0gsZUFBTyxNQUFNLHVCQUF1QixNQUFNLENBQUM7QUFFM0M7Ozs7Ozs7OztHQVNHO0FBQ0gscUJBQWEsV0FBVyxDQUFDLENBQUMsU0FBUyxNQUFNO0lBU3JDLCtEQUErRDtJQUN4RCxRQUFRLEVBQUUsQ0FBQztJQVRwQixPQUFPLENBQUMsSUFBSSxDQUFtQjtJQUUvQjs7OztPQUlHO0lBQ0g7SUFDRSwrREFBK0Q7SUFDeEQsUUFBUSxFQUFFLENBQUM7SUFDbEIsNkJBQTZCO0lBQzdCLElBQUksRUFBRSxNQUFNLEVBQUUsRUFHZjtJQUVELE1BQU0sS0FBSyxNQUFNLDJJQUVoQjtJQUVELE1BQU0sQ0FBQyxTQUFTLENBQUMsQ0FBQyxTQUFTLE1BQU0sRUFBRSxJQUFJLEVBQUUsQ0FBQyxxSUFTekM7SUFFRCxNQUFNLDRCQUVMO0lBRUQ7Ozs7OztPQU1HO0lBQ0gsT0FBYyxJQUFJLENBQUMsQ0FBQyxTQUFTLE1BQU0sRUFBRSxJQUFJLEVBQUUsQ0FBQyxFQUFFLFdBQVcsRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLE1BQU0sR0FBRyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBUWpHO0lBRUQsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLFNBQVMsTUFBTSxFQUFFLE1BQU0sRUFBRSxDQUFDLGtCQUd4QztJQUVEOzs7T0FHRztJQUNJLFFBQVEsSUFBSSxNQUFNLENBRXhCO0lBRUQ7OztPQUdHO0lBQ0ksYUFBYSxJQUFJLE1BQU0sRUFBRSxDQUUvQjtJQUVEOzs7T0FHRztJQUNJLFFBQVEsSUFBSSxFQUFFLEVBQUUsQ0FFdEI7SUFFRDs7O09BR0c7SUFDSSxPQUFPLElBQUksS0FBSyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FHN0I7SUFFRDs7Ozs7O09BTUc7SUFDSCxNQUFNLENBQUMsVUFBVSxDQUFDLENBQUMsU0FBUyxNQUFNLEVBQUUsR0FBRyxFQUFFLE1BQU0sRUFBRSxNQUFNLFNBQUksR0FBRyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBSTNFO0lBRUQ7OztPQUdHO0lBQ0ksUUFBUSxJQUFJLE1BQU0sQ0FFeEI7SUFFRDs7OztPQUlHO0lBQ0gsT0FBYyxVQUFVLENBQUMsQ0FBQyxTQUFTLE1BQU0sRUFBRSxJQUFJLEVBQUUsTUFBTSxHQUFHLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FFdkU7SUFFRDs7OztPQUlHO0lBQ0kscUJBQXFCLENBQUMsYUFBYSxTQUFTLE1BQU0sRUFBRSx3QkFBd0IsU0FBUyxNQUFNLEVBQ2hHLGFBQWEsRUFBRSxhQUFhLEdBQzNCLFdBQVcsQ0FBQyx3QkFBd0IsQ0FBQyxDQUt2QztDQUNGO0FBRUQscUZBQXFGO0FBQ3JGLHdCQUFzQiwwQkFBMEIsQ0FDOUMsSUFBSSxFQUFFLE1BQU0sRUFDWixXQUFXLEVBQUUsTUFBTSxFQUFFLEVBQ3JCLEtBQUssRUFBRSxNQUFNLEVBQ2IsTUFBTSxFQUFFLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsTUFBTSxLQUFLLE9BQU8sQ0FBQyxNQUFNLENBQUMsb0NBUXpEIn0=

package/dest/trees/sibling_path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sibling_path.d.ts","sourceRoot":"","sources":["../../src/trees/sibling_path.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAgB,KAAK,KAAK,EAAoD,MAAM,uBAAuB,CAAC;AAEnH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C;;;;;;;;;GASG;AACH,qBAAa,WAAW,CAAC,CAAC,SAAS,MAAM;IASrC,+DAA+D;IACxD,QAAQ,EAAE,CAAC;IATpB,OAAO,CAAC,IAAI,CAAmB;IAE/B;;;;OAIG;IACH;IACE,+DAA+D;IACxD,QAAQ,EAAE,CAAC;IAClB,6BAA6B;IAC7B,IAAI,EAAE,MAAM,EAAE,EAGf;IAED,MAAM,KAAK,MAAM,2IAEhB;IAED,MAAM,CAAC,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC,qIASzC;IAED,MAAM,4BAEL;IAED;;;;;;OAMG;IACH,OAAc,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAQjG;IAED,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,kBAGxC;IAED;;;OAGG;IACI,QAAQ,IAAI,MAAM,CAExB;IAED;;;OAGG;IACI,aAAa,IAAI,MAAM,EAAE,CAE/B;IAED;;;OAGG;IACI,QAAQ,IAAI,EAAE,EAAE,CAEtB;IAED;;;OAGG;IACI,OAAO,IAAI,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,CAG7B;IAED;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,WAAW,CAAC,CAAC,CAAC,CAI3E;IAED;;;OAGG;IACI,QAAQ,IAAI,MAAM,CAExB;IAED;;;;OAIG;IACH,OAAc,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAEvE;IAED;;;;OAIG;IACI,qBAAqB,CAAC,aAAa,SAAS,MAAM,EAAE,wBAAwB,SAAS,MAAM,EAChG,aAAa,EAAE,aAAa,GAC3B,WAAW,CAAC,wBAAwB,CAAC,CAKvC;CACF;AAED,qFAAqF;AACrF,wBAAsB,0BAA0B,CAC9C,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EAAE,EACrB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,oCAQzD"}

package/dest/trees/sibling_path.js

@@ -0,0 +1,139 @@
+import { z } from 'zod';
+import { makeTuple } from '../array/array.js';
+import { Fr } from '../curves/bn254/index.js';
+import { schemas } from '../schemas/index.js';
+import { BufferReader, assertLength, serializeArrayOfBufferableToVector } from '../serialize/index.js';
+import { bufferToHex, hexToBuffer } from '../string/index.js';
+/**
+ * Upper bound on the elements a serialized sibling path may declare. The deepest protocol tree is 42 levels,
+ * and the stacked path proving L2-to-L1 message inclusion spans four unbalanced trees, so this leaves room to
+ * spare while keeping a malformed length prefix from driving a large allocation. `stdlib` asserts that it stays
+ * above every protocol tree height, which this package cannot check itself without depending on `@aztec-labs/constants`.
+ */ export const MAX_SIBLING_PATH_LENGTH = 128;
+/**
+ * Contains functionality to compute and serialize/deserialize a sibling path.
+ * E.g. Sibling path for a leaf at index 3 in a tree of depth 3 consists of:
+ *      d0:                                            [ root ]
+ *      d1:                      [ ]                                               [*]
+ *      d2:         [*]                      [ ]                       [ ]                     [ ]
+ *      d3:   [ ]         [ ]          [*]         [ ]           [ ]         [ ]          [ ]        [ ].
+ *
+ *      And the elements would be ordered as: [ leaf_at_index_2, node_at_level_2_index_0, node_at_level_1_index_1 ].
+ */ export class SiblingPath {
+    pathSize;
+    data;
+    /**
+   * Constructor.
+   * @param pathSize - The size of the sibling path.
+   * @param path - The sibling path data.
+   */ constructor(/** Size of the sibling path (number of fields it contains). */ pathSize, /** The sibling path data. */ path){
+        this.pathSize = pathSize;
+        this.data = assertLength(path, pathSize);
+    }
+    static get schema() {
+        return schemas.Buffer.transform((b)=>SiblingPath.fromBuffer(b));
+    }
+    static schemaFor(size) {
+        return schemas.Buffer.transform((b)=>SiblingPath.fromBuffer(b)).superRefine((path, ctx)=>{
+            if (path.pathSize !== size) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `Expected sibling path size ${size} but got ${path.pathSize}`
+                });
+            }
+        });
+    }
+    toJSON() {
+        return this.toBuffer();
+    }
+    /**
+   * Returns sibling path hashed up from the a element.
+   * @param size - The number of elements in a given path.
+   * @param zeroElement - Value of the zero element.
+   * @param hasher - Implementation of a hasher interface.
+   * @returns A sibling path hashed up from a zero element.
+   */ static ZERO(size, zeroElement, hasher) {
+        const bufs = [];
+        let current = zeroElement;
+        for(let i = 0; i < size; ++i){
+            bufs.push(current);
+            current = hasher.hash(current, current);
+        }
+        return new SiblingPath(size, bufs);
+    }
+    static random(number) {
+        const data = Array.from({
+            length: number
+        }, ()=>Fr.random().toBuffer());
+        return new SiblingPath(number, data);
+    }
+    /**
+   * Serializes this SiblingPath object to a buffer.
+   * @returns The buffer representation of this object.
+   */ toBuffer() {
+        return serializeArrayOfBufferableToVector(this.data);
+    }
+    /**
+   * Returns the path buffer underlying the sibling path.
+   * @returns The Buffer array representation of this object.
+   */ toBufferArray() {
+        return this.data;
+    }
+    /**
+   * Convert the Sibling Path object into an array of field elements.
+   * @returns The field array representation of this object.
+   */ toFields() {
+        return this.data.map((buf)=>Fr.fromBuffer(buf));
+    }
+    /**
+   * Convert Sibling Path object into a tuple of field elements.
+   * @returns A tuple representation of the sibling path.
+   */ toTuple() {
+        const array = this.toFields();
+        return makeTuple(array.length, (i)=>array[i], 0);
+    }
+    /**
+   * Deserializes a SiblingPath from a buffer.
+   * @param buf - A buffer containing the buffer representation of SiblingPath.
+   * @param offset - An offset to start deserializing from.
+   * @returns A SiblingPath object.
+   * @throws If the length prefix exceeds MAX_SIBLING_PATH_LENGTH or the buffer holds fewer elements than it declares.
+   */ static fromBuffer(buf, offset = 0) {
+        const reader = new BufferReader(buf, offset);
+        const path = reader.readVector({
+            fromBuffer: (r)=>r.readBytes(Fr.SIZE_IN_BYTES)
+        }, MAX_SIBLING_PATH_LENGTH);
+        return new SiblingPath(path.length, path);
+    }
+    /**
+   * Serializes this SiblingPath object to a hex string representation.
+   * @returns A hex string representation of the sibling path.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    /**
+   * Deserializes a SiblingPath object from a hex string representation.
+   * @param repr - A hex string representation of the sibling path.
+   * @returns A SiblingPath object.
+   */ static fromString(repr) {
+        return SiblingPath.fromBuffer(hexToBuffer(repr));
+    }
+    /**
+   * Generate a subtree path from the current sibling path.
+   * @param subtreeHeight - The size of the subtree that we are getting the path for.
+   * @returns A new sibling path that is the for the requested subtree.
+   */ getSubtreeSiblingPath(subtreeHeight) {
+        // Drop the size of the subtree from the path, and return the rest.
+        const subtreeData = this.data.slice(subtreeHeight);
+        const subtreePathSize = this.pathSize - subtreeHeight;
+        return new SiblingPath(subtreePathSize, subtreeData);
+    }
+}
+/** Computes the expected root of a merkle tree given a leaf and its sibling path. */ export async function computeRootFromSiblingPath(leaf, siblingPath, index, hasher) {
+    let result = leaf;
+    for (const sibling of siblingPath){
+        result = index & 1 ? await hasher(sibling, result) : await hasher(result, sibling);
+        index >>= 1;
+    }
+    return result;
+}

package/dest/trees/unbalanced_merkle_tree_calculator.d.ts

@@ -0,0 +1,48 @@
+import { type Hasher } from './hasher.js';
+import { SiblingPath } from './sibling_path.js';
+import { type TreeNodeLocation } from './unbalanced_tree_store.js';
+/**
+ * An ephemeral unbalanced Merkle tree implementation.
+ * Follows the rollup implementation which greedily hashes pairs of nodes up the tree.
+ * Remaining rightmost nodes are shifted up until they can be paired.
+ * The values that match the `valueToCompress` are skipped and the sibling of the compressed leaf are shifted up until
+ * they can be paired.
+ * If there is only one leaf, the root is the leaf.
+ */
+export declare class UnbalancedMerkleTreeCalculator {
+    private readonly leaves;
+    private readonly valueToCompress;
+    private readonly emptyRoot;
+    private readonly hasher;
+    private store;
+    private leafLocations;
+    constructor(leaves: Buffer[], valueToCompress: Buffer, emptyRoot: Buffer, hasher: Hasher['hash']);
+    static create(leaves: Buffer[], valueToCompress?: Buffer<ArrayBuffer>, emptyRoot?: Buffer<ArrayBuffer>, hasher?: (lhs: Uint8Array<ArrayBufferLike>, rhs: Uint8Array<ArrayBufferLike>) => Buffer<ArrayBuffer>): UnbalancedMerkleTreeCalculator;
+    /**
+     * Returns the root of the tree.
+     * @returns The root of the tree.
+     */
+    getRoot(): Buffer;
+    /**
+     * Returns a sibling path for the element.
+     * @param value - The value of the element.
+     * @returns A sibling path for the element.
+     * Note: The sibling path is an array of sibling hashes, with the lowest hash (leaf hash) first, and the highest hash last.
+     */
+    getSiblingPath<N extends number>(value: Buffer): SiblingPath<N>;
+    /**
+     * Returns a sibling path for the leaf at the given index.
+     * @param leafIndex - The index of the leaf.
+     * @returns A sibling path for the leaf.
+     */
+    getSiblingPathByLeafIndex<N extends number>(leafIndex: number): SiblingPath<N>;
+    getLeafLocation(leafIndex: number): TreeNodeLocation;
+    /**
+     * Adds leaves and nodes to the store. Updates the leafLocations.
+     * @param leaves - The leaves of the tree.
+     */
+    private buildTree;
+    private shiftNodeUp;
+    private collectNodesToShift;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5iYWxhbmNlZF9tZXJrbGVfdHJlZV9jYWxjdWxhdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJlZXMvdW5iYWxhbmNlZF9tZXJrbGVfdHJlZV9jYWxjdWxhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBaUIsTUFBTSxhQUFhLENBQUM7QUFDekQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ2hELE9BQU8sRUFBRSxLQUFLLGdCQUFnQixFQUF1QixNQUFNLDRCQUE0QixDQUFDO0FBT3hGOzs7Ozs7O0dBT0c7QUFDSCxxQkFBYSw4QkFBOEI7SUFLdkMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxNQUFNO0lBQ3ZCLE9BQU8sQ0FBQyxRQUFRLENBQUMsZUFBZTtJQUNoQyxPQUFPLENBQUMsUUFBUSxDQUFDLFNBQVM7SUFDMUIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxNQUFNO0lBUHpCLE9BQU8sQ0FBQyxLQUFLLENBQWdDO0lBQzdDLE9BQU8sQ0FBQyxhQUFhLENBQTBCO0lBRS9DLFlBQ21CLE1BQU0sRUFBRSxNQUFNLEVBQUUsRUFDaEIsZUFBZSxFQUFFLE1BQU0sRUFDdkIsU0FBUyxFQUFFLE1BQU0sRUFDakIsTUFBTSxFQUFFLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFJeEM7SUFFRCxNQUFNLENBQUMsTUFBTSxDQUNYLE1BQU0sRUFBRSxNQUFNLEVBQUUsRUFDaEIsZUFBZSxzQkFBa0IsRUFDakMsU0FBUyxzQkFBbUIsRUFDNUIsTUFBTSw4RkFBZ0Isa0NBR3ZCO0lBRUQ7OztPQUdHO0lBQ0ksT0FBTyxJQUFJLE1BQU0sQ0FFdkI7SUFFRDs7Ozs7T0FLRztJQUNJLGNBQWMsQ0FBQyxDQUFDLFNBQVMsTUFBTSxFQUFFLEtBQUssRUFBRSxNQUFNLEdBQUcsV0FBVyxDQUFDLENBQUMsQ0FBQyxDQU9yRTtJQUVEOzs7O09BSUc7SUFDSSx5QkFBeUIsQ0FBQyxDQUFDLFNBQVMsTUFBTSxFQUFFLFNBQVMsRUFBRSxNQUFNLEdBQUcsV0FBVyxDQUFDLENBQUMsQ0FBQyxDQW1CcEY7SUFFTSxlQUFlLENBQUMsU0FBUyxFQUFFLE1BQU0sb0JBRXZDO0lBRUQ7OztPQUdHO0lBQ0gsT0FBTyxDQUFDLFNBQVM7SUErQ2pCLE9BQU8sQ0FBQyxXQUFXO0lBWW5CLE9BQU8sQ0FBQyxtQkFBbUI7Q0FtQjVCIn0=

package/dest/trees/unbalanced_merkle_tree_calculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unbalanced_merkle_tree_calculator.d.ts","sourceRoot":"","sources":["../../src/trees/unbalanced_merkle_tree_calculator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAiB,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,KAAK,gBAAgB,EAAuB,MAAM,4BAA4B,CAAC;AAOxF;;;;;;;GAOG;AACH,qBAAa,8BAA8B;IAKvC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAPzB,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,aAAa,CAA0B;IAE/C,YACmB,MAAM,EAAE,MAAM,EAAE,EAChB,eAAe,EAAE,MAAM,EACvB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAIxC;IAED,MAAM,CAAC,MAAM,CACX,MAAM,EAAE,MAAM,EAAE,EAChB,eAAe,sBAAkB,EACjC,SAAS,sBAAmB,EAC5B,MAAM,8FAAgB,kCAGvB;IAED;;;OAGG;IACI,OAAO,IAAI,MAAM,CAEvB;IAED;;;;;OAKG;IACI,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAOrE;IAED;;;;OAIG;IACI,yBAAyB,CAAC,CAAC,SAAS,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAmBpF;IAEM,eAAe,CAAC,SAAS,EAAE,MAAM,oBAEvC;IAED;;;OAGG;IACH,OAAO,CAAC,SAAS;IA+CjB,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,mBAAmB;CAmB5B"}

package/dest/trees/unbalanced_merkle_tree_calculator.js

@@ -0,0 +1,154 @@
+import { shaMerkleHash } from './hasher.js';
+import { SiblingPath } from './sibling_path.js';
+import { UnbalancedTreeStore } from './unbalanced_tree_store.js';
+/**
+ * An ephemeral unbalanced Merkle tree implementation.
+ * Follows the rollup implementation which greedily hashes pairs of nodes up the tree.
+ * Remaining rightmost nodes are shifted up until they can be paired.
+ * The values that match the `valueToCompress` are skipped and the sibling of the compressed leaf are shifted up until
+ * they can be paired.
+ * If there is only one leaf, the root is the leaf.
+ */ export class UnbalancedMerkleTreeCalculator {
+    leaves;
+    valueToCompress;
+    emptyRoot;
+    hasher;
+    store;
+    leafLocations;
+    constructor(leaves, valueToCompress, emptyRoot, hasher){
+        this.leaves = leaves;
+        this.valueToCompress = valueToCompress;
+        this.emptyRoot = emptyRoot;
+        this.hasher = hasher;
+        this.leafLocations = [];
+        this.store = new UnbalancedTreeStore(leaves.length);
+        this.buildTree();
+    }
+    static create(leaves, valueToCompress = Buffer.alloc(0), emptyRoot = Buffer.alloc(32), hasher = shaMerkleHash) {
+        return new UnbalancedMerkleTreeCalculator(leaves, valueToCompress, emptyRoot, hasher);
+    }
+    /**
+   * Returns the root of the tree.
+   * @returns The root of the tree.
+   */ getRoot() {
+        return this.store.getRoot().value;
+    }
+    /**
+   * Returns a sibling path for the element.
+   * @param value - The value of the element.
+   * @returns A sibling path for the element.
+   * Note: The sibling path is an array of sibling hashes, with the lowest hash (leaf hash) first, and the highest hash last.
+   */ getSiblingPath(value) {
+        const leafIndex = this.leaves.findIndex((leaf)=>leaf.equals(value));
+        if (leafIndex === -1) {
+            throw Error(`Leaf value ${value.toString('hex')} not found in tree.`);
+        }
+        return this.getSiblingPathByLeafIndex(leafIndex);
+    }
+    /**
+   * Returns a sibling path for the leaf at the given index.
+   * @param leafIndex - The index of the leaf.
+   * @returns A sibling path for the leaf.
+   */ getSiblingPathByLeafIndex(leafIndex) {
+        if (leafIndex >= this.leaves.length) {
+            throw Error(`Leaf index ${leafIndex} out of bounds. Tree has ${this.leaves.length} leaves.`);
+        }
+        const leaf = this.leaves[leafIndex];
+        if (leaf.equals(this.valueToCompress)) {
+            throw Error(`Leaf at index ${leafIndex} has been compressed.`);
+        }
+        const path = [];
+        let location = this.leafLocations[leafIndex];
+        while(location.level > 0){
+            const sibling = this.store.getSibling(location);
+            path.push(sibling.value);
+            location = this.store.getParentLocation(location);
+        }
+        return new SiblingPath(path.length, path);
+    }
+    getLeafLocation(leafIndex) {
+        return this.leafLocations[leafIndex];
+    }
+    /**
+   * Adds leaves and nodes to the store. Updates the leafLocations.
+   * @param leaves - The leaves of the tree.
+   */ buildTree() {
+        this.leafLocations = this.leaves.map((value, i)=>this.store.setLeaf(i, {
+                value,
+                leafIndex: i
+            }));
+        // Start with the leaves that are not compressed.
+        let toProcess = this.leafLocations.filter((_, i)=>!this.leaves[i].equals(this.valueToCompress));
+        if (!toProcess.length) {
+            // All leaves are compressed. Set empty root to the root.
+            this.store.setNode({
+                level: 0,
+                index: 0
+            }, {
+                value: this.emptyRoot
+            });
+            return;
+        }
+        const level = toProcess[0].level;
+        for(let i = level; i > 0; i--){
+            const toProcessNext = [];
+            for (const location of toProcess){
+                if (location.level !== i) {
+                    toProcessNext.push(location);
+                    continue;
+                }
+                const parentLocation = this.store.getParentLocation(location);
+                if (this.store.getNode(parentLocation)) {
+                    continue;
+                }
+                const sibling = this.store.getSibling(location);
+                // If sibling is undefined, all its children are compressed.
+                const shouldShiftUp = !sibling || sibling.value.equals(this.valueToCompress);
+                if (shouldShiftUp) {
+                    // The node becomes the parent if the sibling is a compressed leaf.
+                    this.shiftNodeUp(location, parentLocation);
+                } else {
+                    // Hash the value with the (right) sibling and update the parent node.
+                    const node = this.store.getNode(location);
+                    const parentValue = this.hasher(node.value, sibling.value);
+                    this.store.setNode(parentLocation, {
+                        value: parentValue
+                    });
+                }
+                // Add the parent location to be processed next.
+                toProcessNext.push(parentLocation);
+            }
+            toProcess = toProcessNext;
+        }
+    }
+    shiftNodeUp(from, to) {
+        // Collect all nodes that need to shift.
+        const nodesToShift = this.collectNodesToShift(from, to);
+        // Move all nodes to their new locations.
+        for (const { node, newLocation } of nodesToShift){
+            this.store.setNode(newLocation, node);
+            if (node.leafIndex !== undefined) {
+                this.leafLocations[node.leafIndex] = newLocation;
+            }
+        }
+    }
+    collectNodesToShift(from, to) {
+        const node = this.store.getNode(from);
+        if (!node) {
+            return [];
+        }
+        let result = [
+            {
+                node,
+                newLocation: to
+            }
+        ];
+        // If not a leaf, collect its children.
+        if (node.leafIndex === undefined) {
+            const [leftChild, rightChild] = this.store.getChildLocations(from);
+            const [leftChildNew, rightChildNew] = this.store.getChildLocations(to);
+            result = result.concat(this.collectNodesToShift(leftChild, leftChildNew)).concat(this.collectNodesToShift(rightChild, rightChildNew));
+        }
+        return result;
+    }
+}

package/dest/trees/unbalanced_merkle_tree_root.d.ts

@@ -0,0 +1,27 @@
+export declare const computeUnbalancedShaRoot: (leaves: Buffer<ArrayBufferLike>[]) => Buffer<ArrayBufferLike>;
+export declare const computeWonkyShaRoot: (leaves: Buffer<ArrayBufferLike>[]) => Buffer<ArrayBufferLike>;
+/**
+ * Computes the Merkle root of an unbalanced tree.
+ *
+ * Unlike a balanced Merkle tree, which requires the number of leaves to be a power of two, an unbalanced tree can have
+ * any number of leaves.
+ *
+ * The tree is constructed by iteratively extracting the smallest power-of-two-sized subtrees from **right to left**.
+ * For each such subtree, it computes the subtree root and then combines all subtree roots (again from right to left)
+ * into a single root using the provided hash function.
+ *
+ * Note: We need the final tree to be as shallow as possible, to minimize the size of the sibling path required to prove
+ * membership of a leaf. Therefor, the computation proceeds from right to left - smaller subtrees must always be
+ * combined before being merged with a larger sibling on their left.
+ *
+ * For example, consider an unbalanced tree made of three subtrees of sizes 2, 4, and 8. If we combine the size-2 and
+ * size-4 subtrees first (producing a subtree of depth 3), and then merge it with the size-8 subtree (also depth 3), the
+ * resulting tree has a maximum depth of 4.
+ *
+ * But if we instead combine the size-4 and size-8 subtrees first (depth 4), and then merge with the size-2 subtree
+ * (depth 1), the final tree has a depth of 5.
+ */
+export declare function computeUnbalancedMerkleTreeRoot(leaves: Buffer[], hasher?: (lhs: Uint8Array<ArrayBufferLike>, rhs: Uint8Array<ArrayBufferLike>) => Buffer<ArrayBuffer>, emptyRoot?: Buffer<ArrayBuffer>): Buffer;
+export declare function computeUnbalancedMerkleTreeRootAsync(leaves: Buffer[], hasher: (left: Uint8Array, right: Uint8Array) => Promise<Buffer<ArrayBuffer>>, emptyRoot?: Buffer<ArrayBuffer>): Promise<Buffer>;
+export declare function computeWonkyMerkleTreeRoot(leaves: Buffer[], valueToCompress?: Buffer<ArrayBuffer>, emptyRoot?: Buffer<ArrayBuffer>, hasher?: (lhs: Uint8Array<ArrayBufferLike>, rhs: Uint8Array<ArrayBufferLike>) => Buffer<ArrayBuffer>): Buffer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5iYWxhbmNlZF9tZXJrbGVfdHJlZV9yb290LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJlZXMvdW5iYWxhbmNlZF9tZXJrbGVfdHJlZV9yb290LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLGVBQU8sTUFBTSx3QkFBd0IsZ0VBQStFLENBQUM7QUFFckgsZUFBTyxNQUFNLG1CQUFtQixnRUFBMkQsQ0FBQztBQUU1Rjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FvQkc7QUFDSCx3QkFBZ0IsK0JBQStCLENBQzdDLE1BQU0sRUFBRSxNQUFNLEVBQUUsRUFDaEIsTUFBTSw4RkFBZ0IsRUFDdEIsU0FBUyxzQkFBbUIsR0FDM0IsTUFBTSxDQTZCUjtBQUVELHdCQUFzQixvQ0FBb0MsQ0FDeEQsTUFBTSxFQUFFLE1BQU0sRUFBRSxFQUNoQixNQUFNLEVBQUUsQ0FBQyxJQUFJLEVBQUUsVUFBVSxFQUFFLEtBQUssRUFBRSxVQUFVLEtBQUssT0FBTyxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQyxFQUM3RSxTQUFTLHNCQUFtQixHQUMzQixPQUFPLENBQUMsTUFBTSxDQUFDLENBNkJqQjtBQU1ELHdCQUFnQiwwQkFBMEIsQ0FDeEMsTUFBTSxFQUFFLE1BQU0sRUFBRSxFQUNoQixlQUFlLHNCQUFtQixFQUNsQyxTQUFTLHNCQUFtQixFQUM1QixNQUFNLDhGQUFnQixHQUNyQixNQUFNLENBR1IifQ==

package/dest/trees/unbalanced_merkle_tree_root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unbalanced_merkle_tree_root.d.ts","sourceRoot":"","sources":["../../src/trees/unbalanced_merkle_tree_root.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,wBAAwB,gEAA+E,CAAC;AAErH,eAAO,MAAM,mBAAmB,gEAA2D,CAAC;AAE5F;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,MAAM,EAAE,EAChB,MAAM,8FAAgB,EACtB,SAAS,sBAAmB,GAC3B,MAAM,CA6BR;AAED,wBAAsB,oCAAoC,CACxD,MAAM,EAAE,MAAM,EAAE,EAChB,MAAM,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,EAC7E,SAAS,sBAAmB,GAC3B,OAAO,CAAC,MAAM,CAAC,CA6BjB;AAMD,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EAAE,EAChB,eAAe,sBAAmB,EAClC,SAAS,sBAAmB,EAC5B,MAAM,8FAAgB,GACrB,MAAM,CAGR"}

package/dest/trees/unbalanced_merkle_tree_root.js

@@ -0,0 +1,83 @@
+import { computeBalancedMerkleTreeRoot, computeBalancedMerkleTreeRootAsync } from './balanced_merkle_tree_root.js';
+import { shaMerkleHash } from './hasher.js';
+import { UnbalancedMerkleTreeCalculator } from './unbalanced_merkle_tree_calculator.js';
+export const computeUnbalancedShaRoot = (leaves)=>computeUnbalancedMerkleTreeRoot(leaves, shaMerkleHash);
+export const computeWonkyShaRoot = (leaves)=>computeWonkyMerkleTreeRoot(leaves);
+/**
+ * Computes the Merkle root of an unbalanced tree.
+ *
+ * Unlike a balanced Merkle tree, which requires the number of leaves to be a power of two, an unbalanced tree can have
+ * any number of leaves.
+ *
+ * The tree is constructed by iteratively extracting the smallest power-of-two-sized subtrees from **right to left**.
+ * For each such subtree, it computes the subtree root and then combines all subtree roots (again from right to left)
+ * into a single root using the provided hash function.
+ *
+ * Note: We need the final tree to be as shallow as possible, to minimize the size of the sibling path required to prove
+ * membership of a leaf. Therefor, the computation proceeds from right to left - smaller subtrees must always be
+ * combined before being merged with a larger sibling on their left.
+ *
+ * For example, consider an unbalanced tree made of three subtrees of sizes 2, 4, and 8. If we combine the size-2 and
+ * size-4 subtrees first (producing a subtree of depth 3), and then merge it with the size-8 subtree (also depth 3), the
+ * resulting tree has a maximum depth of 4.
+ *
+ * But if we instead combine the size-4 and size-8 subtrees first (depth 4), and then merge with the size-2 subtree
+ * (depth 1), the final tree has a depth of 5.
+ */ export function computeUnbalancedMerkleTreeRoot(leaves, hasher = shaMerkleHash, emptyRoot = Buffer.alloc(32)) {
+    if (!leaves.length) {
+        return emptyRoot;
+    }
+    if (leaves.length === 1) {
+        return leaves[0];
+    }
+    let numRemainingLeaves = leaves.length;
+    let subtreeSize = 1;
+    let root;
+    while(numRemainingLeaves > 1){
+        if ((numRemainingLeaves & subtreeSize) !== 0) {
+            const subtreeLeaves = leaves.slice(numRemainingLeaves - subtreeSize, numRemainingLeaves);
+            const subtreeRoot = computeBalancedMerkleTreeRoot(subtreeLeaves, hasher);
+            if (!root) {
+                root = subtreeRoot;
+            } else {
+                root = hasher(subtreeRoot, root);
+            }
+            numRemainingLeaves -= subtreeSize;
+        }
+        subtreeSize *= 2;
+    }
+    return root;
+}
+export async function computeUnbalancedMerkleTreeRootAsync(leaves, hasher, emptyRoot = Buffer.alloc(32)) {
+    if (!leaves.length) {
+        return emptyRoot;
+    }
+    if (leaves.length === 1) {
+        return leaves[0];
+    }
+    let numRemainingLeaves = leaves.length;
+    let subtreeSize = 1;
+    let root;
+    while(numRemainingLeaves > 1){
+        if ((numRemainingLeaves & subtreeSize) !== 0) {
+            const subtreeLeaves = leaves.slice(numRemainingLeaves - subtreeSize, numRemainingLeaves);
+            const subtreeRoot = await computeBalancedMerkleTreeRootAsync(subtreeLeaves, hasher);
+            if (!root) {
+                root = subtreeRoot;
+            } else {
+                root = await hasher(subtreeRoot, root);
+            }
+            numRemainingLeaves -= subtreeSize;
+        }
+        subtreeSize *= 2;
+    }
+    return root;
+}
+// A **wonky** tree is a "compressed" unbalanced Merkle tree.
+// It is constructed in the same way as an unbalanced tree: by first creating the largest possible left subtree, with
+// the remaining leaves forming a right subtree that follows the same process recursively.
+// During construction, leaves equal to `valueToCompress` are skipped (compressed) and do not contribute to the tree.
+export function computeWonkyMerkleTreeRoot(leaves, valueToCompress = Buffer.alloc(32), emptyRoot = Buffer.alloc(32), hasher = shaMerkleHash) {
+    const calculator = UnbalancedMerkleTreeCalculator.create(leaves, valueToCompress, emptyRoot, hasher);
+    return calculator.getRoot();
+}

package/dest/trees/unbalanced_tree_store.d.ts

@@ -0,0 +1,24 @@
+export interface TreeNodeLocation {
+    level: number;
+    index: number;
+}
+export declare class UnbalancedTreeStore<T> {
+    #private;
+    constructor(numLeaves: number);
+    setLeaf(leafIndex: number, value: T): TreeNodeLocation;
+    setNode({ level, index }: TreeNodeLocation, value: T): void;
+    getParentLocation({ level, index }: TreeNodeLocation): TreeNodeLocation;
+    getSiblingLocation({ level, index }: TreeNodeLocation): TreeNodeLocation;
+    getChildLocations({ level, index }: TreeNodeLocation): [TreeNodeLocation, TreeNodeLocation];
+    getLeaf(leafIndex: number): T | undefined;
+    getNode(location: TreeNodeLocation): T | undefined;
+    getRoot(): T | undefined;
+    getParent(location: TreeNodeLocation): T | undefined;
+    getSibling(location: TreeNodeLocation): T | undefined;
+    getChildren(location: TreeNodeLocation): [T | undefined, T | undefined];
+}
+export declare function findLeafLevelAndIndex(numLeaves: number, leafIndex: number): {
+    level: number;
+    indexAtLevel: number;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5iYWxhbmNlZF90cmVlX3N0b3JlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJlZXMvdW5iYWxhbmNlZF90cmVlX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sV0FBVyxnQkFBZ0I7SUFDL0IsS0FBSyxFQUFFLE1BQU0sQ0FBQztJQUNkLEtBQUssRUFBRSxNQUFNLENBQUM7Q0FDZjtBQU9ELHFCQUFhLG1CQUFtQixDQUFDLENBQUM7O0lBSWhDLFlBQVksU0FBUyxFQUFFLE1BQU0sRUFFNUI7SUFFRCxPQUFPLENBQUMsU0FBUyxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsQ0FBQyxHQUFHLGdCQUFnQixDQWVyRDtJQUVELE9BQU8sQ0FBQyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsRUFBRSxnQkFBZ0IsRUFBRSxLQUFLLEVBQUUsQ0FBQyxRQVNuRDtJQUVELGlCQUFpQixDQUFDLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxFQUFFLGdCQUFnQixHQUFHLGdCQUFnQixDQU10RTtJQUVELGtCQUFrQixDQUFDLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxFQUFFLGdCQUFnQixHQUFHLGdCQUFnQixDQU12RTtJQUVELGlCQUFpQixDQUFDLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxFQUFFLGdCQUFnQixHQUFHLENBQUMsZ0JBQWdCLEVBQUUsZ0JBQWdCLENBQUMsQ0FJMUY7SUFFRCxPQUFPLENBQUMsU0FBUyxFQUFFLE1BQU0sR0FBRyxDQUFDLEdBQUcsU0FBUyxDQU94QztJQUVELE9BQU8sQ0FBQyxRQUFRLEVBQUUsZ0JBQWdCLEdBQUcsQ0FBQyxHQUFHLFNBQVMsQ0FFakQ7SUFFRCxPQUFPLElBQUksQ0FBQyxHQUFHLFNBQVMsQ0FFdkI7SUFFRCxTQUFTLENBQUMsUUFBUSxFQUFFLGdCQUFnQixHQUFHLENBQUMsR0FBRyxTQUFTLENBR25EO0lBRUQsVUFBVSxDQUFDLFFBQVEsRUFBRSxnQkFBZ0IsR0FBRyxDQUFDLEdBQUcsU0FBUyxDQUdwRDtJQUVELFdBQVcsQ0FBQyxRQUFRLEVBQUUsZ0JBQWdCLEdBQUcsQ0FBQyxDQUFDLEdBQUcsU0FBUyxFQUFFLENBQUMsR0FBRyxTQUFTLENBQUMsQ0FHdEU7Q0FLRjtBQXNERCx3QkFBZ0IscUJBQXFCLENBQUMsU0FBUyxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsTUFBTTs7O0VBR3pFIn0=

package/dest/trees/unbalanced_tree_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unbalanced_tree_store.d.ts","sourceRoot":"","sources":["../../src/trees/unbalanced_tree_store.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAOD,qBAAa,mBAAmB,CAAC,CAAC;;IAIhC,YAAY,SAAS,EAAE,MAAM,EAE5B;IAED,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,gBAAgB,CAerD;IAED,OAAO,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,gBAAgB,EAAE,KAAK,EAAE,CAAC,QASnD;IAED,iBAAiB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,gBAAgB,GAAG,gBAAgB,CAMtE;IAED,kBAAkB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,gBAAgB,GAAG,gBAAgB,CAMvE;IAED,iBAAiB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,gBAAgB,GAAG,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAI1F;IAED,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAOxC;IAED,OAAO,CAAC,QAAQ,EAAE,gBAAgB,GAAG,CAAC,GAAG,SAAS,CAEjD;IAED,OAAO,IAAI,CAAC,GAAG,SAAS,CAEvB;IAED,SAAS,CAAC,QAAQ,EAAE,gBAAgB,GAAG,CAAC,GAAG,SAAS,CAGnD;IAED,UAAU,CAAC,QAAQ,EAAE,gBAAgB,GAAG,CAAC,GAAG,SAAS,CAGpD;IAED,WAAW,CAAC,QAAQ,EAAE,gBAAgB,GAAG,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC,GAAG,SAAS,CAAC,CAGtE;CAKF;AAsDD,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;;;EAGzE"}