@helios-lang/contract-utils 0.1.6 → 0.1.8

package/src/runtime/ContractContextBuilder.js

@@ -0,0 +1,325 @@
+import { bytesToHex } from "@helios-lang/codec-utils"
+import {
+    ScriptHash,
+    StakingValidatorHash,
+    ValidatorHash,
+    MintingPolicyHash
+} from "@helios-lang/ledger"
+import { None, expectSome } from "@helios-lang/type-utils"
+import { UplcProgramV2 } from "@helios-lang/uplc"
+import { loadLibrary } from "../lib/index.js"
+import { Cast } from "./Cast.js"
+import { ContractContext } from "./ContractContext.js"
+
+/**
+ * @typedef {import("./ContractContext.js").Validator} CompiledValidator
+ */
+
+/**
+ * @template TRedeemerStrict
+ * @template TRedeemerPermissive
+ * @typedef {import("@helios-lang/ledger").MintingContext<TRedeemerStrict, TRedeemerPermissive>} MintingContext
+ */
+
+/**
+ * @template TDatumStrict
+ * @template TDatumPermissive
+ * @template TRedeemerStrict
+ * @template TRedeemerPermissive
+ * @typedef {import("@helios-lang/ledger").SpendingContext<TDatumStrict, TDatumPermissive, TRedeemerStrict, TRedeemerPermissive>} SpendingContext
+ */
+
+/**
+ * @template TRedeemerStrict
+ * @template TRedeemerPermissive
+ * @typedef {import("@helios-lang/ledger").StakingContext<TRedeemerStrict, TRedeemerPermissive>} StakingContext
+ */
+
+/**
+ * @template {Cast} C
+ * @typedef {import("./PermissiveType.js").PermissiveType<C>} PermissiveType
+ */
+
+/**
+ * @template {Cast} C
+ * @typedef {import("./StrictType.js").StrictType<C>} StrictType
+ */
+
+/**
+ * @typedef {{
+ *   $name: string
+ *   $sourceCode: string
+ *   $dependencies: Module[]
+ * }} Module
+ */
+
+/**
+ * @typedef {{
+ *   $name: string
+ *   $purpose: string
+ *   $sourceCode: string
+ *   $dependencies: Module[]
+ *   $hashDependencies: Validator[]
+ *   $dependsOnOwnHash: boolean
+ *   $Redeemer: Cast<any, any>
+ *   $Datum?: Cast<any, any>
+ * }} Validator
+ */
+
+/**
+ * @template {{[name: string]: Validator}} T
+ */
+export class ContractContextBuilder {
+    /**
+     * @private
+     * @readonly
+     * @type {T}
+     */
+    validators
+
+    /**
+     * @private
+     * @param {T} validators
+     */
+    constructor(validators) {
+        this.validators = validators
+    }
+
+    /**
+     * @returns {ContractContextBuilder<{}>}
+     */
+    static new() {
+        return new ContractContextBuilder({})
+    }
+
+    /**
+     * @template {Validator} V
+     * @param {V} validator
+     * @returns {ContractContextBuilder<T & {
+     *   [K in V["$name"]]: V
+     * }>}
+     */
+    with(validator) {
+        return new ContractContextBuilder({
+            ...this.validators,
+            [validator.$name]: validator
+        })
+    }
+
+    /**
+     *
+     * @param {Option<{[name: string]: string}>} expectedHashes
+     * @returns {{
+     *   [K in keyof T]:
+     *     T[K]["$purpose"] extends "spending" ? ValidatorHash<
+     *       SpendingContext<
+     *         StrictType<T[K]["$Datum"]>,
+     *         PermissiveType<T[K]["$Datum"]>,
+     *         StrictType<T[K]["$Redeemer"]>,
+     *         PermissiveType<T[K]["$Redeemer"]>
+     *       >
+     *     > :
+     *     T[K]["$purpose"] extends "minting" ? MintingPolicyHash<
+     *       MintingContext<
+     *         StrictType<T[K]["$Redeemer"]>,
+     *         PermissiveType<T[K]["$Redeemer"]>
+     *       >
+     *     > :
+     *     T[K]["$purpose"] extends ("certifying" | "rewarding") ? StakingValidatorHash<
+     *       StakingContext<
+     *         StrictType<T[K]["$Redeemer"]>,
+     *         PermissiveType<T[K]["$Redeemer"]>
+     *       >
+     *     > : never
+     * }}
+     */
+    build(expectedHashes = None) {
+        const lib = loadLibrary()
+
+        /**
+         * @type {{[name: string]: (
+         *   ValidatorHash<SpendingContext<any, any, any, any>> |
+         *   MintingPolicyHash<MintingContext<any, any>> |
+         *   StakingValidatorHash<StakingContext<any, any>>
+         * )}}
+         */
+        const validators = {}
+
+        /**
+         * @param {Validator} validator
+         * @returns {Map<string, string>}
+         */
+        function collectModules(validator) {
+            /**
+             * @type {Map<string, string>}
+             */
+            const result = new Map()
+
+            let stack = validator.$dependencies.slice()
+
+            let m = stack.pop()
+            while (m) {
+                if (result.has(m.$name)) {
+                    continue
+                }
+
+                result.set(m.$name, m.$sourceCode)
+
+                stack = stack.concat(m.$dependencies)
+
+                m = stack.pop()
+            }
+
+            return result
+        }
+
+        /**
+         * @returns {{[name: string]: {purpose: string, hash: string}}}
+         */
+        function getOtherValidators() {
+            /**
+             * @type {{[name: string]: {purpose: string, hash: string}}}
+             */
+            const otherValidators = {}
+
+            for (let k in validators) {
+                const v = validators[k]
+
+                if (v instanceof ValidatorHash) {
+                    otherValidators[k] = {
+                        purpose: "spending",
+                        hash: v.toHex()
+                    }
+                } else if (v instanceof MintingPolicyHash) {
+                    otherValidators[k] = {
+                        purpose: "minting",
+                        hash: v.toHex()
+                    }
+                } else if (v instanceof StakingValidatorHash) {
+                    otherValidators[k] = {
+                        purpose: "staking",
+                        hash: v.toHex()
+                    }
+                } else {
+                    throw new Error("unexpected ScriptHash")
+                }
+            }
+
+            return otherValidators
+        }
+
+        /**
+         * @param {Validator} validator
+         */
+        function buildValidator(validator) {
+            const name = validator.$name
+
+            if (name in validator) {
+                return
+            }
+
+            for (let v of validator.$hashDependencies) {
+                buildValidator(v)
+            }
+
+            const modules = collectModules(validator)
+
+            const { cborHex: optimizedCborHex } = lib.compile(
+                validator.$sourceCode,
+                Array.from(modules.values()),
+                {
+                    optimize: true,
+                    otherValidators: getOtherValidators(),
+                    dependsOnOwnHash: validator.$dependsOnOwnHash
+                }
+            )
+
+            const optimizedProgram = UplcProgramV2.fromCbor(optimizedCborHex)
+
+            const ownHash = bytesToHex(optimizedProgram.hash())
+
+            if (expectedHashes && name in expectedHashes) {
+                if (expectedHashes[name] != ownHash) {
+                    throw new Error(
+                        `expected hash ${expectedHashes[name]} for validator ${name}, got ${ownHash}`
+                    )
+                }
+            }
+
+            /**
+             * @type {ScriptHash}
+             */
+            let ownTypedHash
+
+            const purpose = validator.$purpose
+
+            switch (purpose) {
+                case "spending":
+                    ownTypedHash = new ValidatorHash(ownHash)
+                    break
+                case "minting":
+                    ownTypedHash = new MintingPolicyHash(ownHash)
+                    break
+                case "staking":
+                case "certifying":
+                case "rewarding":
+                    ownTypedHash = new StakingValidatorHash(ownHash)
+                    break
+                default:
+                    throw new Error("unhandled purpose")
+            }
+
+            const { cborHex: unoptimizedCborHex } = lib.compile(
+                validator.$sourceCode,
+                Array.from(modules.values()),
+                {
+                    optimize: false,
+                    otherValidators: getOtherValidators(),
+                    ownHash: validator.$dependsOnOwnHash ? ownHash : undefined
+                }
+            )
+
+            const unoptimizedProgram =
+                UplcProgramV2.fromCbor(unoptimizedCborHex)
+
+            if (purpose == "spending") {
+                validators[validator.$name] = new ValidatorHash(
+                    ownTypedHash.bytes,
+                    {
+                        program: optimizedProgram.withAlt(unoptimizedProgram),
+                        datum: expectSome(validator.$Datum),
+                        redeemer: validator.$Redeemer
+                    }
+                )
+            } else if (purpose == "minting") {
+                validators[validator.$name] = new MintingPolicyHash(
+                    ownTypedHash.bytes,
+                    {
+                        program: optimizedProgram.withAlt(unoptimizedProgram),
+                        redeemer: validator.$Redeemer
+                    }
+                )
+            } else if (
+                purpose == "staking" ||
+                purpose == "certifying" ||
+                purpose == "rewarding"
+            ) {
+                validators[validator.$name] = new StakingValidatorHash(
+                    ownTypedHash.bytes,
+                    {
+                        program: optimizedProgram.withAlt(unoptimizedProgram),
+                        redeemer: validator.$Redeemer
+                    }
+                )
+            } else {
+                throw new Error("unhandled purpose")
+            }
+        }
+
+        for (let k in this.validators) {
+            buildValidator(this.validators[k])
+        }
+
+        return /** @type {any} */ (validators)
+    }
+}

