phantasma-sdk-ts 0.1.71

package/core/utils/index.js

@@ -0,0 +1,236 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Int2Buffer = exports.hex2ascii = exports.bigIntToByteArray = exports.numberToByteArray = exports.uint8ArrayToHex = exports.uint8ArrayToBytes = exports.arrayNumberToUint8Array = exports.hexStringToUint8Array = exports.stringToUint8Array = exports.uint8ArrayToNumberArray = exports.uint8ArrayToStringDefault = exports.uint8ArrayToString = exports.encodeBase16 = exports.decodeBase16 = exports.getDifficulty = exports.reverseHex = exports.BytesToHex = exports.byteArrayToHex = exports.hexStringToBytes = exports.bufferToHex = exports.hexToBuffer = exports.HexToBytes = exports.hexToByteArray = void 0;
+function hexToByteArray(hexBytes) {
+    var res = [hexBytes.length / 2];
+    for (var i = 0; i < hexBytes.length; i += 2) {
+        var hexdig = hexBytes.substr(i, 2);
+        if (hexdig == '') {
+            res.push(0);
+        }
+        else
+            res.push(parseInt(hexdig, 16));
+    }
+    return res;
+}
+exports.hexToByteArray = hexToByteArray;
+function HexToBytes(hex) {
+    return hexToByteArray(hex);
+}
+exports.HexToBytes = HexToBytes;
+function hexToBuffer(hex) {
+    return new Uint8Array(hexToByteArray(hex));
+}
+exports.hexToBuffer = hexToBuffer;
+function bufferToHex(buffer) {
+    return byteArrayToHex(buffer);
+}
+exports.bufferToHex = bufferToHex;
+function hexStringToBytes(hexString) {
+    for (var bytes = [], c = 0; c < hexString.length; c += 2)
+        bytes.push(parseInt(hexString.substr(c, 2), 16));
+    return bytes;
+}
+exports.hexStringToBytes = hexStringToBytes;
+function byteArrayToHex(arr) {
+    var e_1, _a;
+    if (typeof arr !== 'object') {
+        throw new Error("ba2hex expects an array.Input was ".concat(arr));
+    }
+    var result = '';
+    var intArray = new Uint8Array(arr);
+    try {
+        for (var intArray_1 = __values(intArray), intArray_1_1 = intArray_1.next(); !intArray_1_1.done; intArray_1_1 = intArray_1.next()) {
+            var i = intArray_1_1.value;
+            var str = i.toString(16);
+            str = str.length === 0 ? '00' : str.length === 1 ? '0' + str : str;
+            result += str;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (intArray_1_1 && !intArray_1_1.done && (_a = intArray_1.return)) _a.call(intArray_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return result;
+}
+exports.byteArrayToHex = byteArrayToHex;
+function BytesToHex(bytes) {
+    return byteArrayToHex(bytes);
+}
+exports.BytesToHex = BytesToHex;
+function reverseHex(hex) {
+    var out = '';
+    for (var i = hex.length - 2; i >= 0; i -= 2) {
+        out += hex.substr(i, 2);
+    }
+    return out;
+}
+exports.reverseHex = reverseHex;
+function getDifficulty(transactionHash) {
+    var bytes = hexStringToBytes(transactionHash).reverse();
+    var result = 0;
+    for (var i = 0; i < bytes.length; i++) {
+        var n = bytes[i];
+        for (var j = 0; j < 8; j++) {
+            if ((bytes[i] & (1 << j)) != 0) {
+                result = 1 + (i << 3) + j;
+            }
+        }
+    }
+    return 256 - result;
+}
+exports.getDifficulty = getDifficulty;
+function decodeBase16(hex) {
+    var str = '';
+    for (var i = 0; i < hex.length; i += 2) {
+        str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
+    }
+    return str;
+}
+exports.decodeBase16 = decodeBase16;
+function encodeBase16(str) {
+    return str
+        .split('')
+        .map(function (c) { return c.charCodeAt(0).toString(16).padStart(2, '0'); })
+        .join('')
+        .toUpperCase();
+}
+exports.encodeBase16 = encodeBase16;
+function uint8ArrayToString(array) {
+    var result = '';
+    for (var i = 0; i < array.length; i++) {
+        result += String.fromCharCode(array[i]);
+    }
+    return result;
+}
+exports.uint8ArrayToString = uint8ArrayToString;
+function uint8ArrayToStringDefault(array) {
+    var result = '';
+    for (var i = 0; i < array.length; i++) {
+        result += array[i].toString(16);
+    }
+    return result;
+}
+exports.uint8ArrayToStringDefault = uint8ArrayToStringDefault;
+function uint8ArrayToNumberArray(array) {
+    var result = [];
+    for (var i = 0; i < array.length; i++) {
+        result.push(array[i]);
+    }
+    return result;
+}
+exports.uint8ArrayToNumberArray = uint8ArrayToNumberArray;
+function stringToUint8Array(str) {
+    var result = new Uint8Array(str.length);
+    for (var i = 0; i < str.length; i++) {
+        result[i] = str.charCodeAt(i);
+    }
+    return result;
+}
+exports.stringToUint8Array = stringToUint8Array;
+function hexStringToUint8Array(str) {
+    var result = new Uint8Array(str.length);
+    for (var i = 0; i < str.length; i++) {
+        result[i] = str.charCodeAt(i).toString(16).charCodeAt(0);
+    }
+    return result;
+}
+exports.hexStringToUint8Array = hexStringToUint8Array;
+function arrayNumberToUint8Array(arr) {
+    var result = new Uint8Array(arr.length);
+    for (var i = 0; i < arr.length; i++) {
+        result[i] = arr[i];
+    }
+    return result;
+}
+exports.arrayNumberToUint8Array = arrayNumberToUint8Array;
+function uint8ArrayToBytes(array) {
+    var result = [];
+    for (var i = 0; i < array.length; i++) {
+        result.push(array[i]);
+    }
+    return result;
+}
+exports.uint8ArrayToBytes = uint8ArrayToBytes;
+function uint8ArrayToHex(arr) {
+    var hexString = '';
+    for (var i = 0; i < arr.length; i++) {
+        hexString += arr[i].toString(16).padStart(2, '0');
+    }
+    return hexString;
+}
+exports.uint8ArrayToHex = uint8ArrayToHex;
+function numberToByteArray(num, size) {
+    if (size === undefined) {
+        if (num < 0xfd) {
+            size = 1;
+        }
+        else if (num <= 0xfffd) {
+            size = 2;
+        }
+        else if (num <= 0xffffd) {
+            size = 3;
+        }
+        else if (num <= 0xfffffffd) {
+            size = 4;
+        }
+        else if (num <= 0xffffffff) {
+            size = 5;
+        }
+        else if (num <= 0xffffffffffffffff) {
+            size = 9;
+        }
+    }
+    var bytes = new Uint8Array(size);
+    var i = 0;
+    do {
+        bytes[i++] = num & 0xff;
+        num = num >> 8;
+    } while (num);
+    return bytes;
+}
+exports.numberToByteArray = numberToByteArray;
+function bigIntToByteArray(bigint) {
+    // Get a big-endian byte representation of the bigint
+    var bytes = bigint.toString(16).padStart(64, '0');
+    var byteArray = new Uint8Array(bytes.length / 2);
+    for (var i = 0; i < bytes.length; i += 2) {
+        byteArray[i / 2] = parseInt(bytes.substring(i, i + 2), 16);
+    }
+    return byteArray;
+}
+exports.bigIntToByteArray = bigIntToByteArray;
+var hex2ascii = function (hexx) {
+    var hex = hexx.toString();
+    var str = '';
+    for (var i = 0; i < hex.length; i += 2) {
+        var char = hex.substr(i, 2);
+        var charCode = String.fromCharCode(parseInt(char, 16));
+        // console.log('char', char, 'charCode', charCode);
+        str += charCode;
+    }
+    return str;
+};
+exports.hex2ascii = hex2ascii;
+var Int2Buffer = function (i) {
+    var hex = i.toString(16).toUpperCase();
+    if (hex.length % 2 === 1) {
+        hex = '0' + hex;
+    }
+    return Buffer.from(hex, 'hex');
+};
+exports.Int2Buffer = Int2Buffer;

package/core/vm/Contracts.d.ts

@@ -0,0 +1,17 @@
+export declare enum Contracts {
+    GasContractName = "gas",
+    BlockContractName = "block",
+    StakeContractName = "stake",
+    SwapContractName = "swap",
+    AccountContractName = "account",
+    ConsensusContractName = "consensus",
+    GovernanceContractName = "governance",
+    StorageContractName = "storage",
+    ValidatorContractName = "validator",
+    InteropContractName = "interop",
+    ExchangeContractName = "exchange",
+    PrivacyContractName = "privacy",
+    RelayContractName = "relay",
+    RankingContractName = "ranking"
+}
+//# sourceMappingURL=Contracts.d.ts.map

package/core/vm/Contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Contracts.d.ts","sourceRoot":"","sources":["../../src/core/vm/Contracts.ts"],"names":[],"mappings":"AACA,oBAAY,SAAS;IACnB,eAAe,QAAQ;IACvB,iBAAiB,UAAU;IAC3B,iBAAiB,UAAU;IAC3B,gBAAgB,SAAS;IACzB,mBAAmB,YAAY;IAC/B,qBAAqB,cAAc;IACnC,sBAAsB,eAAe;IACrC,mBAAmB,YAAY;IAC/B,qBAAqB,cAAc;IACnC,mBAAmB,YAAY;IAC/B,oBAAoB,aAAa;IACjC,mBAAmB,YAAY;IAC/B,iBAAiB,UAAU;IAC3B,mBAAmB,YAAY;CAChC"}

package/core/vm/Contracts.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Contracts = void 0;
+var Contracts;
+(function (Contracts) {
+    Contracts["GasContractName"] = "gas";
+    Contracts["BlockContractName"] = "block";
+    Contracts["StakeContractName"] = "stake";
+    Contracts["SwapContractName"] = "swap";
+    Contracts["AccountContractName"] = "account";
+    Contracts["ConsensusContractName"] = "consensus";
+    Contracts["GovernanceContractName"] = "governance";
+    Contracts["StorageContractName"] = "storage";
+    Contracts["ValidatorContractName"] = "validator";
+    Contracts["InteropContractName"] = "interop";
+    Contracts["ExchangeContractName"] = "exchange";
+    Contracts["PrivacyContractName"] = "privacy";
+    Contracts["RelayContractName"] = "relay";
+    Contracts["RankingContractName"] = "ranking";
+})(Contracts = exports.Contracts || (exports.Contracts = {}));

package/core/vm/Decoder.d.ts

@@ -0,0 +1,19 @@
+import { ISignature } from "../interfaces";
+export declare class Decoder {
+    str: string;
+    constructor(str: string);
+    isEnd(): boolean;
+    readCharPair(): string;
+    readByte(): number;
+    read(numBytes: number): string;
+    readString(): string;
+    readStringBytes(numBytes: number): string;
+    readByteArray(): any;
+    readSignature(): ISignature;
+    readTimestamp(): number;
+    readVarInt(): number;
+    readBigInt(): number;
+    readBigIntAccurate(): string;
+    readVmObject(): any;
+}
+//# sourceMappingURL=Decoder.d.ts.map

package/core/vm/Decoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Decoder.d.ts","sourceRoot":"","sources":["../../src/core/vm/Decoder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAiB,MAAM,eAAe,CAAC;AAG1D,qBAAa,OAAO;IAClB,GAAG,EAAE,MAAM,CAAC;gBAEA,GAAG,EAAE,MAAM;IAIvB,KAAK;IAIL,YAAY;IAMZ,QAAQ;IAIR,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAM9B,UAAU,IAAI,MAAM;IAKpB,eAAe,CAAC,QAAQ,EAAE,MAAM;IAQhC,aAAa;IASb,aAAa;IAwBb,aAAa;IAWb,UAAU;IAsBV,UAAU;IAWV,kBAAkB;IAUlB,YAAY;CA8Bb"}

package/core/vm/Decoder.js

@@ -0,0 +1,175 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Decoder = void 0;
+var big_integer_1 = __importDefault(require("big-integer"));
+var interfaces_1 = require("../interfaces");
+var VMType_1 = require("./VMType");
+var Decoder = /** @class */ (function () {
+    function Decoder(str) {
+        this.str = str;
+    }
+    Decoder.prototype.isEnd = function () {
+        return this.str.length == 0;
+    };
+    Decoder.prototype.readCharPair = function () {
+        var res = this.str.substr(0, 2);
+        this.str = this.str.slice(2);
+        return res;
+    };
+    Decoder.prototype.readByte = function () {
+        return parseInt(this.readCharPair(), 16);
+    };
+    Decoder.prototype.read = function (numBytes) {
+        var res = this.str.substr(0, numBytes * 2);
+        this.str = this.str.slice(numBytes * 2);
+        return res;
+    };
+    Decoder.prototype.readString = function () {
+        var len = this.readVarInt();
+        return this.readStringBytes(len);
+    };
+    Decoder.prototype.readStringBytes = function (numBytes) {
+        var res = "";
+        for (var i = 0; i < numBytes; ++i) {
+            res += String.fromCharCode(this.readByte());
+        }
+        return res;
+    };
+    Decoder.prototype.readByteArray = function () {
+        var res;
+        var length = this.readVarInt();
+        if (length == 0)
+            return [];
+        res = this.read(length);
+        return res;
+    };
+    Decoder.prototype.readSignature = function () {
+        var kind = this.readByte();
+        var signature = new interfaces_1.ISignature();
+        var curve;
+        signature.kind = kind;
+        switch (kind) {
+            case interfaces_1.SignatureKind.None:
+                return null;
+            case interfaces_1.SignatureKind.Ed25519:
+                var len = this.readVarInt();
+                signature.signature = this.read(len);
+                break;
+            case interfaces_1.SignatureKind.ECDSA:
+                curve = this.readByte();
+                signature.signature = this.readString();
+                break;
+            default:
+                throw "read signature: " + kind;
+        }
+        return signature;
+    };
+    Decoder.prototype.readTimestamp = function () {
+        //var len = this.readByte();
+        var result = 0;
+        var bytes = this.read(4);
+        bytes
+            .match(/.{1,2}/g)
+            .reverse()
+            .forEach(function (c) { return (result = result * 256 + parseInt(c, 16)); });
+        return result;
+    };
+    Decoder.prototype.readVarInt = function () {
+        var len = this.readByte();
+        var res = 0;
+        if (len === 0xfd) {
+            __spreadArray([], __read(this.read(2).match(/.{1,2}/g)), false).reverse()
+                .forEach(function (c) { return (res = res * 256 + parseInt(c, 16)); });
+            return res;
+        }
+        else if (len === 0xfe) {
+            __spreadArray([], __read(this.read(4).match(/.{1,2}/g)), false).reverse()
+                .forEach(function (c) { return (res = res * 256 + parseInt(c, 16)); });
+            return res;
+        }
+        else if (len === 0xff) {
+            __spreadArray([], __read(this.read(8).match(/.{1,2}/g)), false).reverse()
+                .forEach(function (c) { return (res = res * 256 + parseInt(c, 16)); });
+            return res;
+        }
+        return len;
+    };
+    Decoder.prototype.readBigInt = function () {
+        // TO DO: implement negative numbers
+        var len = this.readVarInt();
+        var res = 0;
+        var stringBytes = this.read(len);
+        __spreadArray([], __read(stringBytes.match(/.{1,2}/g)), false).reverse()
+            .forEach(function (c) { return (res = res * 256 + parseInt(c, 16)); });
+        return res;
+    };
+    Decoder.prototype.readBigIntAccurate = function () {
+        var len = this.readVarInt();
+        var res = (0, big_integer_1.default)();
+        var stringBytes = this.read(len);
+        __spreadArray([], __read(stringBytes.match(/.{1,2}/g)), false).reverse().forEach(function (c) {
+            res = res.times(256).plus(parseInt(c, 16));
+        });
+        return res.toString();
+    };
+    Decoder.prototype.readVmObject = function () {
+        var type = this.readByte();
+        console.log("type", type);
+        switch (type) {
+            case VMType_1.VMType.String:
+                return this.readString();
+            case VMType_1.VMType.Number:
+                return this.readBigIntAccurate();
+            case VMType_1.VMType.Bool:
+                return this.readByte() != 0;
+            case VMType_1.VMType.Struct:
+                var numFields = this.readVarInt();
+                var res = {};
+                for (var i = 0; i < numFields; ++i) {
+                    var key = this.readVmObject();
+                    console.log("  key", key);
+                    var value = this.readVmObject();
+                    console.log("  value", value);
+                    res[key] = value;
+                }
+                return res;
+            case VMType_1.VMType.Enum:
+                return this.readVarInt();
+            case VMType_1.VMType.Object:
+                var numBytes = this.readVarInt();
+                return this.read(numBytes);
+            default:
+                return "unsupported type " + type;
+        }
+    };
+    return Decoder;
+}());
+exports.Decoder = Decoder;

package/core/vm/EventData.d.ts

@@ -0,0 +1,97 @@
+export declare enum EventKind {
+    Unknown = 0,
+    ChainCreate = 1,
+    TokenCreate = 2,
+    TokenSend = 3,
+    TokenReceive = 4,
+    TokenMint = 5,
+    TokenBurn = 6,
+    TokenStake = 7,
+    TokenClaim = 8,
+    AddressRegister = 9,
+    AddressLink = 10,
+    AddressUnlink = 11,
+    OrganizationCreate = 12,
+    OrganizationAdd = 13,
+    OrganizationRemove = 14,
+    GasEscrow = 15,
+    GasPayment = 16,
+    AddressUnregister = 17,
+    OrderCreated = 18,
+    OrderCancelled = 19,
+    OrderFilled = 20,
+    OrderClosed = 21,
+    FeedCreate = 22,
+    FeedUpdate = 23,
+    FileCreate = 24,
+    FileDelete = 25,
+    ValidatorPropose = 26,
+    ValidatorElect = 27,
+    ValidatorRemove = 28,
+    ValidatorSwitch = 29,
+    PackedNFT = 30,
+    ValueCreate = 31,
+    ValueUpdate = 32,
+    PollCreated = 33,
+    PollClosed = 34,
+    PollVote = 35,
+    ChannelCreate = 36,
+    ChannelRefill = 37,
+    ChannelSettle = 38,
+    LeaderboardCreate = 39,
+    LeaderboardInsert = 40,
+    LeaderboardReset = 41,
+    PlatformCreate = 42,
+    ChainSwap = 43,
+    ContractRegister = 44,
+    ContractDeploy = 45,
+    AddressMigration = 46,
+    ContractUpgrade = 47,
+    Log = 48,
+    Inflation = 49,
+    OrderBid = 59,
+    MasterClaim = 61,
+    Custom = 64
+}
+export declare enum TypeAuction {
+    Fixed = 0,
+    Classic = 1,
+    Reserve = 2,
+    Dutch = 3
+}
+export declare function decodeVMObject(str: string): any;
+export declare function getTokenEventData(str: string): {
+    symbol: string;
+    value: string;
+    chainName: string;
+};
+export declare function getChainValueEventData(str: string): {
+    name: () => string;
+    value: number;
+};
+export declare function getTransactionSettleEventData(str: string): {
+    hash: string;
+    platform: string;
+    chain: string;
+};
+export declare function getGasEventData(str: string): {
+    address: string;
+    price: number;
+    amount: number;
+    endAmount: number;
+};
+export declare function getInfusionEventData(str: string): {
+    baseSymbol: string;
+    TokenID: string;
+    InfusedSymbol: string;
+    InfusedValue: string;
+    ChainName: string;
+};
+export declare function getMarketEventData(str: string): {
+    baseSymbol: string;
+    quoteSymbol: string;
+    id: string;
+    amount: number;
+};
+export declare function getString(str: string): string;
+//# sourceMappingURL=EventData.d.ts.map

package/core/vm/EventData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventData.d.ts","sourceRoot":"","sources":["../../src/core/vm/EventData.ts"],"names":[],"mappings":"AAKA,oBAAY,SAAS;IACnB,OAAO,IAAI;IACX,WAAW,IAAI;IACf,WAAW,IAAI;IACf,SAAS,IAAI;IACb,YAAY,IAAI;IAChB,SAAS,IAAI;IACb,SAAS,IAAI;IACb,UAAU,IAAI;IACd,UAAU,IAAI;IACd,eAAe,IAAI;IACnB,WAAW,KAAK;IAChB,aAAa,KAAK;IAClB,kBAAkB,KAAK;IACvB,eAAe,KAAK;IACpB,kBAAkB,KAAK;IACvB,SAAS,KAAK;IACd,UAAU,KAAK;IACf,iBAAiB,KAAK;IACtB,YAAY,KAAK;IACjB,cAAc,KAAK;IACnB,WAAW,KAAK;IAChB,WAAW,KAAK;IAChB,UAAU,KAAK;IACf,UAAU,KAAK;IACf,UAAU,KAAK;IACf,UAAU,KAAK;IACf,gBAAgB,KAAK;IACrB,cAAc,KAAK;IACnB,eAAe,KAAK;IACpB,eAAe,KAAK;IACpB,SAAS,KAAK;IACd,WAAW,KAAK;IAChB,WAAW,KAAK;IAChB,WAAW,KAAK;IAChB,UAAU,KAAK;IACf,QAAQ,KAAK;IACb,aAAa,KAAK;IAClB,aAAa,KAAK;IAClB,aAAa,KAAK;IAClB,iBAAiB,KAAK;IACtB,iBAAiB,KAAK;IACtB,gBAAgB,KAAK;IACrB,cAAc,KAAK;IACnB,SAAS,KAAK;IACd,gBAAgB,KAAK;IACrB,cAAc,KAAK;IACnB,gBAAgB,KAAK;IACrB,eAAe,KAAK;IACpB,GAAG,KAAK;IACR,SAAS,KAAK;IACd,QAAQ,KAAK;IACb,WAAW,KAAK;IAChB,MAAM,KAAK;CACZ;AAED,oBAAY,WAAW;IACrB,KAAK,IAAI;IACT,OAAO,IAAI;IACX,OAAO,IAAI;IACX,KAAK,IAAI;CACV;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,OAGzC;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM;;;;EAQ5C;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM;;;EAMjD;AAED,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,MAAM;;;;EAQxD;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM;;;;;EAQ1C;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM;;;;;;EAS/C;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM;;;;;EAQ7C;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,UAEpC"}