@aztec/foundation 0.0.0-test.0

package/dest/fields/point.js

@@ -0,0 +1,260 @@
+import { toBigIntBE } from '../bigint-buffer/index.js';
+import { poseidon2Hash } from '../crypto/poseidon/index.js';
+import { randomBoolean } from '../crypto/random/index.js';
+import { hexSchemaFor } from '../schemas/utils.js';
+import { BufferReader, FieldReader, serializeToBuffer } from '../serialize/index.js';
+import { bufferToHex, hexToBuffer } from '../string/index.js';
+import { Fr } from './fields.js';
+/**
+ * Represents a Point on an elliptic curve with x and y coordinates.
+ * The Point class provides methods for creating instances from different input types,
+ * converting instances to various output formats, and checking the equality of points.
+ * TODO(#7386): Clean up this class.
+ */ export class Point {
+    x;
+    y;
+    isInfinite;
+    static ZERO = new Point(Fr.ZERO, Fr.ZERO, false);
+    static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * 2;
+    static COMPRESSED_SIZE_IN_BYTES = Fr.SIZE_IN_BYTES;
+    /** Used to differentiate this class from AztecAddress */ kind;
+    constructor(/**
+     * The point's x coordinate
+     */ x, /**
+     * The point's y coordinate
+     */ y, /**
+     * Whether the point is at infinity
+     */ isInfinite){
+        this.x = x;
+        this.y = y;
+        this.isInfinite = isInfinite;
+        this.kind = 'point';
+    // TODO(#7386): check if on curve
+    }
+    toJSON() {
+        return this.toString();
+    }
+    static get schema() {
+        return hexSchemaFor(Point);
+    }
+    /**
+   * Generate a random Point instance.
+   *
+   * @returns A randomly generated Point instance.
+   */ static async random() {
+        while(true){
+            try {
+                return await Point.fromXAndSign(Fr.random(), randomBoolean());
+            } catch (e) {
+                if (!(e instanceof NotOnCurveError)) {
+                    throw e;
+                }
+                continue;
+            }
+        }
+    }
+    /**
+   * Create a Point instance from a given buffer or BufferReader.
+   * The input 'buffer' should have exactly 64 bytes representing the x and y coordinates.
+   *
+   * @param buffer - The buffer or BufferReader containing the x and y coordinates of the point.
+   * @returns A Point instance.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new this(Fr.fromBuffer(reader), Fr.fromBuffer(reader), false);
+    }
+    /**
+   * Create a Point instance from a compressed buffer.
+   * The input 'buffer' should have exactly 33 bytes representing the x coordinate and the sign of the y coordinate.
+   *
+   * @param buffer - The buffer containing the x coordinate and the sign of the y coordinate.
+   * @returns A Point instance.
+   */ static fromCompressedBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const value = toBigIntBE(reader.readBytes(Point.COMPRESSED_SIZE_IN_BYTES));
+        const x = new Fr(value & (1n << 255n) - 1n);
+        const sign = (value & 1n << 255n) !== 0n;
+        return this.fromXAndSign(x, sign);
+    }
+    /**
+   * Create a Point instance from a hex-encoded string.
+   * The input should be prefixed with '0x' or not, and have exactly 128 hex characters representing the x and y coordinates.
+   * Throws an error if the input length is invalid or coordinate values are out of range.
+   *
+   * @param str - The hex-encoded string representing the Point coordinates.
+   * @returns A Point instance.
+   */ static fromString(str) {
+        return this.fromBuffer(hexToBuffer(str));
+    }
+    /**
+   * Returns the contents of the point as an array of 2 fields.
+   * @returns The point as an array of 2 fields
+   */ toFields() {
+        return [
+            this.x,
+            this.y,
+            new Fr(this.isInfinite)
+        ];
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new this(reader.readField(), reader.readField(), reader.readBoolean());
+    }
+    /**
+   * Uses the x coordinate and isPositive flag (+/-) to reconstruct the point.
+   * @dev The y coordinate can be derived from the x coordinate and the "sign" flag by solving the grumpkin curve
+   * equation for y.
+   * @param x - The x coordinate of the point
+   * @param sign - The "sign" of the y coordinate - note that this is not a sign as is known in integer arithmetic.
+   * Instead it is a boolean flag that determines whether the y coordinate is <= (Fr.MODULUS - 1) / 2
+   * @returns The point as an array of 2 fields
+   */ static async fromXAndSign(x, sign) {
+        const y = await Point.YFromX(x);
+        if (y == null) {
+            throw new NotOnCurveError(x);
+        }
+        const yPositiveBigInt = y.toBigInt() <= (Fr.MODULUS - 1n) / 2n ? y.toBigInt() : Fr.MODULUS - y.toBigInt();
+        const yNegativeBigInt = Fr.MODULUS - yPositiveBigInt;
+        // Choose the positive or negative root based on isPositive
+        const finalY = sign ? new Fr(yPositiveBigInt) : new Fr(yNegativeBigInt);
+        // Create and return the new Point
+        return new this(x, finalY, false);
+    }
+    /**
+   * @returns
+   */ static YFromX(x) {
+        // Calculate y^2 = x^3 - 17 (i.e. the Grumpkin curve equation)
+        const ySquared = x.square().mul(x).sub(new Fr(17));
+        // y is then simply the square root. Note however that not all square roots exist in the field: if sqrt returns null
+        // then there is no point in the curve with this x coordinate.
+        return ySquared.sqrt();
+    }
+    /**
+   * Returns the x coordinate and the sign of the y coordinate.
+   * @dev The y sign can be determined by checking if the y coordinate is greater than half of the modulus.
+   * @returns The x coordinate and the sign of the y coordinate.
+   */ toXAndSign() {
+        return [
+            this.x,
+            this.y.toBigInt() <= (Fr.MODULUS - 1n) / 2n
+        ];
+    }
+    /**
+   * Returns the contents of the point as BigInts.
+   * @returns The point as BigInts
+   */ toBigInts() {
+        return {
+            x: this.x.toBigInt(),
+            y: this.y.toBigInt(),
+            isInfinite: this.isInfinite ? 1n : 0n
+        };
+    }
+    /**
+   * Converts the Point instance to a Buffer representation of the coordinates.
+   * @returns A Buffer representation of the Point instance.
+   * @dev Note that toBuffer does not include the isInfinite flag and other serialization methods do (e.g. toFields).
+   * This is because currently when we work with point as bytes we don't want to populate the extra bytes for
+   * isInfinite flag because:
+   * 1. Our Grumpkin BB API currently does not handle point at infinity,
+   * 2. we use toBuffer when serializing notes and events and there we only work with public keys and point at infinity
+   *   is not considered a valid public key and the extra byte would raise DA cost.
+   */ toBuffer() {
+        if (this.isInfinite) {
+            throw new Error('Cannot serialize infinite point without isInfinite flag');
+        }
+        const buf = serializeToBuffer([
+            this.x,
+            this.y
+        ]);
+        if (buf.length !== Point.SIZE_IN_BYTES) {
+            throw new Error(`Invalid buffer length for Point: ${buf.length}`);
+        }
+        return buf;
+    }
+    /**
+   * Converts the Point instance to a compressed Buffer representation of the coordinates.
+   * @returns A Buffer representation of the Point instance
+   */ toCompressedBuffer() {
+        const [x, sign] = this.toXAndSign();
+        // Here we leverage that Fr fits into 254 bits (log2(Fr.MODULUS) < 254) and given that we serialize Fr to 32 bytes
+        // and we use big-endian the 2 most significant bits are never populated. Hence we can use one of the bits as
+        // a sign bit.
+        const compressedValue = x.toBigInt() + (sign ? 2n ** 255n : 0n);
+        const buf = serializeToBuffer(compressedValue);
+        if (buf.length !== Point.COMPRESSED_SIZE_IN_BYTES) {
+            throw new Error(`Invalid buffer length for compressed Point: ${buf.length}`);
+        }
+        return buf;
+    }
+    /**
+   * Convert the Point instance to a hexadecimal string representation.
+   * The output string is prefixed with '0x' and consists of exactly 128 hex characters,
+   * representing the concatenated x and y coordinates of the point.
+   *
+   * @returns A hex-encoded string representing the Point instance.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    /**
+   * Generate a short string representation of the Point instance.
+   * The returned string includes the first 10 and last 4 characters of the full string representation,
+   * with '...' in between to indicate truncation. This is useful for displaying or logging purposes
+   * when the full string representation may be too long.
+   *
+   * @returns A truncated string representation of the Point instance.
+   */ toShortString() {
+        const str = this.toString();
+        return `${str.slice(0, 10)}...${str.slice(-4)}`;
+    }
+    toNoirStruct() {
+        /* eslint-disable camelcase */ return {
+            x: this.x,
+            y: this.y,
+            is_infinite: this.isInfinite
+        };
+    /* eslint-enable camelcase */ }
+    // Used for IvpkM, OvpkM, NpkM and TpkM. TODO(#8124): Consider removing this method.
+    toWrappedNoirStruct() {
+        /* eslint-disable camelcase */ return {
+            inner: this.toNoirStruct()
+        };
+    /* eslint-enable camelcase */ }
+    /**
+   * Check if two Point instances are equal by comparing their buffer values.
+   * Returns true if the buffer values are the same, and false otherwise.
+   *
+   * @param rhs - The Point instance to compare with the current instance.
+   * @returns A boolean indicating whether the two Point instances are equal.
+   */ equals(rhs) {
+        return this.x.equals(rhs.x) && this.y.equals(rhs.y);
+    }
+    isZero() {
+        return this.x.isZero() && this.y.isZero();
+    }
+    hash() {
+        return poseidon2Hash(this.toFields());
+    }
+    /**
+   * Check if this is point at infinity.
+   * Check this is consistent with how bb is encoding the point at infinity
+   */ get inf() {
+        return this.isInfinite;
+    }
+    isOnGrumpkin() {
+        // TODO: Check this against how bb handles curve check and infinity point check
+        if (this.inf) {
+            return true;
+        }
+        // The Grumpkin equation is y^2 = x^3 - 17. We could use `YFromX` and then compare to `this.y`, but this would
+        // involve computing the square root of y, of which there are two possible valid values. This method is also faster.
+        const lhs = this.y.square();
+        const rhs = this.x.mul(this.x).mul(this.x).sub(new Fr(17));
+        return lhs.equals(rhs);
+    }
+}
+export class NotOnCurveError extends Error {
+    constructor(x){
+        super('The given x-coordinate is not on the Grumpkin curve: ' + x.toString());
+        this.name = 'NotOnCurveError';
+    }
+}

