@aztec/stdlib 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/dest/tx/profiling.d.ts

@@ -0,0 +1,360 @@
+import { type ZodFor } from '@aztec/foundation/schemas';
+import { z } from 'zod';
+import type { AbiDecoded } from '../abi/decoder.js';
+import type { AztecNode } from '../interfaces/aztec-node.js';
+import { type PrivateExecutionStep } from '../kernel/private_kernel_prover_output.js';
+export type NodeStats = Partial<Record<keyof AztecNode, {
+    times: number[];
+}>>;
+type FunctionTiming = {
+    functionName: string;
+    time: number;
+    oracles?: Record<string, {
+        times: number[];
+    }>;
+};
+export type ProvingTimings = {
+    sync?: number;
+    proving?: number;
+    perFunction: FunctionTiming[];
+    unaccounted: number;
+    total: number;
+};
+export declare const ProvingTimingsSchema: z.ZodObject<{
+    sync: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+    proving: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+    perFunction: z.ZodArray<z.ZodObject<{
+        functionName: z.ZodString;
+        time: z.ZodNumber;
+        oracles: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            times: z.ZodArray<z.ZodNumber, "many">;
+        }, "strip", z.ZodTypeAny, {
+            times: number[];
+        }, {
+            times: number[];
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }, {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }>, "many">;
+    unaccounted: z.ZodNumber;
+    total: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    total: number;
+    perFunction: {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }[];
+    unaccounted: number;
+    sync?: number | undefined;
+    proving?: number | undefined;
+}, {
+    total: number;
+    perFunction: {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }[];
+    unaccounted: number;
+    sync?: number | undefined;
+    proving?: number | undefined;
+}>;
+export interface ProvingStats {
+    timings: ProvingTimings;
+    nodeRPCCalls?: NodeStats;
+}
+export declare const ProvingStatsSchema: z.ZodObject<{
+    timings: z.ZodObject<{
+        sync: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+        proving: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+        perFunction: z.ZodArray<z.ZodObject<{
+            functionName: z.ZodString;
+            time: z.ZodNumber;
+            oracles: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                times: z.ZodArray<z.ZodNumber, "many">;
+            }, "strip", z.ZodTypeAny, {
+                times: number[];
+            }, {
+                times: number[];
+            }>>>;
+        }, "strip", z.ZodTypeAny, {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }, {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }>, "many">;
+        unaccounted: z.ZodNumber;
+        total: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        total: number;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        sync?: number | undefined;
+        proving?: number | undefined;
+    }, {
+        total: number;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        sync?: number | undefined;
+        proving?: number | undefined;
+    }>;
+    nodeRPCCalls: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        times: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+        times: number[];
+    }, {
+        times: number[];
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    timings: {
+        total: number;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        sync?: number | undefined;
+        proving?: number | undefined;
+    };
+    nodeRPCCalls?: Record<string, {
+        times: number[];
+    }> | undefined;
+}, {
+    timings: {
+        total: number;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        sync?: number | undefined;
+        proving?: number | undefined;
+    };
+    nodeRPCCalls?: Record<string, {
+        times: number[];
+    }> | undefined;
+}>;
+export interface SimulationTimings {
+    sync: number;
+    publicSimulation?: number;
+    validation?: number;
+    perFunction: FunctionTiming[];
+    unaccounted: number;
+    total: number;
+}
+export declare const SimulationTimingsSchema: z.ZodObject<{
+    sync: z.ZodNumber;
+    publicSimulation: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+    validation: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+    perFunction: z.ZodArray<z.ZodObject<{
+        functionName: z.ZodString;
+        time: z.ZodNumber;
+        oracles: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            times: z.ZodArray<z.ZodNumber, "many">;
+        }, "strip", z.ZodTypeAny, {
+            times: number[];
+        }, {
+            times: number[];
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }, {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }>, "many">;
+    unaccounted: z.ZodNumber;
+    total: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    total: number;
+    sync: number;
+    perFunction: {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }[];
+    unaccounted: number;
+    validation?: number | undefined;
+    publicSimulation?: number | undefined;
+}, {
+    total: number;
+    sync: number;
+    perFunction: {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }[];
+    unaccounted: number;
+    validation?: number | undefined;
+    publicSimulation?: number | undefined;
+}>;
+export interface SimulationStats {
+    timings: SimulationTimings;
+    nodeRPCCalls: NodeStats;
+}
+export declare const SimulationStatsSchema: z.ZodObject<{
+    timings: z.ZodObject<{
+        sync: z.ZodNumber;
+        publicSimulation: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+        validation: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+        perFunction: z.ZodArray<z.ZodObject<{
+            functionName: z.ZodString;
+            time: z.ZodNumber;
+            oracles: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                times: z.ZodArray<z.ZodNumber, "many">;
+            }, "strip", z.ZodTypeAny, {
+                times: number[];
+            }, {
+                times: number[];
+            }>>>;
+        }, "strip", z.ZodTypeAny, {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }, {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }>, "many">;
+        unaccounted: z.ZodNumber;
+        total: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        total: number;
+        sync: number;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        validation?: number | undefined;
+        publicSimulation?: number | undefined;
+    }, {
+        total: number;
+        sync: number;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        validation?: number | undefined;
+        publicSimulation?: number | undefined;
+    }>;
+    nodeRPCCalls: z.ZodRecord<z.ZodString, z.ZodObject<{
+        times: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+        times: number[];
+    }, {
+        times: number[];
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    timings: {
+        total: number;
+        sync: number;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        validation?: number | undefined;
+        publicSimulation?: number | undefined;
+    };
+    nodeRPCCalls: Record<string, {
+        times: number[];
+    }>;
+}, {
+    timings: {
+        total: number;
+        sync: number;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        validation?: number | undefined;
+        publicSimulation?: number | undefined;
+    };
+    nodeRPCCalls: Record<string, {
+        times: number[];
+    }>;
+}>;
+export declare class TxProfileResult {
+    executionSteps: PrivateExecutionStep[];
+    stats: ProvingStats;
+    constructor(executionSteps: PrivateExecutionStep[], stats: ProvingStats);
+    static get schema(): ZodFor<TxProfileResult>;
+    static random(): TxProfileResult;
+}
+export declare class UtilitySimulationResult {
+    result: AbiDecoded;
+    stats?: SimulationStats | undefined;
+    constructor(result: AbiDecoded, stats?: SimulationStats | undefined);
+    static get schema(): ZodFor<UtilitySimulationResult>;
+    static random(): UtilitySimulationResult;
+}
+export {};
+//# sourceMappingURL=profiling.d.ts.map

