const CDP = require('chrome-remote-interface')
const { WebDriver } = require('../common/web_driver')
const { inflate } = require('pako')

class Bitget {

    async example () {
        let wd = new WebDriver()

        await wd.builder()

        console.info(wd)
    }

    /**
     * 解密
     * */
    decode (data) {


        //
        // let A = {
        //     f () {
        //         this.mode = 0,
        //             this.last = !1,
        //             this.wrap = 0,
        //             this.havedict = !1,
        //             this.flags = 0,
        //             this.dmax = 0,
        //             this.check = 0,
        //             this.total = 0,
        //             this.head = null,
        //             this.wbits = 0,
        //             this.wsize = 0,
        //             this.whave = 0,
        //             this.wnext = 0,
        //             this.window = null,
        //             this.hold = 0,
        //             this.bits = 0,
        //             this.length = 0,
        //             this.offset = 0,
        //             this.extra = 0,
        //             this.lencode = null,
        //             this.distcode = null,
        //             this.lenbits = 0,
        //             this.distbits = 0,
        //             this.ncode = 0,
        //             this.nlen = 0,
        //             this.ndist = 0,
        //             this.have = 0,
        //             this.next = null,
        //             this.lens = new r.Buf16(320),
        //             this.work = new r.Buf16(288),
        //             this.lendyn = null,
        //             this.distdyn = null,
        //             this.sane = 0,
        //             this.back = 0,
        //             this.was = 0
        //     },
        //     s: {
        //         'Z_NO_FLUSH': 0,
        //         'Z_PARTIAL_FLUSH': 1,
        //         'Z_SYNC_FLUSH': 2,
        //         'Z_FULL_FLUSH': 3,
        //         'Z_FINISH': 4,
        //         'Z_BLOCK': 5,
        //         'Z_TREES': 6,
        //         'Z_OK': 0,
        //         'Z_STREAM_END': 1,
        //         'Z_NEED_DICT': 2,
        //         'Z_ERRNO': -1,
        //         'Z_STREAM_ERROR': -2,
        //         'Z_DATA_ERROR': -3,
        //         'Z_BUF_ERROR': -5,
        //         'Z_NO_COMPRESSION': 0,
        //         'Z_BEST_SPEED': 1,
        //         'Z_BEST_COMPRESSION': 9,
        //         'Z_DEFAULT_COMPRESSION': -1,
        //         'Z_FILTERED': 1,
        //         'Z_HUFFMAN_ONLY': 2,
        //         'Z_RLE': 3,
        //         'Z_FIXED': 4,
        //         'Z_DEFAULT_STRATEGY': 0,
        //         'Z_BINARY': 0,
        //         'Z_TEXT': 1,
        //         'Z_UNKNOWN': 2,
        //         'Z_DEFLATED': 8,
        //     },
        //     o: {
        //         '0': '',
        //         '1': 'stream end',
        //         '2': 'need dictionary',
        //         '-1': 'file error',
        //         '-2': 'stream error',
        //         '-3': 'data error',
        //         '-4': 'insufficient memory',
        //         '-5': 'buffer error',
        //         '-6': 'incompatible version',
        //     },
        //     h: function() {
        //         this.text = 0,
        //             this.time = 0,
        //             this.xflags = 0,
        //             this.os = 0,
        //             this.extra = null,
        //             this.extra_len = 0,
        //             this.name = '',
        //             this.comment = '',
        //             this.hcrc = 0,
        //             this.done = !1
        //     },
        //     l: function() {
        //         this.input = null,
        //             this.next_in = 0,
        //             this.avail_in = 0,
        //             this.total_in = 0,
        //             this.output = null,
        //             this.next_out = 0,
        //             this.avail_out = 0,
        //             this.total_out = 0,
        //             this.msg = '',
        //             this.state = null,
        //             this.data_type = 2,
        //             this.adler = 0
        //     },
        //     p: function(t, e, a, i) {
        //         var n, s = t.state
        //         return null === s.window && (s.wsize = 1 << s.wbits,
        //             s.wnext = 0,
        //             s.whave = 0,
        //             s.window = new r.Buf8(s.wsize)),
        //             i >= s.wsize ? (r.arraySet(s.window, e, a - s.wsize, s.wsize, 0),
        //                 s.wnext = 0,
        //                 s.whave = s.wsize) : ((n = s.wsize - s.wnext) > i && (n = i),
        //                 r.arraySet(s.window, e, a - i, n, s.wnext),
        //                 (i -= n) ? (r.arraySet(s.window, e, a - i, i, 0),
        //                     s.wnext = i,
        //                     s.whave = s.wsize) : (s.wnext += n,
        //                 s.wnext === s.wsize && (s.wnext = 0),
        //                 s.whave < s.wsize && (s.whave += n))),
        //             0
        //     },
        //     c: function(t, e) {
        //         var a, i
        //         return t && t.state ? (i = t.state,
        //             e < 0 ? (a = 0,
        //                 e = -e) : (a = (e >> 4) + 1,
        //             e < 48 && (e &= 15)),
        //         e && (e < 8 || e > 15)) ? -2 : (null !== i.window && i.wbits !== e && (i.window = null),
        //             i.wrap = a,
        //             i.wbits = e,
        //             u(t)) : -2
        //     },
        // }
        //
        // let n = {
        //     assign: function(t) {
        //         for (let e = Array.prototype.slice.call(arguments, 1); e.length;) {
        //             const a = e.shift()
        //             if (a) {
        //                 if ('object' != typeof a) {
        //                     throw TypeError(a + 'must be non-object')
        //                 }
        //                 for (const i in a) {
        //                     Object.prototype.hasOwnProperty.call(a, i) && (t[i] = a[i])
        //                 }
        //             }
        //         }
        //         return t
        //     }
        //     ,
        //     shrinkBuf: function(t, e) {
        //         return t.length === e ? t : t.subarray ? t.subarray(0, e) : (t.length = e, t)
        //     },
        //     Buf8: Uint8Array,
        //     Buf16: Uint16Array,
        //     Buf32: Int32Array,
        //     arraySet: function(t, e, a, i, n) {
        //         for (let r = 0; r < i; r++) {
        //             t[n + r] = e[a + r]
        //         }
        //
        //     },
        //     flattenChunks: function(t) {
        //         return [].concat.apply([], t)
        //     },
        // }
        //
        // let r = {
        //
        //     inflateInit2: function g (t, e) {
        //
        //         let a, i
        //         return t ? (i = new A.f,
        //             t.state = i,
        //             i.window = null,
        //         0 !== (a = c(t, e)) && (t.state = null), a) : -2
        //     },
        // }
        // let i = {
        //
        //     inflateGetHeader (t, e) {
        //         let a
        //         return t && t.state && (2 & (a = t.state).wrap) != 0 ? (a.head = e, e.done = !1, 0) : -2
        //     },
        //     inflateInit2 (t, e) {
        //         let a, i
        //         //TODO c
        //         return t ? (i = new f, t.state = i, i.window = null, 0 !== (a = c(t, e)) && (t.state = null), a) : -2
        //     },
        //     inflate (t, e) {
        //         let a, f, _, u, c, g, w, m, v, k, y, x, z, B, E, S, A, T, Z, O, R, D, I, C, N = 0, L = new n.Buf8(4),
        //             U = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]
        //         if (!t || !t.state || !t.output || !t.input && 0 !== t.avail_in) {
        //             return -2
        //         }
        //         12 === (a = t.state).mode && (a.mode = 13),
        //             c = t.next_out,
        //             _ = t.output,
        //             w = t.avail_out,
        //             u = t.next_in,
        //             f = t.input,
        //             g = t.avail_in,
        //             m = a.hold,
        //             v = a.bits,
        //             k = g,
        //             y = w,
        //             D = 0
        //         e: for (; ;) {
        //             switch (a.mode) {
        //                 case 1:
        //                     if (0 === a.wrap) {
        //                         a.mode = 13
        //                         break
        //                     }
        //                     for (; v < 16;) {
        //                         if (0 === g) {
        //                             break e
        //                         }
        //                         g--,
        //                             m += f[u++] << v,
        //                             v += 8
        //                     }
        //                     if (2 & a.wrap && 35615 === m) {
        //                         a.check = 0,
        //                             L[0] = 255 & m,
        //                             L[1] = m >>> 8 & 255,
        //                             a.check = o(a.check, L, 2, 0),
        //                             m = 0,
        //                             v = 0,
        //                             a.mode = 2
        //                         break
        //                     }
        //                     if (a.flags = 0,
        //                     a.head && (a.head.done = !1),
        //                     !(1 & a.wrap) || (((255 & m) << 8) + (m >> 8)) % 31) {
        //                         t.msg = 'incorrect header check',
        //                             a.mode = 30
        //                         break
        //                     }
        //                     if ((15 & m) != 8) {
        //                         t.msg = 'unknown compression method',
        //                             a.mode = 30
        //                         break
        //                     }
        //                     if (m >>>= 4,
        //                         v -= 4,
        //                         R = (15 & m) + 8,
        //                     0 === a.wbits) {
        //                         a.wbits = R
        //                     } else if (R > a.wbits) {
        //                         t.msg = 'invalid window size',
        //                             a.mode = 30
        //                         break
        //                     }
        //                     a.dmax = 1 << R,
        //                         t.adler = a.check = 1,
        //                         a.mode = 512 & m ? 10 : 12,
        //                         m = 0,
        //                         v = 0
        //                     break
        //                 case 2:
        //                     for (; v < 16;) {
        //                         if (0 === g) {
        //                             break e
        //                         }
        //                         g--,
        //                             m += f[u++] << v,
        //                             v += 8
        //                     }
        //                     if (a.flags = m,
        //                     (255 & a.flags) != 8) {
        //                         t.msg = 'unknown compression method',
        //                             a.mode = 30
        //                         break
        //                     }
        //                     if (57344 & a.flags) {
        //                         t.msg = 'unknown header flags set',
        //                             a.mode = 30
        //                         break
        //                     }
        //                     a.head && (a.head.text = m >> 8 & 1),
        //                     512 & a.flags && (L[0] = 255 & m,
        //                         L[1] = m >>> 8 & 255,
        //                         a.check = o(a.check, L, 2, 0)),
        //                         m = 0,
        //                         v = 0,
        //                         a.mode = 3
        //                 case 3:
        //                     for (; v < 32;) {
        //                         if (0 === g) {
        //                             break e
        //                         }
        //                         g--,
        //                             m += f[u++] << v,
        //                             v += 8
        //                     }
        //                     a.head && (a.head.time = m),
        //                     512 & a.flags && (L[0] = 255 & m,
        //                         L[1] = m >>> 8 & 255,
        //                         L[2] = m >>> 16 & 255,
        //                         L[3] = m >>> 24 & 255,
        //                         a.check = o(a.check, L, 4, 0)),
        //                         m = 0,
        //                         v = 0,
        //                         a.mode = 4
        //                 case 4:
        //                     for (; v < 16;) {
        //                         if (0 === g) {
        //                             break e
        //                         }
        //                         g--,
        //                             m += f[u++] << v,
        //                             v += 8
        //                     }
        //                     a.head && (a.head.xflags = 255 & m,
        //                         a.head.os = m >> 8),
        //                     512 & a.flags && (L[0] = 255 & m,
        //                         L[1] = m >>> 8 & 255,
        //                         a.check = o(a.check, L, 2, 0)),
        //                         m = 0,
        //                         v = 0,
        //                         a.mode = 5
        //                 case 5:
        //                     if (1024 & a.flags) {
        //                         for (; v < 16;) {
        //                             if (0 === g) {
        //                                 break e
        //                             }
        //                             g--,
        //                                 m += f[u++] << v,
        //                                 v += 8
        //                         }
        //                         a.length = m,
        //                         a.head && (a.head.extra_len = m),
        //                         512 & a.flags && (L[0] = 255 & m,
        //                             L[1] = m >>> 8 & 255,
        //                             a.check = o(a.check, L, 2, 0)),
        //                             m = 0,
        //                             v = 0
        //                     } else {
        //                         a.head && (a.head.extra = null)
        //                     }
        //                     a.mode = 6
        //                 case 6:
        //                     if (1024 & a.flags && ((x = a.length) > g && (x = g),
        //                     x && (a.head && (R = a.head.extra_len - a.length,
        //                     a.head.extra || (a.head.extra = Array(a.head.extra_len)),
        //                         r.arraySet(a.head.extra, f, u, x, R)),
        //                     512 & a.flags && (a.check = o(a.check, f, x, u)),
        //                         g -= x,
        //                         u += x,
        //                         a.length -= x),
        //                         a.length)) {
        //                         break e
        //                     }
        //                     a.length = 0,
        //                         a.mode = 7
        //                 case 7:
        //                     if (2048 & a.flags) {
        //                         if (0 === g) {
        //                             break e
        //                         }
        //                         x = 0
        //                         do {
        //                             R = f[u + x++],
        //                             a.head && R && a.length < 65536 && (a.head.name += String.fromCharCode(R))
        //                         } while (R && x < g)
        //                         if (512 & a.flags && (a.check = o(a.check, f, x, u)),
        //                             g -= x,
        //                             u += x,
        //                             R) {
        //                             break e
        //                         }
        //                     } else {
        //                         a.head && (a.head.name = null)
        //                     }
        //                     a.length = 0,
        //                         a.mode = 8
        //                 case 8:
        //                     if (4096 & a.flags) {
        //                         if (0 === g) {
        //                             break e
        //                         }
        //                         x = 0
        //                         do {
        //                             R = f[u + x++],
        //                             a.head && R && a.length < 65536 && (a.head.comment += String.fromCharCode(R))
        //                         } while (R && x < g)
        //                         if (512 & a.flags && (a.check = o(a.check, f, x, u)),
        //                             g -= x,
        //                             u += x,
        //                             R) {
        //                             break e
        //                         }
        //                     } else {
        //                         a.head && (a.head.comment = null)
        //                     }
        //                     a.mode = 9
        //                 case 9:
        //                     if (512 & a.flags) {
        //                         for (; v < 16;) {
        //                             if (0 === g) {
        //                                 break e
        //                             }
        //                             g--,
        //                                 m += f[u++] << v,
        //                                 v += 8
        //                         }
        //                         if (m !== (65535 & a.check)) {
        //                             t.msg = 'header crc mismatch',
        //                                 a.mode = 30
        //                             break
        //                         }
        //                         m = 0,
        //                             v = 0
        //                     }
        //                     a.head && (a.head.hcrc = a.flags >> 9 & 1,
        //                         a.head.done = !0),
        //                         t.adler = a.check = 0,
        //                         a.mode = 12
        //                     break
        //                 case 10:
        //                     for (; v < 32;) {
        //                         if (0 === g) {
        //                             break e
        //                         }
        //                         g--,
        //                             m += f[u++] << v,
        //                             v += 8
        //                     }
        //                     //TODO d
        //                     t.adler = a.check = d(m),
        //                         m = 0,
        //                         v = 0,
        //                         a.mode = 11
        //                 case 11:
        //                     if (0 === a.havedict) {
        //                         return t.next_out = c,
        //                             t.avail_out = w,
        //                             t.next_in = u,
        //                             t.avail_in = g,
        //                             a.hold = m,
        //                             a.bits = v,
        //                             2
        //                     }
        //                     t.adler = a.check = 1,
        //                         a.mode = 12
        //                 case 12:
        //                     if (5 === e || 6 === e) {
        //                         break e
        //                     }
        //                 case 13:
        //                     if (a.last) {
        //                         m >>>= 7 & v,
        //                             v -= 7 & v,
        //                             a.mode = 27
        //                         break
        //                     }
        //                     for (; v < 3;) {
        //                         if (0 === g) {
        //                             break e
        //                         }
        //                         g--,
        //                             m += f[u++] << v,
        //                             v += 8
        //                     }
        //                     switch (a.last = 1 & m,
        //                         v -= 1,
        //                     3 & (m >>>= 1)) {
        //                         case 0:
        //                             a.mode = 14
        //                             break
        //                         case 1:
        //                             if (function(t) {
        //                                 if (b) {
        //                                     var e
        //                                     for (i = new r.Buf32(512),
        //                                         n = new r.Buf32(32),
        //                                         e = 0; e < 144;) {
        //                                         t.lens[e++] = 8
        //                                     }
        //                                     for (; e < 256;) {
        //                                         t.lens[e++] = 9
        //                                     }
        //                                     for (; e < 280;) {
        //                                         t.lens[e++] = 7
        //                                     }
        //                                     for (; e < 288;) {
        //                                         t.lens[e++] = 8
        //                                     }
        //                                     for (h(1, t.lens, 0, 288, i, 0, t.work, {
        //                                         bits: 9,
        //                                     }),
        //                                         e = 0; e < 32;) {
        //                                         t.lens[e++] = 5
        //                                     }
        //                                     h(2, t.lens, 0, 32, n, 0, t.work, {
        //                                         bits: 5,
        //                                     }),
        //                                         b = !1
        //                                 }
        //                                 t.lencode = i,
        //                                     t.lenbits = 9,
        //                                     t.distcode = n,
        //                                     t.distbits = 5
        //                             }(a),
        //                                 a.mode = 20,
        //                             6 === e) {
        //                                 m >>>= 2,
        //                                     v -= 2
        //                                 break e
        //                             }
        //                             break
        //                         case 2:
        //                             a.mode = 17
        //                             break
        //                         case 3:
        //                             t.msg = 'invalid block type',
        //                                 a.mode = 30
        //                     }
        //                     m >>>= 2,
        //                         v -= 2
        //                     break
        //                 case 14:
        //                     for (m >>>= 7 & v,
        //                         v -= 7 & v; v < 32;) {
        //                         if (0 === g) {
        //                             break e
        //                         }
        //                         g--,
        //                             m += f[u++] << v,
        //                             v += 8
        //                     }
        //                     if ((65535 & m) != (m >>> 16 ^ 65535)) {
        //                         t.msg = 'invalid stored block lengths',
        //                             a.mode = 30
        //                         break
        //                     }
        //                     if (a.length = 65535 & m,
        //                         m = 0,
        //                         v = 0,
        //                         a.mode = 15,
        //                     6 === e) {
        //                         break e
        //                     }
        //                 case 15:
        //                     a.mode = 16
        //                 case 16:
        //                     if (x = a.length) {
        //                         if (x > g && (x = g),
        //                         x > w && (x = w),
        //                         0 === x) {
        //                             break e
        //                         }
        //                         r.arraySet(_, f, u, x, c),
        //                             g -= x,
        //                             u += x,
        //                             w -= x,
        //                             c += x,
        //                             a.length -= x
        //                         break
        //                     }
        //                     a.mode = 12
        //                     break
        //                 case 17:
        //                     for (; v < 14;) {
        //                         if (0 === g) {
        //                             break e
        //                         }
        //                         g--,
        //                             m += f[u++] << v,
        //                             v += 8
        //                     }
        //                     if (a.nlen = (31 & m) + 257,
        //                         m >>>= 5,
        //                         v -= 5,
        //                         a.ndist = (31 & m) + 1,
        //                         m >>>= 5,
        //                         v -= 5,
        //                         a.ncode = (15 & m) + 4,
        //                         m >>>= 4,
        //                         v -= 4,
        //                     a.nlen > 286 || a.ndist > 30) {
        //                         t.msg = 'too many length or distance symbols',
        //                             a.mode = 30
        //                         break
        //                     }
        //                     a.have = 0,
        //                         a.mode = 18
        //                 case 18:
        //                     for (; a.have < a.ncode;) {
        //                         for (; v < 3;) {
        //                             if (0 === g) {
        //                                 break e
        //                             }
        //                             g--,
        //                                 m += f[u++] << v,
        //                                 v += 8
        //                         }
        //                         a.lens[U[a.have++]] = 7 & m,
        //                             m >>>= 3,
        //                             v -= 3
        //                     }
        //                     for (; a.have < 19;) {
        //                         a.lens[U[a.have++]] = 0
        //                     }
        //                     if (a.lencode = a.lendyn,
        //                         a.lenbits = 7,
        //                         I = {
        //                             bits: a.lenbits,
        //                         },
        //                         D = h(0, a.lens, 0, 19, a.lencode, 0, a.work, I),
        //                         a.lenbits = I.bits,
        //                         D) {
        //                         t.msg = 'invalid code lengths set',
        //                             a.mode = 30
        //                         break
        //                     }
        //                     a.have = 0,
        //                         a.mode = 19
        //                 case 19:
        //                     for (; a.have < a.nlen + a.ndist;) {
        //                         for (; E = (N = a.lencode[m & (1 << a.lenbits) - 1]) >>> 24,
        //                             S = N >>> 16 & 255,
        //                             A = 65535 & N,
        //                             !(E <= v);) {
        //                             if (0 === g) {
        //                                 break e
        //                             }
        //                             g--,
        //                                 m += f[u++] << v,
        //                                 v += 8
        //                         }
        //                         if (A < 16) {
        //                             m >>>= E,
        //                                 v -= E,
        //                                 a.lens[a.have++] = A
        //                         } else {
        //                             if (16 === A) {
        //                                 for (C = E + 2; v < C;) {
        //                                     if (0 === g) {
        //                                         break e
        //                                     }
        //                                     g--,
        //                                         m += f[u++] << v,
        //                                         v += 8
        //                                 }
        //                                 if (m >>>= E,
        //                                     v -= E,
        //                                 0 === a.have) {
        //                                     t.msg = 'invalid bit length repeat',
        //                                         a.mode = 30
        //                                     break
        //                                 }
        //                                 R = a.lens[a.have - 1],
        //                                     x = 3 + (3 & m),
        //                                     m >>>= 2,
        //                                     v -= 2
        //                             } else if (17 === A) {
        //                                 for (C = E + 3; v < C;) {
        //                                     if (0 === g) {
        //                                         break e
        //                                     }
        //                                     g--,
        //                                         m += f[u++] << v,
        //                                         v += 8
        //                                 }
        //                                 m >>>= E,
        //                                     v -= E,
        //                                     R = 0,
        //                                     x = 3 + (7 & m),
        //                                     m >>>= 3,
        //                                     v -= 3
        //                             } else {
        //                                 for (C = E + 7; v < C;) {
        //                                     if (0 === g) {
        //                                         break e
        //                                     }
        //                                     g--,
        //                                         m += f[u++] << v,
        //                                         v += 8
        //                                 }
        //                                 m >>>= E,
        //                                     v -= E,
        //                                     R = 0,
        //                                     x = 11 + (127 & m),
        //                                     m >>>= 7,
        //                                     v -= 7
        //                             }
        //                             if (a.have + x > a.nlen + a.ndist) {
        //                                 t.msg = 'invalid bit length repeat',
        //                                     a.mode = 30
        //                                 break
        //                             }
        //                             for (; x--;) {
        //                                 a.lens[a.have++] = R
        //                             }
        //                         }
        //                     }
        //                     if (30 === a.mode) {
        //                         break
        //                     }
        //                     if (0 === a.lens[256]) {
        //                         t.msg = 'invalid code -- missing end-of-block',
        //                             a.mode = 30
        //                         break
        //                     }
        //                     if (a.lenbits = 9,
        //                         I = {
        //                             bits: a.lenbits,
        //                         },
        //                         D = h(1, a.lens, 0, a.nlen, a.lencode, 0, a.work, I),
        //                         a.lenbits = I.bits,
        //                         D) {
        //                         t.msg = 'invalid literal/lengths set',
        //                             a.mode = 30
        //                         break
        //                     }
        //                     if (a.distbits = 6,
        //                         a.distcode = a.distdyn,
        //                         I = {
        //                             bits: a.distbits,
        //                         },
        //                         D = h(2, a.lens, a.nlen, a.ndist, a.distcode, 0, a.work, I),
        //                         a.distbits = I.bits,
        //                         D) {
        //                         t.msg = 'invalid distances set',
        //                             a.mode = 30
        //                         break
        //                     }
        //                     if (a.mode = 20,
        //                     6 === e) {
        //                         break e
        //                     }
        //                 case 20:
        //                     a.mode = 21
        //                 case 21:
        //                     if (g >= 6 && w >= 258) {
        //                         t.next_out = c,
        //                             t.avail_out = w,
        //                             t.next_in = u,
        //                             t.avail_in = g,
        //                             a.hold = m,
        //                             a.bits = v,
        //                             l(t, y),
        //                             c = t.next_out,
        //                             _ = t.output,
        //                             w = t.avail_out,
        //                             u = t.next_in,
        //                             f = t.input,
        //                             g = t.avail_in,
        //                             m = a.hold,
        //                             v = a.bits,
        //                         12 === a.mode && (a.back = -1)
        //                         break
        //                     }
        //                     for (a.back = 0; E = (N = a.lencode[m & (1 << a.lenbits) - 1]) >>> 24,
        //                         S = N >>> 16 & 255,
        //                         A = 65535 & N,
        //                         !(E <= v);) {
        //                         if (0 === g) {
        //                             break e
        //                         }
        //                         g--,
        //                             m += f[u++] << v,
        //                             v += 8
        //                     }
        //                     if (S && (240 & S) == 0) {
        //                         for (T = E,
        //                             Z = S,
        //                             O = A; E = (N = a.lencode[O + ((m & (1 << T + Z) - 1) >> T)]) >>> 24,
        //                             S = N >>> 16 & 255,
        //                             A = 65535 & N,
        //                             !(T + E <= v);) {
        //                             if (0 === g) {
        //                                 break e
        //                             }
        //                             g--,
        //                                 m += f[u++] << v,
        //                                 v += 8
        //                         }
        //                         m >>>= T,
        //                             v -= T,
        //                             a.back += T
        //                     }
        //                     if (m >>>= E,
        //                         v -= E,
        //                         a.back += E,
        //                         a.length = A,
        //                     0 === S) {
        //                         a.mode = 26
        //                         break
        //                     }
        //                     if (32 & S) {
        //                         a.back = -1,
        //                             a.mode = 12
        //                         break
        //                     }
        //                     if (64 & S) {
        //                         t.msg = 'invalid literal/length code',
        //                             a.mode = 30
        //                         break
        //                     }
        //                     a.extra = 15 & S,
        //                         a.mode = 22
        //                 case 22:
        //                     if (a.extra) {
        //                         for (C = a.extra; v < C;) {
        //                             if (0 === g) {
        //                                 break e
        //                             }
        //                             g--,
        //                                 m += f[u++] << v,
        //                                 v += 8
        //                         }
        //                         a.length += m & (1 << a.extra) - 1,
        //                             m >>>= a.extra,
        //                             v -= a.extra,
        //                             a.back += a.extra
        //                     }
        //                     a.was = a.length,
        //                         a.mode = 23
        //                 case 23:
        //                     for (; E = (N = a.distcode[m & (1 << a.distbits) - 1]) >>> 24,
        //                         S = N >>> 16 & 255,
        //                         A = 65535 & N,
        //                         !(E <= v);) {
        //                         if (0 === g) {
        //                             break e
        //                         }
        //                         g--,
        //                             m += f[u++] << v,
        //                             v += 8
        //                     }
        //                     if ((240 & S) == 0) {
        //                         for (T = E,
        //                             Z = S,
        //                             O = A; E = (N = a.distcode[O + ((m & (1 << T + Z) - 1) >> T)]) >>> 24,
        //                             S = N >>> 16 & 255,
        //                             A = 65535 & N,
        //                             !(T + E <= v);) {
        //                             if (0 === g) {
        //                                 break e
        //                             }
        //                             g--,
        //                                 m += f[u++] << v,
        //                                 v += 8
        //                         }
        //                         m >>>= T,
        //                             v -= T,
        //                             a.back += T
        //                     }
        //                     if (m >>>= E,
        //                         v -= E,
        //                         a.back += E,
        //                     64 & S) {
        //                         t.msg = 'invalid distance code',
        //                             a.mode = 30
        //                         break
        //                     }
        //                     a.offset = A,
        //                         a.extra = 15 & S,
        //                         a.mode = 24
        //                 case 24:
        //                     if (a.extra) {
        //                         for (C = a.extra; v < C;) {
        //                             if (0 === g) {
        //                                 break e
        //                             }
        //                             g--,
        //                                 m += f[u++] << v,
        //                                 v += 8
        //                         }
        //                         a.offset += m & (1 << a.extra) - 1,
        //                             m >>>= a.extra,
        //                             v -= a.extra,
        //                             a.back += a.extra
        //                     }
        //                     if (a.offset > a.dmax) {
        //                         t.msg = 'invalid distance too far back',
        //                             a.mode = 30
        //                         break
        //                     }
        //                     a.mode = 25
        //                 case 25:
        //                     if (0 === w) {
        //                         break e
        //                     }
        //                     if (x = y - w,
        //                     a.offset > x) {
        //                         if ((x = a.offset - x) > a.whave && a.sane) {
        //                             t.msg = 'invalid distance too far back',
        //                                 a.mode = 30
        //                             break
        //                         }
        //                         x > a.wnext ? (x -= a.wnext,
        //                             z = a.wsize - x) : z = a.wnext - x,
        //                         x > a.length && (x = a.length),
        //                             B = a.window
        //                     } else {
        //                         B = _,
        //                             z = c - a.offset,
        //                             x = a.length
        //                     }
        //                     x > w && (x = w),
        //                         w -= x,
        //                         a.length -= x
        //                     do {
        //                         _[c++] = B[z++]
        //                     } while (--x)
        //                     0 === a.length && (a.mode = 21)
        //                     break
        //                 case 26:
        //                     if (0 === w) {
        //                         break e
        //                     }
        //                     _[c++] = a.length,
        //                         w--,
        //                         a.mode = 21
        //                     break
        //                 case 27:
        //                     if (a.wrap) {
        //                         for (; v < 32;) {
        //                             if (0 === g) {
        //                                 break e
        //                             }
        //                             g--,
        //                                 m |= f[u++] << v,
        //                                 v += 8
        //                         }
        //                         if (y -= w,
        //                             t.total_out += y,
        //                             a.total += y,
        //                         y && (t.adler = a.check = a.flags ? o(a.check, _, y, c - y) : s(a.check, _, y, c - y)),
        //                             y = w,
        //                         (a.flags ? m : d(m)) !== a.check) {
        //                             t.msg = 'incorrect data check',
        //                                 a.mode = 30
        //                             break
        //                         }
        //                         m = 0,
        //                             v = 0
        //                     }
        //                     a.mode = 28
        //                 case 28:
        //                     if (a.wrap && a.flags) {
        //                         for (; v < 32;) {
        //                             if (0 === g) {
        //                                 break e
        //                             }
        //                             g--,
        //                                 m += f[u++] << v,
        //                                 v += 8
        //                         }
        //                         if (m !== (4294967295 & a.total)) {
        //                             t.msg = 'incorrect length check',
        //                                 a.mode = 30
        //                             break
        //                         }
        //                         m = 0,
        //                             v = 0
        //                     }
        //                     a.mode = 29
        //                 case 29:
        //                     D = 1
        //                     break e
        //                 case 30:
        //                     D = -3
        //                     break e
        //                 case 31:
        //                     return -4
        //                 default:
        //                     return -2
        //             }
        //         }
        //         return (t.next_out = c,
        //             t.avail_out = w,
        //             t.next_in = u,
        //             t.avail_in = g,
        //             a.hold = m,
        //             a.bits = v,
        //
        //         (a.wsize || y !== t.avail_out && a.mode < 30 && (a.mode < 27 || 4 !== e)) && A.p(t, t.output, t.next_out, y - t.avail_out)) ? (a.mode = 31,
        //             -4) : (k -= t.avail_in,
        //             y -= t.avail_out,
        //             t.total_in += k,
        //             t.total_out += y,
        //             a.total += y,
        //         a.wrap && y && (t.adler = a.check = a.flags ? o(a.check, _, y, t.next_out - y) : s(a.check, _, y, t.next_out - y)),
        //             t.data_type = a.bits + (a.last ? 64 : 0) + (12 === a.mode ? 128 : 0) + (20 === a.mode || 15 === a.mode ? 256 : 0),
        //         (0 === k && 0 === y || 4 === e) && 0 === D && (D = -5), D)
        //     },
        // }
        //
        // function f (t) {
        //     if (!(this instanceof f)) {
        //         return new f(t)
        //     }
        //     this.options = n.assign({
        //         chunkSize: 16384,
        //         windowBits: 0,
        //         to: '',
        //     }, t || {})
        //     const e = this.options
        //     e.raw && e.windowBits >= 0 && e.windowBits < 16 && (e.windowBits = -e.windowBits,
        //     0 === e.windowBits && (e.windowBits = -15)),
        //     e.windowBits >= 0 && e.windowBits < 16 && !(t && t.windowBits) && (e.windowBits += 32),
        //     e.windowBits > 15 && e.windowBits < 48 && (15 & e.windowBits) == 0 && (e.windowBits |= 15),
        //         this.err = 0,
        //         this.msg = '',
        //         this.ended = !1,
        //         this.chunks = [],
        //         this.strm = new A.l,
        //         this.strm.avail_out = 0
        //     let a = i.inflateInit2(this.strm, e.windowBits)
        //     if (a !== A.s.Z_OK || (this.header = new A.h, i.inflateGetHeader(this.strm, this.header),
        //     e.dictionary && ('string' == typeof e.dictionary ? e.dictionary = r.string2buf(e.dictionary) : '[object ArrayBuffer]' === String(e.dictionary)
        //         && (e.dictionary = new Uint8Array(e.dictionary)),
        //     e.raw && (a = i.inflateSetDictionary(this.strm, e.dictionary)) !== A.s.Z_OK))) {
        //         throw Error(A.o[a])
        //     }
        // }
        //
        // f.prototype.push = function(t, e) {
        //     let a, o, l, h, f, _ = this.strm, u = this.options.chunkSize, c = this.options.dictionary, g = !1
        //     if (this.ended) {
        //         return !1
        //     }
        //     o = e === ~~e ? e : !0 === e ? A.s.Z_FINISH : A.s.Z_NO_FLUSH,
        //         'string' == typeof t ? _.input = r.binstring2buf(t) : '[object ArrayBuffer]' === String(t) ? _.input = new Uint8Array(t) : _.input = t,
        //         _.next_in = 0,
        //         _.avail_in = _.input.length
        //     do {
        //         if (0 === _.avail_out && (_.output = new n.Buf8(u),
        //             _.next_out = 0,
        //             _.avail_out = u),
        //         (a = i.inflate(_, A.s.Z_NO_FLUSH)) === A.s.Z_NEED_DICT && c && (a = i.inflateSetDictionary(this.strm, c)),
        //         a === A.s.Z_BUF_ERROR && !0 === g && (a = A.s.Z_OK,
        //             g = !1),
        //         a !== A.s.Z_STREAM_END && a !== A.s.Z_OK) {
        //             return this.onEnd(a),
        //                 this.ended = !0,
        //                 !1
        //         }
        //         _.next_out && (0 === _.avail_out || a === A.s.Z_STREAM_END || 0 === _.avail_in && (o === A.s.Z_FINISH || o === A.s.Z_SYNC_FLUSH)) && ('string' === this.options.to ? (l = r.utf8border(_.output, _.next_out),
        //             h = _.next_out - l,
        //             f = r.buf2string(_.output, l),
        //             _.next_out = h,
        //             _.avail_out = u - h,
        //         h && n.arraySet(_.output, _.output, l, h, 0),
        //             this.onData(f)) : this.onData(n.shrinkBuf(_.output, _.next_out))),
        //         0 === _.avail_in && 0 === _.avail_out && (g = !0)
        //     } while ((_.avail_in > 0 || 0 === _.avail_out) && a !== A.s.Z_STREAM_END)
        //     return (a === A.s.Z_STREAM_END && (o = A.s.Z_FINISH),
        //     o === A.s.Z_FINISH) ? (a = i.inflateEnd(this.strm),
        //         this.onEnd(a),
        //         this.ended = !0,
        //     a === A.s.Z_OK) : (o === A.s.Z_SYNC_FLUSH && (this.onEnd(A.s.Z_OK), _.avail_out = 0), !0)
        // }
        //
        // f.prototype.onData = function(t) {
        //     this.chunks.push(t)
        // }
        //
        // f.prototype.onEnd = function(t) {
        //     t === A.s.Z_OK && ('string' === this.options.to ? this.result = this.chunks.join('') : this.result = n.flattenChunks(this.chunks)),
        //         this.chunks = [],
        //         this.err = t,
        //         this.msg = this.strm.msg
        // }

    }
}

module.exports = { Bitget }