xpi-ts 0.2.0

package/dist/lib/bitcore/hdprivatekey.js

@@ -0,0 +1,381 @@
+import { BN } from './crypto/bn.js';
+import { PrivateKey } from './privatekey.js';
+import { PublicKey } from './publickey.js';
+import { Point } from './crypto/point.js';
+import { get as getNetwork, defaultNetwork, } from './networks.js';
+import { Hash } from './crypto/hash.js';
+import { Random } from './crypto/random.js';
+import { Base58Check } from './encoding/base58check.js';
+import { JSUtil } from './util/js.js';
+import { Preconditions } from './util/preconditions.js';
+import { HDPublicKey } from './hdpublickey.js';
+export class HDPrivateKey {
+    privateKey;
+    network;
+    depth;
+    parentFingerPrint;
+    childIndex;
+    chainCode;
+    fingerPrint;
+    publicKey;
+    xprivkey;
+    _hdPublicKey;
+    _buffers;
+    static Hardened = 0x80000000;
+    static MaxIndex = 2 * HDPrivateKey.Hardened;
+    static RootElementAlias = ['m', 'M', "m'", "M'"];
+    constructor(data) {
+        if (data instanceof HDPrivateKey) {
+            return data;
+        }
+        if (data === undefined) {
+            data = HDPrivateKey._getRandomData();
+        }
+        const info = this._classifyArguments(data);
+        this._buildFromObject(info);
+    }
+    get hdPublicKey() {
+        return this._hdPublicKey;
+    }
+    get xpubkey() {
+        return this._hdPublicKey.xpubkey;
+    }
+    _classifyArguments(data) {
+        if (typeof data === 'string') {
+            return HDPrivateKey._transformString(data);
+        }
+        else if (Buffer.isBuffer(data)) {
+            const str = data.toString();
+            if (HDPrivateKey.isValidSerialized(str)) {
+                return HDPrivateKey._transformSerialized(str);
+            }
+            else {
+                return HDPrivateKey._transformBuffer(data);
+            }
+        }
+        else if (typeof data === 'object' && data !== null) {
+            if ('xprivkey' in data) {
+                return HDPrivateKey._transformObject(data);
+            }
+            else {
+                return data;
+            }
+        }
+        else {
+            throw new Error('Invalid HDPrivateKey data');
+        }
+    }
+    static _transformString(str) {
+        if (!JSUtil.isHexa(str)) {
+            return HDPrivateKey._transformSerialized(str);
+        }
+        return HDPrivateKey._transformBuffer(Buffer.from(str, 'hex'));
+    }
+    static _transformSerialized(str) {
+        const buf = Base58Check.decode(str);
+        return HDPrivateKey._transformBuffer(buf);
+    }
+    static _transformBuffer(buf) {
+        if (buf.length !== 78) {
+            throw new Error('Invalid HDPrivateKey buffer length');
+        }
+        const version = buf.readUInt32BE(0);
+        const network = getNetwork(version, 'xprivkey');
+        if (!network) {
+            throw new Error('Invalid HDPrivateKey network');
+        }
+        const depth = buf.readUInt8(4);
+        const parentFingerPrint = buf.subarray(5, 9);
+        const childIndex = buf.readUInt32BE(9);
+        const chainCode = buf.subarray(13, 45);
+        const privateKeyBuffer = buf.subarray(46, 78);
+        const compressed = buf[45] === 0x01;
+        return {
+            network,
+            depth,
+            parentFingerPrint,
+            childIndex,
+            chainCode,
+            privateKey: new PrivateKey({ buf: privateKeyBuffer, compressed }, network),
+        };
+    }
+    static _transformObject(obj) {
+        const network = getNetwork(obj.network);
+        if (!network) {
+            throw new Error('Invalid network');
+        }
+        return {
+            network,
+            depth: obj.depth,
+            parentFingerPrint: Buffer.from(obj.parentFingerPrint, 'hex'),
+            childIndex: obj.childIndex,
+            chainCode: Buffer.from(obj.chainCode, 'hex'),
+            privateKey: new PrivateKey(obj.privateKey, network),
+        };
+    }
+    static _getRandomData() {
+        const seed = Random.getRandomBuffer(64);
+        return HDPrivateKey._fromSeed(seed);
+    }
+    static _fromSeed(seed) {
+        const hash = Hash.sha512hmac(seed, Buffer.from('Bitcoin seed'));
+        const privateKeyBuffer = hash.subarray(0, 32);
+        const chainCode = hash.subarray(32, 64);
+        return {
+            network: defaultNetwork,
+            depth: 0,
+            parentFingerPrint: Buffer.alloc(4),
+            childIndex: 0,
+            chainCode,
+            privateKey: new PrivateKey(privateKeyBuffer, defaultNetwork),
+        };
+    }
+    _buildFromObject(info) {
+        Preconditions.checkArgument(!!info.network, 'network', 'Network is required');
+        Preconditions.checkArgument(!!info.privateKey, 'privateKey', 'Private key is required');
+        Preconditions.checkArgument(!!info.chainCode, 'chainCode', 'Chain code is required');
+        const buffers = {
+            version: Buffer.alloc(4),
+            depth: Buffer.from([info.depth || 0]),
+            parentFingerPrint: info.parentFingerPrint || Buffer.alloc(4),
+            childIndex: Buffer.alloc(4),
+            chainCode: info.chainCode,
+            privateKey: info.privateKey.toBuffer(),
+            checksum: undefined,
+        };
+        buffers.version.writeUInt32BE(info.network.xprivkey, 0);
+        buffers.childIndex.writeUInt32BE(info.childIndex || 0, 0);
+        const version = info.network.xprivkey;
+        const depth = info.depth || 0;
+        const parentFingerPrint = info.parentFingerPrint || Buffer.alloc(4);
+        const childIndex = info.childIndex || 0;
+        const chainCode = info.chainCode;
+        const privateKeyBuffer = info.privateKey.toBuffer();
+        const buf = Buffer.alloc(78);
+        buf.writeUInt32BE(version, 0);
+        buf.writeUInt8(depth, 4);
+        parentFingerPrint.copy(buf, 5);
+        buf.writeUInt32BE(childIndex, 9);
+        chainCode.copy(buf, 13);
+        privateKeyBuffer.copy(buf, 46);
+        const xprivkey = Base58Check.encode(buf);
+        JSUtil.defineImmutable(this, {
+            network: info.network,
+            depth: info.depth || 0,
+            parentFingerPrint: info.parentFingerPrint || Buffer.alloc(4),
+            childIndex: info.childIndex || 0,
+            chainCode: info.chainCode,
+            privateKey: info.privateKey,
+            publicKey: PublicKey.fromPoint(info.privateKey.toPublicKey().point, true),
+            fingerPrint: Hash.sha256ripemd160(PublicKey.fromPoint(info.privateKey.toPublicKey().point, true).toBuffer()).subarray(0, 4),
+            xprivkey: xprivkey,
+            _buffers: buffers,
+        });
+        this._hdPublicKey = new HDPublicKey({
+            network: this.network,
+            depth: this.depth,
+            parentFingerPrint: this.parentFingerPrint,
+            childIndex: this.childIndex,
+            chainCode: this.chainCode,
+            publicKey: this.publicKey,
+        });
+    }
+    isValidPath(arg, hardened) {
+        if (typeof arg === 'string') {
+            const indexes = HDPrivateKey._getDerivationIndexes(arg);
+            return indexes !== null && indexes.every(index => this.isValidPath(index));
+        }
+        if (typeof arg === 'number') {
+            if (arg < HDPrivateKey.Hardened && hardened === true) {
+                arg += HDPrivateKey.Hardened;
+            }
+            return arg >= 0 && arg < HDPrivateKey.MaxIndex;
+        }
+        return false;
+    }
+    static _getDerivationIndexes(path) {
+        const steps = path.split('/');
+        if (HDPrivateKey.RootElementAlias.includes(path)) {
+            return [];
+        }
+        if (!HDPrivateKey.RootElementAlias.includes(steps[0])) {
+            return null;
+        }
+        const indexes = steps.slice(1).map(step => {
+            const isHardened = step.slice(-1) === "'";
+            if (isHardened) {
+                step = step.slice(0, -1);
+            }
+            if (!step || step[0] === '-') {
+                return NaN;
+            }
+            let index = +step;
+            if (isHardened) {
+                index += HDPrivateKey.Hardened;
+            }
+            return index;
+        });
+        return indexes.some(isNaN) ? null : indexes;
+    }
+    static isValidSerialized(data, network) {
+        try {
+            HDPrivateKey._transformString(typeof data === 'string' ? data : data.toString('hex'));
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    getSerializedError(data, network) {
+        try {
+            HDPrivateKey._transformString(typeof data === 'string' ? data : data.toString('hex'));
+            return null;
+        }
+        catch (e) {
+            return e;
+        }
+    }
+    derive(arg, hardened) {
+        return this.deriveNonCompliantChild(arg, hardened);
+    }
+    _deriveFromString(path, nonCompliant) {
+        if (!this.isValidPath(path)) {
+            throw new Error('Invalid derivation path');
+        }
+        const indexes = HDPrivateKey._getDerivationIndexes(path);
+        if (indexes === null) {
+            throw new Error('Invalid derivation path');
+        }
+        return indexes.reduce((prev, index) => {
+            return prev._deriveWithNumber(index, undefined, nonCompliant);
+        }, this);
+    }
+    _deriveWithNumber(index, hardened, nonCompliant) {
+        if (!this.isValidPath(index, hardened)) {
+            throw new Error('Invalid derivation path');
+        }
+        hardened = index >= HDPrivateKey.Hardened ? true : hardened;
+        if (index < HDPrivateKey.Hardened && hardened === true) {
+            index += HDPrivateKey.Hardened;
+        }
+        const indexBuffer = Buffer.from([
+            index >> 24,
+            index >> 16,
+            index >> 8,
+            index,
+        ]);
+        let data;
+        if (hardened && nonCompliant) {
+            const nonZeroPadded = this.privateKey.bn.toBuffer();
+            data = Buffer.concat([Buffer.from([0]), nonZeroPadded, indexBuffer]);
+        }
+        else if (hardened) {
+            const privateKeyBuffer = this.privateKey.bn.toBuffer({ size: 32 });
+            data = Buffer.concat([Buffer.from([0]), privateKeyBuffer, indexBuffer]);
+        }
+        else {
+            data = Buffer.concat([this.publicKey.toBuffer(), indexBuffer]);
+        }
+        const hash = Hash.sha512hmac(data, this.chainCode);
+        const leftPart = BN.fromBuffer(hash.subarray(0, 32), { size: 32 });
+        const childChainCode = hash.subarray(32, 64);
+        const childPrivateKey = leftPart
+            .add(this.privateKey.toBigNumber())
+            .umod(Point.getN())
+            .toBuffer({ size: 32 });
+        if (!PrivateKey.isValid(childPrivateKey)) {
+            return this._deriveWithNumber(index + 1, undefined, nonCompliant);
+        }
+        return new HDPrivateKey({
+            network: this.network,
+            depth: this.depth + 1,
+            parentFingerPrint: Hash.sha256ripemd160(this.privateKey.toPublicKey().toBuffer()).subarray(0, 4),
+            childIndex: index,
+            chainCode: childChainCode,
+            privateKey: new PrivateKey({
+                bn: childPrivateKey.toString('hex'),
+                network: this.network.name,
+                compressed: this.privateKey.compressed,
+            }),
+        });
+    }
+    deriveChild(arg, hardened) {
+        if (typeof arg === 'string') {
+            return this._deriveFromString(arg, false);
+        }
+        else if (typeof arg === 'number') {
+            return this._deriveWithNumber(arg, hardened, false);
+        }
+        else {
+            throw new Error('Invalid derivation argument');
+        }
+    }
+    deriveNonCompliantChild(arg, hardened) {
+        if (typeof arg === 'string') {
+            return this._deriveFromString(arg, true);
+        }
+        else if (typeof arg === 'number') {
+            return this._deriveWithNumber(arg, hardened, true);
+        }
+        else {
+            throw new Error('Invalid derivation argument');
+        }
+    }
+    toString() {
+        return this.xprivkey;
+    }
+    toObject() {
+        return {
+            xprivkey: this.xprivkey,
+            network: this.network.toString(),
+            depth: this.depth,
+            parentFingerPrint: this.parentFingerPrint.toString('hex'),
+            childIndex: this.childIndex,
+            chainCode: this.chainCode.toString('hex'),
+            privateKey: this.privateKey.toString(),
+        };
+    }
+    toJSON() {
+        return this.toObject();
+    }
+    toBuffer() {
+        if (this._buffers.xprivkey) {
+            return this._buffers.xprivkey;
+        }
+        const version = this.network.xprivkey;
+        const depth = this.depth;
+        const parentFingerPrint = this.parentFingerPrint;
+        const childIndex = this.childIndex;
+        const chainCode = this.chainCode;
+        const privateKeyBuffer = this.privateKey.toBuffer();
+        const buf = Buffer.alloc(78);
+        buf.writeUInt32BE(version, 0);
+        buf.writeUInt8(depth, 4);
+        parentFingerPrint.copy(buf, 5);
+        buf.writeUInt32BE(childIndex, 9);
+        chainCode.copy(buf, 13);
+        privateKeyBuffer.copy(buf, 46);
+        this._buffers.xprivkey = buf;
+        return buf;
+    }
+    static fromBuffer(arg) {
+        return new HDPrivateKey(arg.toString('hex'));
+    }
+    static fromString(arg) {
+        return new HDPrivateKey(arg);
+    }
+    static fromObject(obj) {
+        return new HDPrivateKey(obj);
+    }
+    static fromSeed(hexa, network) {
+        const seed = typeof hexa === 'string' ? Buffer.from(hexa, 'hex') : hexa;
+        const data = HDPrivateKey._fromSeed(seed);
+        if (network) {
+            data.network = getNetwork(network) || defaultNetwork;
+        }
+        return new HDPrivateKey(data);
+    }
+    inspect() {
+        return `<HDPrivateKey: ${this.xprivkey}, network: ${this.network}>`;
+    }
+}

package/dist/lib/bitcore/hdpublickey.d.ts

@@ -0,0 +1,98 @@
+import { PublicKey } from './publickey.js';
+import { HDPrivateKey } from './hdprivatekey.js';
+import { Network } from './networks.js';
+export interface HDPublicKeyData {
+    xpubkey?: string;
+    network?: Network;
+    depth?: number;
+    parentFingerPrint?: Buffer;
+    childIndex?: number;
+    chainCode?: Buffer;
+    publicKey?: PublicKey;
+}
+export interface HDPublicKeyObject {
+    xpubkey: string;
+    network: string;
+    depth: number;
+    fingerPrint: string;
+    parentFingerPrint: string;
+    childIndex: number;
+    chainCode: string;
+    publicKey: string;
+}
+export interface HDPublicKeyBuffers {
+    version: Buffer;
+    depth: Buffer;
+    parentFingerPrint: Buffer;
+    childIndex: Buffer;
+    chainCode: Buffer;
+    publicKey: Buffer;
+    checksum?: Buffer;
+    xpubkey?: Buffer;
+    privateKey?: Buffer;
+    xprivkey?: Buffer;
+}
+export declare class HDPublicKey {
+    readonly xpubkey: Buffer;
+    readonly network: Network;
+    readonly depth: number;
+    readonly publicKey: PublicKey;
+    readonly fingerPrint: Buffer;
+    readonly parentFingerPrint: Buffer;
+    readonly childIndex: number;
+    readonly chainCode: Buffer;
+    private _buffers;
+    static readonly Hardened = 2147483648;
+    static readonly RootElementAlias: string[];
+    static readonly VersionSize = 4;
+    static readonly DepthSize = 1;
+    static readonly ParentFingerPrintSize = 4;
+    static readonly ChildIndexSize = 4;
+    static readonly ChainCodeSize = 32;
+    static readonly PublicKeySize = 33;
+    static readonly CheckSumSize = 4;
+    static readonly DataSize = 78;
+    static readonly SerializedByteSize = 82;
+    static readonly VersionStart = 0;
+    static readonly VersionEnd: number;
+    static readonly DepthStart: number;
+    static readonly DepthEnd: number;
+    static readonly ParentFingerPrintStart: number;
+    static readonly ParentFingerPrintEnd: number;
+    static readonly ChildIndexStart: number;
+    static readonly ChildIndexEnd: number;
+    static readonly ChainCodeStart: number;
+    static readonly ChainCodeEnd: number;
+    static readonly PublicKeyStart: number;
+    static readonly PublicKeyEnd: number;
+    static readonly ChecksumStart: number;
+    static readonly ChecksumEnd: number;
+    constructor(arg: string | Buffer | HDPublicKeyData | HDPublicKeyObject | HDPrivateKey);
+    static isValidPath(arg: string | number): boolean;
+    static isValidSerialized(data: string | Buffer, network?: string | Network): boolean;
+    static getSerializedError(data: string | Buffer, network?: string | Network): Error | null;
+    private static _validateNetwork;
+    static fromString(arg: string): HDPublicKey;
+    static fromObject(arg: HDPublicKeyData | HDPublicKeyObject): HDPublicKey;
+    static fromBuffer(arg: Buffer): HDPublicKey;
+    private _classifyArguments;
+    private static _transformString;
+    private static _transformSerialized;
+    private static _transformBuffer;
+    private static _transformObject;
+    private _buildFromPrivate;
+    private _buildFromSerialized;
+    private _buildFromBuffers;
+    private static _validateBufferArguments;
+    private _buildFromObject;
+    derive(arg: string | number, hardened?: boolean): HDPublicKey;
+    deriveChild(arg: string | number, hardened?: boolean): HDPublicKey;
+    private _deriveWithNumber;
+    private _deriveFromString;
+    toString(): string;
+    toBuffer(): Buffer;
+    toObject(): HDPublicKeyObject;
+    toJSON(): string;
+    inspect(): string;
+}
+//# sourceMappingURL=hdpublickey.d.ts.map

package/dist/lib/bitcore/hdpublickey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hdpublickey.d.ts","sourceRoot":"","sources":["../../../lib/bitcore/hdpublickey.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,OAAO,EAAqC,MAAM,eAAe,CAAA;AAQ1E,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,SAAS,CAAA;CACtB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,iBAAiB,EAAE,MAAM,CAAA;IACzB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,iBAAiB,EAAE,MAAM,CAAA;IACzB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,qBAAa,WAAW;IACtB,QAAQ,CAAC,OAAO,EAAG,MAAM,CAAA;IACzB,QAAQ,CAAC,OAAO,EAAG,OAAO,CAAA;IAC1B,QAAQ,CAAC,KAAK,EAAG,MAAM,CAAA;IACvB,QAAQ,CAAC,SAAS,EAAG,SAAS,CAAA;IAC9B,QAAQ,CAAC,WAAW,EAAG,MAAM,CAAA;IAC7B,QAAQ,CAAC,iBAAiB,EAAG,MAAM,CAAA;IACnC,QAAQ,CAAC,UAAU,EAAG,MAAM,CAAA;IAC5B,QAAQ,CAAC,SAAS,EAAG,MAAM,CAAA;IAC3B,OAAO,CAAC,QAAQ,CAAqB;IAGrC,MAAM,CAAC,QAAQ,CAAC,QAAQ,cAAa;IACrC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,WAAa;IAC7C,MAAM,CAAC,QAAQ,CAAC,WAAW,KAAI;IAC/B,MAAM,CAAC,QAAQ,CAAC,SAAS,KAAI;IAC7B,MAAM,CAAC,QAAQ,CAAC,qBAAqB,KAAI;IACzC,MAAM,CAAC,QAAQ,CAAC,cAAc,KAAI;IAClC,MAAM,CAAC,QAAQ,CAAC,aAAa,MAAK;IAClC,MAAM,CAAC,QAAQ,CAAC,aAAa,MAAK;IAClC,MAAM,CAAC,QAAQ,CAAC,YAAY,KAAI;IAChC,MAAM,CAAC,QAAQ,CAAC,QAAQ,MAAK;IAC7B,MAAM,CAAC,QAAQ,CAAC,kBAAkB,MAAK;IAGvC,MAAM,CAAC,QAAQ,CAAC,YAAY,KAAI;IAChC,MAAM,CAAC,QAAQ,CAAC,UAAU,SAC0B;IACpD,MAAM,CAAC,QAAQ,CAAC,UAAU,SAAyB;IACnD,MAAM,CAAC,QAAQ,CAAC,QAAQ,SAAiD;IACzE,MAAM,CAAC,QAAQ,CAAC,sBAAsB,SAAuB;IAC7D,MAAM,CAAC,QAAQ,CAAC,oBAAoB,SACoC;IACxE,MAAM,CAAC,QAAQ,CAAC,eAAe,SAAmC;IAClE,MAAM,CAAC,QAAQ,CAAC,aAAa,SAC6B;IAC1D,MAAM,CAAC,QAAQ,CAAC,cAAc,SAA4B;IAC1D,MAAM,CAAC,QAAQ,CAAC,YAAY,SAC4B;IACxD,MAAM,CAAC,QAAQ,CAAC,cAAc,SAA2B;IACzD,MAAM,CAAC,QAAQ,CAAC,YAAY,SAC4B;IACxD,MAAM,CAAC,QAAQ,CAAC,aAAa,SAA2B;IACxD,MAAM,CAAC,QAAQ,CAAC,WAAW,SAC2B;gBAGpD,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,eAAe,GAAG,iBAAiB,GAAG,YAAY;IA0C3E,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO;IAiBjD,MAAM,CAAC,iBAAiB,CACtB,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,GACzB,OAAO;IAOV,MAAM,CAAC,kBAAkB,CACvB,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,GACzB,KAAK,GAAG,IAAI;IAgCf,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAyB/B,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW;IAW3C,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,WAAW;IAWxE,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW;IAI3C,OAAO,CAAC,kBAAkB;IAkB1B,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAO/B,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAKnC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IA2B/B,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAmB/B,OAAO,CAAC,iBAAiB;IAkBzB,OAAO,CAAC,oBAAoB;IAoC5B,OAAO,CAAC,iBAAiB;IAkDzB,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAuBvC,OAAO,CAAC,gBAAgB;IAiDxB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,WAAW;IAO7D,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,WAAW;IAalE,OAAO,CAAC,iBAAiB;IAwCzB,OAAO,CAAC,iBAAiB;IAmBzB,QAAQ,IAAI,MAAM;IAOlB,QAAQ,IAAI,MAAM;IAOlB,QAAQ,IAAI,iBAAiB;IAgB7B,MAAM,IAAI,MAAM;IAOhB,OAAO,IAAI,MAAM;CAGlB"}