package/dest/fs/index.d.ts

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

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

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

package/dest/fs/index.js

@@ -0,0 +1 @@
+export * from './run_in_dir.js';

package/dest/fs/run_in_dir.d.ts

@@ -0,0 +1,2 @@
+export declare function runInDirectory<T>(workingDirBase: string, fn: (dir: string) => Promise<T>, skipCleanup: boolean | undefined, logger?: import("../log/pino-logger.js").Logger): Promise<T>;
+//# sourceMappingURL=run_in_dir.d.ts.map

package/dest/fs/run_in_dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run_in_dir.d.ts","sourceRoot":"","sources":["../../src/fs/run_in_dir.ts"],"names":[],"mappings":"AAOA,wBAAsB,cAAc,CAAC,CAAC,EACpC,cAAc,EAAE,MAAM,EACtB,EAAE,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EAC/B,WAAW,EAAE,OAAO,GAAG,SAAS,EAChC,MAAM,yCAA8C,GACnD,OAAO,CAAC,CAAC,CAAC,CAoBZ"}

package/dest/fs/run_in_dir.js

@@ -0,0 +1,31 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { createLogger } from '../log/pino-logger.js';
+// Create a random directory underneath a 'base' directory
+// Calls a provided method, ensures the random directory is cleaned up afterwards unless the operation fails
+export async function runInDirectory(workingDirBase, fn, skipCleanup, logger = createLogger('foundation:run-in-directory')) {
+    // Create random directory to be used for temp files
+    const workingDirectory = await fs.mkdtemp(path.join(workingDirBase, 'tmp-'));
+    await fs.access(workingDirectory);
+    try {
+        return await fn(workingDirectory);
+    } catch (err) {
+        skipCleanup = true;
+        throw err;
+    } finally{
+        if (!skipCleanup) {
+            try {
+                await fs.rm(workingDirectory, {
+                    recursive: true,
+                    force: true,
+                    maxRetries: 3,
+                    retryDelay: 100
+                });
+            } catch (err) {
+                logger.warn(`Failed to cleanup temporary directory ${workingDirectory}: ${err}`, {
+                    err
+                });
+            }
+        }
+    }
+}

