@based/db 0.0.2 → 0.0.4

package/dist/test/binary.js

@@ -1,45 +0,0 @@
-import { BasedDb } from '../src/index.js';
-import test from './shared/test.js';
-import { deepEqual, equal } from './shared/assert.js';
-import { italy } from './shared/examples.js';
-await test('simple', async (t) => {
-    const db = new BasedDb({
-        path: t.tmp,
-    });
-    await db.start({ clean: true });
-    t.after(() => {
-        return db.destroy();
-    });
-    await db.putSchema({
-        types: {
-            user: {
-                props: {
-                    file: { type: 'binary' },
-                },
-            },
-        },
-    });
-    db.create('user', {
-        file: new Uint32Array([1, 2, 3, 4]),
-    });
-    await db.drain();
-    deepEqual((await db.query('user').get()).toObject(), [
-        {
-            id: 1,
-            file: new Uint8Array(new Uint32Array([1, 2, 3, 4]).buffer),
-        },
-    ]);
-    const id = await db.create('user', {
-        file: new Uint8Array([1, 2, 3, 4]),
-    });
-    deepEqual((await db.query('user', id).get()).toObject(), {
-        id,
-        file: new Uint8Array([1, 2, 3, 4]),
-    });
-    const italyBytes = Buffer.from(italy, 'utf-8');
-    const id2 = await db.create('user', {
-        file: italyBytes,
-    });
-    equal((await db.query('user', id2).get()).toObject().file.length, italyBytes.byteLength);
-});
-//# sourceMappingURL=binary.js.map

package/dist/test/binary.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"binary.js","sourceRoot":"","sources":["../../test/binary.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AACzC,OAAO,IAAI,MAAM,kBAAkB,CAAA;AACnC,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAA;AAE5C,MAAM,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;IAC/B,MAAM,EAAE,GAAG,IAAI,OAAO,CAAC;QACrB,IAAI,EAAE,CAAC,CAAC,GAAG;KACZ,CAAC,CAAA;IAEF,MAAM,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;IAE/B,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE;QACX,OAAO,EAAE,CAAC,OAAO,EAAE,CAAA;IACrB,CAAC,CAAC,CAAA;IAEF,MAAM,EAAE,CAAC,SAAS,CAAC;QACjB,KAAK,EAAE;YACL,IAAI,EAAE;gBACJ,KAAK,EAAE;oBACL,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;iBACzB;aACF;SACF;KACF,CAAC,CAAA;IAEF,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE;QAChB,IAAI,EAAE,IAAI,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;KACpC,CAAC,CAAA;IAEF,MAAM,EAAE,CAAC,KAAK,EAAE,CAAA;IAEhB,SAAS,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,EAAE,EAAE;QACnD;YACE,EAAE,EAAE,CAAC;YACL,IAAI,EAAE,IAAI,UAAU,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;SAC3D;KACF,CAAC,CAAA;IAEF,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE;QACjC,IAAI,EAAE,IAAI,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;KACnC,CAAC,CAAA;IAEF,SAAS,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,EAAE,EAAE;QACvD,EAAE;QACF,IAAI,EAAE,IAAI,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;KACnC,CAAC,CAAA;IAEF,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;IAC9C,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE;QAClC,IAAI,EAAE,UAAU;KACjB,CAAC,CAAA;IAEF,KAAK,CACH,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,MAAM,EAC1D,UAAU,CAAC,UAAU,CACtB,CAAA;AACH,CAAC,CAAC,CAAA"}

package/dist/test/boolean.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/boolean.js

@@ -1,43 +0,0 @@
-import { BasedDb } from '../src/index.js';
-import test from './shared/test.js';
-import { deepEqual } from './shared/assert.js';
-await test('boolean', async (t) => {
-    const db = new BasedDb({
-        path: t.tmp,
-    });
-    await db.start({ clean: true });
-    t.after(() => {
-        return db.destroy();
-    });
-    await db.putSchema({
-        types: {
-            user: {
-                props: {
-                    isNice: 'boolean',
-                },
-            },
-        },
-    });
-    db.create('user', {});
-    db.create('user', {
-        isNice: true,
-    });
-    db.create('user', {
-        isNice: false,
-    });
-    await db.drain();
-    deepEqual((await db.query('user').get()).toObject(), [
-        { id: 1, isNice: false },
-        { id: 2, isNice: true },
-        { id: 3, isNice: false },
-    ]);
-    deepEqual((await db.query('user').filter('isNice', '=', true).get()).toObject(), [{ id: 2, isNice: true }]);
-    deepEqual((await db.query('user').filter('isNice').get()).toObject(), [
-        { id: 2, isNice: true },
-    ]);
-    deepEqual((await db.query('user').filter('isNice', false).get()).toObject(), [
-        { id: 1, isNice: false },
-        { id: 3, isNice: false },
-    ]);
-});
-//# sourceMappingURL=boolean.js.map