package/dest/tx/profiling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profiling.d.ts","sourceRoot":"","sources":["../../src/tx/profiling.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAY,MAAM,2BAA2B,CAAC;AAElE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,KAAK,oBAAoB,EAA8B,MAAM,2CAA2C,CAAC;AAGlH,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,SAAS,EAAE;IAAE,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAAC,CAAC;AAI9E,KAAK,cAAc,GAAG;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CAC/C,CAAC;AAQF,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM/B,CAAC;AAEH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,cAAc,CAAC;IACxB,YAAY,CAAC,EAAE,SAAS,CAAC;CAC1B;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG7B,CAAC;AAEH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOlC,CAAC;AAEH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,YAAY,EAAE,SAAS,CAAC;CACzB;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGhC,CAAC;AAGH,qBAAa,eAAe;IAEjB,cAAc,EAAE,oBAAoB,EAAE;IACtC,KAAK,EAAE,YAAY;gBADnB,cAAc,EAAE,oBAAoB,EAAE,EACtC,KAAK,EAAE,YAAY;IAG5B,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,eAAe,CAAC,CAO3C;IAED,MAAM,CAAC,MAAM,IAAI,eAAe;CA+BjC;AAED,qBAAa,uBAAuB;IAEzB,MAAM,EAAE,UAAU;IAClB,KAAK,CAAC,EAAE,eAAe;gBADvB,MAAM,EAAE,UAAU,EAClB,KAAK,CAAC,EAAE,eAAe,YAAA;IAGhC,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,uBAAuB,CAAC,CAOnD;IAED,MAAM,CAAC,MAAM,IAAI,uBAAuB;CAkBzC"}

package/dest/tx/profiling.js

