@seljs/env 1.0.0 → 1.0.1

package/dist/builder.js

@@ -1,223 +0,0 @@
-import { structTypeName } from "@seljs/common";
-import { mapSolidityTypeToCEL } from "@seljs/types";
-import { CEL_BUILTIN_FUNCTIONS, CEL_BUILTIN_MACROS, SOLIDITY_PRIMITIVE_TYPES, } from "./builtins.js";
-/**
- * Checks if the given ABI parameter is a tuple type with components, indicating that it represents a struct in Solidity.
- * @param param
- */
-const isTupleParam = (param) => param.type === "tuple" && "components" in param;
-/**
- * Checks if the given ABI parameter is an array of tuples with components, indicating that it represents an array of structs in Solidity.
- * @param param
- */
-const isTupleArrayParam = (param) => param.type === "tuple[]" && "components" in param;
-/**
- * Checks if the given ABI parameter is either a tuple or an array of tuples, both of which indicate the presence of components and thus represent struct types in Solidity.
- *
- * @param param
- */
-const isAnyTupleParam = (param) => isTupleParam(param) || isTupleArrayParam(param);
-/**
- * Generates a unique type name for a nested struct based on the parent type name and the field name, used for naming struct types in the SEL schema.
- *
- * @param parentTypeName Name of the parent type (e.g., contract name or parent struct name) to which the field belongs, used as a prefix for the nested struct type name.
- * @param fieldName Name of the field for which to generate the nested struct type name, used as a suffix in the nested struct type name.
- */
-const nestedTypeName = (parentTypeName, fieldName) => `${parentTypeName}__${fieldName}`;
-/**
- * Recursively builds struct field definitions.
- *
- * @param components Array of ABI parameters representing the components of a tuple type.
- * @param parentTypeName Name to use for the struct type representing the current level of nesting.
- */
-export const buildStructFields = (components, parentTypeName) => {
-    const fields = {};
-    const nestedTypes = [];
-    for (const component of components) {
-        const fieldName = component.name ?? "arg0";
-        if (isTupleParam(component) && component.components.length > 0) {
-            const childTypeName = nestedTypeName(parentTypeName, fieldName);
-            const child = buildStructFields(component.components, childTypeName);
-            nestedTypes.push(...child.nestedTypes);
-            nestedTypes.push({ typeName: childTypeName, fields: child.fields });
-            fields[fieldName] = childTypeName;
-            continue;
-        }
-        if (isTupleArrayParam(component) && component.components.length > 0) {
-            const childTypeName = nestedTypeName(parentTypeName, fieldName);
-            const child = buildStructFields(component.components, childTypeName);
-            nestedTypes.push(...child.nestedTypes);
-            nestedTypes.push({ typeName: childTypeName, fields: child.fields });
-            fields[fieldName] = `list<${childTypeName}>`;
-            continue;
-        }
-        // For primitive types, directly map to CEL type or use "dyn" if mapping is not possible.
-        fields[fieldName] = mapSolidityTypeToCEL(component.type) ?? "dyn";
-    }
-    return { fields, nestedTypes };
-};
-/**
- * Builds method parameters for a given array of ABI parameters.
- *
- * @param inputs Array of ABI parameters representing the inputs of a function.
- */
-const buildMethodParams = (inputs) => {
-    return inputs.map((param, index) => ({
-        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- empty string name means unnamed param
-        name: param.name || `arg${String(index)}`,
-        type: mapSolidityTypeToCEL(param.type) ?? "dyn",
-    }));
-};
-/**
- * Builds the return type resolution for a method based on its ABI components, handling nested structs as needed.
- *
- * @param components Array of ABI parameters representing the components of a tuple return type.
- * @param typeName Name to use for the struct type representing the return value, used for naming nested struct types as well.
- */
-const buildStructReturn = (components, typeName) => {
-    const result = buildStructFields(components, typeName);
-    const structTypes = [];
-    for (const nested of result.nestedTypes) {
-        structTypes.push({
-            name: nested.typeName,
-            kind: "struct",
-            fields: Object.entries(nested.fields).map(([name, type]) => ({
-                name,
-                type,
-            })),
-        });
-    }
-    structTypes.push({
-        name: typeName,
-        kind: "struct",
-        fields: Object.entries(result.fields).map(([name, type]) => ({
-            name,
-            type,
-        })),
-    });
-    return { returns: typeName, structTypes };
-};
-/**
- * Resolves the return type of method based on its ABI function definition.
- *
- * @param fn ABI function for which to resolve the return type.
- * @param contractName Name of the contract to which the function belongs, used for naming nested struct types.
- */
-const resolveMethodReturnType = (fn, contractName) => {
-    const firstOutput = fn.outputs[0];
-    if (!firstOutput) {
-        return { returns: "dyn", structTypes: [] };
-    }
-    /*
-     * This is the most basic case:
-     * Single non-tuple return value can be directly mapped to a CEL type without needing to define a struct.
-     */
-    if (fn.outputs.length === 1 && !isAnyTupleParam(firstOutput)) {
-        const celType = mapSolidityTypeToCEL(firstOutput.type) ?? "dyn";
-        return { returns: celType, structTypes: [] };
-    }
-    const typeName = structTypeName(contractName, fn.name);
-    // For more complex cases, we need to define struct types.
-    const isSingleOutput = fn.outputs.length === 1;
-    const isSingleTupleArray = isSingleOutput && isTupleArrayParam(firstOutput);
-    const isSingleTuple = isSingleOutput && isTupleParam(firstOutput);
-    let components;
-    if (isSingleTuple || isSingleTupleArray) {
-        components = firstOutput.components;
-    }
-    else {
-        components = fn.outputs.map((o, i) => ({
-            ...o,
-            name: o.name ?? `arg${String(i)}`,
-        }));
-    }
-    // Build the struct return type and collect any nested struct types needed for the return value.
-    const resolution = buildStructReturn(components, typeName);
-    if (isSingleTupleArray) {
-        return {
-            returns: `list<${typeName}>`,
-            structTypes: resolution.structTypes,
-        };
-    }
-    else {
-        return resolution;
-    }
-};
-/**
- * Builds a MethodSchema for a given ABI function.
- *
- * @param fn ABI function for which to build the MethodSchema.
- * @param contractName Name of the contract to which the function belongs, used for naming nested struct types.
- * @param acc Accumulator to keep track of seen struct types and collect unique TypeSchemas for nested structs.
- */
-const buildMethodSchema = (fn, contractName, acc) => {
-    const params = buildMethodParams(fn.inputs);
-    // Handle the return type resolution.
-    const resolution = resolveMethodReturnType(fn, contractName);
-    // Add any struct types discovered during return type resolution to the accumulator, ensuring uniqueness.
-    for (const st of resolution.structTypes) {
-        if (!acc.seen.has(st.name)) {
-            acc.types.push(st);
-            acc.seen.add(st.name);
-        }
-    }
-    return { name: fn.name, params, returns: resolution.returns, abi: fn };
-};
-/**
- * Builds a ContractSchema for a given contract by processing its ABI and extracting view/pure functions as methods.
- *
- * @param contractName Name of the contract for which to build the schema.
- * @param input ContractInput containing the ABI and other relevant information for the contract.
- * @param acc Accumulator to keep track of seen struct types and collect unique TypeSchemas for nested structs.
- */
-const buildContractSchema = (contractName, input, acc) => {
-    // Filter ABI to include only view and pure functions, which are relevant for read-only interactions in the SEL environment.
-    const viewFunctions = input.abi.filter((item) => item.type === "function" &&
-        (item.stateMutability === "view" || item.stateMutability === "pure"));
-    const methods = viewFunctions.map((fn) => buildMethodSchema(fn, contractName, acc));
-    return {
-        name: contractName,
-        address: input.address,
-        description: input.description,
-        methods,
-    };
-};
-/**
- * Resolves a ContextFieldDefinition to its CEL type string.
- */
-const resolveFieldType = (field) => typeof field === "string" ? field : field.type;
-/**
- * Resolves the optional description from a ContextFieldDefinition.
- */
-const resolveFieldDescription = (field) => typeof field === "string" ? undefined : field.description;
-/**
- * Extracts variables from the provided context definition and builds an array of VariableSchema objects.
- */
-const buildVariablesFromContext = (config) => {
-    if (!config.context) {
-        return [];
-    }
-    return Object.entries(config.context).map(([name, field]) => ({
-        name,
-        type: resolveFieldType(field),
-        description: resolveFieldDescription(field),
-    }));
-};
-/**
- * Builds a SELSchema based on the provided configuration, which includes contract definitions and an optional context for variables.
- *
- * @param config Configuration object containing contract definitions and an optional context for variables.
- * @returns A SELSchema object representing the schema for the SEL environment.
- */
-export const buildSchema = (config) => {
-    const acc = { seen: new Set(), types: [] };
-    const contracts = Object.entries(config.contracts ?? {}).map(([name, input]) => buildContractSchema(name, input, acc));
-    return {
-        version: "1.0.0",
-        contracts,
-        variables: buildVariablesFromContext(config),
-        types: [...SOLIDITY_PRIMITIVE_TYPES, ...acc.types],
-        functions: CEL_BUILTIN_FUNCTIONS,
-        macros: CEL_BUILTIN_MACROS,
-    };
-};