package/dist/test/boolean.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"boolean.js","sourceRoot":"","sources":["../../test/boolean.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AACzC,OAAO,IAAI,MAAM,kBAAkB,CAAA;AACnC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAE9C,MAAM,IAAI,CAAC,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;IAChC,MAAM,EAAE,GAAG,IAAI,OAAO,CAAC;QACrB,IAAI,EAAE,CAAC,CAAC,GAAG;KACZ,CAAC,CAAA;IAEF,MAAM,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;IAE/B,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE;QACX,OAAO,EAAE,CAAC,OAAO,EAAE,CAAA;IACrB,CAAC,CAAC,CAAA;IAEF,MAAM,EAAE,CAAC,SAAS,CAAC;QACjB,KAAK,EAAE;YACL,IAAI,EAAE;gBACJ,KAAK,EAAE;oBACL,MAAM,EAAE,SAAS;iBAClB;aACF;SACF;KACF,CAAC,CAAA;IAEF,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,CAAA;IACrB,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE;QAChB,MAAM,EAAE,IAAI;KACb,CAAC,CAAA;IAEF,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE;QAChB,MAAM,EAAE,KAAK;KACd,CAAC,CAAA;IAEF,MAAM,EAAE,CAAC,KAAK,EAAE,CAAA;IAEhB,SAAS,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,EAAE,EAAE;QACnD,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE;QACxB,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE;QACvB,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE;KACzB,CAAC,CAAA;IAEF,SAAS,CACP,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,QAAQ,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,EAAE,EACrE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAC1B,CAAA;IAED,SAAS,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,EAAE,EAAE;QACpE,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE;KACxB,CAAC,CAAA;IAEF,SAAS,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,EAAE,EAAE;QAC3E,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE;QACxB,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE;KACzB,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA"}

package/dist/test/clientServer.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/clientServer.js

@@ -1,64 +0,0 @@
-import { DbClient } from '../src/client/index.js';
-import { DbServer } from '../src/server/index.js';
-import { deepEqual } from './shared/assert.js';
-import test from './shared/test.js';
-await test('client server', async (t) => {
-    const server = new DbServer({
-        path: t.tmp,
-        onSchemaChange(schema) {
-            client1.putLocalSchema(schema);
-            client2.putLocalSchema(schema);
-        },
-    });
-    await server.start({ clean: true });
-    t.after(() => {
-        return server.destroy();
-    });
-    const hooks = {
-        async putSchema(schema, fromStart, transformFns) {
-            return server.putSchema(schema, fromStart, transformFns);
-        },
-        async flushModify(buf) {
-            const offsets = server.modify(buf);
-            return { offsets };
-        },
-        async getQueryBuf(buf) {
-            return server.getQueryBuf(buf);
-        },
-    };
-    const client1 = new DbClient({
-        hooks,
-    });
-    const client2 = new DbClient({
-        hooks,
-    });
-    await client1.putSchema({
-        types: {
-            user: {
-                name: 'string',
-            },
-        },
-    });
-    const youzi = await client1.create('user', {
-        name: 'youzi',
-    });
-    const jamez = await client1.create('user', {
-        name: 'jamez',
-    });
-    deepEqual(await client1.query('user').get().toObject(), [
-        { id: 1, name: 'youzi' },
-        { id: 2, name: 'jamez' },
-    ]);
-    await client1.putSchema({
-        types: {
-            user: {
-                age: 'number',
-            },
-        },
-    });
-    deepEqual(await client1.query('user').get().toObject(), [
-        { id: 1, age: 0 },
-        { id: 2, age: 0 },
-    ]);
-});
-//# sourceMappingURL=clientServer.js.map