@@ -0,0 +1,131 @@
+import { Fr } from '@aztec/foundation/fields';
+import { optional } from '@aztec/foundation/schemas';
+import { z } from 'zod';
+import { PrivateExecutionStepSchema } from '../kernel/private_kernel_prover_output.js';
+import { AbiDecodedSchema } from '../schemas/schemas.js';
+const NodeStatsSchema = z.record(z.string(), z.object({
+    times: z.array(z.number())
+}));
+const FunctionTimingSchema = z.object({
+    functionName: z.string(),
+    time: z.number(),
+    oracles: optional(z.record(z.string(), z.object({
+        times: z.array(z.number())
+    })))
+});
+export const ProvingTimingsSchema = z.object({
+    sync: optional(z.number()),
+    proving: optional(z.number()),
+    perFunction: z.array(FunctionTimingSchema),
+    unaccounted: z.number(),
+    total: z.number()
+});
+export const ProvingStatsSchema = z.object({
+    timings: ProvingTimingsSchema,
+    nodeRPCCalls: optional(NodeStatsSchema)
+});
+export const SimulationTimingsSchema = z.object({
+    sync: z.number(),
+    publicSimulation: optional(z.number()),
+    validation: optional(z.number()),
+    perFunction: z.array(FunctionTimingSchema),
+    unaccounted: z.number(),
+    total: z.number()
+});
+export const SimulationStatsSchema = z.object({
+    timings: SimulationTimingsSchema,
+    nodeRPCCalls: NodeStatsSchema
+});
+// docs:start:tx-profile-result
+export class TxProfileResult {
+    executionSteps;
+    stats;
+    constructor(executionSteps, stats){
+        this.executionSteps = executionSteps;
+        this.stats = stats;
+    }
+    // docs:end:tx-profile-result
+    static get schema() {
+        return z.object({
+            executionSteps: z.array(PrivateExecutionStepSchema),
+            stats: ProvingStatsSchema
+        }).transform(({ executionSteps, stats })=>new TxProfileResult(executionSteps, stats));
+    }
+    static random() {
+        return new TxProfileResult([
+            {
+                functionName: 'random',
+                bytecode: Buffer.from('random'),
+                witness: new Map([
+                    [
+                        1,
+                        'random'
+                    ]
+                ]),
+                vk: Buffer.from('random'),
+                timings: {
+                    witgen: 1,
+                    gateCount: 1
+                }
+            }
+        ], {
+            nodeRPCCalls: {
+                getBlockHeader: {
+                    times: [
+                        1
+                    ]
+                }
+            },
+            timings: {
+                sync: 1,
+                proving: 1,
+                perFunction: [
+                    {
+                        functionName: 'random',
+                        time: 1
+                    }
+                ],
+                unaccounted: 1,
+                total: 4
+            }
+        });
+    }
+}
+export class UtilitySimulationResult {
+    result;
+    stats;
+    constructor(result, stats){
+        this.result = result;
+        this.stats = stats;
+    }
+    static get schema() {
+        return z.object({
+            result: AbiDecodedSchema,
+            stats: optional(SimulationStatsSchema)
+        }).transform(({ result, stats })=>new UtilitySimulationResult(result, stats));
+    }
+    static random() {
+        return new UtilitySimulationResult(Fr.random().toBigInt(), {
+            nodeRPCCalls: {
+                getBlockHeader: {
+                    times: [
+                        1
+                    ]
+                }
+            },
+            timings: {
+                sync: 1,
+                publicSimulation: 1,
+                validation: 1,
+                perFunction: [
+                    {
+                        functionName: 'random',
+                        time: 1
+                    }
+                ],
+                unaccounted: 1,
+                total: 5
+            }
+        });
+    }
+}

package/dest/tx/proposed_block_header.d.ts