package/src/runtime/PermissiveType.js

@@ -0,0 +1,6 @@
+import { Cast } from "./Cast.js"
+
+/**
+ * @template {Cast} C
+ * @typedef {C extends Cast<any, infer TPermissive> ? TPermissive : never} PermissiveType
+ */

package/src/runtime/StrictType.js

@@ -0,0 +1,6 @@
+import { Cast } from "./Cast.js"
+
+/**
+ * @template {Cast} C
+ * @typedef {C extends Cast<infer TStrict, any> ? TStrict : never} StrictType
+ */

package/src/runtime/index.js

@@ -0,0 +1,3 @@
+export { Cast } from "./Cast.js"
+export { ContractContext } from "./ContractContext.js"
+export { ContractContextBuilder } from "./ContractContextBuilder.js"

package/types/codegen/Module.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @typedef {import("./TypeSchema.js").TypeSchema} TypeSchema
+ */
+/**
+ * @typedef {{
+ *   name: string
+ *   purpose: string
+ *   sourceCode: string
+ *   moduleDepedencies: string[]
+ *   types: {[name: string]: TypeSchema}
+ * }} Module
+ */
+export const _: {};
+export type TypeSchema = import("./TypeSchema.js").TypeSchema;
+export type Module = {
+    name: string;
+    purpose: string;
+    sourceCode: string;
+    moduleDepedencies: string[];
+    types: {
+        [name: string]: import("./TypeSchema.js").TypeSchema;
+    };
+};
+//# sourceMappingURL=Module.d.ts.map