package/dest/index.d.ts

@@ -0,0 +1,31 @@
+export * as asyncMap from './async-map/index.js';
+export * as bigintBuffer from './bigint-buffer/index.js';
+export * as collection from './collection/index.js';
+export * as committable from './committable/index.js';
+export * as crypto from './crypto/index.js';
+export * as errors from './error/index.js';
+export * as ethAddress from './eth-address/index.js';
+export * as fields from './fields/index.js';
+export * as fifo from './queue/index.js';
+export * as fs from './fs/index.js';
+export * as jsonRpc from './json-rpc/index.js';
+export * as jsonRpcClient from './json-rpc/client/index.js';
+export * as jsonRpcServer from './json-rpc/server/index.js';
+export * as log from './log/index.js';
+export * as mutex from './mutex/index.js';
+export * as retry from './retry/index.js';
+export * as runningPromise from './running-promise/index.js';
+export * as serialize from './serialize/index.js';
+export * as sleep from './sleep/index.js';
+export * as timer from './timer/index.js';
+export * as transport from './transport/index.js';
+export * as trees from './trees/index.js';
+export * as types from './types/index.js';
+export * as url from './url/index.js';
+export * as wasm from './wasm/index.js';
+export * as worker from './worker/index.js';
+export * as testing from './testing/index.js';
+export * as config from './config/index.js';
+export * as buffer from './buffer/index.js';
+export * as ethSignature from './eth-signature/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AACjD,OAAO,KAAK,YAAY,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,UAAU,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,WAAW,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAC5C,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAC3C,OAAO,KAAK,UAAU,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAC5C,OAAO,KAAK,IAAI,MAAM,kBAAkB,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,eAAe,CAAC;AACpC,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAC;AAC/C,OAAO,KAAK,aAAa,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,aAAa,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,GAAG,MAAM,gBAAgB,CAAC;AACtC,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,cAAc,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,SAAS,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,SAAS,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,GAAG,MAAM,gBAAgB,CAAC;AACtC,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAC5C,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAC;AAC9C,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAC5C,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAC5C,OAAO,KAAK,YAAY,MAAM,0BAA0B,CAAC"}

