@aztec/foundation 0.0.0-test.0

package/dest/fields/fields.js

@@ -0,0 +1,383 @@
+import { BarretenbergSync } from '@aztec/bb.js';
+import { inspect } from 'util';
+import { toBigIntBE, toBufferBE } from '../bigint-buffer/index.js';
+import { randomBytes } from '../crypto/random/index.js';
+import { hexSchemaFor } from '../schemas/utils.js';
+import { BufferReader } from '../serialize/buffer_reader.js';
+import { TypeRegistry } from '../serialize/type_registry.js';
+const ZERO_BUFFER = Buffer.alloc(32);
+/**
+ * Base field class.
+ * Conversions from Buffer to BigInt and vice-versa are not cheap.
+ * We allow construction with either form and lazily convert to other as needed.
+ * We only check we are within the field modulus when initializing with bigint.
+ */ class BaseField {
+    static SIZE_IN_BYTES = 32;
+    asBuffer;
+    asBigInt;
+    /**
+   * Return bigint representation.
+   * @deprecated Just to get things compiling. Use toBigInt().
+   * */ get value() {
+        return this.toBigInt();
+    }
+    /** Returns the size in bytes. */ get size() {
+        return BaseField.SIZE_IN_BYTES;
+    }
+    constructor(value){
+        if (Buffer.isBuffer(value)) {
+            if (value.length > BaseField.SIZE_IN_BYTES) {
+                throw new Error(`Value length ${value.length} exceeds ${BaseField.SIZE_IN_BYTES}`);
+            }
+            this.asBuffer = value.length === BaseField.SIZE_IN_BYTES ? value : Buffer.concat([
+                Buffer.alloc(BaseField.SIZE_IN_BYTES - value.length),
+                value
+            ]);
+        } else if (typeof value === 'bigint' || typeof value === 'number' || typeof value === 'boolean') {
+            this.asBigInt = BigInt(value);
+            if (this.asBigInt >= this.modulus()) {
+                throw new Error(`Value 0x${this.asBigInt.toString(16)} is greater or equal to field modulus.`);
+            }
+        } else if (value instanceof BaseField) {
+            this.asBuffer = value.asBuffer;
+            this.asBigInt = value.asBigInt;
+        } else {
+            throw new Error(`Type '${typeof value}' with value '${value}' passed to BaseField ctor.`);
+        }
+    }
+    /**
+   * We return a copy of the Buffer to ensure this remains immutable.
+   */ toBuffer() {
+        if (!this.asBuffer) {
+            this.asBuffer = toBufferBE(this.asBigInt, 32);
+        }
+        return Buffer.from(this.asBuffer);
+    }
+    toString() {
+        return `0x${this.toBuffer().toString('hex')}`;
+    }
+    toBigInt() {
+        if (this.asBigInt === undefined) {
+            this.asBigInt = toBigIntBE(this.asBuffer);
+            if (this.asBigInt >= this.modulus()) {
+                throw new Error(`Value 0x${this.asBigInt.toString(16)} is greater or equal to field modulus.`);
+            }
+        }
+        return this.asBigInt;
+    }
+    toBool() {
+        return Boolean(this.toBigInt());
+    }
+    /**
+   * Converts this field to a number.
+   * Throws if the underlying value is greater than MAX_SAFE_INTEGER.
+   */ toNumber() {
+        const value = this.toBigInt();
+        if (value > Number.MAX_SAFE_INTEGER) {
+            throw new Error(`Value ${value.toString(16)} greater than than max safe integer`);
+        }
+        return Number(value);
+    }
+    /**
+   * Converts this field to a number.
+   * May cause loss of precision if the underlying value is greater than MAX_SAFE_INTEGER.
+   */ toNumberUnsafe() {
+        const value = this.toBigInt();
+        return Number(value);
+    }
+    toShortString() {
+        const str = this.toString();
+        return `${str.slice(0, 10)}...${str.slice(-4)}`;
+    }
+    equals(rhs) {
+        return this.toBuffer().equals(rhs.toBuffer());
+    }
+    lt(rhs) {
+        return this.toBigInt() < rhs.toBigInt();
+    }
+    cmp(rhs) {
+        const lhsBigInt = this.toBigInt();
+        const rhsBigInt = rhs.toBigInt();
+        return lhsBigInt === rhsBigInt ? 0 : lhsBigInt < rhsBigInt ? -1 : 1;
+    }
+    isZero() {
+        return this.toBuffer().equals(ZERO_BUFFER);
+    }
+    isEmpty() {
+        return this.isZero();
+    }
+    toFriendlyJSON() {
+        return this.toString();
+    }
+    toField() {
+        return this;
+    }
+}
+/**
+ * Constructs a field from a Buffer of BufferReader.
+ * It maybe not read the full 32 bytes if the Buffer is shorter, but it will padded in BaseField constructor.
+ */ export function fromBuffer(buffer, f) {
+    const reader = BufferReader.asReader(buffer);
+    return new f(reader.readBytes(BaseField.SIZE_IN_BYTES));
+}
+/**
+ * Constructs a field from a Buffer, but reduces it first, modulo the field modulus.
+ * This requires a conversion to a bigint first so the initial underlying representation will be a bigint.
+ */ function fromBufferReduce(buffer, f) {
+    return new f(toBigIntBE(buffer) % f.MODULUS);
+}
+/**
+ * To ensure a field is uniformly random, it's important to reduce a 512 bit value.
+ * If you reduced a 256 bit number, there would a be a high skew in the lower range of the field.
+ */ function random(f) {
+    return fromBufferReduce(randomBytes(64), f);
+}
+/**
+ * Constructs a field from a 0x prefixed hex string.
+ */ function fromHexString(buf, f) {
+    const withoutPrefix = buf.replace(/^0x/i, '');
+    const checked = withoutPrefix.match(/^[0-9A-F]+$/i)?.[0];
+    if (checked === undefined) {
+        throw new Error(`Invalid hex-encoded string: "${buf}"`);
+    }
+    const buffer = Buffer.from(checked.length % 2 === 1 ? '0' + checked : checked, 'hex');
+    return new f(buffer);
+}
+/**
+ * Fr field class.
+ * @dev This class is used to represent elements of BN254 scalar field or elements in the base field of Grumpkin.
+ * (Grumpkin's scalar field corresponds to BN254's base field and vice versa.)
+ */ export class Fr extends BaseField {
+    static ZERO = new Fr(0n);
+    static ONE = new Fr(1n);
+    static MODULUS = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001n;
+    static MAX_FIELD_VALUE = new Fr(this.MODULUS - 1n);
+    constructor(value){
+        super(value);
+    }
+    [inspect.custom]() {
+        return `Fr<${this.toString()}>`;
+    }
+    modulus() {
+        return Fr.MODULUS;
+    }
+    static random() {
+        return random(Fr);
+    }
+    static zero() {
+        return Fr.ZERO;
+    }
+    static isZero(value) {
+        return value.isZero();
+    }
+    static fromBuffer(buffer) {
+        return fromBuffer(buffer, Fr);
+    }
+    static fromBufferReduce(buffer) {
+        return fromBufferReduce(buffer, Fr);
+    }
+    /**
+   * Creates a Fr instance from a string.
+   * @param buf - the string to create a Fr from.
+   * @returns the Fr instance
+   * @remarks if the string only consists of numbers, we assume we are parsing a bigint,
+   * otherwise we require the hex string to be prepended with "0x", to ensure there is no misunderstanding
+   * as to what is being parsed.
+   */ static fromString(buf) {
+        if (buf.match(/^\d+$/) !== null) {
+            return new Fr(toBufferBE(BigInt(buf), 32));
+        }
+        if (buf.match(/^0x/i) !== null) {
+            return fromHexString(buf, Fr);
+        }
+        throw new Error(`Tried to create a Fr from an invalid string: ${buf}`);
+    }
+    /**
+   * Creates a Fr instance from a hex string.
+   * @param buf - a hex encoded string.
+   * @returns the Fr instance
+   */ static fromHexString(buf) {
+        return fromHexString(buf, Fr);
+    }
+    /** Arithmetic */ add(rhs) {
+        return new Fr((this.toBigInt() + rhs.toBigInt()) % Fr.MODULUS);
+    }
+    square() {
+        return new Fr(this.toBigInt() * this.toBigInt() % Fr.MODULUS);
+    }
+    negate() {
+        return new Fr(Fr.MODULUS - this.toBigInt());
+    }
+    sub(rhs) {
+        const result = this.toBigInt() - rhs.toBigInt();
+        return new Fr(result < 0 ? result + Fr.MODULUS : result);
+    }
+    mul(rhs) {
+        return new Fr(this.toBigInt() * rhs.toBigInt() % Fr.MODULUS);
+    }
+    div(rhs) {
+        if (rhs.isZero()) {
+            throw new Error('Division by zero');
+        }
+        const bInv = modInverse(rhs.toBigInt());
+        return this.mul(bInv);
+    }
+    // Integer division.
+    ediv(rhs) {
+        if (rhs.isZero()) {
+            throw new Error('Division by zero');
+        }
+        return new Fr(this.toBigInt() / rhs.toBigInt());
+    }
+    /**
+   * Computes a square root of the field element.
+   * @returns A square root of the field element (null if it does not exist).
+   */ async sqrt() {
+        const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+        const wasm = api.getWasm();
+        const [buf] = wasm.callWasmExport('bn254_fr_sqrt', [
+            this.toBuffer()
+        ], [
+            Fr.SIZE_IN_BYTES + 1
+        ]);
+        const isSqrt = buf[0] === 1;
+        if (!isSqrt) {
+            // Field element is not a quadratic residue mod p so it has no square root.
+            return null;
+        }
+        return new Fr(Buffer.from(buf.slice(1)));
+    }
+    toJSON() {
+        return this.toString();
+    }
+    static get schema() {
+        return hexSchemaFor(Fr);
+    }
+}
+// For deserializing JSON.
+TypeRegistry.register('Fr', Fr);
+/**
+ * Fq field class.
+ * @dev This class is used to represent elements of BN254 base field or elements in the scalar field of Grumpkin.
+ * (Grumpkin's scalar field corresponds to BN254's base field and vice versa.)
+ */ export class Fq extends BaseField {
+    static ZERO = new Fq(0n);
+    static MODULUS = 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47n;
+    static HIGH_SHIFT = BigInt(BaseField.SIZE_IN_BYTES / 2 * 8);
+    static LOW_MASK = (1n << Fq.HIGH_SHIFT) - 1n;
+    [inspect.custom]() {
+        return `Fq<${this.toString()}>`;
+    }
+    get lo() {
+        return new Fr(this.toBigInt() & Fq.LOW_MASK);
+    }
+    get hi() {
+        return new Fr(this.toBigInt() >> Fq.HIGH_SHIFT);
+    }
+    constructor(value){
+        super(value);
+    }
+    modulus() {
+        return Fq.MODULUS;
+    }
+    static random() {
+        return random(Fq);
+    }
+    static zero() {
+        return Fq.ZERO;
+    }
+    static fromBuffer(buffer) {
+        return fromBuffer(buffer, Fq);
+    }
+    static fromBufferReduce(buffer) {
+        return fromBufferReduce(buffer, Fq);
+    }
+    /**
+   * Creates a Fq instance from a string.
+   * @param buf - the string to create a Fq from.
+   * @returns the Fq instance
+   * @remarks if the string only consists of numbers, we assume we are parsing a bigint,
+   * otherwise we require the hex string to be prepended with "0x", to ensure there is no misunderstanding
+   * as to what is being parsed.
+   */ static fromString(buf) {
+        if (buf.match(/^\d+$/) !== null) {
+            return new Fq(toBufferBE(BigInt(buf), 32));
+        }
+        if (buf.match(/^0x/i) !== null) {
+            return fromHexString(buf, Fq);
+        }
+        throw new Error(`Tried to create a Fq from an invalid string: ${buf}`);
+    }
+    /**
+   * Creates a Fq instance from a hex string.
+   * @param buf - a hex encoded string.
+   * @returns the Fq instance
+   */ static fromHexString(buf) {
+        return fromHexString(buf, Fq);
+    }
+    static fromHighLow(high, low) {
+        return new Fq((high.toBigInt() << Fq.HIGH_SHIFT) + low.toBigInt());
+    }
+    add(rhs) {
+        return new Fq((this.toBigInt() + rhs.toBigInt()) % Fq.MODULUS);
+    }
+    toJSON() {
+        return this.toString();
+    }
+    static get schema() {
+        return hexSchemaFor(Fq);
+    }
+}
+// For deserializing JSON.
+TypeRegistry.register('Fq', Fq);
+// Beware: Performance bottleneck below
+/**
+ * Find the modular inverse of a given element, for BN254 Fr.
+ */ function modInverse(b) {
+    const [gcd, x, _] = extendedEuclidean(b, Fr.MODULUS);
+    if (gcd != 1n) {
+        throw Error('Inverse does not exist');
+    }
+    // Add modulus if -ve to ensure positive
+    return new Fr(x > 0 ? x : x + Fr.MODULUS);
+}
+/**
+ * The extended Euclidean algorithm can be used to find the multiplicative inverse of a field element
+ * This is used to perform field division.
+ */ function extendedEuclidean(a, modulus) {
+    if (a == 0n) {
+        return [
+            modulus,
+            0n,
+            1n
+        ];
+    } else {
+        const [gcd, x, y] = extendedEuclidean(modulus % a, a);
+        return [
+            gcd,
+            y - modulus / a * x,
+            x
+        ];
+    }
+}
+export const GrumpkinScalar = Fq;
+/** Wraps a function that returns a buffer so that all results are reduced into a field of the given type. */ export function reduceFn(fn, field) {
+    return (input)=>fromBufferReduce(fn(input), field);
+}
+/** If we are in test mode, we register a special equality for fields. */ if (process.env.NODE_ENV === 'test' && typeof expect !== 'undefined') {
+    const areFieldsEqual = (a, b)=>{
+        const isAField = a instanceof BaseField;
+        const isBField = b instanceof BaseField;
+        if (isAField && isBField) {
+            return a.equals(b);
+        } else if (isAField === isBField) {
+            return undefined;
+        } else {
+            return false;
+        }
+    };
+    // `addEqualityTesters` doesn't seem to be in the types yet.
+    expect.addEqualityTesters([
+        areFieldsEqual
+    ]);
+}