package/types/codegen/Module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Module.d.ts","sourceRoot":"","sources":["../../src/codegen/Module.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;GAQG;AAEH,mBAAmB;yBAbN,OAAO,iBAAiB,EAAE,UAAU;;UAKtC,MAAM;aACH,MAAM;gBACH,MAAM;uBACC,MAAM,EAAE"}

package/types/codegen/TypeSchema.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @typedef {{
+ *     primitiveType: string
+ * } | {
+ *     listItemType: TypeSchema
+ * } | {
+ *     mapKeyType: TypeSchema
+ *     mapValueType: TypeSchema
+ * } | {
+ *     optionSomeType: TypeSchema
+ * } | {
+ *     structFieldTypes: {
+ *         name: string
+ *         type: TypeSchema
+ *     }[]
+ * } | {
+ *     enumVariantTypes: {
+ *          name: string,
+ *          fieldTypes: {
+ *              name: string
+ *              type: TypeSchema
+ *          }[]
+ *     }[]
+ * }} TypeSchema
+ */
+/**
+ * @param {TypeSchema} schema
+ * @returns {[string, string]} - the first entry is the canonical type, the second is the permissive type
+ */
+export function genTypes(schema: TypeSchema): [string, string];
+export type TypeSchema = {
+    primitiveType: string;
+} | {
+    listItemType: TypeSchema;
+} | {
+    mapKeyType: TypeSchema;
+    mapValueType: TypeSchema;
+} | {
+    optionSomeType: TypeSchema;
+} | {
+    structFieldTypes: {
+        name: string;
+        type: TypeSchema;
+    }[];
+} | {
+    enumVariantTypes: {
+        name: string;
+        fieldTypes: {
+            name: string;
+            type: TypeSchema;
+        }[];
+    }[];
+};
+//# sourceMappingURL=TypeSchema.d.ts.map