package/dest/index.js

@@ -0,0 +1,31 @@
+// Reexport all folders at the root for packages targeting CommonJS
+export * as asyncMap from './async-map/index.js';
+export * as bigintBuffer from './bigint-buffer/index.js';
+export * as collection from './collection/index.js';
+export * as committable from './committable/index.js';
+export * as crypto from './crypto/index.js';
+export * as errors from './error/index.js';
+export * as ethAddress from './eth-address/index.js';
+export * as fields from './fields/index.js';
+export * as fifo from './queue/index.js';
+export * as fs from './fs/index.js';
+export * as jsonRpc from './json-rpc/index.js';
+export * as jsonRpcClient from './json-rpc/client/index.js';
+export * as jsonRpcServer from './json-rpc/server/index.js';
+export * as log from './log/index.js';
+export * as mutex from './mutex/index.js';
+export * as retry from './retry/index.js';
+export * as runningPromise from './running-promise/index.js';
+export * as serialize from './serialize/index.js';
+export * as sleep from './sleep/index.js';
+export * as timer from './timer/index.js';
+export * as transport from './transport/index.js';
+export * as trees from './trees/index.js';
+export * as types from './types/index.js';
+export * as url from './url/index.js';
+export * as wasm from './wasm/index.js';
+export * as worker from './worker/index.js';
+export * as testing from './testing/index.js';
+export * as config from './config/index.js';
+export * as buffer from './buffer/index.js';
+export * as ethSignature from './eth-signature/index.js';

