@aztec/foundation 0.7.2 → 0.7.4

package/dest/async-map/async_map.test.js

@@ -0,0 +1,9 @@
+import { asyncMap } from './index.js';
+describe('asyncMap', () => {
+    test('execute list item sequentially', async () => {
+        const sleepAndLog = (ms, idx) => new Promise(resolve => setTimeout(() => resolve(idx), ms));
+        const result = await asyncMap([100, 0, 30, 1], (ms, i) => sleepAndLog(ms, i));
+        expect(result).toEqual([0, 1, 2, 3]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXN5bmNfbWFwLnRlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXN5bmMtbWFwL2FzeW5jX21hcC50ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFdEMsUUFBUSxDQUFDLFVBQVUsRUFBRSxHQUFHLEVBQUU7SUFDeEIsSUFBSSxDQUFDLGdDQUFnQyxFQUFFLEtBQUssSUFBSSxFQUFFO1FBQ2hELE1BQU0sV0FBVyxHQUFHLENBQUMsRUFBVSxFQUFFLEdBQVcsRUFBRSxFQUFFLENBQUMsSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsR0FBRyxFQUFFLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDNUcsTUFBTSxNQUFNLEdBQUcsTUFBTSxRQUFRLENBQUMsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDLFdBQVcsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUM5RSxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUN2QyxDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMsQ0FBQyxDQUFDIn0=

package/dest/async-map/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Maps an array of elements by applying an asynchronous function to each element in sequence,
+ * and returns a new array with the results. The function receives each element of the array
+ * and its index as arguments, and should return a Promise that resolves to the desired value.
+ *
+ * @typeParam T - The original array element type.
+ * @typeParam U - The resulting array element type.
+ * @param arr - The array to map.
+ * @param fn - The async function to apply on each element of the array.
+ * @returns A Promise that resolves to a new array containing the mapped values.
+ */
+export declare function asyncMap<T, U>(arr: T[], fn: (e: T, i: number) => Promise<U>): Promise<U[]>;
+//# sourceMappingURL=index.d.ts.map

package/dest/async-map/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/async-map/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAMhG"}

package/dest/async-map/index.js

@@ -0,0 +1,19 @@
+/**
+ * Maps an array of elements by applying an asynchronous function to each element in sequence,
+ * and returns a new array with the results. The function receives each element of the array
+ * and its index as arguments, and should return a Promise that resolves to the desired value.
+ *
+ * @typeParam T - The original array element type.
+ * @typeParam U - The resulting array element type.
+ * @param arr - The array to map.
+ * @param fn - The async function to apply on each element of the array.
+ * @returns A Promise that resolves to a new array containing the mapped values.
+ */
+export async function asyncMap(arr, fn) {
+    const results = [];
+    for (let i = 0; i < arr.length; ++i) {
+        results.push(await fn(arr[i], i));
+    }
+    return results;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXN5bmMtbWFwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7O0dBVUc7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLFFBQVEsQ0FBTyxHQUFRLEVBQUUsRUFBbUM7SUFDaEYsTUFBTSxPQUFPLEdBQVEsRUFBRSxDQUFDO0lBQ3hCLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxHQUFHLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxFQUFFO1FBQ25DLE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7S0FDbkM7SUFDRCxPQUFPLE9BQU8sQ0FBQztBQUNqQixDQUFDIn0=

package/dest/aztec-address/index.d.ts

@@ -0,0 +1,114 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '../fields/index.js';
+import { BufferReader } from '../serialize/buffer_reader.js';
+/**
+ * AztecAddress represents a 32-byte address in the Aztec Protocol. It provides methods to create, manipulate, and
+ * compare addresses. The maximum value of an address is determined by the field modulus and all instances of AztecAddress
+ * should have a value less than or equal to this max value. This class also provides helper functions to convert
+ * addresses from strings, buffers, and other formats.
+ */
+export declare class AztecAddress {
+    /**
+     * The buffer field.
+     */
+    readonly buffer: Buffer;
+    static SIZE_IN_BYTES: number;
+    static ZERO: AztecAddress;
+    static MODULUS: bigint;
+    static MAX_VALUE: bigint;
+    constructor(
+    /**
+     * The buffer field.
+     */
+    buffer: Buffer);
+    /**
+     * Generates a random AztecAddress instance, using the Fr field (a finite field) to create a random value
+     * within a valid range and then converting it into a Buffer of a fixed size in bytes.
+     *
+     * @returns A new AztecAddress instance with a random value.
+     */
+    static random(): AztecAddress;
+    /**
+     * Creates an AztecAddress instance from a given buffer or BufferReader.
+     * If the input is a Buffer, it wraps it in a BufferReader before processing.
+     * Throws an error if the input length is not equal to the expected size.
+     *
+     * @param buffer - The input buffer or BufferReader containing the address data.
+     * @returns - A new AztecAddress instance with the extracted address data.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): AztecAddress;
+    /**
+     * Create an AztecAddress instance from a hex-encoded string.
+     * The input 'address' should be prefixed with '0x' or not, and have exactly 64 hex characters.
+     * Throws an error if the input length is invalid or address value is out of range.
+     *
+     * @param address - The hex-encoded string representing the Aztec address.
+     * @returns An AztecAddress instance.
+     */
+    static fromString(address: string): AztecAddress;
+    /**
+     * Creates an AztecAddress from a bigint.
+     * The provided value must be within the range of a field.
+     * @param address - The bigint representation of the address.
+     * @returns An AztecAddress instance.
+     */
+    static fromBigInt(address: bigint): AztecAddress;
+    /**
+     * Converts the AztecAddress instance into a Buffer.
+     * This method should be used when encoding the address for storage, transmission or serialization purposes.
+     *
+     * @returns A Buffer representation of the AztecAddress instance.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Convert the AztecAddress to a hexadecimal string representation, with a "0x" prefix.
+     * The resulting string will have a length of 66 characters (including the prefix).
+     *
+     * @returns A hexadecimal string representation of the AztecAddress.
+     */
+    toString(): `0x${string}`;
+    /**
+     * Returns a shortened string representation of the AztecAddress, displaying only the first 10 characters and last 4 characters.
+     * This is useful for human-readable displays where the full address is not necessary.
+     *
+     * @returns A shortened string representation of the address.
+     */
+    toShortString(): string;
+    /**
+     * Returns this address from a Field element.
+     * @param field - The Field element to convert.
+     * @returns An Address Object from a Field element with the same value.
+     */
+    static fromField(field: Fr): AztecAddress;
+    /**
+     * Returns this address as a field element.
+     * @returns A field element with the same value as the address.
+     */
+    toField(): Fr;
+    /**
+     * Returns this address as a bigint. Useful for creating maps indexed by addresses.
+     * @returns A bigint with the same value as the address.
+     */
+    toBigInt(): bigint;
+    /**
+     * Determines if this AztecAddress instance is equal to the given AztecAddress instance.
+     * Equality is based on the content of their respective buffers.
+     *
+     * @param other - The AztecAddress instance to compare against.
+     * @returns True if the buffers of both instances are equal, false otherwise.
+     */
+    equals(other: AztecAddress): boolean;
+    /**
+     * Checks if the AztecAddress is zero.
+     *
+     * @returns Returns true if the AztecAddress is equal to the zero address, otherwise returns false.
+     */
+    isZero(): boolean;
+    /**
+     * Friendly representation for debugging purposes.
+     *
+     * @returns A hex string representing the address.
+     */
+    toFriendlyJSON(): `0x${string}`;
+}
+//# sourceMappingURL=index.d.ts.map

package/dest/aztec-address/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/aztec-address/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D;;;;;GAKG;AACH,qBAAa,YAAY;IAOrB;;OAEG;aACa,MAAM,EAAE,MAAM;IAThC,MAAM,CAAC,aAAa,SAAM;IAC1B,MAAM,CAAC,IAAI,eAA8D;IACzE,MAAM,CAAC,OAAO,SAAuE;IACrF,MAAM,CAAC,SAAS,SAA6B;;IAG3C;;OAEG;IACa,MAAM,EAAE,MAAM;IAQhC;;;;;OAKG;IACH,MAAM,CAAC,MAAM;IAIb;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAK/C;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM;IAQjC;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM;IAIjC;;;;;OAKG;IACH,QAAQ;IAIR;;;;;OAKG;IACH,QAAQ,IAAI,KAAK,MAAM,EAAE;IAIzB;;;;;OAKG;IACH,aAAa;IAKb;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,EAAE,GAAG,YAAY;IAIzC;;;OAGG;IACH,OAAO;IAIP;;;OAGG;IACH,QAAQ;IAIR;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,EAAE,YAAY;IAI1B;;;;OAIG;IACH,MAAM;IAIN;;;;OAIG;IACH,cAAc;CAGf"}

package/dest/aztec-address/index.js

@@ -0,0 +1,148 @@
+import { toBigIntBE, toBufferBE } from '../bigint-buffer/index.js';
+import { Fr } from '../fields/index.js';
+import { BufferReader } from '../serialize/buffer_reader.js';
+/**
+ * AztecAddress represents a 32-byte address in the Aztec Protocol. It provides methods to create, manipulate, and
+ * compare addresses. The maximum value of an address is determined by the field modulus and all instances of AztecAddress
+ * should have a value less than or equal to this max value. This class also provides helper functions to convert
+ * addresses from strings, buffers, and other formats.
+ */
+export class AztecAddress {
+    constructor(
+    /**
+     * The buffer field.
+     */
+    buffer) {
+        this.buffer = buffer;
+        const value = toBigIntBE(buffer);
+        if (value > AztecAddress.MAX_VALUE) {
+            throw new Error(`AztecAddress out of range ${value}.`);
+        }
+    }
+    /**
+     * Generates a random AztecAddress instance, using the Fr field (a finite field) to create a random value
+     * within a valid range and then converting it into a Buffer of a fixed size in bytes.
+     *
+     * @returns A new AztecAddress instance with a random value.
+     */
+    static random() {
+        return new AztecAddress(toBufferBE(Fr.random().value, AztecAddress.SIZE_IN_BYTES));
+    }
+    /**
+     * Creates an AztecAddress instance from a given buffer or BufferReader.
+     * If the input is a Buffer, it wraps it in a BufferReader before processing.
+     * Throws an error if the input length is not equal to the expected size.
+     *
+     * @param buffer - The input buffer or BufferReader containing the address data.
+     * @returns - A new AztecAddress instance with the extracted address data.
+     */
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new this(reader.readBytes(this.SIZE_IN_BYTES));
+    }
+    /**
+     * Create an AztecAddress instance from a hex-encoded string.
+     * The input 'address' should be prefixed with '0x' or not, and have exactly 64 hex characters.
+     * Throws an error if the input length is invalid or address value is out of range.
+     *
+     * @param address - The hex-encoded string representing the Aztec address.
+     * @returns An AztecAddress instance.
+     */
+    static fromString(address) {
+        const buf = Buffer.from(address.replace(/^0x/i, ''), 'hex');
+        if (buf.length !== AztecAddress.SIZE_IN_BYTES) {
+            throw new Error(`Invalid length ${buf.length}.`);
+        }
+        return new AztecAddress(buf);
+    }
+    /**
+     * Creates an AztecAddress from a bigint.
+     * The provided value must be within the range of a field.
+     * @param address - The bigint representation of the address.
+     * @returns An AztecAddress instance.
+     */
+    static fromBigInt(address) {
+        return new AztecAddress(toBufferBE(address, AztecAddress.SIZE_IN_BYTES));
+    }
+    /**
+     * Converts the AztecAddress instance into a Buffer.
+     * This method should be used when encoding the address for storage, transmission or serialization purposes.
+     *
+     * @returns A Buffer representation of the AztecAddress instance.
+     */
+    toBuffer() {
+        return this.buffer;
+    }
+    /**
+     * Convert the AztecAddress to a hexadecimal string representation, with a "0x" prefix.
+     * The resulting string will have a length of 66 characters (including the prefix).
+     *
+     * @returns A hexadecimal string representation of the AztecAddress.
+     */
+    toString() {
+        return `0x${this.buffer.toString('hex')}`;
+    }
+    /**
+     * Returns a shortened string representation of the AztecAddress, displaying only the first 10 characters and last 4 characters.
+     * This is useful for human-readable displays where the full address is not necessary.
+     *
+     * @returns A shortened string representation of the address.
+     */
+    toShortString() {
+        const str = this.toString();
+        return `${str.slice(0, 10)}...${str.slice(-4)}`;
+    }
+    /**
+     * Returns this address from a Field element.
+     * @param field - The Field element to convert.
+     * @returns An Address Object from a Field element with the same value.
+     */
+    static fromField(field) {
+        return new AztecAddress(toBufferBE(field.value, AztecAddress.SIZE_IN_BYTES));
+    }
+    /**
+     * Returns this address as a field element.
+     * @returns A field element with the same value as the address.
+     */
+    toField() {
+        return Fr.fromBuffer(this.toBuffer());
+    }
+    /**
+     * Returns this address as a bigint. Useful for creating maps indexed by addresses.
+     * @returns A bigint with the same value as the address.
+     */
+    toBigInt() {
+        return toBigIntBE(this.buffer);
+    }
+    /**
+     * Determines if this AztecAddress instance is equal to the given AztecAddress instance.
+     * Equality is based on the content of their respective buffers.
+     *
+     * @param other - The AztecAddress instance to compare against.
+     * @returns True if the buffers of both instances are equal, false otherwise.
+     */
+    equals(other) {
+        return this.buffer.equals(other.buffer);
+    }
+    /**
+     * Checks if the AztecAddress is zero.
+     *
+     * @returns Returns true if the AztecAddress is equal to the zero address, otherwise returns false.
+     */
+    isZero() {
+        return this.equals(AztecAddress.ZERO);
+    }
+    /**
+     * Friendly representation for debugging purposes.
+     *
+     * @returns A hex string representing the address.
+     */
+    toFriendlyJSON() {
+        return this.toString();
+    }
+}
+AztecAddress.SIZE_IN_BYTES = 32;
+AztecAddress.ZERO = new AztecAddress(Buffer.alloc(AztecAddress.SIZE_IN_BYTES));
+AztecAddress.MODULUS = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001n;
+AztecAddress.MAX_VALUE = AztecAddress.MODULUS - 1n;
+//# sourceMappingURL=data:application/json;base64,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

package/dest/bigint-buffer/bigint-buffer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bigint-buffer.test.d.ts.map

package/dest/bigint-buffer/bigint-buffer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigint-buffer.test.d.ts","sourceRoot":"","sources":["../../src/bigint-buffer/bigint-buffer.test.ts"],"names":[],"mappings":""}

package/dest/bigint-buffer/bigint-buffer.test.js

@@ -0,0 +1,18 @@
+import { toHex } from './index.js';
+describe('bigint-buffer', () => {
+    describe('toHex', () => {
+        it('does not pad even length', () => {
+            expect(toHex(16n)).toEqual('0x10');
+        });
+        it('pads odd length hex to even length', () => {
+            expect(toHex(10n)).toEqual('0x0a');
+        });
+        it('pads zero to even length', () => {
+            expect(toHex(0n)).toEqual('0x00');
+        });
+        it('pads zero to 32 bytes', () => {
+            expect(toHex(0n, true)).toEqual('0x0000000000000000000000000000000000000000000000000000000000000000');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmlnaW50LWJ1ZmZlci50ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2JpZ2ludC1idWZmZXIvYmlnaW50LWJ1ZmZlci50ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFbkMsUUFBUSxDQUFDLGVBQWUsRUFBRSxHQUFHLEVBQUU7SUFDN0IsUUFBUSxDQUFDLE9BQU8sRUFBRSxHQUFHLEVBQUU7UUFDckIsRUFBRSxDQUFDLDBCQUEwQixFQUFFLEdBQUcsRUFBRTtZQUNsQyxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ3JDLENBQUMsQ0FBQyxDQUFDO1FBRUgsRUFBRSxDQUFDLG9DQUFvQyxFQUFFLEdBQUcsRUFBRTtZQUM1QyxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ3JDLENBQUMsQ0FBQyxDQUFDO1FBRUgsRUFBRSxDQUFDLDBCQUEwQixFQUFFLEdBQUcsRUFBRTtZQUNsQyxNQUFNLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ3BDLENBQUMsQ0FBQyxDQUFDO1FBRUgsRUFBRSxDQUFDLHVCQUF1QixFQUFFLEdBQUcsRUFBRTtZQUMvQixNQUFNLENBQUMsS0FBSyxDQUFDLEVBQUUsRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxvRUFBb0UsQ0FBQyxDQUFDO1FBQ3hHLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDLENBQUMsQ0FBQyJ9

package/dest/bigint-buffer/index.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * Convert a little-endian buffer into a BigInt.
+ * @param buf - The little-endian buffer to convert.
+ * @returns A BigInt with the little-endian representation of buf.
+ */
+export declare function toBigIntLE(buf: Buffer): bigint;
+/**
+ * Convert a big-endian buffer into a BigInt.
+ * @param buf - The big-endian buffer to convert.
+ * @returns A BigInt with the big-endian representation of buf.
+ */
+export declare function toBigIntBE(buf: Buffer): bigint;
+/**
+ * Convert a BigInt to a little-endian buffer.
+ * @param num - The BigInt to convert.
+ * @param width - The number of bytes that the resulting buffer should be.
+ * @returns A little-endian buffer representation of num.
+ */
+export declare function toBufferLE(num: bigint, width: number): Buffer;
+/**
+ * Convert a BigInt to a big-endian buffer.
+ * @param num - The BigInt to convert.
+ * @param width - The number of bytes that the resulting buffer should be.
+ * @returns A big-endian buffer representation of num.
+ */
+export declare function toBufferBE(num: bigint, width: number): Buffer;
+/**
+ * Converts a BigInt to its hex representation.
+ * @param num - The BigInt to convert.
+ * @param padTo32 - Whether to pad the resulting string to 32 bytes.
+ * @returns An even-length 0x-prefixed string.
+ */
+export declare function toHex(num: bigint, padTo32?: boolean): `0x${string}`;
+//# sourceMappingURL=index.d.ts.map

package/dest/bigint-buffer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bigint-buffer/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ9C;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAM9C;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAM7D;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAM7D;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,UAAQ,GAAG,KAAK,MAAM,EAAE,CAKjE"}

package/dest/bigint-buffer/index.js

@@ -0,0 +1,68 @@
+/**
+ * Convert a little-endian buffer into a BigInt.
+ * @param buf - The little-endian buffer to convert.
+ * @returns A BigInt with the little-endian representation of buf.
+ */
+export function toBigIntLE(buf) {
+    const reversed = Buffer.from(buf);
+    reversed.reverse();
+    const hex = reversed.toString('hex');
+    if (hex.length === 0) {
+        return BigInt(0);
+    }
+    return BigInt(`0x${hex}`);
+}
+/**
+ * Convert a big-endian buffer into a BigInt.
+ * @param buf - The big-endian buffer to convert.
+ * @returns A BigInt with the big-endian representation of buf.
+ */
+export function toBigIntBE(buf) {
+    const hex = buf.toString('hex');
+    if (hex.length === 0) {
+        return BigInt(0);
+    }
+    return BigInt(`0x${hex}`);
+}
+/**
+ * Convert a BigInt to a little-endian buffer.
+ * @param num - The BigInt to convert.
+ * @param width - The number of bytes that the resulting buffer should be.
+ * @returns A little-endian buffer representation of num.
+ */
+export function toBufferLE(num, width) {
+    if (num < BigInt(0))
+        throw new Error(`Cannot convert negative bigint ${num.toString()} to buffer with toBufferLE.`);
+    const hex = num.toString(16);
+    const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
+    buffer.reverse();
+    return buffer;
+}
+/**
+ * Convert a BigInt to a big-endian buffer.
+ * @param num - The BigInt to convert.
+ * @param width - The number of bytes that the resulting buffer should be.
+ * @returns A big-endian buffer representation of num.
+ */
+export function toBufferBE(num, width) {
+    if (num < BigInt(0))
+        throw new Error(`Cannot convert negative bigint ${num.toString()} to buffer with toBufferBE.`);
+    const hex = num.toString(16);
+    const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
+    if (buffer.length > width)
+        throw new Error(`Number ${num.toString(16)} does not fit in ${width}`);
+    return buffer;
+}
+/**
+ * Converts a BigInt to its hex representation.
+ * @param num - The BigInt to convert.
+ * @param padTo32 - Whether to pad the resulting string to 32 bytes.
+ * @returns An even-length 0x-prefixed string.
+ */
+export function toHex(num, padTo32 = false) {
+    const str = num.toString(16);
+    const targetLen = str.length % 2 === 0 ? str.length : str.length + 1;
+    const paddedStr = str.padStart(padTo32 ? 64 : targetLen, '0');
+    return `0x${paddedStr}`;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYmlnaW50LWJ1ZmZlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLFVBQVUsQ0FBQyxHQUFXO0lBQ3BDLE1BQU0sUUFBUSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDbEMsUUFBUSxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQ25CLE1BQU0sR0FBRyxHQUFHLFFBQVEsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDckMsSUFBSSxHQUFHLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRTtRQUNwQixPQUFPLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQztLQUNsQjtJQUNELE9BQU8sTUFBTSxDQUFDLEtBQUssR0FBRyxFQUFFLENBQUMsQ0FBQztBQUM1QixDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxVQUFVLENBQUMsR0FBVztJQUNwQyxNQUFNLEdBQUcsR0FBRyxHQUFHLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ2hDLElBQUksR0FBRyxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUU7UUFDcEIsT0FBTyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUM7S0FDbEI7SUFDRCxPQUFPLE1BQU0sQ0FBQyxLQUFLLEdBQUcsRUFBRSxDQUFDLENBQUM7QUFDNUIsQ0FBQztBQUVEOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLFVBQVUsQ0FBQyxHQUFXLEVBQUUsS0FBYTtJQUNuRCxJQUFJLEdBQUcsR0FBRyxNQUFNLENBQUMsQ0FBQyxDQUFDO1FBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyxrQ0FBa0MsR0FBRyxDQUFDLFFBQVEsRUFBRSw2QkFBNkIsQ0FBQyxDQUFDO0lBQ3BILE1BQU0sR0FBRyxHQUFHLEdBQUcsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDN0IsTUFBTSxNQUFNLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLEtBQUssR0FBRyxDQUFDLEVBQUUsR0FBRyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxLQUFLLEdBQUcsQ0FBQyxDQUFDLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDcEYsTUFBTSxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQ2pCLE9BQU8sTUFBTSxDQUFDO0FBQ2hCLENBQUM7QUFFRDs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSxVQUFVLENBQUMsR0FBVyxFQUFFLEtBQWE7SUFDbkQsSUFBSSxHQUFHLEdBQUcsTUFBTSxDQUFDLENBQUMsQ0FBQztRQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsa0NBQWtDLEdBQUcsQ0FBQyxRQUFRLEVBQUUsNkJBQTZCLENBQUMsQ0FBQztJQUNwSCxNQUFNLEdBQUcsR0FBRyxHQUFHLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQzdCLE1BQU0sTUFBTSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxLQUFLLEdBQUcsQ0FBQyxFQUFFLEdBQUcsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsS0FBSyxHQUFHLENBQUMsQ0FBQyxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBQ3BGLElBQUksTUFBTSxDQUFDLE1BQU0sR0FBRyxLQUFLO1FBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyxVQUFVLEdBQUcsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLG9CQUFvQixLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBQ2xHLE9BQU8sTUFBTSxDQUFDO0FBQ2hCLENBQUM7QUFFRDs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSxLQUFLLENBQUMsR0FBVyxFQUFFLE9BQU8sR0FBRyxLQUFLO0lBQ2hELE1BQU0sR0FBRyxHQUFHLEdBQUcsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDN0IsTUFBTSxTQUFTLEdBQUcsR0FBRyxDQUFDLE1BQU0sR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQztJQUNyRSxNQUFNLFNBQVMsR0FBRyxHQUFHLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxTQUFTLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDOUQsT0FBTyxLQUFLLFNBQVMsRUFBRSxDQUFDO0FBQzFCLENBQUMifQ==

package/dest/collection/array.d.ts

@@ -0,0 +1,30 @@
+import { Tuple } from '../serialize/types.js';
+/**
+ * Pads an array to the target length by appending an element to its end. Throws if target length exceeds the input array length. Does not modify the input array.
+ * @param arr - Array with elements to pad.
+ * @param elem - Element to use for padding.
+ * @param length - Target length.
+ * @returns A new padded array.
+ */
+export declare function padArrayEnd<T, N extends number>(arr: T[], elem: T, length: N): Tuple<T, N>;
+/**
+ * Pads an array to the target length by prepending elements at the beginning. Throws if target length exceeds the input array length. Does not modify the input array.
+ * @param arr - Array with elements to pad.
+ * @param elem - Element to use for padding.
+ * @param length - Target length.
+ * @returns A new padded array.
+ */
+export declare function padArrayStart<T, N extends number>(arr: T[], elem: T, length: N): Tuple<T, N>;
+/**
+ * Returns if an array is composed of empty items.
+ * @param arr - Array to check.
+ * @returns True if every item in the array isEmpty.
+ */
+export declare function isArrayEmpty<T>(arr: T[], isEmpty: (item: T) => boolean): boolean;
+/**
+ * Returns the number of non-empty items in an array.
+ * @param arr - Array to check.
+ * @returns Number of non-empty items in an array.
+ */
+export declare function arrayNonEmptyLength<T>(arr: T[], isEmpty: (item: T) => boolean): number;
+//# sourceMappingURL=array.d.ts.map

package/dest/collection/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/collection/array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAI1F;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAI5F;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAKhF;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAAG,MAAM,CAEtF"}

package/dest/collection/array.js

@@ -0,0 +1,47 @@
+/**
+ * Pads an array to the target length by appending an element to its end. Throws if target length exceeds the input array length. Does not modify the input array.
+ * @param arr - Array with elements to pad.
+ * @param elem - Element to use for padding.
+ * @param length - Target length.
+ * @returns A new padded array.
+ */
+export function padArrayEnd(arr, elem, length) {
+    if (arr.length > length)
+        throw new Error(`Array size exceeds target length`);
+    // Since typescript cannot always deduce that something is a tuple, we cast
+    return [...arr, ...Array(length - arr.length).fill(elem)];
+}
+/**
+ * Pads an array to the target length by prepending elements at the beginning. Throws if target length exceeds the input array length. Does not modify the input array.
+ * @param arr - Array with elements to pad.
+ * @param elem - Element to use for padding.
+ * @param length - Target length.
+ * @returns A new padded array.
+ */
+export function padArrayStart(arr, elem, length) {
+    if (arr.length > length)
+        throw new Error(`Array size exceeds target length`);
+    // Since typescript cannot always deduce that something is a tuple, we cast
+    return [...Array(length - arr.length).fill(elem), ...arr];
+}
+/**
+ * Returns if an array is composed of empty items.
+ * @param arr - Array to check.
+ * @returns True if every item in the array isEmpty.
+ */
+export function isArrayEmpty(arr, isEmpty) {
+    for (const item of arr) {
+        if (!isEmpty(item))
+            return false;
+    }
+    return true;
+}
+/**
+ * Returns the number of non-empty items in an array.
+ * @param arr - Array to check.
+ * @returns Number of non-empty items in an array.
+ */
+export function arrayNonEmptyLength(arr, isEmpty) {
+    return arr.reduce((sum, item) => (isEmpty(item) ? sum : sum + 1), 0);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29sbGVjdGlvbi9hcnJheS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7Ozs7O0dBTUc7QUFDSCxNQUFNLFVBQVUsV0FBVyxDQUFzQixHQUFRLEVBQUUsSUFBTyxFQUFFLE1BQVM7SUFDM0UsSUFBSSxHQUFHLENBQUMsTUFBTSxHQUFHLE1BQU07UUFBRSxNQUFNLElBQUksS0FBSyxDQUFDLGtDQUFrQyxDQUFDLENBQUM7SUFDN0UsMkVBQTJFO0lBQzNFLE9BQU8sQ0FBQyxHQUFHLEdBQUcsRUFBRSxHQUFHLEtBQUssQ0FBQyxNQUFNLEdBQUcsR0FBRyxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBZ0IsQ0FBQztBQUMzRSxDQUFDO0FBRUQ7Ozs7OztHQU1HO0FBQ0gsTUFBTSxVQUFVLGFBQWEsQ0FBc0IsR0FBUSxFQUFFLElBQU8sRUFBRSxNQUFTO0lBQzdFLElBQUksR0FBRyxDQUFDLE1BQU0sR0FBRyxNQUFNO1FBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyxrQ0FBa0MsQ0FBQyxDQUFDO0lBQzdFLDJFQUEyRTtJQUMzRSxPQUFPLENBQUMsR0FBRyxLQUFLLENBQUMsTUFBTSxHQUFHLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsR0FBRyxHQUFHLENBQWdCLENBQUM7QUFDM0UsQ0FBQztBQUVEOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsWUFBWSxDQUFJLEdBQVEsRUFBRSxPQUE2QjtJQUNyRSxLQUFLLE1BQU0sSUFBSSxJQUFJLEdBQUcsRUFBRTtRQUN0QixJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQztZQUFFLE9BQU8sS0FBSyxDQUFDO0tBQ2xDO0lBQ0QsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxtQkFBbUIsQ0FBSSxHQUFRLEVBQUUsT0FBNkI7SUFDNUUsT0FBTyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUMsR0FBRyxFQUFFLElBQUksRUFBRSxFQUFFLENBQUMsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsR0FBRyxHQUFHLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0FBQ3ZFLENBQUMifQ==

package/dest/collection/index.d.ts

@@ -0,0 +1,2 @@
+export * from './array.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/collection/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/collection/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dest/collection/index.js

@@ -0,0 +1,2 @@
+export * from './array.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29sbGVjdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFlBQVksQ0FBQyJ9

package/dest/committable/committable.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A class that allows for a value to be committed or rolled back.
+ */
+export declare class Committable<T> {
+    private currentValue;
+    private nextValue;
+    constructor(initialValue: T);
+    /**
+     * Commits the uncommitted value.
+     */
+    commit(): void;
+    /**
+     * Rolls back the uncommitted value.
+     */
+    rollback(): void;
+    /**
+     * Gets the current value.
+     * @param includeUncommitted - Whether to include the uncommitted value.
+     * @returns The current value if includeUncommitted is false, otherwise the uncommitted value.
+     */
+    get(includeUncommitted?: boolean): T;
+    /**
+     * Sets the next value to be committed to.
+     * @param value - The new value to be set.
+     */
+    set(value: T): void;
+}
+//# sourceMappingURL=committable.d.ts.map

package/dest/committable/committable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"committable.d.ts","sourceRoot":"","sources":["../../src/committable/committable.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,WAAW,CAAC,CAAC;IACxB,OAAO,CAAC,YAAY,CAAI;IACxB,OAAO,CAAC,SAAS,CAA4B;gBAEjC,YAAY,EAAE,CAAC;IAI3B;;OAEG;IACI,MAAM;IAQb;;OAEG;IACI,QAAQ;IAIf;;;;OAIG;IACI,GAAG,CAAC,kBAAkB,GAAE,OAAe,GAAG,CAAC;IAIlD;;;OAGG;IACI,GAAG,CAAC,KAAK,EAAE,CAAC;CAGpB"}

package/dest/committable/committable.js

@@ -0,0 +1,41 @@
+/**
+ * A class that allows for a value to be committed or rolled back.
+ */
+export class Committable {
+    constructor(initialValue) {
+        this.nextValue = undefined;
+        this.currentValue = initialValue;
+    }
+    /**
+     * Commits the uncommitted value.
+     */
+    commit() {
+        if (this.nextValue === undefined) {
+            return;
+        }
+        this.currentValue = this.nextValue;
+        this.nextValue = undefined;
+    }
+    /**
+     * Rolls back the uncommitted value.
+     */
+    rollback() {
+        this.nextValue === undefined;
+    }
+    /**
+     * Gets the current value.
+     * @param includeUncommitted - Whether to include the uncommitted value.
+     * @returns The current value if includeUncommitted is false, otherwise the uncommitted value.
+     */
+    get(includeUncommitted = false) {
+        return includeUncommitted && this.nextValue ? this.nextValue : this.currentValue;
+    }
+    /**
+     * Sets the next value to be committed to.
+     * @param value - The new value to be set.
+     */
+    set(value) {
+        this.nextValue = value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbWl0dGFibGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29tbWl0dGFibGUvY29tbWl0dGFibGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLE9BQU8sV0FBVztJQUl0QixZQUFZLFlBQWU7UUFGbkIsY0FBUyxHQUFrQixTQUFTLENBQUM7UUFHM0MsSUFBSSxDQUFDLFlBQVksR0FBRyxZQUFZLENBQUM7SUFDbkMsQ0FBQztJQUVEOztPQUVHO0lBQ0ksTUFBTTtRQUNYLElBQUksSUFBSSxDQUFDLFNBQVMsS0FBSyxTQUFTLEVBQUU7WUFDaEMsT0FBTztTQUNSO1FBQ0QsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDO1FBQ25DLElBQUksQ0FBQyxTQUFTLEdBQUcsU0FBUyxDQUFDO0lBQzdCLENBQUM7SUFFRDs7T0FFRztJQUNJLFFBQVE7UUFDYixJQUFJLENBQUMsU0FBUyxLQUFLLFNBQVMsQ0FBQztJQUMvQixDQUFDO0lBRUQ7Ozs7T0FJRztJQUNJLEdBQUcsQ0FBQyxxQkFBOEIsS0FBSztRQUM1QyxPQUFPLGtCQUFrQixJQUFJLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUM7SUFDbkYsQ0FBQztJQUVEOzs7T0FHRztJQUNJLEdBQUcsQ0FBQyxLQUFRO1FBQ2pCLElBQUksQ0FBQyxTQUFTLEdBQUcsS0FBSyxDQUFDO0lBQ3pCLENBQUM7Q0FDRiJ9

package/dest/committable/committable.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=committable.test.d.ts.map

package/dest/committable/committable.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"committable.test.d.ts","sourceRoot":"","sources":["../../src/committable/committable.test.ts"],"names":[],"mappings":""}