package/types/codegen/TypeSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeSchema.d.ts","sourceRoot":"","sources":["../../src/codegen/TypeSchema.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;GAGG;AACH,iCAHW,UAAU,GACR,CAAC,MAAM,EAAE,MAAM,CAAC,CA0H5B;yBArJY;IACZ,aAAmB,EAAE,MAAM,CAAA;CACxB,GAAG;IACN,YAAkB,EAAE,UAAU,CAAA;CAC3B,GAAG;IACN,UAAgB,EAAE,UAAU,CAAA;IAC5B,YAAkB,EAAE,UAAU,CAAA;CAC3B,GAAG;IACN,cAAoB,EAAE,UAAU,CAAA;CAC7B,GAAG;IACN,gBAAsB,EAAE;QACxB,MAAgB,MAAM,CAAA;QACtB,IAAc,EAAE,UAAU,CAAA;KACnB,EAAE,CAAA;CACN,GAAG;IACN,gBAAsB,EAAE;QACxB,MAAiB,MAAM,CAAC;QACxB,UAAqB,EAAE;YACvB,MAAqB,MAAM,CAAA;YAC3B,IAAmB,EAAE,UAAU,CAAA;SACnB,EAAE,CAAA;KACP,EAAE,CAAA;CACN"}

package/types/codegen/TypescriptWriter.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @typedef {import("./Module.js").Module} Module
+ * @typedef {import("./Validator.js").Validator} Validator
+ */
+export class TypescriptWriter {
+    wjs: Writer;
+    wdts: Writer;
+    /**
+     * @param {string} js
+     * @param {string} dts
+     * @returns {TypescriptWriter}
+     */
+    write(js: string, dts?: string): TypescriptWriter;
+    /**
+     * @param {string} js
+     * @param {string} dts
+     * @returns {TypescriptWriter}
+     */
+    writeLine(js: string, dts?: string): TypescriptWriter;
+    /**
+     * @param {Module} m
+     */
+    writeModule(m: Module): void;
+    /**
+     * @param {Validator} v
+     */
+    writeValidator(v: Validator): void;
+    writeHeaders(): void;
+    /**
+     * @param {{[name: string]: Module}} ms
+     */
+    writeModules(ms: {
+        [name: string]: import("./Module.js").Module;
+    }): void;
+    /**
+     *
+     * @param {{[name: string]: Validator}} validators
+     */
+    writeValidators(validators: {
+        [name: string]: import("./Validator.js").Validator;
+    }): void;
+    /**
+     * @returns {[string, string]}
+     */
+    finalize(): [string, string];
+}
+export type Module = import("./Module.js").Module;
+export type Validator = import("./Validator.js").Validator;
+import { Writer } from "./Writer.js";
+//# sourceMappingURL=TypescriptWriter.d.ts.map