package/dest/iterable/all.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Collects all values from an (async) iterable and returns them as an array
+ * @param source - Iterable to collect all values from
+ * @returns All of the iterable's values as an array.
+ */
+declare function all<T>(source: Iterable<T>): T[];
+declare function all<T>(source: Iterable<T> | AsyncIterable<T>): Promise<T[]>;
+export { all };
+//# sourceMappingURL=all.d.ts.map

package/dest/iterable/all.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../../src/iterable/all.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,iBAAS,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;AAC1C,iBAAS,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;AAuBtE,OAAO,EAAE,GAAG,EAAE,CAAC"}

package/dest/iterable/all.js

@@ -0,0 +1,18 @@
+import { isAsyncIterable } from './isAsyncIt.js';
+function all(source) {
+    if (isAsyncIterable(source)) {
+        return (async ()=>{
+            const arr = [];
+            for await (const entry of source){
+                arr.push(entry);
+            }
+            return arr;
+        })();
+    }
+    const arr = [];
+    for (const entry of source){
+        arr.push(entry);
+    }
+    return arr;
+}
+export { all };

package/dest/iterable/filter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Filters the passed (async) iterable by using the filter function.
+ * @param source - An iterable to filter.
+ * @returns A generator of the filtered values.
+ */
+declare function filter<T>(source: Iterable<T>, fn: (val: T, index: number) => Promise<boolean>): AsyncGenerator<T, void, undefined>;
+declare function filter<T>(source: Iterable<T>, fn: (val: T, index: number) => boolean): Generator<T, void, undefined>;
+declare function filter<T>(source: Iterable<T> | AsyncIterable<T>, fn: (val: T, index: number) => boolean | Promise<boolean>): AsyncGenerator<T, void, undefined>;
+export { filter };
+//# sourceMappingURL=filter.d.ts.map

package/dest/iterable/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/iterable/filter.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,iBAAS,MAAM,CAAC,CAAC,EACf,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EACnB,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GAC9C,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;AACtC,iBAAS,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;AAC/G,iBAAS,MAAM,CAAC,CAAC,EACf,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,EACtC,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GACxD,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;AAyDtC,OAAO,EAAE,MAAM,EAAE,CAAC"}

package/dest/iterable/filter.js

@@ -0,0 +1,48 @@
+import { peek } from './peek.js';
+function isAsyncIterable(thing) {
+    return thing[Symbol.asyncIterator] != null;
+}
+function filter(source, fn) {
+    let index = 0;
+    if (isAsyncIterable(source)) {
+        return async function*() {
+            for await (const entry of source){
+                if (await fn(entry, index++)) {
+                    yield entry;
+                }
+            }
+        }();
+    }
+    // if mapping function returns a promise we have to return an async generator
+    const peekable = peek(source);
+    const { value, done } = peekable.next();
+    if (done === true) {
+        return function*() {}();
+    }
+    const res = fn(value, index++);
+    // @ts-expect-error .then is not present on O
+    if (typeof res.then === 'function') {
+        return async function*() {
+            if (await res) {
+                yield value;
+            }
+            for await (const entry of peekable){
+                if (await fn(entry, index++)) {
+                    yield entry;
+                }
+            }
+        }();
+    }
+    const func = fn;
+    return function*() {
+        if (res === true) {
+            yield value;
+        }
+        for (const entry of peekable){
+            if (func(entry, index++)) {
+                yield entry;
+            }
+        }
+    }();
+}
+export { filter };

