@canton-network/core-ledger-proto 0.10.0 → 0.12.0

package/dist/_proto/google/protobuf/struct.js

@@ -1,417 +0,0 @@
-import { WireType } from '@protobuf-ts/runtime';
-import { UnknownFieldHandler } from '@protobuf-ts/runtime';
-import { reflectionMergePartial } from '@protobuf-ts/runtime';
-import { isJsonObject } from '@protobuf-ts/runtime';
-import { typeofJsonValue } from '@protobuf-ts/runtime';
-import { MessageType } from '@protobuf-ts/runtime';
-/**
- * `NullValue` is a singleton enumeration to represent the null value for the
- * `Value` type union.
- *
- *  The JSON representation for `NullValue` is JSON `null`.
- *
- * @generated from protobuf enum google.protobuf.NullValue
- */
-export var NullValue;
-(function (NullValue) {
-    /**
-     * Null value.
-     *
-     * @generated from protobuf enum value: NULL_VALUE = 0;
-     */
-    NullValue[NullValue["NULL_VALUE"] = 0] = "NULL_VALUE";
-})(NullValue || (NullValue = {}));
-// @generated message type with reflection information, may provide speed optimized methods
-class Struct$Type extends MessageType {
-    constructor() {
-        super('google.protobuf.Struct', [
-            {
-                no: 1,
-                name: 'fields',
-                kind: 'map',
-                K: 9 /*ScalarType.STRING*/,
-                V: { kind: 'message', T: () => Value },
-            },
-        ]);
-    }
-    /**
-     * Encode `Struct` to JSON object.
-     */
-    internalJsonWrite(message, options) {
-        let json = {};
-        for (let [k, v] of Object.entries(message.fields)) {
-            json[k] = Value.toJson(v);
-        }
-        return json;
-    }
-    /**
-     * Decode `Struct` from JSON object.
-     */
-    internalJsonRead(json, options, target) {
-        if (!isJsonObject(json))
-            throw new globalThis.Error('Unable to parse message ' +
-                this.typeName +
-                ' from JSON ' +
-                typeofJsonValue(json) +
-                '.');
-        if (!target)
-            target = this.create();
-        for (let [k, v] of globalThis.Object.entries(json)) {
-            target.fields[k] = Value.fromJson(v);
-        }
-        return target;
-    }
-    create(value) {
-        const message = globalThis.Object.create(this.messagePrototype);
-        message.fields = {};
-        if (value !== undefined)
-            reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* map<string, google.protobuf.Value> fields */ 1:
-                    this.binaryReadMap1(message.fields, reader, options);
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === 'throw')
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    binaryReadMap1(map, reader, options) {
-        let len = reader.uint32(), end = reader.pos + len, key, val;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case 1:
-                    key = reader.string();
-                    break;
-                case 2:
-                    val = Value.internalBinaryRead(reader, reader.uint32(), options);
-                    break;
-                default:
-                    throw new globalThis.Error('unknown map entry field for google.protobuf.Struct.fields');
-            }
-        }
-        map[key ?? ''] = val ?? Value.create();
-    }
-    internalBinaryWrite(message, writer, options) {
-        /* map<string, google.protobuf.Value> fields = 1; */
-        for (let k of globalThis.Object.keys(message.fields)) {
-            writer
-                .tag(1, WireType.LengthDelimited)
-                .fork()
-                .tag(1, WireType.LengthDelimited)
-                .string(k);
-            writer.tag(2, WireType.LengthDelimited).fork();
-            Value.internalBinaryWrite(message.fields[k], writer, options);
-            writer.join().join();
-        }
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message google.protobuf.Struct
- */
-export const Struct = new Struct$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class Value$Type extends MessageType {
-    constructor() {
-        super('google.protobuf.Value', [
-            {
-                no: 1,
-                name: 'null_value',
-                kind: 'enum',
-                oneof: 'kind',
-                T: () => ['google.protobuf.NullValue', NullValue],
-            },
-            {
-                no: 2,
-                name: 'number_value',
-                kind: 'scalar',
-                oneof: 'kind',
-                T: 1 /*ScalarType.DOUBLE*/,
-            },
-            {
-                no: 3,
-                name: 'string_value',
-                kind: 'scalar',
-                oneof: 'kind',
-                T: 9 /*ScalarType.STRING*/,
-            },
-            {
-                no: 4,
-                name: 'bool_value',
-                kind: 'scalar',
-                oneof: 'kind',
-                T: 8 /*ScalarType.BOOL*/,
-            },
-            {
-                no: 5,
-                name: 'struct_value',
-                kind: 'message',
-                oneof: 'kind',
-                T: () => Struct,
-            },
-            {
-                no: 6,
-                name: 'list_value',
-                kind: 'message',
-                oneof: 'kind',
-                T: () => ListValue,
-            },
-        ]);
-    }
-    /**
-     * Encode `Value` to JSON value.
-     */
-    internalJsonWrite(message, options) {
-        if (message.kind.oneofKind === undefined)
-            throw new globalThis.Error();
-        switch (message.kind.oneofKind) {
-            case undefined:
-                throw new globalThis.Error();
-            case 'boolValue':
-                return message.kind.boolValue;
-            case 'nullValue':
-                return null;
-            case 'numberValue':
-                let numberValue = message.kind.numberValue;
-                if (typeof numberValue == 'number' &&
-                    !Number.isFinite(numberValue))
-                    throw new globalThis.Error();
-                return numberValue;
-            case 'stringValue':
-                return message.kind.stringValue;
-            case 'listValue':
-                let listValueField = this.fields.find((f) => f.no === 6);
-                if (listValueField?.kind !== 'message')
-                    throw new globalThis.Error();
-                return listValueField.T().toJson(message.kind.listValue);
-            case 'structValue':
-                let structValueField = this.fields.find((f) => f.no === 5);
-                if (structValueField?.kind !== 'message')
-                    throw new globalThis.Error();
-                return structValueField.T().toJson(message.kind.structValue);
-        }
-    }
-    /**
-     * Decode `Value` from JSON value.
-     */
-    internalJsonRead(json, options, target) {
-        if (!target)
-            target = this.create();
-        switch (typeof json) {
-            case 'number':
-                target.kind = { oneofKind: 'numberValue', numberValue: json };
-                break;
-            case 'string':
-                target.kind = { oneofKind: 'stringValue', stringValue: json };
-                break;
-            case 'boolean':
-                target.kind = { oneofKind: 'boolValue', boolValue: json };
-                break;
-            case 'object':
-                if (json === null) {
-                    target.kind = {
-                        oneofKind: 'nullValue',
-                        nullValue: NullValue.NULL_VALUE,
-                    };
-                }
-                else if (globalThis.Array.isArray(json)) {
-                    target.kind = {
-                        oneofKind: 'listValue',
-                        listValue: ListValue.fromJson(json),
-                    };
-                }
-                else {
-                    target.kind = {
-                        oneofKind: 'structValue',
-                        structValue: Struct.fromJson(json),
-                    };
-                }
-                break;
-            default:
-                throw new globalThis.Error('Unable to parse ' +
-                    this.typeName +
-                    ' from JSON ' +
-                    typeofJsonValue(json));
-        }
-        return target;
-    }
-    create(value) {
-        const message = globalThis.Object.create(this.messagePrototype);
-        message.kind = { oneofKind: undefined };
-        if (value !== undefined)
-            reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* google.protobuf.NullValue null_value */ 1:
-                    message.kind = {
-                        oneofKind: 'nullValue',
-                        nullValue: reader.int32(),
-                    };
-                    break;
-                case /* double number_value */ 2:
-                    message.kind = {
-                        oneofKind: 'numberValue',
-                        numberValue: reader.double(),
-                    };
-                    break;
-                case /* string string_value */ 3:
-                    message.kind = {
-                        oneofKind: 'stringValue',
-                        stringValue: reader.string(),
-                    };
-                    break;
-                case /* bool bool_value */ 4:
-                    message.kind = {
-                        oneofKind: 'boolValue',
-                        boolValue: reader.bool(),
-                    };
-                    break;
-                case /* google.protobuf.Struct struct_value */ 5:
-                    message.kind = {
-                        oneofKind: 'structValue',
-                        structValue: Struct.internalBinaryRead(reader, reader.uint32(), options, message.kind.structValue),
-                    };
-                    break;
-                case /* google.protobuf.ListValue list_value */ 6:
-                    message.kind = {
-                        oneofKind: 'listValue',
-                        listValue: ListValue.internalBinaryRead(reader, reader.uint32(), options, message.kind.listValue),
-                    };
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === 'throw')
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        /* google.protobuf.NullValue null_value = 1; */
-        if (message.kind.oneofKind === 'nullValue')
-            writer.tag(1, WireType.Varint).int32(message.kind.nullValue);
-        /* double number_value = 2; */
-        if (message.kind.oneofKind === 'numberValue')
-            writer.tag(2, WireType.Bit64).double(message.kind.numberValue);
-        /* string string_value = 3; */
-        if (message.kind.oneofKind === 'stringValue')
-            writer
-                .tag(3, WireType.LengthDelimited)
-                .string(message.kind.stringValue);
-        /* bool bool_value = 4; */
-        if (message.kind.oneofKind === 'boolValue')
-            writer.tag(4, WireType.Varint).bool(message.kind.boolValue);
-        /* google.protobuf.Struct struct_value = 5; */
-        if (message.kind.oneofKind === 'structValue')
-            Struct.internalBinaryWrite(message.kind.structValue, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
-        /* google.protobuf.ListValue list_value = 6; */
-        if (message.kind.oneofKind === 'listValue')
-            ListValue.internalBinaryWrite(message.kind.listValue, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message google.protobuf.Value
- */
-export const Value = new Value$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class ListValue$Type extends MessageType {
-    constructor() {
-        super('google.protobuf.ListValue', [
-            {
-                no: 1,
-                name: 'values',
-                kind: 'message',
-                repeat: 2 /*RepeatType.UNPACKED*/,
-                T: () => Value,
-            },
-        ]);
-    }
-    /**
-     * Encode `ListValue` to JSON array.
-     */
-    internalJsonWrite(message, options) {
-        return message.values.map((v) => Value.toJson(v));
-    }
-    /**
-     * Decode `ListValue` from JSON array.
-     */
-    internalJsonRead(json, options, target) {
-        if (!globalThis.Array.isArray(json))
-            throw new globalThis.Error('Unable to parse ' +
-                this.typeName +
-                ' from JSON ' +
-                typeofJsonValue(json));
-        if (!target)
-            target = this.create();
-        let values = json.map((v) => Value.fromJson(v));
-        target.values.push(...values);
-        return target;
-    }
-    create(value) {
-        const message = globalThis.Object.create(this.messagePrototype);
-        message.values = [];
-        if (value !== undefined)
-            reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* repeated google.protobuf.Value values */ 1:
-                    message.values.push(Value.internalBinaryRead(reader, reader.uint32(), options));
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === 'throw')
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        /* repeated google.protobuf.Value values = 1; */
-        for (let i = 0; i < message.values.length; i++)
-            Value.internalBinaryWrite(message.values[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message google.protobuf.ListValue
- */
-export const ListValue = new ListValue$Type();

package/dist/_proto/google/protobuf/timestamp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timestamp.d.ts","sourceRoot":"","sources":["../../../../src/_proto/google/protobuf/timestamp.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAG1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAE5D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAClD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AACH,MAAM,WAAW,SAAS;IACtB;;;;;;OAMG;IACH,OAAO,EAAE,MAAM,CAAA;IACf;;;;;;;OAOG;IACH,KAAK,EAAE,MAAM,CAAA;CAChB;AAED,cAAM,cAAe,SAAQ,WAAW,CAAC,SAAS,CAAC;;IAa/C;;OAEG;IACH,GAAG,IAAI,SAAS;IAOhB;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,SAAS,GAAG,IAAI;IAMhC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS;IAQ/B;;;OAGG;IACH,iBAAiB,CACb,OAAO,EAAE,SAAS,EAClB,OAAO,EAAE,gBAAgB,GAC1B,SAAS;IAwBZ;;;OAGG;IACH,gBAAgB,CACZ,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,eAAe,EACxB,MAAM,CAAC,EAAE,SAAS,GACnB,SAAS;IAgDZ,MAAM,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC,SAAS,CAAC,GAAG,SAAS;IAQpD,kBAAkB,CACd,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,iBAAiB,EAC1B,MAAM,CAAC,EAAE,SAAS,GACnB,SAAS;IA+BZ,mBAAmB,CACf,OAAO,EAAE,SAAS,EAClB,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,kBAAkB,GAC5B,aAAa;CAgBnB;AACD;;GAEG;AACH,eAAO,MAAM,SAAS,gBAAuB,CAAA"}

package/dist/_proto/google/protobuf/timestamp.js

@@ -1,157 +0,0 @@
-import { WireType } from '@protobuf-ts/runtime';
-import { UnknownFieldHandler } from '@protobuf-ts/runtime';
-import { reflectionMergePartial } from '@protobuf-ts/runtime';
-import { typeofJsonValue } from '@protobuf-ts/runtime';
-import { PbLong } from '@protobuf-ts/runtime';
-import { MessageType } from '@protobuf-ts/runtime';
-// @generated message type with reflection information, may provide speed optimized methods
-class Timestamp$Type extends MessageType {
-    constructor() {
-        super('google.protobuf.Timestamp', [
-            {
-                no: 1,
-                name: 'seconds',
-                kind: 'scalar',
-                T: 3 /*ScalarType.INT64*/,
-                L: 0 /*LongType.BIGINT*/,
-            },
-            { no: 2, name: 'nanos', kind: 'scalar', T: 5 /*ScalarType.INT32*/ },
-        ]);
-    }
-    /**
-     * Creates a new `Timestamp` for the current time.
-     */
-    now() {
-        const msg = this.create();
-        const ms = Date.now();
-        msg.seconds = PbLong.from(Math.floor(ms / 1000)).toBigInt();
-        msg.nanos = (ms % 1000) * 1000000;
-        return msg;
-    }
-    /**
-     * Converts a `Timestamp` to a JavaScript Date.
-     */
-    toDate(message) {
-        return new Date(PbLong.from(message.seconds).toNumber() * 1000 +
-            Math.ceil(message.nanos / 1000000));
-    }
-    /**
-     * Converts a JavaScript Date to a `Timestamp`.
-     */
-    fromDate(date) {
-        const msg = this.create();
-        const ms = date.getTime();
-        msg.seconds = PbLong.from(Math.floor(ms / 1000)).toBigInt();
-        msg.nanos =
-            ((ms % 1000) + (ms < 0 && ms % 1000 !== 0 ? 1000 : 0)) * 1000000;
-        return msg;
-    }
-    /**
-     * In JSON format, the `Timestamp` type is encoded as a string
-     * in the RFC 3339 format.
-     */
-    internalJsonWrite(message, options) {
-        let ms = PbLong.from(message.seconds).toNumber() * 1000;
-        if (ms < Date.parse('0001-01-01T00:00:00Z') ||
-            ms > Date.parse('9999-12-31T23:59:59Z'))
-            throw new Error('Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.');
-        if (message.nanos < 0)
-            throw new Error('Unable to encode invalid Timestamp to JSON. Nanos must not be negative.');
-        let z = 'Z';
-        if (message.nanos > 0) {
-            let nanosStr = (message.nanos + 1000000000).toString().substring(1);
-            if (nanosStr.substring(3) === '000000')
-                z = '.' + nanosStr.substring(0, 3) + 'Z';
-            else if (nanosStr.substring(6) === '000')
-                z = '.' + nanosStr.substring(0, 6) + 'Z';
-            else
-                z = '.' + nanosStr + 'Z';
-        }
-        return new Date(ms).toISOString().replace('.000Z', z);
-    }
-    /**
-     * In JSON format, the `Timestamp` type is encoded as a string
-     * in the RFC 3339 format.
-     */
-    internalJsonRead(json, options, target) {
-        if (typeof json !== 'string')
-            throw new Error('Unable to parse Timestamp from JSON ' +
-                typeofJsonValue(json) +
-                '.');
-        let matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/);
-        if (!matches)
-            throw new Error('Unable to parse Timestamp from JSON. Invalid format.');
-        let ms = Date.parse(matches[1] +
-            '-' +
-            matches[2] +
-            '-' +
-            matches[3] +
-            'T' +
-            matches[4] +
-            ':' +
-            matches[5] +
-            ':' +
-            matches[6] +
-            (matches[8] ? matches[8] : 'Z'));
-        if (Number.isNaN(ms))
-            throw new Error('Unable to parse Timestamp from JSON. Invalid value.');
-        if (ms < Date.parse('0001-01-01T00:00:00Z') ||
-            ms > Date.parse('9999-12-31T23:59:59Z'))
-            throw new globalThis.Error('Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.');
-        if (!target)
-            target = this.create();
-        target.seconds = PbLong.from(ms / 1000).toBigInt();
-        target.nanos = 0;
-        if (matches[7])
-            target.nanos =
-                parseInt('1' + matches[7] + '0'.repeat(9 - matches[7].length)) -
-                    1000000000;
-        return target;
-    }
-    create(value) {
-        const message = globalThis.Object.create(this.messagePrototype);
-        message.seconds = 0n;
-        message.nanos = 0;
-        if (value !== undefined)
-            reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* int64 seconds */ 1:
-                    message.seconds = reader.int64().toBigInt();
-                    break;
-                case /* int32 nanos */ 2:
-                    message.nanos = reader.int32();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === 'throw')
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        /* int64 seconds = 1; */
-        if (message.seconds !== 0n)
-            writer.tag(1, WireType.Varint).int64(message.seconds);
-        /* int32 nanos = 2; */
-        if (message.nanos !== 0)
-            writer.tag(2, WireType.Varint).int32(message.nanos);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message google.protobuf.Timestamp
- */
-export const Timestamp = new Timestamp$Type();

package/dist/_proto/google/rpc/code.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"code.d.ts","sourceRoot":"","sources":["../../../../src/_proto/google/rpc/code.ts"],"names":[],"mappings":"AAkBA;;;;;;;;;;GAUG;AACH,oBAAY,IAAI;IACZ;;;;;;OAMG;IACH,EAAE,IAAI;IACN;;;;;;OAMG;IACH,SAAS,IAAI;IACb;;;;;;;;;;OAUG;IACH,OAAO,IAAI;IACX;;;;;;;;;OASG;IACH,gBAAgB,IAAI;IACpB;;;;;;;;;;OAUG;IACH,iBAAiB,IAAI;IACrB;;;;;;;;;;;;OAYG;IACH,SAAS,IAAI;IACb;;;;;;;OAOG;IACH,cAAc,IAAI;IAClB;;;;;;;;;;;;;OAaG;IACH,iBAAiB,IAAI;IACrB;;;;;;;OAOG;IACH,eAAe,KAAK;IACpB;;;;;;;OAOG;IACH,kBAAkB,IAAI;IACtB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,mBAAmB,IAAI;IACvB;;;;;;;;;;OAUG;IACH,OAAO,KAAK;IACZ;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,YAAY,KAAK;IACjB;;;;;;;OAOG;IACH,aAAa,KAAK;IAClB;;;;;;;;OAQG;IACH,QAAQ,KAAK;IACb;;;;;;;;;;;;OAYG;IACH,WAAW,KAAK;IAChB;;;;;;OAMG;IACH,SAAS,KAAK;CACjB"}