package/dest/fields/index.d.ts

@@ -0,0 +1,4 @@
+export * from './fields.js';
+export * from './point.js';
+export * from './coordinate.js';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dest/fields/index.js

@@ -0,0 +1,3 @@
+export * from './fields.js';
+export * from './point.js';
+export * from './coordinate.js';

package/dest/fields/point.d.ts

@@ -0,0 +1,175 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { BufferReader, FieldReader } from '../serialize/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 declare class Point {
+    /**
+     * The point's x coordinate
+     */
+    readonly x: Fr;
+    /**
+     * The point's y coordinate
+     */
+    readonly y: Fr;
+    /**
+     * Whether the point is at infinity
+     */
+    readonly isInfinite: boolean;
+    static ZERO: Point;
+    static SIZE_IN_BYTES: number;
+    static COMPRESSED_SIZE_IN_BYTES: number;
+    /** Used to differentiate this class from AztecAddress */
+    readonly kind = "point";
+    constructor(
+    /**
+     * The point's x coordinate
+     */
+    x: Fr, 
+    /**
+     * The point's y coordinate
+     */
+    y: Fr, 
+    /**
+     * Whether the point is at infinity
+     */
+    isInfinite: boolean);
+    toJSON(): `0x${string}`;
+    static get schema(): import("zod").ZodType<Point, any, string>;
+    /**
+     * Generate a random Point instance.
+     *
+     * @returns A randomly generated Point instance.
+     */
+    static random(): Promise<Point>;
+    /**
+     * 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: Buffer | BufferReader): Point;
+    /**
+     * 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: Buffer | BufferReader): Promise<Point>;
+    /**
+     * 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: string): Point;
+    /**
+     * Returns the contents of the point as an array of 2 fields.
+     * @returns The point as an array of 2 fields
+     */
+    toFields(): Fr[];
+    static fromFields(fields: Fr[] | FieldReader): Point;
+    /**
+     * 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 fromXAndSign(x: Fr, sign: boolean): Promise<Point>;
+    /**
+     * @returns
+     */
+    static YFromX(x: Fr): Promise<Fr | null>;
+    /**
+     * 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(): [Fr, boolean];
+    /**
+     * Returns the contents of the point as BigInts.
+     * @returns The point as BigInts
+     */
+    toBigInts(): {
+        x: bigint;
+        y: bigint;
+        isInfinite: bigint;
+    };
+    /**
+     * 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(): Buffer;
+    /**
+     * Converts the Point instance to a compressed Buffer representation of the coordinates.
+     * @returns A Buffer representation of the Point instance
+     */
+    toCompressedBuffer(): Buffer;
+    /**
+     * 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(): `0x${string}`;
+    /**
+     * 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(): string;
+    toNoirStruct(): {
+        x: Fr;
+        y: Fr;
+        is_infinite: boolean;
+    };
+    toWrappedNoirStruct(): {
+        inner: {
+            x: Fr;
+            y: Fr;
+            is_infinite: boolean;
+        };
+    };
+    /**
+     * 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: Point): boolean;
+    isZero(): boolean;
+    hash(): Promise<Fr>;
+    /**
+     * Check if this is point at infinity.
+     * Check this is consistent with how bb is encoding the point at infinity
+     */
+    get inf(): boolean;
+    isOnGrumpkin(): boolean;
+}
+export declare class NotOnCurveError extends Error {
+    constructor(x: Fr);
+}
+//# sourceMappingURL=point.d.ts.map