@@ -0,0 +1,84 @@
+import type { ViemHeader } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import type { ZodFor } from '@aztec/foundation/schemas';
+import { BufferReader } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { inspect } from 'util';
+import { AztecAddress } from '../aztec-address/index.js';
+import { GasFees } from '../gas/index.js';
+import type { UInt64 } from '../types/shared.js';
+import { ContentCommitment } from './content_commitment.js';
+/** The proposed values of an L2 block. */
+export declare class ProposedBlockHeader {
+    /** Root of the archive tree before this block is added. */
+    lastArchiveRoot: Fr;
+    /** Content commitment of the L2 block. */
+    contentCommitment: ContentCommitment;
+    /** Slot number of the L2 block */
+    slotNumber: Fr;
+    /** Timestamp of the L2 block. */
+    timestamp: UInt64;
+    /** Recipient of block reward. */
+    coinbase: EthAddress;
+    /** Address to receive fees. */
+    feeRecipient: AztecAddress;
+    /** Global gas prices for this block. */
+    gasFees: GasFees;
+    /** Total mana used in the block, computed by the root rollup circuit */
+    totalManaUsed: Fr;
+    constructor(
+    /** Root of the archive tree before this block is added. */
+    lastArchiveRoot: Fr, 
+    /** Content commitment of the L2 block. */
+    contentCommitment: ContentCommitment, 
+    /** Slot number of the L2 block */
+    slotNumber: Fr, 
+    /** Timestamp of the L2 block. */
+    timestamp: UInt64, 
+    /** Recipient of block reward. */
+    coinbase: EthAddress, 
+    /** Address to receive fees. */
+    feeRecipient: AztecAddress, 
+    /** Global gas prices for this block. */
+    gasFees: GasFees, 
+    /** Total mana used in the block, computed by the root rollup circuit */
+    totalManaUsed: Fr);
+    static get schema(): ZodFor<ProposedBlockHeader>;
+    static getFields(fields: FieldsOf<ProposedBlockHeader>): readonly [Fr, ContentCommitment, Fr, bigint, EthAddress, AztecAddress, GasFees, Fr];
+    static from(fields: FieldsOf<ProposedBlockHeader>): ProposedBlockHeader;
+    static fromBuffer(buffer: Buffer | BufferReader): ProposedBlockHeader;
+    equals(other: ProposedBlockHeader): boolean;
+    toBuffer(): Buffer<ArrayBufferLike>;
+    hash(): Fr;
+    static empty(fields?: Partial<FieldsOf<ProposedBlockHeader>>): ProposedBlockHeader;
+    static random(): ProposedBlockHeader;
+    isEmpty(): boolean;
+    /**
+     * Serializes this instance into a string.
+     * @returns Encoded string.
+     */
+    toString(): `0x${string}`;
+    static fromString(str: string): ProposedBlockHeader;
+    static fromViem(header: ViemHeader): ProposedBlockHeader;
+    toViem(): ViemHeader;
+    toInspect(): {
+        lastArchive: `0x${string}`;
+        contentCommitment: {
+            blobsHash: `0x${string}`;
+            inHash: `0x${string}`;
+            outHash: `0x${string}`;
+        };
+        slotNumber: bigint;
+        timestamp: bigint;
+        coinbase: `0x${string}`;
+        feeRecipient: `0x${string}`;
+        gasFees: {
+            feePerDaGas: bigint;
+            feePerL2Gas: bigint;
+        };
+        totalManaUsed: bigint;
+    };
+    [inspect.custom](): string;
+}
+//# sourceMappingURL=proposed_block_header.d.ts.map

package/dest/tx/proposed_block_header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proposed_block_header.d.ts","sourceRoot":"","sources":["../../src/tx/proposed_block_header.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,YAAY,EAAuC,MAAM,6BAA6B,CAAC;AAEhG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAG/B,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE1C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAE5D,0CAA0C;AAC1C,qBAAa,mBAAmB;IAE5B,2DAA2D;IACpD,eAAe,EAAE,EAAE;IAC1B,0CAA0C;IACnC,iBAAiB,EAAE,iBAAiB;IAC3C,kCAAkC;IAC3B,UAAU,EAAE,EAAE;IACrB,iCAAiC;IAC1B,SAAS,EAAE,MAAM;IACxB,iCAAiC;IAC1B,QAAQ,EAAE,UAAU;IAC3B,+BAA+B;IACxB,YAAY,EAAE,YAAY;IACjC,wCAAwC;IACjC,OAAO,EAAE,OAAO;IACvB,wEAAwE;IACjE,aAAa,EAAE,EAAE;;IAfxB,2DAA2D;IACpD,eAAe,EAAE,EAAE;IAC1B,0CAA0C;IACnC,iBAAiB,EAAE,iBAAiB;IAC3C,kCAAkC;IAC3B,UAAU,EAAE,EAAE;IACrB,iCAAiC;IAC1B,SAAS,EAAE,MAAM;IACxB,iCAAiC;IAC1B,QAAQ,EAAE,UAAU;IAC3B,+BAA+B;IACxB,YAAY,EAAE,YAAY;IACjC,wCAAwC;IACjC,OAAO,EAAE,OAAO;IACvB,wEAAwE;IACjE,aAAa,EAAE,EAAE;IAG1B,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,mBAAmB,CAAC,CAa/C;IAED,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,mBAAmB,CAAC;IAatD,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,mBAAmB,CAAC;IAIjD,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,mBAAmB;IAerE,MAAM,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO;IAa3C,QAAQ;IAcR,IAAI,IAAI,EAAE;IAIV,MAAM,CAAC,KAAK,CAAC,MAAM,GAAE,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAM,GAAG,mBAAmB;IActF,MAAM,CAAC,MAAM,IAAI,mBAAmB;IAapC,OAAO,IAAI,OAAO;IAalB;;;OAGG;IACI,QAAQ;IAIf,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB;IAInD,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,UAAU;IAalC,MAAM,IAAI,UAAU;IAgBpB,SAAS;;;;;;;;;;;;;;;;;IAaT,CAAC,OAAO,CAAC,MAAM,CAAC;CAajB"}