package/types/codegen/TypescriptWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypescriptWriter.d.ts","sourceRoot":"","sources":["../../src/codegen/TypescriptWriter.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;IAEQ,YAAuB;IACvB,aAAwB;IAG5B;;;;OAIG;IACH,UAJW,MAAM,QACN,MAAM,GACJ,gBAAgB,CAM5B;IAED;;;;OAIG;IACH,cAJW,MAAM,QACN,MAAM,GACJ,gBAAgB,CAY5B;IAED;;OAEG;IACH,eAFW,MAAM,QAmBhB;IAED;;OAEG;IACH,kBAFW,SAAS,QAiCnB;IAED,qBAcC;IAED;;OAEG;IACH;;aA4BC;IAED;;;OAGG;IACH;;aA8BC;IAED;;OAEG;IACH,YAFa,CAAC,MAAM,EAAE,MAAM,CAAC,CAI5B;CACJ;qBA3LY,OAAO,aAAa,EAAE,MAAM;wBAC5B,OAAO,gBAAgB,EAAE,SAAS;uBAJxB,aAAa"}

package/types/codegen/Validator.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @typedef {import("./TypeSchema.js").TypeSchema} TypeSchema
+ */
+/**
+ * @typedef {import("./Module.js").Module} Module
+ */
+/**
+ * @typedef {Module & {
+ *   hashDependencies: string[]
+ *   Redeemer: TypeSchema
+ *   Datum?: TypeSchema
+ * }} Validator
+ */
+export const _: {};
+export type TypeSchema = import("./TypeSchema.js").TypeSchema;
+export type Module = import("./Module.js").Module;
+export type Validator = Module & {
+    hashDependencies: string[];
+    Redeemer: TypeSchema;
+    Datum?: TypeSchema;
+};
+//# sourceMappingURL=Validator.d.ts.map

package/types/codegen/Validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Validator.d.ts","sourceRoot":"","sources":["../../src/codegen/Validator.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AAEH;;;;;;GAMG;AAEH,mBAAmB;yBAfN,OAAO,iBAAiB,EAAE,UAAU;qBAIpC,OAAO,aAAa,EAAE,MAAM;wBAI5B,MAAM,GAAG;IACrB,gBAAoB,EAAE,MAAM,EAAE,CAAA;IAC9B,QAAY,EAAE,UAAU,CAAA;IACxB,KAAS,CAAC,EAAE,UAAU,CAAA;CACnB"}

package/types/codegen/Writer.d.ts

@@ -0,0 +1,23 @@
+export class Writer {
+    /**
+     * @private
+     * @readonly
+     * @type {string[]}
+     */
+    private readonly parts;
+    /**
+     * @param {string} part
+     * @returns {Writer}
+     */
+    write(part: string): Writer;
+    /**
+     * @param {string} line
+     * @returns {Writer}
+     */
+    writeLine(line: string): Writer;
+    /**
+     * @returns {string}
+     */
+    finalize(): string;
+}
+//# sourceMappingURL=Writer.d.ts.map

package/types/codegen/Writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Writer.d.ts","sourceRoot":"","sources":["../../src/codegen/Writer.js"],"names":[],"mappings":"AAAA;IACI;;;;OAIG;IACH,uBAAK;IAML;;;OAGG;IACH,YAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;OAEG;IACH,YAFa,MAAM,CAIlB;CACJ"}

package/types/codegen/index.d.ts

@@ -0,0 +1,6 @@
+export { TypescriptWriter } from "./TypescriptWriter.js";
+export { Writer } from "./Writer.js";
+export type Module = import("./Module.js").Module;
+export type TypeSchema = import("./TypeSchema.js").TypeSchema;
+export type Validator = import("./Validator.js").Validator;
+//# sourceMappingURL=index.d.ts.map

package/types/codegen/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/codegen/index.js"],"names":[],"mappings":";;qBAIa,OAAO,aAAa,EAAE,MAAM;yBAC5B,OAAO,iBAAiB,EAAE,UAAU;wBACpC,OAAO,gBAAgB,EAAE,SAAS"}

package/types/hl2ts.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+export type Lib = import("./lib/Lib.js").Lib;
+export type SourceDetails = import("./lib/Lib.js").SourceDetails;
+export type ModuleDetails = import("./lib/Lib.js").ModuleDetails;
+export type ValidatorDetails = import("./lib/Lib.js").ValidatorDetails;
+//# sourceMappingURL=hl2ts.d.ts.map