package/dist/test/clientServer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"clientServer.js","sourceRoot":"","sources":["../../test/clientServer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAiB,MAAM,wBAAwB,CAAA;AAEhE,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AACjD,OAAO,EAAE,SAAS,EAAU,MAAM,oBAAoB,CAAA;AACtD,OAAO,IAAI,MAAM,kBAAkB,CAAA;AAEnC,MAAM,IAAI,CAAC,eAAe,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;IACtC,MAAM,MAAM,GAAG,IAAI,QAAQ,CAAC;QAC1B,IAAI,EAAE,CAAC,CAAC,GAAG;QACX,cAAc,CAAC,MAAM;YACnB,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAA;YAC9B,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAA;QAChC,CAAC;KACF,CAAC,CAAA;IAEF,MAAM,MAAM,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;IAEnC,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE;QACX,OAAO,MAAM,CAAC,OAAO,EAAE,CAAA;IACzB,CAAC,CAAC,CAAA;IAEF,MAAM,KAAK,GAAkB;QAC3B,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,YAAY;YAC7C,OAAO,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,YAAY,CAAC,CAAA;QAC1D,CAAC;QACD,KAAK,CAAC,WAAW,CAAC,GAAG;YACnB,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;YAClC,OAAO,EAAE,OAAO,EAAE,CAAA;QACpB,CAAC;QACD,KAAK,CAAC,WAAW,CAAC,GAAG;YACnB,OAAO,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,CAAA;QAChC,CAAC;KACF,CAAA;IAED,MAAM,OAAO,GAAG,IAAI,QAAQ,CAAC;QAC3B,KAAK;KACN,CAAC,CAAA;IAEF,MAAM,OAAO,GAAG,IAAI,QAAQ,CAAC;QAC3B,KAAK;KACN,CAAC,CAAA;IAEF,MAAM,OAAO,CAAC,SAAS,CAAC;QACtB,KAAK,EAAE;YACL,IAAI,EAAE;gBACJ,IAAI,EAAE,QAAQ;aACf;SACF;KACF,CAAC,CAAA;IAEF,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE;QACzC,IAAI,EAAE,OAAO;KACd,CAAC,CAAA;IAEF,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE;QACzC,IAAI,EAAE,OAAO;KACd,CAAC,CAAA;IAEF,SAAS,CAAC,MAAM,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,EAAE;QACtD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;QACxB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;KACzB,CAAC,CAAA;IAEF,MAAM,OAAO,CAAC,SAAS,CAAC;QACtB,KAAK,EAAE;YACL,IAAI,EAAE;gBACJ,GAAG,EAAE,QAAQ;aACd;SACF;KACF,CAAC,CAAA;IAEF,SAAS,CAAC,MAAM,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,EAAE;QACtD,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE;QACjB,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE;KAClB,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA"}

package/dist/test/concurrency.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/concurrency.js

@@ -1,61 +0,0 @@
-import { BasedDb } from '../src/index.js';
-import test from './shared/test.js';
-import { setTimeout as setTimeoutAsync } from 'timers/promises';
-await test('concurrency', async (t) => {
-    const db = new BasedDb({
-        path: t.tmp,
-    });
-    await db.start({ clean: true });
-    t.after(() => {
-        return db.destroy();
-    });
-    await db.putSchema({
-        types: {
-            user: {
-                props: {
-                    friends: {
-                        items: {
-                            ref: 'user',
-                            prop: 'friends',
-                        },
-                    },
-                },
-            },
-        },
-    });
-    console.time('create stuff');
-    let id = 0;
-    let queries = 0;
-    let refs = [];
-    let timer = setTimeout(() => {
-        // db.destroy()
-        timer = null;
-    }, 5e3);
-    const query = async () => {
-        queries++;
-        try {
-            await db.query('user').include('friends').range(0, 1000_000).get();
-        }
-        catch (e) {
-            console.error('err:', e);
-        }
-        queries--;
-    };
-    while (timer) {
-        let i = 100;
-        while (i--) {
-            query();
-        }
-        while (timer && queries) {
-            db.create('user', {
-                friends: refs,
-            });
-            refs.push(++id);
-            await db.drain();
-            await setTimeoutAsync();
-        }
-    }
-    clearTimeout(timer);
-    console.timeEnd('create stuff');
-});
-//# sourceMappingURL=concurrency.js.map