package/dest/fields/point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../src/fields/point.ts"],"names":[],"mappings":";;AAIA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,uBAAuB,CAAC;AAErF,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEjC;;;;;GAKG;AACH,qBAAa,KAAK;IASd;;OAEG;aACa,CAAC,EAAE,EAAE;IACrB;;OAEG;aACa,CAAC,EAAE,EAAE;IACrB;;OAEG;aACa,UAAU,EAAE,OAAO;IAnBrC,MAAM,CAAC,IAAI,QAAsC;IACjD,MAAM,CAAC,aAAa,SAAwB;IAC5C,MAAM,CAAC,wBAAwB,SAAoB;IAEnD,yDAAyD;IACzD,SAAgB,IAAI,WAAW;;IAG7B;;OAEG;IACa,CAAC,EAAE,EAAE;IACrB;;OAEG;IACa,CAAC,EAAE,EAAE;IACrB;;OAEG;IACa,UAAU,EAAE,OAAO;IAKrC,MAAM;IAIN,MAAM,KAAK,MAAM,8CAEhB;IAED;;;;OAIG;WACU,MAAM;IAcnB;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAK/C;;;;;;OAMG;IACH,MAAM,CAAC,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,OAAO,CAAC,KAAK,CAAC;IAU1E;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM;IAI7B;;;OAGG;IACH,QAAQ;IAIR,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;IAK5C;;;;;;;;OAQG;WACU,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO;IAgB9C;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,GAAG,IAAI,CAAC;IASxC;;;;OAIG;IACH,UAAU,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC;IAI3B;;;OAGG;IACH,SAAS;;;;;IAQT;;;;;;;;;OASG;IACH,QAAQ;IAWR;;;OAGG;IACH,kBAAkB;IAalB;;;;;;OAMG;IACH,QAAQ;IAIR;;;;;;;OAOG;IACH,aAAa;IAKb,YAAY;;;;;IAOZ,mBAAmB;;;;;;;IAMnB;;;;;;OAMG;IACH,MAAM,CAAC,GAAG,EAAE,KAAK;IAIjB,MAAM;IAIN,IAAI;IAIJ;;;OAGG;IACH,IAAW,GAAG,YAEb;IAED,YAAY;CAYb;AAED,qBAAa,eAAgB,SAAQ,KAAK;gBAC5B,CAAC,EAAE,EAAE;CAIlB"}