package/types/hl2ts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hl2ts.d.ts","sourceRoot":"","sources":["../src/hl2ts.js"],"names":[],"mappings":";kBASa,OAAO,cAAc,EAAE,GAAG;4BAC1B,OAAO,cAAc,EAAE,aAAa;4BACpC,OAAO,cAAc,EAAE,aAAa;+BACpC,OAAO,cAAc,EAAE,gBAAgB"}

package/types/index.d.ts

@@ -0,0 +1,2 @@
+export { Cast, ContractContextBuilder } from "./runtime/index.js";
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

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

package/types/lib/Lib.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @typedef {{
+ *   otherValidators: {[name: string]: {purpose: string, hash: string}},
+ *   dependsOnOwnHash?: boolean,
+ *   ownHash?: string,
+ *   optimize: boolean
+ * }} CompileOptions
+ */
+/**
+ * @typedef {{
+ *   cborHex: string
+ * }} CompileOutput
+ */
+/**
+ * @typedef {{
+ *   version: string
+ *   typeCheck: (validators: {[name: string]: SourceDetails}, modules: {[name: string]: SourceDetails}) => ({
+ * modules: {[name: string]: ModuleDetails}, validators: {[name: string]: ValidatorDetails}})
+ *   compile: (main: string, modules: string[], options: CompileOptions) => CompileOutput
+ * }} Lib
+ */
+/**
+ * @typedef {import("../codegen/index.js").TypeSchema} InternalTypeDetails
+ * @typedef {import("../codegen/index.js").Module} ModuleDetails
+ * @typedef {import("../codegen/index.js").Validator} ValidatorDetails
+ */
+/**
+ * @typedef {{
+ *   name: string
+ *   purpose: string
+ *   sourceCode: string
+ * }} SourceDetails
+ */
+/**
+ * @param {{VERSION: string}} lib
+ * @returns {number[]}
+ */
+export function getVersion(lib: {
+    VERSION: string;
+}): number[];
+export type CompileOptions = {
+    otherValidators: {
+        [name: string]: {
+            purpose: string;
+            hash: string;
+        };
+    };
+    dependsOnOwnHash?: boolean | undefined;
+    ownHash?: string | undefined;
+    optimize: boolean;
+};
+export type CompileOutput = {
+    cborHex: string;
+};
+export type Lib = {
+    version: string;
+    typeCheck: (validators: {
+        [name: string]: SourceDetails;
+    }, modules: {
+        [name: string]: SourceDetails;
+    }) => {
+        modules: {
+            [name: string]: import("../codegen/Module.js").Module;
+        };
+        validators: {
+            [name: string]: import("../codegen/Validator.js").Validator;
+        };
+    };
+    compile: (main: string, modules: string[], options: CompileOptions) => CompileOutput;
+};
+export type InternalTypeDetails = import("../codegen/index.js").TypeSchema;
+export type ModuleDetails = import("../codegen/index.js").Module;
+export type ValidatorDetails = import("../codegen/index.js").Validator;
+export type SourceDetails = {
+    name: string;
+    purpose: string;
+    sourceCode: string;
+};
+//# sourceMappingURL=Lib.d.ts.map

package/types/lib/Lib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Lib.d.ts","sourceRoot":"","sources":["../../src/lib/Lib.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;GAIG;AACH;;;;;;;GAOG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;GAGG;AACH,gCAHW;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,GACf,MAAM,EAAE,CAIpB;;;;qBAzCgD,MAAM;kBAAQ,MAAM;;;;;cAGtD,OAAO;;4BAKT;IACZ,OAAW,EAAE,MAAM,CAAA;CAChB;;aAIU,MAAM;;;;;;;;;;;;;oBAGC,MAAM,WAAW,MAAM,EAAE,WAAW,cAAc,KAAK,aAAa;;kCAK5E,OAAO,qBAAqB,EAAE,UAAU;4BACxC,OAAO,qBAAqB,EAAE,MAAM;+BACpC,OAAO,qBAAqB,EAAE,SAAS;4BAIvC;IACZ,MAAU,MAAM,CAAA;IAChB,OAAW,EAAE,MAAM,CAAA;IACnB,UAAc,EAAE,MAAM,CAAA;CACnB"}