package/dist/test/concurrency.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"concurrency.js","sourceRoot":"","sources":["../../test/concurrency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AACzC,OAAO,IAAI,MAAM,kBAAkB,CAAA;AACnC,OAAO,EAAE,UAAU,IAAI,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAE/D,MAAM,IAAI,CAAC,aAAa,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;IACpC,MAAM,EAAE,GAAG,IAAI,OAAO,CAAC;QACrB,IAAI,EAAE,CAAC,CAAC,GAAG;KACZ,CAAC,CAAA;IAEF,MAAM,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;IAE/B,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE;QACX,OAAO,EAAE,CAAC,OAAO,EAAE,CAAA;IACrB,CAAC,CAAC,CAAA;IAEF,MAAM,EAAE,CAAC,SAAS,CAAC;QACjB,KAAK,EAAE;YACL,IAAI,EAAE;gBACJ,KAAK,EAAE;oBACL,OAAO,EAAE;wBACP,KAAK,EAAE;4BACL,GAAG,EAAE,MAAM;4BACX,IAAI,EAAE,SAAS;yBAChB;qBACF;iBACF;aACF;SACF;KACF,CAAC,CAAA;IAEF,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,CAAA;IAE5B,IAAI,EAAE,GAAG,CAAC,CAAA;IACV,IAAI,OAAO,GAAG,CAAC,CAAA;IACf,IAAI,IAAI,GAAG,EAAE,CAAA;IACb,IAAI,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;QAC1B,eAAe;QACf,KAAK,GAAG,IAAI,CAAA;IACd,CAAC,EAAE,GAAG,CAAC,CAAA;IAEP,MAAM,KAAK,GAAG,KAAK,IAAI,EAAE;QACvB,OAAO,EAAE,CAAA;QACT,IAAI,CAAC;YACH,MAAM,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,EAAE,CAAA;QACpE,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;QAC1B,CAAC;QACD,OAAO,EAAE,CAAA;IACX,CAAC,CAAA;IAED,OAAO,KAAK,EAAE,CAAC;QACb,IAAI,CAAC,GAAG,GAAG,CAAA;QACX,OAAO,CAAC,EAAE,EAAE,CAAC;YACX,KAAK,EAAE,CAAA;QACT,CAAC;QACD,OAAO,KAAK,IAAI,OAAO,EAAE,CAAC;YACxB,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE;gBAChB,OAAO,EAAE,IAAI;aACd,CAAC,CAAA;YACF,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,CAAA;YACf,MAAM,EAAE,CAAC,KAAK,EAAE,CAAA;YAChB,MAAM,eAAe,EAAE,CAAA;QACzB,CAAC;IACH,CAAC;IAED,YAAY,CAAC,KAAK,CAAC,CAAA;IAEnB,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,CAAA;AACjC,CAAC,CAAC,CAAA"}

package/dist/test/csmt.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/csmt.js