package/dest/iterable/index.d.ts

@@ -0,0 +1,8 @@
+export * from './map.js';
+export * from './filter.js';
+export * from './sort.js';
+export * from './take.js';
+export * from './all.js';
+export * from './peek.js';
+export * from './toArray.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/iterable/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC"}

package/dest/iterable/index.js

@@ -0,0 +1,7 @@
+export * from './map.js';
+export * from './filter.js';
+export * from './sort.js';
+export * from './take.js';
+export * from './all.js';
+export * from './peek.js';
+export * from './toArray.js';

package/dest/iterable/isAsyncIt.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Utility function to type check an AsyncIterable
+ * @param thing - Input to type check
+ * @returns Type-checked input
+ */
+export declare function isAsyncIterable<T>(thing: any): thing is AsyncIterable<T>;
+//# sourceMappingURL=isAsyncIt.d.ts.map

package/dest/iterable/isAsyncIt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isAsyncIt.d.ts","sourceRoot":"","sources":["../../src/iterable/isAsyncIt.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,aAAa,CAAC,CAAC,CAAC,CAExE"}

package/dest/iterable/isAsyncIt.js

@@ -0,0 +1,7 @@
+/**
+ * Utility function to type check an AsyncIterable
+ * @param thing - Input to type check
+ * @returns Type-checked input
+ */ export function isAsyncIterable(thing) {
+    return thing[Symbol.asyncIterator] != null;
+}

package/dest/iterable/map.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Takes an (async) iterable and returns one with each item mapped by the passed
+ * function.
+ * @param source - The iterable to run the map function on.
+ * @param func - The function to run over the iterable's items.
+ * @returns A generator of the mapped items.
+ */
+declare function map<I, O>(source: Iterable<I>, func: (val: I, index: number) => Promise<O>): AsyncGenerator<O, void, undefined>;
+declare function map<I, O>(source: Iterable<I>, func: (val: I, index: number) => O): Generator<O, void, undefined>;
+declare function map<I, O>(source: AsyncIterable<I> | Iterable<I>, func: (val: I, index: number) => O | Promise<O>): AsyncGenerator<O, void, undefined>;
+export { map };
+//# sourceMappingURL=map.d.ts.map

package/dest/iterable/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/iterable/map.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,iBAAS,GAAG,CAAC,CAAC,EAAE,CAAC,EACf,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EACnB,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAC1C,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;AACtC,iBAAS,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;AAC3G,iBAAS,GAAG,CAAC,CAAC,EAAE,CAAC,EACf,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,EACtC,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAC9C,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;AA+CtC,OAAO,EAAE,GAAG,EAAE,CAAC"}

package/dest/iterable/map.js

@@ -0,0 +1,36 @@
+import { isAsyncIterable } from './isAsyncIt.js';
+import { peek } from './peek.js';
+function map(source, func) {
+    let index = 0;
+    if (isAsyncIterable(source)) {
+        return async function*() {
+            for await (const val of source){
+                yield func(val, index++);
+            }
+        }();
+    }
+    // if mapping function returns a promise we have to return an async generator
+    const peekable = peek(source);
+    const { value, done } = peekable.next();
+    if (done === true) {
+        return function*() {}();
+    }
+    const res = func(value, index++);
+    // @ts-expect-error .then is not present on O
+    if (typeof res.then === 'function') {
+        return async function*() {
+            yield await res;
+            for await (const val of peekable){
+                yield func(val, index++);
+            }
+        }();
+    }
+    const fn = func;
+    return function*() {
+        yield res;
+        for (const val of peekable){
+            yield fn(val, index++);
+        }
+    }();
+}
+export { map };