package/dist/builder.spec.d.ts

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

package/dist/builder.spec.d.ts.map

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

package/dist/builder.spec.js

@@ -1,428 +0,0 @@
-import { parseAbi } from "viem";
-import { describe, expect, it } from "vitest";
-import { buildSchema } from "./builder.js";
-const SIMPLE_ABI = [
-    {
-        type: "function",
-        name: "balanceOf",
-        stateMutability: "view",
-        inputs: [{ name: "account", type: "address" }],
-        outputs: [{ name: "", type: "uint256" }],
-    },
-    {
-        type: "function",
-        name: "totalSupply",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [{ name: "", type: "uint256" }],
-    },
-    {
-        type: "function",
-        name: "name",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [{ name: "", type: "string" }],
-    },
-];
-/**
- * Comprehensive ABI covering all struct return scenarios:
- * - tuple return (getPool)
- * - multi-return (getReserves)
- * - nested tuple (getInfo)
- * - tuple[] return (getPositions)
- * - tuple with tuple[] field (getAccount)
- */
-const STRUCT_ABI = [
-    {
-        type: "function",
-        name: "getPool",
-        stateMutability: "view",
-        inputs: [{ name: "id", type: "uint256" }],
-        outputs: [
-            {
-                name: "",
-                type: "tuple",
-                components: [
-                    { name: "token", type: "address" },
-                    { name: "balance", type: "uint256" },
-                ],
-            },
-        ],
-    },
-    {
-        type: "function",
-        name: "getReserves",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            { name: "reserve0", type: "uint112" },
-            { name: "reserve1", type: "uint112" },
-            { name: "blockTimestampLast", type: "uint32" },
-        ],
-    },
-    {
-        type: "function",
-        name: "getInfo",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                name: "",
-                type: "tuple",
-                components: [
-                    { name: "id", type: "uint256" },
-                    {
-                        name: "details",
-                        type: "tuple",
-                        components: [
-                            { name: "token", type: "address" },
-                            { name: "amount", type: "uint256" },
-                        ],
-                    },
-                ],
-            },
-        ],
-    },
-    {
-        type: "function",
-        name: "getPositions",
-        stateMutability: "view",
-        inputs: [{ name: "user", type: "address" }],
-        outputs: [
-            {
-                name: "",
-                type: "tuple[]",
-                components: [
-                    { name: "token", type: "address" },
-                    { name: "amount", type: "uint256" },
-                ],
-            },
-        ],
-    },
-    {
-        type: "function",
-        name: "getAccount",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                name: "",
-                type: "tuple",
-                components: [
-                    { name: "owner", type: "address" },
-                    {
-                        name: "positions",
-                        type: "tuple[]",
-                        components: [
-                            { name: "token", type: "address" },
-                            { name: "amount", type: "uint256" },
-                        ],
-                    },
-                ],
-            },
-        ],
-    },
-];
-describe("src/builder.ts", () => {
-    describe("contracts", () => {
-        it("builds a schema with the correct contract name and method count", () => {
-            const schema = buildSchema({
-                contracts: {
-                    erc20: {
-                        address: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
-                        abi: SIMPLE_ABI,
-                    },
-                },
-            });
-            expect(schema.version).toBe("1.0.0");
-            expect(schema.contracts).toHaveLength(1);
-            expect(schema.contracts[0]?.name).toBe("erc20");
-            expect(schema.contracts[0]?.methods).toHaveLength(3);
-        });
-        it("includes contract description", () => {
-            const schema = buildSchema({
-                contracts: {
-                    erc20: {
-                        address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-                        abi: SIMPLE_ABI,
-                        description: "ERC-20 Token",
-                    },
-                },
-            });
-            expect(schema.contracts[0]?.description).toBe("ERC-20 Token");
-        });
-        it("handles empty config", () => {
-            const schema = buildSchema({});
-            expect(schema.contracts).toEqual([]);
-            expect(schema.variables).toEqual([]);
-            expect(schema.version).toBe("1.0.0");
-        });
-        it("includes builtin types, functions, and macros", () => {
-            const schema = buildSchema({});
-            expect(schema.types.length).toBeGreaterThan(0);
-            expect(schema.functions.length).toBeGreaterThan(0);
-            expect(schema.macros.length).toBeGreaterThan(0);
-        });
-        it("only includes view and pure functions (excludes nonpayable, payable, events)", () => {
-            const schema = buildSchema({
-                contracts: {
-                    c: {
-                        address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-                        abi: [
-                            {
-                                type: "function",
-                                name: "viewFn",
-                                stateMutability: "view",
-                                inputs: [],
-                                outputs: [{ name: "", type: "uint256" }],
-                            },
-                            {
-                                type: "function",
-                                name: "pureFn",
-                                stateMutability: "pure",
-                                inputs: [],
-                                outputs: [{ name: "", type: "bool" }],
-                            },
-                            {
-                                type: "function",
-                                name: "nonpayableFn",
-                                stateMutability: "nonpayable",
-                                inputs: [],
-                                outputs: [],
-                            },
-                            {
-                                type: "function",
-                                name: "payableFn",
-                                stateMutability: "payable",
-                                inputs: [],
-                                outputs: [],
-                            },
-                            {
-                                type: "event",
-                                name: "Transfer",
-                                inputs: [],
-                            },
-                        ],
-                    },
-                },
-            });
-            const methodNames = schema.contracts[0]?.methods.map((m) => m.name);
-            expect(methodNames).toContain("viewFn");
-            expect(methodNames).toContain("pureFn");
-            expect(methodNames).not.toContain("nonpayableFn");
-            expect(methodNames).not.toContain("payableFn");
-            expect(methodNames).not.toContain("Transfer");
-        });
-        it("maps unnamed params to arg{index}", () => {
-            const schema = buildSchema({
-                contracts: {
-                    c: {
-                        address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-                        abi: [
-                            {
-                                type: "function",
-                                name: "foo",
-                                stateMutability: "view",
-                                inputs: [
-                                    { name: "", type: "address" },
-                                    { name: "", type: "uint256" },
-                                ],
-                                outputs: [{ name: "", type: "bool" }],
-                            },
-                        ],
-                    },
-                },
-            });
-            const params = schema.contracts[0]?.methods[0]?.params;
-            expect(params?.[0]?.name).toBe("arg0");
-            expect(params?.[1]?.name).toBe("arg1");
-        });
-    });
-    describe("method param and return types (CEL types)", () => {
-        const schema = buildSchema({
-            contracts: {
-                token: {
-                    address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-                    abi: SIMPLE_ABI,
-                },
-            },
-        });
-        it("maps address param to sol_address", () => {
-            const method = schema.contracts[0]?.methods.find((m) => m.name === "balanceOf");
-            expect(method?.params[0]?.name).toBe("account");
-            expect(method?.params[0]?.type).toBe("sol_address");
-        });
-        it.each([
-            ["balanceOf", "sol_int"],
-            ["totalSupply", "sol_int"],
-            ["name", "string"],
-        ])("%s returns %s", (methodName, expectedReturn) => {
-            const method = schema.contracts[0]?.methods.find((m) => m.name === methodName);
-            expect(method?.returns).toBe(expectedReturn);
-        });
-    });
-    describe("context variables", () => {
-        it("builds a schema with context variables", () => {
-            const schema = buildSchema({
-                context: {
-                    user: "sol_address",
-                    amount: "sol_int",
-                },
-            });
-            expect(schema.variables).toHaveLength(2);
-            expect(schema.variables).toEqual(expect.arrayContaining([
-                expect.objectContaining({ name: "user", type: "sol_address" }),
-                expect.objectContaining({ name: "amount", type: "sol_int" }),
-            ]));
-        });
-        it("builds a schema with both contracts and context", () => {
-            const schema = buildSchema({
-                contracts: {
-                    erc20: {
-                        address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-                        abi: SIMPLE_ABI,
-                    },
-                },
-                context: {
-                    user: "sol_address",
-                },
-            });
-            expect(schema.contracts).toHaveLength(1);
-            expect(schema.variables).toHaveLength(1);
-        });
-    });
-    describe("struct returns", () => {
-        const schema = buildSchema({
-            contracts: {
-                vault: {
-                    address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-                    abi: STRUCT_ABI,
-                },
-            },
-        });
-        it("generates TypeSchema for struct-returning method", () => {
-            const structType = schema.types.find((t) => t.name === "SEL_Struct_vault_getPool");
-            expect(structType).toBeDefined();
-            expect(structType?.kind).toBe("struct");
-        });
-        it("sets method returns to struct type name", () => {
-            const method = schema.contracts[0]?.methods.find((m) => m.name === "getPool");
-            expect(method?.returns).toBe("SEL_Struct_vault_getPool");
-        });
-        it("struct fields use CEL types (sol_address, sol_int)", () => {
-            const structType = schema.types.find((t) => t.name === "SEL_Struct_vault_getPool");
-            expect(structType?.fields).toEqual(expect.arrayContaining([
-                { name: "token", type: "sol_address" },
-                { name: "balance", type: "sol_int" },
-            ]));
-        });
-        it("generates TypeSchema for multi-return method", () => {
-            const structType = schema.types.find((t) => t.name === "SEL_Struct_vault_getReserves");
-            expect(structType).toBeDefined();
-            expect(structType?.kind).toBe("struct");
-            expect(structType?.fields).toHaveLength(3);
-            expect(structType?.fields).toEqual(expect.arrayContaining([
-                { name: "reserve0", type: "sol_int" },
-                { name: "reserve1", type: "sol_int" },
-                { name: "blockTimestampLast", type: "sol_int" },
-            ]));
-        });
-        it("does not generate struct types for simple returns", () => {
-            const simpleSchema = buildSchema({
-                contracts: {
-                    erc20: {
-                        address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-                        abi: SIMPLE_ABI,
-                    },
-                },
-            });
-            const structTypes = simpleSchema.types.filter((t) => t.kind === "struct");
-            expect(structTypes).toHaveLength(0);
-        });
-        it("emits struct type name for struct method and CEL type for simple method", () => {
-            const mixedSchema = buildSchema({
-                contracts: {
-                    token: {
-                        address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-                        abi: SIMPLE_ABI,
-                    },
-                    pool: {
-                        address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-                        abi: STRUCT_ABI,
-                    },
-                },
-            });
-            const balanceOf = mixedSchema.contracts
-                .find((c) => c.name === "token")
-                ?.methods.find((m) => m.name === "balanceOf");
-            expect(balanceOf?.returns).toBe("sol_int");
-            const getPool = mixedSchema.contracts
-                .find((c) => c.name === "pool")
-                ?.methods.find((m) => m.name === "getPool");
-            expect(getPool?.returns).toBe("SEL_Struct_pool_getPool");
-        });
-        it("generates nested struct TypeSchema entries", () => {
-            const parentType = schema.types.find((t) => t.name === "SEL_Struct_vault_getInfo");
-            expect(parentType).toBeDefined();
-            expect(parentType?.kind).toBe("struct");
-            const nestedType = schema.types.find((t) => t.name === "SEL_Struct_vault_getInfo__details");
-            expect(nestedType).toBeDefined();
-            expect(nestedType?.kind).toBe("struct");
-            expect(nestedType?.fields).toEqual(expect.arrayContaining([
-                { name: "token", type: "sol_address" },
-                { name: "amount", type: "sol_int" },
-            ]));
-            const detailsField = parentType?.fields?.find((f) => f.name === "details");
-            expect(detailsField?.type).toBe("SEL_Struct_vault_getInfo__details");
-        });
-        it("generates list<struct> return for tuple[] method", () => {
-            const method = schema.contracts[0]?.methods.find((m) => m.name === "getPositions");
-            expect(method?.returns).toBe("list<SEL_Struct_vault_getPositions>");
-        });
-        it("registers struct type for tuple[] return", () => {
-            const structType = schema.types.find((t) => t.name === "SEL_Struct_vault_getPositions");
-            expect(structType).toBeDefined();
-            expect(structType?.kind).toBe("struct");
-            expect(structType?.fields).toEqual(expect.arrayContaining([
-                { name: "token", type: "sol_address" },
-                { name: "amount", type: "sol_int" },
-            ]));
-        });
-        it("resolves tuple[] field inside struct to list<nested struct>", () => {
-            const parentType = schema.types.find((t) => t.name === "SEL_Struct_vault_getAccount");
-            const positionsField = parentType?.fields?.find((f) => f.name === "positions");
-            expect(positionsField?.type).toBe("list<SEL_Struct_vault_getAccount__positions>");
-        });
-        it("registers nested struct type for tuple[] field", () => {
-            const nestedType = schema.types.find((t) => t.name === "SEL_Struct_vault_getAccount__positions");
-            expect(nestedType).toBeDefined();
-            expect(nestedType?.kind).toBe("struct");
-            expect(nestedType?.fields).toEqual(expect.arrayContaining([
-                { name: "token", type: "sol_address" },
-                { name: "amount", type: "sol_int" },
-            ]));
-        });
-        it("nested struct types appear before parent in types array", () => {
-            const typeNames = schema.types.map((t) => t.name);
-            const nestedIdx = typeNames.indexOf("SEL_Struct_vault_getInfo__details");
-            const parentIdx = typeNames.indexOf("SEL_Struct_vault_getInfo");
-            expect(nestedIdx).toBeGreaterThan(-1);
-            expect(parentIdx).toBeGreaterThan(-1);
-            expect(nestedIdx).toBeLessThan(parentIdx);
-        });
-        it("includes AbiFunction on method schema", () => {
-            const abi = parseAbi([
-                "function balanceOf(address owner) view returns (uint256)",
-            ]);
-            const schema = buildSchema({
-                contracts: {
-                    token: { address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", abi },
-                },
-            });
-            const method = schema.contracts[0].methods[0];
-            expect(method.abi).toBeDefined();
-            expect(method.abi.name).toBe("balanceOf");
-            expect(method.abi.type).toBe("function");
-        });
-    });
-});

package/dist/builtins.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"builtins.d.ts","sourceRoot":"","sources":["../src/builtins.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE7E;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,EAsNjD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAAW,EAiD3C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,wBAAwB,EAAE,UAAU,EAkChD,CAAC"}