@@ -1,365 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { createHash } from 'crypto';
-import test from './shared/test.js';
-import { equal } from './shared/assert.js';
-import { createTree } from '../src/server/csmt/index.js';
-const shortHash = (buf) => buf.toString('base64').substring(0, 5);
-function genNodeHash(lHash, rHash) {
-    return createHash('sha256').update(lHash).update(rHash).digest();
-}
-await test('insert: A basic tree is formed correctly', async (t) => {
-    const tree = createTree(() => createHash('sha256'));
-    tree.insert(1, Buffer.from('a'));
-    tree.insert(2, Buffer.from('b'));
-    tree.insert(3, Buffer.from('c'));
-    tree.insert(4, Buffer.from('d'));
-    const root = tree.getRoot();
-    assert.ok(root);
-    assert.ok(root.hash instanceof Buffer);
-    assert.equal(shortHash(root.hash), 'jq/kE');
-    assert.equal(root.key, 4);
-    assert.ok(root.left);
-    assert.equal(shortHash(root.left.hash), '8AS3E');
-    assert.equal(root.left.key, 3);
-    assert.ok(root.left.left);
-    assert.equal(shortHash(root.left.left.hash), 'YQ==');
-    assert.equal(root.left.left.key, 1);
-    assert.ok(!root.left.left.left);
-    assert.ok(!root.left.left.right);
-    assert.ok(root.left.right);
-    assert.equal(shortHash(root.left.right.hash), 'Hgu9b');
-    assert.equal(root.left.right.key, 3);
-    assert.ok(root.left.right.left);
-    assert.equal(shortHash(root.left.right.left.hash), 'Yg==');
-    assert.equal(root.left.right.left.key, 2);
-    assert.ok(!root.left.right.left.left);
-    assert.ok(!root.left.right.left.right);
-    assert.ok(root.left.right.right);
-    assert.equal(shortHash(root.left.right.right.hash), 'Yw==');
-    assert.equal(root.left.right.right.key, 3);
-    assert.ok(!root.left.right.right.left);
-    assert.ok(!root.left.right.right.right);
-    assert.ok(root.right);
-    assert.equal(shortHash(root.right.hash), 'ZA==');
-    assert.equal(root.right.key, 4);
-    assert.ok(!root.right.left);
-    assert.ok(!root.right.right);
-});
-await test('insert: The root hash is recomputed on every insert', async (t) => {
-    const tree = createTree(() => createHash('sha256'));
-    tree.insert(1, Buffer.from('a'));
-    assert.equal(shortHash(tree.getRoot().hash), 'YQ==');
-    tree.insert(2, Buffer.from('b'));
-    assert.equal(shortHash(tree.getRoot().hash), '+44g/');
-    tree.insert(5, Buffer.from('c'));
-    assert.equal(shortHash(tree.getRoot().hash), 'OvuAS');
-});
-await test('insert: Trees are reproducible regardless of the insertion order', async (t) => {
-    const tree1 = createTree(() => createHash('sha256'));
-    const tree2 = createTree(() => createHash('sha256'));
-    tree1.insert(1, Buffer.from('a'));
-    tree1.insert(2, Buffer.from('b'));
-    tree1.insert(3, Buffer.from('c'));
-    tree1.insert(4, Buffer.from('d'));
-    tree2.insert(2, Buffer.from('b'));
-    tree2.insert(4, Buffer.from('d'));
-    tree2.insert(3, Buffer.from('c'));
-    tree2.insert(1, Buffer.from('a'));
-    assert.deepEqual(tree1.getRoot(), tree2.getRoot());
-});
-await test('insert: Difference in a single node causes the root hash to differ', async (t) => {
-    const tree1 = createTree(() => createHash('sha256'));
-    const tree2 = createTree(() => createHash('sha256'));
-    tree1.insert(1, Buffer.from('a'));
-    tree1.insert(2, Buffer.from('b'));
-    tree1.insert(3, Buffer.from('c'));
-    tree1.insert(4, Buffer.from('d'));
-    tree2.insert(1, Buffer.from('a'));
-    tree2.insert(2, Buffer.from('b'));
-    tree2.insert(3, Buffer.from('x'));
-    tree2.insert(4, Buffer.from('d'));
-    assert.notEqual(tree2.getRoot().hash, tree1.getRoot().hash);
-});
-await test('delete: two trees are no longer equal after deleting a key', async (t) => {
-    const tree1 = createTree(() => createHash('sha256'));
-    const tree2 = createTree(() => createHash('sha256'));
-    tree1.insert(1, Buffer.from('a'));
-    tree1.insert(2, Buffer.from('b'));
-    tree1.insert(3, Buffer.from('c'));
-    tree1.insert(4, Buffer.from('d'));
-    tree1.insert(7, Buffer.from('g'));
-    tree1.insert(8, Buffer.from('h'));
-    tree1.insert(9, Buffer.from('i'));
-    tree2.insert(1, Buffer.from('a'));
-    tree2.insert(2, Buffer.from('b'));
-    tree2.insert(3, Buffer.from('c'));
-    tree2.insert(4, Buffer.from('d'));
-    tree2.insert(7, Buffer.from('g'));
-    tree2.insert(8, Buffer.from('h'));
-    tree2.insert(9, Buffer.from('i'));
-    assert.deepEqual(tree1.getRoot(), tree2.getRoot());
-    tree1.delete(7);
-    assert.notEqual(tree1.getRoot(), tree2.getRoot());
-});
-await test('delete: delete rebalances the tree properly', async (t) => {
-    const tree1 = createTree(() => createHash('sha256'));
-    const tree2 = createTree(() => createHash('sha256'));
-    tree1.insert(1, Buffer.from('a'));
-    tree1.insert(2, Buffer.from('b'));
-    tree1.insert(3, Buffer.from('c'));
-    tree1.insert(4, Buffer.from('d'));
-    tree1.insert(5, Buffer.from('e'));
-    tree1.insert(6, Buffer.from('f'));
-    tree1.insert(7, Buffer.from('g'));
-    tree1.insert(8, Buffer.from('h'));
-    tree1.insert(9, Buffer.from('i'));
-    tree1.insert(10, Buffer.from('j'));
-    tree1.insert(11, Buffer.from('k'));
-    tree1.insert(12, Buffer.from('l'));
-    tree1.insert(13, Buffer.from('m'));
-    tree1.insert(14, Buffer.from('n'));
-    tree1.insert(15, Buffer.from('p'));
-    tree1.insert(16, Buffer.from('q'));
-    tree1.insert(17, Buffer.from('r'));
-    tree1.insert(18, Buffer.from('s'));
-    tree1.insert(19, Buffer.from('t'));
-    tree2.insert(1, Buffer.from('a'));
-    tree2.insert(2, Buffer.from('b'));
-    tree2.insert(3, Buffer.from('c'));
-    tree2.insert(4, Buffer.from('d'));
-    tree2.insert(5, Buffer.from('e'));
-    tree2.insert(6, Buffer.from('f'));
-    tree2.insert(7, Buffer.from('g'));
-    tree2.insert(9, Buffer.from('i'));
-    tree2.insert(10, Buffer.from('j'));
-    tree2.insert(11, Buffer.from('k'));
-    tree2.insert(12, Buffer.from('l'));
-    tree2.insert(13, Buffer.from('m'));
-    tree2.insert(14, Buffer.from('n'));
-    tree2.insert(15, Buffer.from('p'));
-    tree2.insert(16, Buffer.from('q'));
-    tree2.insert(17, Buffer.from('r'));
-    tree2.insert(18, Buffer.from('s'));
-    tree2.insert(19, Buffer.from('t'));
-    assert.notDeepEqual(tree1.getRoot(), tree2.getRoot());
-    tree1.delete(8);
-    assert.deepEqual(tree1.getRoot(), tree2.getRoot());
-});
-await test('delete: delete rebalances the tree properly (upped boundary)', async (t) => {
-    const tree1 = createTree(() => createHash('sha256'));
-    const tree2 = createTree(() => createHash('sha256'));
-    tree1.insert(1, Buffer.from('a'));
-    tree1.insert(2, Buffer.from('b'));
-    tree1.insert(3, Buffer.from('c'));
-    tree1.insert(4, Buffer.from('d'));
-    tree2.insert(1, Buffer.from('a'));
-    tree2.insert(2, Buffer.from('b'));
-    tree2.insert(3, Buffer.from('c'));
-    tree2.insert(4, Buffer.from('d'));
-    tree2.insert(5, Buffer.from('e'));
-    assert.notDeepEqual(tree1.getRoot(), tree2.getRoot());
-    tree2.delete(5);
-    assert.deepEqual(tree1.getRoot(), tree2.getRoot());
-});
-await test('delete rebalances the tree properly (lower boundary)', async (t) => {
-    const tree1 = createTree(() => createHash('sha256'));
-    const tree2 = createTree(() => createHash('sha256'));
-    tree1.insert(1, Buffer.from('a'));
-    tree1.insert(4, Buffer.from('b'));
-    tree1.insert(3, Buffer.from('b'));
-    tree1.insert(5, Buffer.from('c'));
-    tree1.insert(2, Buffer.from('b'));
-    tree2.insert(2, Buffer.from('b'));
-    tree2.insert(3, Buffer.from('b'));
-    tree2.insert(4, Buffer.from('b'));
-    tree2.insert(5, Buffer.from('c'));
-    assert.notDeepEqual(tree1.getRoot(), tree2.getRoot());
-    tree1.delete(1);
-    assert.deepEqual(tree1.getRoot(), tree2.getRoot());
-});
-await test('diff: Equal trees have zero diff', async (t) => {
-    const tree1 = createTree(() => createHash('sha256'));
-    const tree2 = createTree(() => createHash('sha256'));
-    tree1.insert(1, Buffer.from('a'));
-    tree1.insert(2, Buffer.from('b'));
-    tree1.insert(3, Buffer.from('c'));
-    tree1.insert(4, Buffer.from('d'));
-    tree2.insert(1, Buffer.from('a'));
-    tree2.insert(2, Buffer.from('b'));
-    tree2.insert(3, Buffer.from('c'));
-    tree2.insert(4, Buffer.from('d'));
-    const diff = tree1.diff(tree2);
-    assert.equal(diff.left.length, 0);
-    assert.equal(diff.right.length, 0);
-});
-await test('diff: Equal trees have zero diff both ways', async (t) => {
-    const tree1 = createTree(() => createHash('sha256'));
-    const tree2 = createTree(() => createHash('sha256'));
-    tree1.insert(1, Buffer.from('a'));
-    tree1.insert(2, Buffer.from('b'));
-    tree1.insert(3, Buffer.from('c'));
-    tree1.insert(4, Buffer.from('d'));
-    tree2.insert(1, Buffer.from('a'));
-    tree2.insert(2, Buffer.from('b'));
-    tree2.insert(3, Buffer.from('c'));
-    tree2.insert(4, Buffer.from('d'));
-    const diff1 = tree1.diff(tree2);
-    const diff2 = tree2.diff(tree1);
-    assert.equal(diff1.left.length, 0);
-    assert.equal(diff1.right.length, 0);
-    assert.equal(diff2.left.length, 0);
-    assert.equal(diff2.right.length, 0);
-});
-await test('diff: A tree has no diff against itself', async (t) => {
-    const tree = createTree(() => createHash('sha256'));
-    tree.insert(1, Buffer.from('a'));
-    tree.insert(2, Buffer.from('b'));
-    const diff = tree.diff(tree);
-    assert.equal(diff.left.length, 0);
-    assert.equal(diff.right.length, 0);
-});
-await test('diff: Right tree has one new node', async (t) => {
-    const tree1 = createTree(() => createHash('sha256'));
-    const tree2 = createTree(() => createHash('sha256'));
-    tree1.insert(1, Buffer.from('a'));
-    tree1.insert(4, Buffer.from('b'));
-    tree1.insert(3, Buffer.from('b'));
-    tree1.insert(5, Buffer.from('b'));
-    tree2.insert(1, Buffer.from('a'));
-    tree2.insert(4, Buffer.from('b'));
-    tree2.insert(3, Buffer.from('b'));
-    tree2.insert(5, Buffer.from('b'));
-    tree2.insert(2, Buffer.from('b'));
-    const { left, right } = tree1.diff(tree2);
-    assert.equal(left.length, 0);
-    assert.equal(right.length, 1);
-    assert.equal(right[0][0], 2);
-    assert.deepEqual(right[0][1], Buffer.from('b'));
-});
-await test('diff: The same key is marked as a diff in both because the hash has changed', async (t) => {
-    const tree1 = createTree(() => createHash('sha256'));
-    const tree2 = createTree(() => createHash('sha256'));
-    tree1.insert(1, Buffer.from('a'));
-    tree1.insert(4, Buffer.from('b'));
-    tree1.insert(3, Buffer.from('b'));
-    tree1.insert(5, Buffer.from('b'));
-    tree2.insert(1, Buffer.from('a'));
-    tree2.insert(4, Buffer.from('b'));
-    tree2.insert(3, Buffer.from('b'));
-    tree2.insert(5, Buffer.from('c')); // hash changed
-    const { left, right } = tree1.diff(tree2);
-    assert.equal(left.length, 1);
-    assert.equal(left[0][0], 5);
-    assert.deepEqual(left[0][1], Buffer.from('b'));
-    assert.equal(right.length, 1);
-    assert.equal(right[0][0], 5);
-    assert.deepEqual(right[0][1], Buffer.from('c'));
-});
-await test('proof: Prove that 3 is a member of the tree', async (t) => {
-    const tree = createTree(() => createHash('sha256'));
-    tree.insert(1, Buffer.from('a'));
-    tree.insert(4, Buffer.from('b'));
-    tree.insert(3, Buffer.from('c'));
-    tree.insert(5, Buffer.from('d'));
-    const proof = tree.membershipProof(3);
-    const rightHash = Buffer.from('XmV/9hWNPiptI+KlI5F6IwWs7pQjNl4mhpXEt7iRn0w=', 'base64');
-    assert.equal(proof.length, 3);
-    proof.forEach((el) => assert.equal(Array.isArray(el) && el.length, 2));
-    assert.deepEqual(proof[0], [Buffer.from('c'), 3]);
-    assert.deepEqual(proof[1], [Buffer.from('a'), 'L']);
-    assert.deepEqual(proof[2], [rightHash, 'R']);
-    const leftHash = genNodeHash(Buffer.from('a'), Buffer.from('c'));
-    const rootHash = genNodeHash(leftHash, rightHash);
-    const root = tree.getRoot();
-    assert.ok(root);
-    assert.deepEqual(rootHash, root && root.hash);
-});
-await test('proof: Prove that 5 is a member of the tree (boundary)', async (t) => {
-    const tree = createTree(() => createHash('sha256'));
-    tree.insert(1, Buffer.from('a'));
-    tree.insert(4, Buffer.from('b'));
-    tree.insert(3, Buffer.from('c'));
-    tree.insert(5, Buffer.from('d'));
-    const proof = tree.membershipProof(5);
-    const leftHash = genNodeHash(Buffer.from('a'), Buffer.from('c'));
-    assert.equal(proof.length, 3);
-    proof.forEach((el) => assert.equal(Array.isArray(el) && el.length, 2));
-    assert.deepEqual(proof[0], [Buffer.from('d'), 5]);
-    assert.deepEqual(proof[1], [Buffer.from('b'), 'L']);
-    assert.deepEqual(proof[2], [leftHash, 'L']);
-    const rightHash = genNodeHash(Buffer.from('b'), Buffer.from('d'));
-    const rootHash = genNodeHash(leftHash, rightHash);
-    const root = tree.getRoot();
-    assert.ok(root);
-    assert.deepEqual(rootHash, root && root.hash);
-});
-await test('proof: Show a proof that 6 is greater than the greatest key in the tree (5)', async (t) => {
-    const tree = createTree(() => createHash('sha256'));
-    tree.insert(1, Buffer.from('a'));
-    tree.insert(3, Buffer.from('b'));
-    tree.insert(4, Buffer.from('c'));
-    tree.insert(5, Buffer.from('d'));
-    const proof = tree.membershipProof(6);
-    assert.equal(proof.length, 4);
-    const [d, c, ab, miss] = proof;
-    assert.equal(Array.isArray(d) && d.length, 2);
-    assert.deepEqual(d[0], Buffer.from('d'));
-    assert.equal(d[1], 5);
-    assert.equal(Array.isArray(c) && c.length, 2);
-    assert.deepEqual(c[0], Buffer.from('c'));
-    assert.equal(c[1], 'L');
-    assert.equal(Array.isArray(ab) && ab.length, 2);
-    assert.deepEqual(ab[0], genNodeHash(Buffer.from('a'), Buffer.from('b')));
-    assert.equal(ab[1], 'L');
-    assert.ok(!miss);
-});
-await test('proof: Show a proof that 10 is greater than the greatest key in the tree (5)', async (t) => {
-    const tree = createTree(() => createHash('sha256'));
-    tree.insert(1, Buffer.from('a'));
-    tree.insert(3, Buffer.from('b'));
-    tree.insert(4, Buffer.from('c'));
-    tree.insert(5, Buffer.from('d'));
-    const proof = tree.membershipProof(10);
-    assert.equal(proof.length, 4);
-    const [d, c, ab, miss] = proof;
-    assert.equal(Array.isArray(d) && d.length, 2);
-    assert.deepEqual(d[0], Buffer.from('d'));
-    assert.equal(d[1], 5);
-    assert.equal(Array.isArray(c) && c.length, 2);
-    assert.deepEqual(c[0], Buffer.from('c'));
-    assert.equal(c[1], 'L');
-    assert.equal(Array.isArray(ab) && ab.length, 2);
-    assert.deepEqual(ab[0], genNodeHash(Buffer.from('a'), Buffer.from('b')));
-    assert.equal(ab[1], 'L');
-    assert.ok(!miss);
-});
-await test('proof: Show a proof that 1 is smaller than the smallest key in the tree (2)', async (t) => {
-    const tree = createTree(() => createHash('sha256'));
-    tree.insert(2, Buffer.from('a'));
-    tree.insert(3, Buffer.from('b'));
-    tree.insert(4, Buffer.from('c'));
-    tree.insert(5, Buffer.from('d'));
-    const proof = tree.membershipProof(1);
-    assert.equal(proof.length, 4);
-    const expectedProof = [
-        null,
-        [Buffer.from('a'), 2],
-        [Buffer.from('b'), 'R'],
-        [genNodeHash(Buffer.from('c'), Buffer.from('d')), 'R'],
-    ];
-    assert.deepEqual(proof, expectedProof);
-});
-await test('search', async (t) => {
-    const tree = createTree(() => createHash('sha256'));
-    tree.insert(2, Buffer.from('a'));
-    tree.insert(3, Buffer.from('b'));
-    tree.insert(4, Buffer.from('c'));
-    tree.insert(5, Buffer.from('d'));
-    equal(tree.search(1), null);
-    equal(tree.search(10), null);
-    equal(tree.search(2)?.key, 2);
-    equal(tree.search(3)?.key, 3);
-    equal(tree.search(4)?.key, 4);
-    equal(tree.search(5)?.key, 5);
-});
-//# sourceMappingURL=csmt.js.map