5808   var bits;                   /* local strm.bits */
5842   bits = state.bits;
5854     if (bits < 15) {
5855       hold += input[_in++] << bits;
5856       bits += 8;
5857       hold += input[_in++] << bits;
5858       bits += 8;
5867       bits -= op;
5879           if (bits < op) {
5880             hold += input[_in++] << bits;
5881             bits += 8;
5885           bits -= op;
5888         if (bits < 15) {
5889           hold += input[_in++] << bits;
5890           bits += 8;
5891           hold += input[_in++] << bits;
5892           bits += 8;
5900           bits -= op;
5906             if (bits < op) {
5907               hold += input[_in++] << bits;
5908               bits += 8;
5909               if (bits < op) {
5910                 hold += input[_in++] << bits;
5911                 bits += 8;
5923             bits -= op;
6063   len = bits >> 3;
6065   bits -= len << 3;
6066   hold &= (1 << bits) - 1;
6074   state.bits = bits;
6202   this.bits = 0;              /* number of bits in "in" */
6255   state.bits = 0;
6366     inflate_table(LENS,  state.lens, 0, 288, lenfix,   0, state.work, {bits: 9});
6372     inflate_table(DISTS, state.lens, 0, 32,   distfix, 0, state.work, {bits: 5});
6448   var bits;                   /* bits in bit buffer */
6485   bits = state.bits;
6501       while (bits < 16) {
6504         hold += input[next++] << bits;
6505         bits += 8;
6518         bits = 0;
6540       bits -= 4;
6557       bits = 0;
6562       while (bits < 16) {
6565         hold += input[next++] << bits;
6566         bits += 8;
6592       bits = 0;
6598       while (bits < 32) {
6601         hold += input[next++] << bits;
6602         bits += 8;
6619       bits = 0;
6625       while (bits < 16) {
6628         hold += input[next++] << bits;
6629         bits += 8;
6645       bits = 0;
6652         while (bits < 16) {
6655           hold += input[next++] << bits;
6656           bits += 8;
6672         bits = 0;
6771         while (bits < 16) {
6774           hold += input[next++] << bits;
6775           bits += 8;
6785         bits = 0;
6797       while (bits < 32) {
6800         hold += input[next++] << bits;
6801         bits += 8;
6807       bits = 0;
6819         state.bits = bits;
6832         hold >>>= bits & 7;
6833         bits -= bits & 7;
6839       while (bits < 3) {
6842         hold += input[next++] << bits;
6843         bits += 8;
6849       bits -= 1;
6866           bits -= 2;
6882       bits -= 2;
6887       hold >>>= bits & 7;
6888       bits -= bits & 7;
6891       while (bits < 32) {
6894         hold += input[next++] << bits;
6895         bits += 8;
6908       bits = 0;
6937       while (bits < 14) {
6940         hold += input[next++] << bits;
6941         bits += 8;
6947       bits -= 5;
6952       bits -= 5;
6957       bits -= 4;
6973         while (bits < 3) {
6976           hold += input[next++] << bits;
6977           bits += 8;
6983         bits -= 3;
6996       opts = {bits: state.lenbits};  property in AnonymousFunction7bc6a8980100.AnonymousFunction7bc6a8984700.inflate.opts
6998       state.lenbits = opts.bits;
7017           if ((here_bits) <= bits) { break; }
7021           hold += input[next++] << bits;
7022           bits += 8;
7028           bits -= here_bits;
7036             while (bits < n) {
7039               hold += input[next++] << bits;
7040               bits += 8;
7045             bits -= here_bits;
7056             bits -= 2;
7062             while (bits < n) {
7065               hold += input[next++] << bits;
7066               bits += 8;
7071             bits -= here_bits;
7077             bits -= 3;
7083             while (bits < n) {
7086               hold += input[next++] << bits;
7087               bits += 8;
7092             bits -= here_bits;
7098             bits -= 7;
7127       opts = {bits: state.lenbits};  property in AnonymousFunction7bc6a8980100.AnonymousFunction7bc6a8984700.inflate.opts
7131       state.lenbits = opts.bits;
7144       opts = {bits: state.distbits};  property in AnonymousFunction7bc6a8980100.AnonymousFunction7bc6a8984700.inflate.opts
7148       state.distbits = opts.bits;
7171         state.bits = bits;
7182         bits = state.bits;
7197         if (here_bits <= bits) { break; }
7201         hold += input[next++] << bits;
7202         bits += 8;
7216           if ((last_bits + here_bits) <= bits) { break; }
7220           hold += input[next++] << bits;
7221           bits += 8;
7226         bits -= last_bits;
7232       bits -= here_bits;
7261         while (bits < n) {
7264           hold += input[next++] << bits;
7265           bits += 8;
7271         bits -= state.extra;
7286         if ((here_bits) <= bits) { break; }
7290         hold += input[next++] << bits;
7291         bits += 8;
7305           if ((last_bits + here_bits) <= bits) { break; }
7309           hold += input[next++] << bits;
7310           bits += 8;
7315         bits -= last_bits;
7321       bits -= here_bits;
7337         while (bits < n) {
7340           hold += input[next++] << bits;
7341           bits += 8;
7347         bits -= state.extra;
7420         while (bits < 32) {
7424           hold |= input[next++] << bits;
7425           bits += 8;
7446         bits = 0;
7455         while (bits < 32) {
7458           hold += input[next++] << bits;
7459           bits += 8;
7469         bits = 0;
7505   state.bits = bits;
7524   strm.data_type = state.bits + (state.last ? 64 : 0) +
7621   var bits = opts.bits;
7689   root = bits;
7708     opts.bits = 1;
7905   opts.bits = root;
8189   var bits;           /* bit length */
8194   for (bits = 0; bits <= MAX_BITS; bits++) {
8195     s.bl_count[bits] = 0;
8205     bits = tree[tree[n*2 +1]/*.Dad*/ * 2 + 1]/*.Len*/ + 1;
8206     if (bits > max_length) {
8207       bits = max_length;
8210     tree[n*2 + 1]/*.Len*/ = bits;
8215     s.bl_count[bits]++;
8221     s.opt_len += f * (bits + xbits);
8233     bits = max_length-1;
8234     while (s.bl_count[bits] === 0) { bits--; }
8235     s.bl_count[bits]--;      /* move one leaf down the tree */
8236     s.bl_count[bits+1] += 2; /* move one overflow item as its brother */
8249   for (bits = max_length; bits !== 0; bits--) {
8250     n = s.bl_count[bits];
8254       if (tree[m*2 + 1]/*.Len*/ !== bits) {
8256         s.opt_len += (bits - tree[m*2 + 1]/*.Len*/)*tree[m*2]/*.Freq*/;
8257         tree[m*2 + 1]/*.Len*/ = bits;
8280   var bits;                  /* bit index */
8286   for (bits = 1; bits <= MAX_BITS; bits++) {
8287     next_code[bits] = code = (code + bl_count[bits-1]) << 1;
8313   var bits;     /* bit counter */
8366   for (bits = 0; bits <= MAX_BITS; bits++) {
8367     bl_count[bits] = 0;