package/dest/iterable/peek.d.ts

@@ -0,0 +1,19 @@
+export interface Peek<T> {
+    peek(): IteratorResult<T, undefined>;
+}
+export interface AsyncPeek<T> {
+    peek(): Promise<IteratorResult<T, undefined>>;
+}
+export interface Push<T> {
+    push(value: T): void;
+}
+export type Peekable<T> = Iterable<T> & Peek<T> & Push<T> & Iterator<T>;
+export type AsyncPeekable<T> = AsyncIterable<T> & AsyncPeek<T> & Push<T> & AsyncIterator<T>;
+/**
+ * Utility function that allows peeking into the contents of an async iterator.
+ * @param iterable - The async iterator to peek the values of.
+ */
+declare function peekable<T>(iterable: Iterable<T>): Peekable<T>;
+declare function peekable<T>(iterable: AsyncIterable<T>): AsyncPeekable<T>;
+export { peekable as peek };
+//# sourceMappingURL=peek.d.ts.map

package/dest/iterable/peek.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peek.d.ts","sourceRoot":"","sources":["../../src/iterable/peek.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,IAAI,CAAC,CAAC;IACrB,IAAI,IAAI,cAAc,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,SAAS,CAAC,CAAC;IAC1B,IAAI,IAAI,OAAO,CAAC,cAAc,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;CAC/C;AAED,MAAM,WAAW,IAAI,CAAC,CAAC;IACrB,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CACtB;AAED,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAExE,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;AAE5F;;;GAGG;AACH,iBAAS,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AACzD,iBAAS,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;AAoCnE,OAAO,EAAE,QAAQ,IAAI,IAAI,EAAE,CAAC"}

package/dest/iterable/peek.js

@@ -0,0 +1,33 @@
+function peekable(iterable) {
+    const [iterator, symbol] = // @ts-expect-error can't use Symbol.asyncIterator to index iterable since it might be Iterable
+    iterable[Symbol.asyncIterator] != null ? [
+        iterable[Symbol.asyncIterator](),
+        Symbol.asyncIterator
+    ] : [
+        iterable[Symbol.iterator](),
+        Symbol.iterator
+    ];
+    const queue = [];
+    // @ts-expect-error can't use symbol to index peekable
+    return {
+        peek: ()=>{
+            return iterator.next();
+        },
+        push: (value)=>{
+            queue.push(value);
+        },
+        next: ()=>{
+            if (queue.length > 0) {
+                return {
+                    done: false,
+                    value: queue.shift()
+                };
+            }
+            return iterator.next();
+        },
+        [symbol] () {
+            return this;
+        }
+    };
+}
+export { peekable as peek };

package/dest/iterable/sort.d.ts

@@ -0,0 +1,14 @@
+export interface CompareFunction<T> {
+    (a: T, b: T): number;
+}
+/**
+ * Collects all values from an async iterator, sorts them
+ * using the passed function and yields them.
+ * @param source - Iterable to sort.
+ * @param sorter - Sorting function.
+ * @returns A generator of the sorted values.
+ */
+declare function sort<T>(source: Iterable<T>, sorter: CompareFunction<T>): Generator<T, void, undefined>;
+declare function sort<T>(source: Iterable<T> | AsyncIterable<T>, sorter: CompareFunction<T>): AsyncGenerator<T, void, undefined>;
+export { sort };
+//# sourceMappingURL=sort.d.ts.map

package/dest/iterable/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../src/iterable/sort.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC;CACtB;AAED;;;;;;GAMG;AACH,iBAAS,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;AACjG,iBAAS,IAAI,CAAC,CAAC,EACb,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,EACtC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,GACzB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;AAoBtC,OAAO,EAAE,IAAI,EAAE,CAAC"}