[ Index ]

PHP Cross Reference of WordPress Trunk (Updated Daily)

Search

title

Body

[close]

/wp-includes/js/dist/ -> edit-site.js (source)

   1  /******/ (() => { // webpackBootstrap
   2  /******/     var __webpack_modules__ = ({
   3  
   4  /***/ 4660:
   5  /***/ ((module) => {
   6  
   7  /* eslint eslint-comments/no-unlimited-disable: 0 */
   8  /* eslint-disable */
   9  /* pako 1.0.10 nodeca/pako */ ( function ( f ) {
  10      if ( true ) {
  11          module.exports = f();
  12      } else { var g; }
  13  } )( function () {
  14      var define, module, exports;
  15      return ( function () {
  16          function r( e, n, t ) {
  17              function o( i, f ) {
  18                  if ( ! n[ i ] ) {
  19                      if ( ! e[ i ] ) {
  20                          var c = undefined;
  21                          if ( ! f && c ) return require( i, ! 0 );
  22                          if ( u ) return u( i, ! 0 );
  23                          var a = new Error( "Cannot find module '" + i + "'" );
  24                          throw ( ( a.code = 'MODULE_NOT_FOUND' ), a );
  25                      }
  26                      var p = ( n[ i ] = { exports: {} } );
  27                      e[ i ][ 0 ].call(
  28                          p.exports,
  29                          function ( r ) {
  30                              var n = e[ i ][ 1 ][ r ];
  31                              return o( n || r );
  32                          },
  33                          p,
  34                          p.exports,
  35                          r,
  36                          e,
  37                          n,
  38                          t
  39                      );
  40                  }
  41                  return n[ i ].exports;
  42              }
  43              for (
  44                  var u = undefined, i = 0;
  45                  i < t.length;
  46                  i++
  47              )
  48                  o( t[ i ] );
  49              return o;
  50          }
  51          return r;
  52      } )()(
  53          {
  54              1: [
  55                  function ( require, module, exports ) {
  56                      'use strict';
  57  
  58                      var TYPED_OK =
  59                          typeof Uint8Array !== 'undefined' &&
  60                          typeof Uint16Array !== 'undefined' &&
  61                          typeof Int32Array !== 'undefined';
  62  
  63  					function _has( obj, key ) {
  64                          return Object.prototype.hasOwnProperty.call( obj, key );
  65                      }
  66  
  67                      exports.assign = function (
  68                          obj /*from1, from2, from3, ...*/
  69                      ) {
  70                          var sources = Array.prototype.slice.call(
  71                              arguments,
  72                              1
  73                          );
  74                          while ( sources.length ) {
  75                              var source = sources.shift();
  76                              if ( ! source ) {
  77                                  continue;
  78                              }
  79  
  80                              if ( typeof source !== 'object' ) {
  81                                  throw new TypeError(
  82                                      source + 'must be non-object'
  83                                  );
  84                              }
  85  
  86                              for ( var p in source ) {
  87                                  if ( _has( source, p ) ) {
  88                                      obj[ p ] = source[ p ];
  89                                  }
  90                              }
  91                          }
  92  
  93                          return obj;
  94                      };
  95  
  96                      // reduce buffer size, avoiding mem copy
  97                      exports.shrinkBuf = function ( buf, size ) {
  98                          if ( buf.length === size ) {
  99                              return buf;
 100                          }
 101                          if ( buf.subarray ) {
 102                              return buf.subarray( 0, size );
 103                          }
 104                          buf.length = size;
 105                          return buf;
 106                      };
 107  
 108                      var fnTyped = {
 109                          arraySet: function (
 110                              dest,
 111                              src,
 112                              src_offs,
 113                              len,
 114                              dest_offs
 115                          ) {
 116                              if ( src.subarray && dest.subarray ) {
 117                                  dest.set(
 118                                      src.subarray( src_offs, src_offs + len ),
 119                                      dest_offs
 120                                  );
 121                                  return;
 122                              }
 123                              // Fallback to ordinary array
 124                              for ( var i = 0; i < len; i++ ) {
 125                                  dest[ dest_offs + i ] = src[ src_offs + i ];
 126                              }
 127                          },
 128                          // Join array of chunks to single array.
 129                          flattenChunks: function ( chunks ) {
 130                              var i, l, len, pos, chunk, result;
 131  
 132                              // calculate data length
 133                              len = 0;
 134                              for ( i = 0, l = chunks.length; i < l; i++ ) {
 135                                  len += chunks[ i ].length;
 136                              }
 137  
 138                              // join chunks
 139                              result = new Uint8Array( len );
 140                              pos = 0;
 141                              for ( i = 0, l = chunks.length; i < l; i++ ) {
 142                                  chunk = chunks[ i ];
 143                                  result.set( chunk, pos );
 144                                  pos += chunk.length;
 145                              }
 146  
 147                              return result;
 148                          },
 149                      };
 150  
 151                      var fnUntyped = {
 152                          arraySet: function (
 153                              dest,
 154                              src,
 155                              src_offs,
 156                              len,
 157                              dest_offs
 158                          ) {
 159                              for ( var i = 0; i < len; i++ ) {
 160                                  dest[ dest_offs + i ] = src[ src_offs + i ];
 161                              }
 162                          },
 163                          // Join array of chunks to single array.
 164                          flattenChunks: function ( chunks ) {
 165                              return [].concat.apply( [], chunks );
 166                          },
 167                      };
 168  
 169                      // Enable/Disable typed arrays use, for testing
 170                      //
 171                      exports.setTyped = function ( on ) {
 172                          if ( on ) {
 173                              exports.Buf8 = Uint8Array;
 174                              exports.Buf16 = Uint16Array;
 175                              exports.Buf32 = Int32Array;
 176                              exports.assign( exports, fnTyped );
 177                          } else {
 178                              exports.Buf8 = Array;
 179                              exports.Buf16 = Array;
 180                              exports.Buf32 = Array;
 181                              exports.assign( exports, fnUntyped );
 182                          }
 183                      };
 184  
 185                      exports.setTyped( TYPED_OK );
 186                  },
 187                  {},
 188              ],
 189              2: [
 190                  function ( require, module, exports ) {
 191                      // String encode/decode helpers
 192                      'use strict';
 193  
 194                      var utils = require( './common' );
 195  
 196                      // Quick check if we can use fast array to bin string conversion
 197                      //
 198                      // - apply(Array) can fail on Android 2.2
 199                      // - apply(Uint8Array) can fail on iOS 5.1 Safari
 200                      //
 201                      var STR_APPLY_OK = true;
 202                      var STR_APPLY_UIA_OK = true;
 203  
 204                      try {
 205                          String.fromCharCode.apply( null, [ 0 ] );
 206                      } catch ( __ ) {
 207                          STR_APPLY_OK = false;
 208                      }
 209                      try {
 210                          String.fromCharCode.apply( null, new Uint8Array( 1 ) );
 211                      } catch ( __ ) {
 212                          STR_APPLY_UIA_OK = false;
 213                      }
 214  
 215                      // Table with utf8 lengths (calculated by first byte of sequence)
 216                      // Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,
 217                      // because max possible codepoint is 0x10ffff
 218                      var _utf8len = new utils.Buf8( 256 );
 219                      for ( var q = 0; q < 256; q++ ) {
 220                          _utf8len[ q ] =
 221                              q >= 252
 222                                  ? 6
 223                                  : q >= 248
 224                                  ? 5
 225                                  : q >= 240
 226                                  ? 4
 227                                  : q >= 224
 228                                  ? 3
 229                                  : q >= 192
 230                                  ? 2
 231                                  : 1;
 232                      }
 233                      _utf8len[ 254 ] = _utf8len[ 254 ] = 1; // Invalid sequence start
 234  
 235                      // convert string to array (typed, when possible)
 236                      exports.string2buf = function ( str ) {
 237                          var buf,
 238                              c,
 239                              c2,
 240                              m_pos,
 241                              i,
 242                              str_len = str.length,
 243                              buf_len = 0;
 244  
 245                          // count binary size
 246                          for ( m_pos = 0; m_pos < str_len; m_pos++ ) {
 247                              c = str.charCodeAt( m_pos );
 248                              if (
 249                                  ( c & 0xfc00 ) === 0xd800 &&
 250                                  m_pos + 1 < str_len
 251                              ) {
 252                                  c2 = str.charCodeAt( m_pos + 1 );
 253                                  if ( ( c2 & 0xfc00 ) === 0xdc00 ) {
 254                                      c =
 255                                          0x10000 +
 256                                          ( ( c - 0xd800 ) << 10 ) +
 257                                          ( c2 - 0xdc00 );
 258                                      m_pos++;
 259                                  }
 260                              }
 261                              buf_len +=
 262                                  c < 0x80
 263                                      ? 1
 264                                      : c < 0x800
 265                                      ? 2
 266                                      : c < 0x10000
 267                                      ? 3
 268                                      : 4;
 269                          }
 270  
 271                          // allocate buffer
 272                          buf = new utils.Buf8( buf_len );
 273  
 274                          // convert
 275                          for ( i = 0, m_pos = 0; i < buf_len; m_pos++ ) {
 276                              c = str.charCodeAt( m_pos );
 277                              if (
 278                                  ( c & 0xfc00 ) === 0xd800 &&
 279                                  m_pos + 1 < str_len
 280                              ) {
 281                                  c2 = str.charCodeAt( m_pos + 1 );
 282                                  if ( ( c2 & 0xfc00 ) === 0xdc00 ) {
 283                                      c =
 284                                          0x10000 +
 285                                          ( ( c - 0xd800 ) << 10 ) +
 286                                          ( c2 - 0xdc00 );
 287                                      m_pos++;
 288                                  }
 289                              }
 290                              if ( c < 0x80 ) {
 291                                  /* one byte */
 292                                  buf[ i++ ] = c;
 293                              } else if ( c < 0x800 ) {
 294                                  /* two bytes */
 295                                  buf[ i++ ] = 0xc0 | ( c >>> 6 );
 296                                  buf[ i++ ] = 0x80 | ( c & 0x3f );
 297                              } else if ( c < 0x10000 ) {
 298                                  /* three bytes */
 299                                  buf[ i++ ] = 0xe0 | ( c >>> 12 );
 300                                  buf[ i++ ] = 0x80 | ( ( c >>> 6 ) & 0x3f );
 301                                  buf[ i++ ] = 0x80 | ( c & 0x3f );
 302                              } else {
 303                                  /* four bytes */
 304                                  buf[ i++ ] = 0xf0 | ( c >>> 18 );
 305                                  buf[ i++ ] = 0x80 | ( ( c >>> 12 ) & 0x3f );
 306                                  buf[ i++ ] = 0x80 | ( ( c >>> 6 ) & 0x3f );
 307                                  buf[ i++ ] = 0x80 | ( c & 0x3f );
 308                              }
 309                          }
 310  
 311                          return buf;
 312                      };
 313  
 314                      // Helper (used in 2 places)
 315  					function buf2binstring( buf, len ) {
 316                          // On Chrome, the arguments in a function call that are allowed is `65534`.
 317                          // If the length of the buffer is smaller than that, we can use this optimization,
 318                          // otherwise we will take a slower path.
 319                          if ( len < 65534 ) {
 320                              if (
 321                                  ( buf.subarray && STR_APPLY_UIA_OK ) ||
 322                                  ( ! buf.subarray && STR_APPLY_OK )
 323                              ) {
 324                                  return String.fromCharCode.apply(
 325                                      null,
 326                                      utils.shrinkBuf( buf, len )
 327                                  );
 328                              }
 329                          }
 330  
 331                          var result = '';
 332                          for ( var i = 0; i < len; i++ ) {
 333                              result += String.fromCharCode( buf[ i ] );
 334                          }
 335                          return result;
 336                      }
 337  
 338                      // Convert byte array to binary string
 339                      exports.buf2binstring = function ( buf ) {
 340                          return buf2binstring( buf, buf.length );
 341                      };
 342  
 343                      // Convert binary string (typed, when possible)
 344                      exports.binstring2buf = function ( str ) {
 345                          var buf = new utils.Buf8( str.length );
 346                          for ( var i = 0, len = buf.length; i < len; i++ ) {
 347                              buf[ i ] = str.charCodeAt( i );
 348                          }
 349                          return buf;
 350                      };
 351  
 352                      // convert array to string
 353                      exports.buf2string = function ( buf, max ) {
 354                          var i, out, c, c_len;
 355                          var len = max || buf.length;
 356  
 357                          // Reserve max possible length (2 words per char)
 358                          // NB: by unknown reasons, Array is significantly faster for
 359                          //     String.fromCharCode.apply than Uint16Array.
 360                          var utf16buf = new Array( len * 2 );
 361  
 362                          for ( out = 0, i = 0; i < len;  ) {
 363                              c = buf[ i++ ];
 364                              // quick process ascii
 365                              if ( c < 0x80 ) {
 366                                  utf16buf[ out++ ] = c;
 367                                  continue;
 368                              }
 369  
 370                              c_len = _utf8len[ c ];
 371                              // skip 5 & 6 byte codes
 372                              if ( c_len > 4 ) {
 373                                  utf16buf[ out++ ] = 0xfffd;
 374                                  i += c_len - 1;
 375                                  continue;
 376                              }
 377  
 378                              // apply mask on first byte
 379                              c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;
 380                              // join the rest
 381                              while ( c_len > 1 && i < len ) {
 382                                  c = ( c << 6 ) | ( buf[ i++ ] & 0x3f );
 383                                  c_len--;
 384                              }
 385  
 386                              // terminated by end of string?
 387                              if ( c_len > 1 ) {
 388                                  utf16buf[ out++ ] = 0xfffd;
 389                                  continue;
 390                              }
 391  
 392                              if ( c < 0x10000 ) {
 393                                  utf16buf[ out++ ] = c;
 394                              } else {
 395                                  c -= 0x10000;
 396                                  utf16buf[ out++ ] =
 397                                      0xd800 | ( ( c >> 10 ) & 0x3ff );
 398                                  utf16buf[ out++ ] = 0xdc00 | ( c & 0x3ff );
 399                              }
 400                          }
 401  
 402                          return buf2binstring( utf16buf, out );
 403                      };
 404  
 405                      // Calculate max possible position in utf8 buffer,
 406                      // that will not break sequence. If that's not possible
 407                      // - (very small limits) return max size as is.
 408                      //
 409                      // buf[] - utf8 bytes array
 410                      // max   - length limit (mandatory);
 411                      exports.utf8border = function ( buf, max ) {
 412                          var pos;
 413  
 414                          max = max || buf.length;
 415                          if ( max > buf.length ) {
 416                              max = buf.length;
 417                          }
 418  
 419                          // go back from last position, until start of sequence found
 420                          pos = max - 1;
 421                          while ( pos >= 0 && ( buf[ pos ] & 0xc0 ) === 0x80 ) {
 422                              pos--;
 423                          }
 424  
 425                          // Very small and broken sequence,
 426                          // return max, because we should return something anyway.
 427                          if ( pos < 0 ) {
 428                              return max;
 429                          }
 430  
 431                          // If we came to start of buffer - that means buffer is too small,
 432                          // return max too.
 433                          if ( pos === 0 ) {
 434                              return max;
 435                          }
 436  
 437                          return pos + _utf8len[ buf[ pos ] ] > max ? pos : max;
 438                      };
 439                  },
 440                  { './common': 1 },
 441              ],
 442              3: [
 443                  function ( require, module, exports ) {
 444                      'use strict';
 445  
 446                      // Note: adler32 takes 12% for level 0 and 2% for level 6.
 447                      // It isn't worth it to make additional optimizations as in original.
 448                      // Small size is preferable.
 449  
 450                      // (C) 1995-2013 Jean-loup Gailly and Mark Adler
 451                      // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
 452                      //
 453                      // This software is provided 'as-is', without any express or implied
 454                      // warranty. In no event will the authors be held liable for any damages
 455                      // arising from the use of this software.
 456                      //
 457                      // Permission is granted to anyone to use this software for any purpose,
 458                      // including commercial applications, and to alter it and redistribute it
 459                      // freely, subject to the following restrictions:
 460                      //
 461                      // 1. The origin of this software must not be misrepresented; you must not
 462                      //   claim that you wrote the original software. If you use this software
 463                      //   in a product, an acknowledgment in the product documentation would be
 464                      //   appreciated but is not required.
 465                      // 2. Altered source versions must be plainly marked as such, and must not be
 466                      //   misrepresented as being the original software.
 467                      // 3. This notice may not be removed or altered from any source distribution.
 468  
 469  					function adler32( adler, buf, len, pos ) {
 470                          var s1 = ( adler & 0xffff ) | 0,
 471                              s2 = ( ( adler >>> 16 ) & 0xffff ) | 0,
 472                              n = 0;
 473  
 474                          while ( len !== 0 ) {
 475                              // Set limit ~ twice less than 5552, to keep
 476                              // s2 in 31-bits, because we force signed ints.
 477                              // in other case %= will fail.
 478                              n = len > 2000 ? 2000 : len;
 479                              len -= n;
 480  
 481                              do {
 482                                  s1 = ( s1 + buf[ pos++ ] ) | 0;
 483                                  s2 = ( s2 + s1 ) | 0;
 484                              } while ( --n );
 485  
 486                              s1 %= 65521;
 487                              s2 %= 65521;
 488                          }
 489  
 490                          return s1 | ( s2 << 16 ) | 0;
 491                      }
 492  
 493                      module.exports = adler32;
 494                  },
 495                  {},
 496              ],
 497              4: [
 498                  function ( require, module, exports ) {
 499                      'use strict';
 500  
 501                      // (C) 1995-2013 Jean-loup Gailly and Mark Adler
 502                      // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
 503                      //
 504                      // This software is provided 'as-is', without any express or implied
 505                      // warranty. In no event will the authors be held liable for any damages
 506                      // arising from the use of this software.
 507                      //
 508                      // Permission is granted to anyone to use this software for any purpose,
 509                      // including commercial applications, and to alter it and redistribute it
 510                      // freely, subject to the following restrictions:
 511                      //
 512                      // 1. The origin of this software must not be misrepresented; you must not
 513                      //   claim that you wrote the original software. If you use this software
 514                      //   in a product, an acknowledgment in the product documentation would be
 515                      //   appreciated but is not required.
 516                      // 2. Altered source versions must be plainly marked as such, and must not be
 517                      //   misrepresented as being the original software.
 518                      // 3. This notice may not be removed or altered from any source distribution.
 519  
 520                      module.exports = {
 521                          /* Allowed flush values; see deflate() and inflate() below for details */
 522                          Z_NO_FLUSH: 0,
 523                          Z_PARTIAL_FLUSH: 1,
 524                          Z_SYNC_FLUSH: 2,
 525                          Z_FULL_FLUSH: 3,
 526                          Z_FINISH: 4,
 527                          Z_BLOCK: 5,
 528                          Z_TREES: 6,
 529  
 530                          /* Return codes for the compression/decompression functions. Negative values
 531                           * are errors, positive values are used for special but normal events.
 532                           */
 533                          Z_OK: 0,
 534                          Z_STREAM_END: 1,
 535                          Z_NEED_DICT: 2,
 536                          Z_ERRNO: -1,
 537                          Z_STREAM_ERROR: -2,
 538                          Z_DATA_ERROR: -3,
 539                          //Z_MEM_ERROR:     -4,
 540                          Z_BUF_ERROR: -5,
 541                          //Z_VERSION_ERROR: -6,
 542  
 543                          /* compression levels */
 544                          Z_NO_COMPRESSION: 0,
 545                          Z_BEST_SPEED: 1,
 546                          Z_BEST_COMPRESSION: 9,
 547                          Z_DEFAULT_COMPRESSION: -1,
 548  
 549                          Z_FILTERED: 1,
 550                          Z_HUFFMAN_ONLY: 2,
 551                          Z_RLE: 3,
 552                          Z_FIXED: 4,
 553                          Z_DEFAULT_STRATEGY: 0,
 554  
 555                          /* Possible values of the data_type field (though see inflate()) */
 556                          Z_BINARY: 0,
 557                          Z_TEXT: 1,
 558                          //Z_ASCII:                1, // = Z_TEXT (deprecated)
 559                          Z_UNKNOWN: 2,
 560  
 561                          /* The deflate compression method */
 562                          Z_DEFLATED: 8,
 563                          //Z_NULL:                 null // Use -1 or null inline, depending on var type
 564                      };
 565                  },
 566                  {},
 567              ],
 568              5: [
 569                  function ( require, module, exports ) {
 570                      'use strict';
 571  
 572                      // Note: we can't get significant speed boost here.
 573                      // So write code to minimize size - no pregenerated tables
 574                      // and array tools dependencies.
 575  
 576                      // (C) 1995-2013 Jean-loup Gailly and Mark Adler
 577                      // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
 578                      //
 579                      // This software is provided 'as-is', without any express or implied
 580                      // warranty. In no event will the authors be held liable for any damages
 581                      // arising from the use of this software.
 582                      //
 583                      // Permission is granted to anyone to use this software for any purpose,
 584                      // including commercial applications, and to alter it and redistribute it
 585                      // freely, subject to the following restrictions:
 586                      //
 587                      // 1. The origin of this software must not be misrepresented; you must not
 588                      //   claim that you wrote the original software. If you use this software
 589                      //   in a product, an acknowledgment in the product documentation would be
 590                      //   appreciated but is not required.
 591                      // 2. Altered source versions must be plainly marked as such, and must not be
 592                      //   misrepresented as being the original software.
 593                      // 3. This notice may not be removed or altered from any source distribution.
 594  
 595                      // Use ordinary array, since untyped makes no boost here
 596  					function makeTable() {
 597                          var c,
 598                              table = [];
 599  
 600                          for ( var n = 0; n < 256; n++ ) {
 601                              c = n;
 602                              for ( var k = 0; k < 8; k++ ) {
 603                                  c = c & 1 ? 0xedb88320 ^ ( c >>> 1 ) : c >>> 1;
 604                              }
 605                              table[ n ] = c;
 606                          }
 607  
 608                          return table;
 609                      }
 610  
 611                      // Create table on load. Just 255 signed longs. Not a problem.
 612                      var crcTable = makeTable();
 613  
 614  					function crc32( crc, buf, len, pos ) {
 615                          var t = crcTable,
 616                              end = pos + len;
 617  
 618                          crc ^= -1;
 619  
 620                          for ( var i = pos; i < end; i++ ) {
 621                              crc =
 622                                  ( crc >>> 8 ) ^ t[ ( crc ^ buf[ i ] ) & 0xff ];
 623                          }
 624  
 625                          return crc ^ -1; // >>> 0;
 626                      }
 627  
 628                      module.exports = crc32;
 629                  },
 630                  {},
 631              ],
 632              6: [
 633                  function ( require, module, exports ) {
 634                      'use strict';
 635  
 636                      // (C) 1995-2013 Jean-loup Gailly and Mark Adler
 637                      // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
 638                      //
 639                      // This software is provided 'as-is', without any express or implied
 640                      // warranty. In no event will the authors be held liable for any damages
 641                      // arising from the use of this software.
 642                      //
 643                      // Permission is granted to anyone to use this software for any purpose,
 644                      // including commercial applications, and to alter it and redistribute it
 645                      // freely, subject to the following restrictions:
 646                      //
 647                      // 1. The origin of this software must not be misrepresented; you must not
 648                      //   claim that you wrote the original software. If you use this software
 649                      //   in a product, an acknowledgment in the product documentation would be
 650                      //   appreciated but is not required.
 651                      // 2. Altered source versions must be plainly marked as such, and must not be
 652                      //   misrepresented as being the original software.
 653                      // 3. This notice may not be removed or altered from any source distribution.
 654  
 655  					function GZheader() {
 656                          /* true if compressed data believed to be text */
 657                          this.text = 0;
 658                          /* modification time */
 659                          this.time = 0;
 660                          /* extra flags (not used when writing a gzip file) */
 661                          this.xflags = 0;
 662                          /* operating system */
 663                          this.os = 0;
 664                          /* pointer to extra field or Z_NULL if none */
 665                          this.extra = null;
 666                          /* extra field length (valid if extra != Z_NULL) */
 667                          this.extra_len = 0; // Actually, we don't need it in JS,
 668                          // but leave for few code modifications
 669  
 670                          //
 671                          // Setup limits is not necessary because in js we should not preallocate memory
 672                          // for inflate use constant limit in 65536 bytes
 673                          //
 674  
 675                          /* space at extra (only when reading header) */
 676                          // this.extra_max  = 0;
 677                          /* pointer to zero-terminated file name or Z_NULL */
 678                          this.name = '';
 679                          /* space at name (only when reading header) */
 680                          // this.name_max   = 0;
 681                          /* pointer to zero-terminated comment or Z_NULL */
 682                          this.comment = '';
 683                          /* space at comment (only when reading header) */
 684                          // this.comm_max   = 0;
 685                          /* true if there was or will be a header crc */
 686                          this.hcrc = 0;
 687                          /* true when done reading gzip header (not used when writing a gzip file) */
 688                          this.done = false;
 689                      }
 690  
 691                      module.exports = GZheader;
 692                  },
 693                  {},
 694              ],
 695              7: [
 696                  function ( require, module, exports ) {
 697                      'use strict';
 698  
 699                      // (C) 1995-2013 Jean-loup Gailly and Mark Adler
 700                      // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
 701                      //
 702                      // This software is provided 'as-is', without any express or implied
 703                      // warranty. In no event will the authors be held liable for any damages
 704                      // arising from the use of this software.
 705                      //
 706                      // Permission is granted to anyone to use this software for any purpose,
 707                      // including commercial applications, and to alter it and redistribute it
 708                      // freely, subject to the following restrictions:
 709                      //
 710                      // 1. The origin of this software must not be misrepresented; you must not
 711                      //   claim that you wrote the original software. If you use this software
 712                      //   in a product, an acknowledgment in the product documentation would be
 713                      //   appreciated but is not required.
 714                      // 2. Altered source versions must be plainly marked as such, and must not be
 715                      //   misrepresented as being the original software.
 716                      // 3. This notice may not be removed or altered from any source distribution.
 717  
 718                      // See state defs from inflate.js
 719                      var BAD = 30; /* got a data error -- remain here until reset */
 720                      var TYPE = 12; /* i: waiting for type bits, including last-flag bit */
 721  
 722                      /*
 723       Decode literal, length, and distance codes and write out the resulting
 724       literal and match bytes until either not enough input or output is
 725       available, an end-of-block is encountered, or a data error is encountered.
 726       When large enough input and output buffers are supplied to inflate(), for
 727       example, a 16K input buffer and a 64K output buffer, more than 95% of the
 728       inflate execution time is spent in this routine.
 729  
 730       Entry assumptions:
 731  
 732            state.mode === LEN
 733            strm.avail_in >= 6
 734            strm.avail_out >= 258
 735            start >= strm.avail_out
 736            state.bits < 8
 737  
 738       On return, state.mode is one of:
 739  
 740            LEN -- ran out of enough output space or enough available input
 741            TYPE -- reached end of block code, inflate() to interpret next block
 742            BAD -- error in block data
 743  
 744       Notes:
 745  
 746        - The maximum input bits used by a length/distance pair is 15 bits for the
 747          length code, 5 bits for the length extra, 15 bits for the distance code,
 748          and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
 749          Therefore if strm.avail_in >= 6, then there is enough input to avoid
 750          checking for available input while decoding.
 751  
 752        - The maximum bytes that a single length/distance pair can output is 258
 753          bytes, which is the maximum length that can be coded.  inflate_fast()
 754          requires strm.avail_out >= 258 for each loop to avoid checking for
 755          output space.
 756     */
 757                      module.exports = function inflate_fast( strm, start ) {
 758                          var state;
 759                          var _in; /* local strm.input */
 760                          var last; /* have enough input while in < last */
 761                          var _out; /* local strm.output */
 762                          var beg; /* inflate()'s initial strm.output */
 763                          var end; /* while out < end, enough space available */
 764                          //#ifdef INFLATE_STRICT
 765                          var dmax; /* maximum distance from zlib header */
 766                          //#endif
 767                          var wsize; /* window size or zero if not using window */
 768                          var whave; /* valid bytes in the window */
 769                          var wnext; /* window write index */
 770                          // Use `s_window` instead `window`, avoid conflict with instrumentation tools
 771                          var s_window; /* allocated sliding window, if wsize != 0 */
 772                          var hold; /* local strm.hold */
 773                          var bits; /* local strm.bits */
 774                          var lcode; /* local strm.lencode */
 775                          var dcode; /* local strm.distcode */
 776                          var lmask; /* mask for first level of length codes */
 777                          var dmask; /* mask for first level of distance codes */
 778                          var here; /* retrieved table entry */
 779                          var op; /* code bits, operation, extra bits, or */
 780                          /*  window position, window bytes to copy */
 781                          var len; /* match length, unused bytes */
 782                          var dist; /* match distance */
 783                          var from; /* where to copy match from */
 784                          var from_source;
 785  
 786                          var input, output; // JS specific, because we have no pointers
 787  
 788                          /* copy state to local variables */
 789                          state = strm.state;
 790                          //here = state.here;
 791                          _in = strm.next_in;
 792                          input = strm.input;
 793                          last = _in + ( strm.avail_in - 5 );
 794                          _out = strm.next_out;
 795                          output = strm.output;
 796                          beg = _out - ( start - strm.avail_out );
 797                          end = _out + ( strm.avail_out - 257 );
 798                          //#ifdef INFLATE_STRICT
 799                          dmax = state.dmax;
 800                          //#endif
 801                          wsize = state.wsize;
 802                          whave = state.whave;
 803                          wnext = state.wnext;
 804                          s_window = state.window;
 805                          hold = state.hold;
 806                          bits = state.bits;
 807                          lcode = state.lencode;
 808                          dcode = state.distcode;
 809                          lmask = ( 1 << state.lenbits ) - 1;
 810                          dmask = ( 1 << state.distbits ) - 1;
 811  
 812                          /* decode literals and length/distances until end-of-block or not enough
 813         input data or output space */
 814  
 815                          top: do {
 816                              if ( bits < 15 ) {
 817                                  hold += input[ _in++ ] << bits;
 818                                  bits += 8;
 819                                  hold += input[ _in++ ] << bits;
 820                                  bits += 8;
 821                              }
 822  
 823                              here = lcode[ hold & lmask ];
 824  
 825                              dolen: for (;;) {
 826                                  // Goto emulation
 827                                  op = here >>> 24 /*here.bits*/;
 828                                  hold >>>= op;
 829                                  bits -= op;
 830                                  op = ( here >>> 16 ) & 0xff /*here.op*/;
 831                                  if ( op === 0 ) {
 832                                      /* literal */
 833                                      //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
 834                                      //        "inflate:         literal '%c'\n" :
 835                                      //        "inflate:         literal 0x%02x\n", here.val));
 836                                      output[ _out++ ] =
 837                                          here & 0xffff /*here.val*/;
 838                                  } else if ( op & 16 ) {
 839                                      /* length base */
 840                                      len = here & 0xffff /*here.val*/;
 841                                      op &= 15; /* number of extra bits */
 842                                      if ( op ) {
 843                                          if ( bits < op ) {
 844                                              hold += input[ _in++ ] << bits;
 845                                              bits += 8;
 846                                          }
 847                                          len += hold & ( ( 1 << op ) - 1 );
 848                                          hold >>>= op;
 849                                          bits -= op;
 850                                      }
 851                                      //Tracevv((stderr, "inflate:         length %u\n", len));
 852                                      if ( bits < 15 ) {
 853                                          hold += input[ _in++ ] << bits;
 854                                          bits += 8;
 855                                          hold += input[ _in++ ] << bits;
 856                                          bits += 8;
 857                                      }
 858                                      here = dcode[ hold & dmask ];
 859  
 860                                      dodist: for (;;) {
 861                                          // goto emulation
 862                                          op = here >>> 24 /*here.bits*/;
 863                                          hold >>>= op;
 864                                          bits -= op;
 865                                          op = ( here >>> 16 ) & 0xff /*here.op*/;
 866  
 867                                          if ( op & 16 ) {
 868                                              /* distance base */
 869                                              dist = here & 0xffff /*here.val*/;
 870                                              op &= 15; /* number of extra bits */
 871                                              if ( bits < op ) {
 872                                                  hold += input[ _in++ ] << bits;
 873                                                  bits += 8;
 874                                                  if ( bits < op ) {
 875                                                      hold +=
 876                                                          input[ _in++ ] << bits;
 877                                                      bits += 8;
 878                                                  }
 879                                              }
 880                                              dist += hold & ( ( 1 << op ) - 1 );
 881                                              //#ifdef INFLATE_STRICT
 882                                              if ( dist > dmax ) {
 883                                                  strm.msg =
 884                                                      'invalid distance too far back';
 885                                                  state.mode = BAD;
 886                                                  break top;
 887                                              }
 888                                              //#endif
 889                                              hold >>>= op;
 890                                              bits -= op;
 891                                              //Tracevv((stderr, "inflate:         distance %u\n", dist));
 892                                              op =
 893                                                  _out -
 894                                                  beg; /* max distance in output */
 895                                              if ( dist > op ) {
 896                                                  /* see if copy from window */
 897                                                  op =
 898                                                      dist -
 899                                                      op; /* distance back in window */
 900                                                  if ( op > whave ) {
 901                                                      if ( state.sane ) {
 902                                                          strm.msg =
 903                                                              'invalid distance too far back';
 904                                                          state.mode = BAD;
 905                                                          break top;
 906                                                      }
 907  
 908                                                      // (!) This block is disabled in zlib defaults,
 909                                                      // don't enable it for binary compatibility
 910                                                      //#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
 911                                                      //                if (len <= op - whave) {
 912                                                      //                  do {
 913                                                      //                    output[_out++] = 0;
 914                                                      //                  } while (--len);
 915                                                      //                  continue top;
 916                                                      //                }
 917                                                      //                len -= op - whave;
 918                                                      //                do {
 919                                                      //                  output[_out++] = 0;
 920                                                      //                } while (--op > whave);
 921                                                      //                if (op === 0) {
 922                                                      //                  from = _out - dist;
 923                                                      //                  do {
 924                                                      //                    output[_out++] = output[from++];
 925                                                      //                  } while (--len);
 926                                                      //                  continue top;
 927                                                      //                }
 928                                                      //#endif
 929                                                  }
 930                                                  from = 0; // window index
 931                                                  from_source = s_window;
 932                                                  if ( wnext === 0 ) {
 933                                                      /* very common case */
 934                                                      from += wsize - op;
 935                                                      if ( op < len ) {
 936                                                          /* some from window */
 937                                                          len -= op;
 938                                                          do {
 939                                                              output[ _out++ ] =
 940                                                                  s_window[
 941                                                                      from++
 942                                                                  ];
 943                                                          } while ( --op );
 944                                                          from =
 945                                                              _out -
 946                                                              dist; /* rest from output */
 947                                                          from_source = output;
 948                                                      }
 949                                                  } else if ( wnext < op ) {
 950                                                      /* wrap around window */
 951                                                      from += wsize + wnext - op;
 952                                                      op -= wnext;
 953                                                      if ( op < len ) {
 954                                                          /* some from end of window */
 955                                                          len -= op;
 956                                                          do {
 957                                                              output[ _out++ ] =
 958                                                                  s_window[
 959                                                                      from++
 960                                                                  ];
 961                                                          } while ( --op );
 962                                                          from = 0;
 963                                                          if ( wnext < len ) {
 964                                                              /* some from start of window */
 965                                                              op = wnext;
 966                                                              len -= op;
 967                                                              do {
 968                                                                  output[
 969                                                                      _out++
 970                                                                  ] =
 971                                                                      s_window[
 972                                                                          from++
 973                                                                      ];
 974                                                              } while ( --op );
 975                                                              from =
 976                                                                  _out -
 977                                                                  dist; /* rest from output */
 978                                                              from_source =
 979                                                                  output;
 980                                                          }
 981                                                      }
 982                                                  } else {
 983                                                      /* contiguous in window */
 984                                                      from += wnext - op;
 985                                                      if ( op < len ) {
 986                                                          /* some from window */
 987                                                          len -= op;
 988                                                          do {
 989                                                              output[ _out++ ] =
 990                                                                  s_window[
 991                                                                      from++
 992                                                                  ];
 993                                                          } while ( --op );
 994                                                          from =
 995                                                              _out -
 996                                                              dist; /* rest from output */
 997                                                          from_source = output;
 998                                                      }
 999                                                  }
1000                                                  while ( len > 2 ) {
1001                                                      output[ _out++ ] =
1002                                                          from_source[ from++ ];
1003                                                      output[ _out++ ] =
1004                                                          from_source[ from++ ];
1005                                                      output[ _out++ ] =
1006                                                          from_source[ from++ ];
1007                                                      len -= 3;
1008                                                  }
1009                                                  if ( len ) {
1010                                                      output[ _out++ ] =
1011                                                          from_source[ from++ ];
1012                                                      if ( len > 1 ) {
1013                                                          output[ _out++ ] =
1014                                                              from_source[
1015                                                                  from++
1016                                                              ];
1017                                                      }
1018                                                  }
1019                                              } else {
1020                                                  from =
1021                                                      _out -
1022                                                      dist; /* copy direct from output */
1023                                                  do {
1024                                                      /* minimum length is three */
1025                                                      output[ _out++ ] =
1026                                                          output[ from++ ];
1027                                                      output[ _out++ ] =
1028                                                          output[ from++ ];
1029                                                      output[ _out++ ] =
1030                                                          output[ from++ ];
1031                                                      len -= 3;
1032                                                  } while ( len > 2 );
1033                                                  if ( len ) {
1034                                                      output[ _out++ ] =
1035                                                          output[ from++ ];
1036                                                      if ( len > 1 ) {
1037                                                          output[ _out++ ] =
1038                                                              output[ from++ ];
1039                                                      }
1040                                                  }
1041                                              }
1042                                          } else if ( ( op & 64 ) === 0 ) {
1043                                              /* 2nd level distance code */
1044                                              here =
1045                                                  dcode[
1046                                                      ( here &
1047                                                          0xffff ) /*here.val*/ +
1048                                                          ( hold &
1049                                                              ( ( 1 << op ) -
1050                                                                  1 ) )
1051                                                  ];
1052                                              continue dodist;
1053                                          } else {
1054                                              strm.msg = 'invalid distance code';
1055                                              state.mode = BAD;
1056                                              break top;
1057                                          }
1058  
1059                                          break; // need to emulate goto via "continue"
1060                                      }
1061                                  } else if ( ( op & 64 ) === 0 ) {
1062                                      /* 2nd level length code */
1063                                      here =
1064                                          lcode[
1065                                              ( here & 0xffff ) /*here.val*/ +
1066                                                  ( hold & ( ( 1 << op ) - 1 ) )
1067                                          ];
1068                                      continue dolen;
1069                                  } else if ( op & 32 ) {
1070                                      /* end-of-block */
1071                                      //Tracevv((stderr, "inflate:         end of block\n"));
1072                                      state.mode = TYPE;
1073                                      break top;
1074                                  } else {
1075                                      strm.msg = 'invalid literal/length code';
1076                                      state.mode = BAD;
1077                                      break top;
1078                                  }
1079  
1080                                  break; // need to emulate goto via "continue"
1081                              }
1082                          } while ( _in < last && _out < end );
1083  
1084                          /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
1085                          len = bits >> 3;
1086                          _in -= len;
1087                          bits -= len << 3;
1088                          hold &= ( 1 << bits ) - 1;
1089  
1090                          /* update state and return */
1091                          strm.next_in = _in;
1092                          strm.next_out = _out;
1093                          strm.avail_in =
1094                              _in < last
1095                                  ? 5 + ( last - _in )
1096                                  : 5 - ( _in - last );
1097                          strm.avail_out =
1098                              _out < end
1099                                  ? 257 + ( end - _out )
1100                                  : 257 - ( _out - end );
1101                          state.hold = hold;
1102                          state.bits = bits;
1103                          return;
1104                      };
1105                  },
1106                  {},
1107              ],
1108              8: [
1109                  function ( require, module, exports ) {
1110                      'use strict';
1111  
1112                      // (C) 1995-2013 Jean-loup Gailly and Mark Adler
1113                      // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
1114                      //
1115                      // This software is provided 'as-is', without any express or implied
1116                      // warranty. In no event will the authors be held liable for any damages
1117                      // arising from the use of this software.
1118                      //
1119                      // Permission is granted to anyone to use this software for any purpose,
1120                      // including commercial applications, and to alter it and redistribute it
1121                      // freely, subject to the following restrictions:
1122                      //
1123                      // 1. The origin of this software must not be misrepresented; you must not
1124                      //   claim that you wrote the original software. If you use this software
1125                      //   in a product, an acknowledgment in the product documentation would be
1126                      //   appreciated but is not required.
1127                      // 2. Altered source versions must be plainly marked as such, and must not be
1128                      //   misrepresented as being the original software.
1129                      // 3. This notice may not be removed or altered from any source distribution.
1130  
1131                      var utils = require( '../utils/common' );
1132                      var adler32 = require( './adler32' );
1133                      var crc32 = require( './crc32' );
1134                      var inflate_fast = require( './inffast' );
1135                      var inflate_table = require( './inftrees' );
1136  
1137                      var CODES = 0;
1138                      var LENS = 1;
1139                      var DISTS = 2;
1140  
1141                      /* Public constants ==========================================================*/
1142                      /* ===========================================================================*/
1143  
1144                      /* Allowed flush values; see deflate() and inflate() below for details */
1145                      //var Z_NO_FLUSH      = 0;
1146                      //var Z_PARTIAL_FLUSH = 1;
1147                      //var Z_SYNC_FLUSH    = 2;
1148                      //var Z_FULL_FLUSH    = 3;
1149                      var Z_FINISH = 4;
1150                      var Z_BLOCK = 5;
1151                      var Z_TREES = 6;
1152  
1153                      /* Return codes for the compression/decompression functions. Negative values
1154                       * are errors, positive values are used for special but normal events.
1155                       */
1156                      var Z_OK = 0;
1157                      var Z_STREAM_END = 1;
1158                      var Z_NEED_DICT = 2;
1159                      //var Z_ERRNO         = -1;
1160                      var Z_STREAM_ERROR = -2;
1161                      var Z_DATA_ERROR = -3;
1162                      var Z_MEM_ERROR = -4;
1163                      var Z_BUF_ERROR = -5;
1164                      //var Z_VERSION_ERROR = -6;
1165  
1166                      /* The deflate compression method */
1167                      var Z_DEFLATED = 8;
1168  
1169                      /* STATES ====================================================================*/
1170                      /* ===========================================================================*/
1171  
1172                      var HEAD = 1; /* i: waiting for magic header */
1173                      var FLAGS = 2; /* i: waiting for method and flags (gzip) */
1174                      var TIME = 3; /* i: waiting for modification time (gzip) */
1175                      var OS = 4; /* i: waiting for extra flags and operating system (gzip) */
1176                      var EXLEN = 5; /* i: waiting for extra length (gzip) */
1177                      var EXTRA = 6; /* i: waiting for extra bytes (gzip) */
1178                      var NAME = 7; /* i: waiting for end of file name (gzip) */
1179                      var COMMENT = 8; /* i: waiting for end of comment (gzip) */
1180                      var HCRC = 9; /* i: waiting for header crc (gzip) */
1181                      var DICTID = 10; /* i: waiting for dictionary check value */
1182                      var DICT = 11; /* waiting for inflateSetDictionary() call */
1183                      var TYPE = 12; /* i: waiting for type bits, including last-flag bit */
1184                      var TYPEDO = 13; /* i: same, but skip check to exit inflate on new block */
1185                      var STORED = 14; /* i: waiting for stored size (length and complement) */
1186                      var COPY_ = 15; /* i/o: same as COPY below, but only first time in */
1187                      var COPY = 16; /* i/o: waiting for input or output to copy stored block */
1188                      var TABLE = 17; /* i: waiting for dynamic block table lengths */
1189                      var LENLENS = 18; /* i: waiting for code length code lengths */
1190                      var CODELENS = 19; /* i: waiting for length/lit and distance code lengths */
1191                      var LEN_ = 20; /* i: same as LEN below, but only first time in */
1192                      var LEN = 21; /* i: waiting for length/lit/eob code */
1193                      var LENEXT = 22; /* i: waiting for length extra bits */
1194                      var DIST = 23; /* i: waiting for distance code */
1195                      var DISTEXT = 24; /* i: waiting for distance extra bits */
1196                      var MATCH = 25; /* o: waiting for output space to copy string */
1197                      var LIT = 26; /* o: waiting for output space to write literal */
1198                      var CHECK = 27; /* i: waiting for 32-bit check value */
1199                      var LENGTH = 28; /* i: waiting for 32-bit length (gzip) */
1200                      var DONE = 29; /* finished check, done -- remain here until reset */
1201                      var BAD = 30; /* got a data error -- remain here until reset */
1202                      var MEM = 31; /* got an inflate() memory error -- remain here until reset */
1203                      var SYNC = 32; /* looking for synchronization bytes to restart inflate() */
1204  
1205                      /* ===========================================================================*/
1206  
1207                      var ENOUGH_LENS = 852;
1208                      var ENOUGH_DISTS = 592;
1209                      //var ENOUGH =  (ENOUGH_LENS+ENOUGH_DISTS);
1210  
1211                      var MAX_WBITS = 15;
1212                      /* 32K LZ77 window */
1213                      var DEF_WBITS = MAX_WBITS;
1214  
1215  					function zswap32( q ) {
1216                          return (
1217                              ( ( q >>> 24 ) & 0xff ) +
1218                              ( ( q >>> 8 ) & 0xff00 ) +
1219                              ( ( q & 0xff00 ) << 8 ) +
1220                              ( ( q & 0xff ) << 24 )
1221                          );
1222                      }
1223  
1224  					function InflateState() {
1225                          this.mode = 0; /* current inflate mode */
1226                          this.last = false; /* true if processing last block */
1227                          this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */
1228                          this.havedict = false; /* true if dictionary provided */
1229                          this.flags = 0; /* gzip header method and flags (0 if zlib) */
1230                          this.dmax = 0; /* zlib header max distance (INFLATE_STRICT) */
1231                          this.check = 0; /* protected copy of check value */
1232                          this.total = 0; /* protected copy of output count */
1233                          // TODO: may be {}
1234                          this.head =
1235                              null; /* where to save gzip header information */
1236  
1237                          /* sliding window */
1238                          this.wbits = 0; /* log base 2 of requested window size */
1239                          this.wsize = 0; /* window size or zero if not using window */
1240                          this.whave = 0; /* valid bytes in the window */
1241                          this.wnext = 0; /* window write index */
1242                          this.window =
1243                              null; /* allocated sliding window, if needed */
1244  
1245                          /* bit accumulator */
1246                          this.hold = 0; /* input bit accumulator */
1247                          this.bits = 0; /* number of bits in "in" */
1248  
1249                          /* for string and stored block copying */
1250                          this.length = 0; /* literal or length of data to copy */
1251                          this.offset = 0; /* distance back to copy string from */
1252  
1253                          /* for table and code decoding */
1254                          this.extra = 0; /* extra bits needed */
1255  
1256                          /* fixed and dynamic code tables */
1257                          this.lencode =
1258                              null; /* starting table for length/literal codes */
1259                          this.distcode =
1260                              null; /* starting table for distance codes */
1261                          this.lenbits = 0; /* index bits for lencode */
1262                          this.distbits = 0; /* index bits for distcode */
1263  
1264                          /* dynamic table building */
1265                          this.ncode = 0; /* number of code length code lengths */
1266                          this.nlen = 0; /* number of length code lengths */
1267                          this.ndist = 0; /* number of distance code lengths */
1268                          this.have = 0; /* number of code lengths in lens[] */
1269                          this.next = null; /* next available space in codes[] */
1270  
1271                          this.lens = new utils.Buf16(
1272                              320
1273                          ); /* temporary storage for code lengths */
1274                          this.work = new utils.Buf16(
1275                              288
1276                          ); /* work area for code table building */
1277  
1278                          /*
1279       because we don't have pointers in js, we use lencode and distcode directly
1280       as buffers so we don't need codes
1281      */
1282                          //this.codes = new utils.Buf32(ENOUGH);       /* space for code tables */
1283                          this.lendyn =
1284                              null; /* dynamic table for length/literal codes (JS specific) */
1285                          this.distdyn =
1286                              null; /* dynamic table for distance codes (JS specific) */
1287                          this.sane = 0; /* if false, allow invalid distance too far */
1288                          this.back = 0; /* bits back of last unprocessed length/lit */
1289                          this.was = 0; /* initial length of match */
1290                      }
1291  
1292  					function inflateResetKeep( strm ) {
1293                          var state;
1294  
1295                          if ( ! strm || ! strm.state ) {
1296                              return Z_STREAM_ERROR;
1297                          }
1298                          state = strm.state;
1299                          strm.total_in = strm.total_out = state.total = 0;
1300                          strm.msg = ''; /*Z_NULL*/
1301                          if ( state.wrap ) {
1302                              /* to support ill-conceived Java test suite */
1303                              strm.adler = state.wrap & 1;
1304                          }
1305                          state.mode = HEAD;
1306                          state.last = 0;
1307                          state.havedict = 0;
1308                          state.dmax = 32768;
1309                          state.head = null /*Z_NULL*/;
1310                          state.hold = 0;
1311                          state.bits = 0;
1312                          //state.lencode = state.distcode = state.next = state.codes;
1313                          state.lencode = state.lendyn = new utils.Buf32(
1314                              ENOUGH_LENS
1315                          );
1316                          state.distcode = state.distdyn = new utils.Buf32(
1317                              ENOUGH_DISTS
1318                          );
1319  
1320                          state.sane = 1;
1321                          state.back = -1;
1322                          //Tracev((stderr, "inflate: reset\n"));
1323                          return Z_OK;
1324                      }
1325  
1326  					function inflateReset( strm ) {
1327                          var state;
1328  
1329                          if ( ! strm || ! strm.state ) {
1330                              return Z_STREAM_ERROR;
1331                          }
1332                          state = strm.state;
1333                          state.wsize = 0;
1334                          state.whave = 0;
1335                          state.wnext = 0;
1336                          return inflateResetKeep( strm );
1337                      }
1338  
1339  					function inflateReset2( strm, windowBits ) {
1340                          var wrap;
1341                          var state;
1342  
1343                          /* get the state */
1344                          if ( ! strm || ! strm.state ) {
1345                              return Z_STREAM_ERROR;
1346                          }
1347                          state = strm.state;
1348  
1349                          /* extract wrap request from windowBits parameter */
1350                          if ( windowBits < 0 ) {
1351                              wrap = 0;
1352                              windowBits = -windowBits;
1353                          } else {
1354                              wrap = ( windowBits >> 4 ) + 1;
1355                              if ( windowBits < 48 ) {
1356                                  windowBits &= 15;
1357                              }
1358                          }
1359  
1360                          /* set number of window bits, free window if different */
1361                          if (
1362                              windowBits &&
1363                              ( windowBits < 8 || windowBits > 15 )
1364                          ) {
1365                              return Z_STREAM_ERROR;
1366                          }
1367                          if (
1368                              state.window !== null &&
1369                              state.wbits !== windowBits
1370                          ) {
1371                              state.window = null;
1372                          }
1373  
1374                          /* update state and reset the rest of it */
1375                          state.wrap = wrap;
1376                          state.wbits = windowBits;
1377                          return inflateReset( strm );
1378                      }
1379  
1380  					function inflateInit2( strm, windowBits ) {
1381                          var ret;
1382                          var state;
1383  
1384                          if ( ! strm ) {
1385                              return Z_STREAM_ERROR;
1386                          }
1387                          //strm.msg = Z_NULL;                 /* in case we return an error */
1388  
1389                          state = new InflateState();
1390  
1391                          //if (state === Z_NULL) return Z_MEM_ERROR;
1392                          //Tracev((stderr, "inflate: allocated\n"));
1393                          strm.state = state;
1394                          state.window = null /*Z_NULL*/;
1395                          ret = inflateReset2( strm, windowBits );
1396                          if ( ret !== Z_OK ) {
1397                              strm.state = null /*Z_NULL*/;
1398                          }
1399                          return ret;
1400                      }
1401  
1402  					function inflateInit( strm ) {
1403                          return inflateInit2( strm, DEF_WBITS );
1404                      }
1405  
1406                      /*
1407     Return state with length and distance decoding tables and index sizes set to
1408     fixed code decoding.  Normally this returns fixed tables from inffixed.h.
1409     If BUILDFIXED is defined, then instead this routine builds the tables the
1410     first time it's called, and returns those tables the first time and
1411     thereafter.  This reduces the size of the code by about 2K bytes, in
1412     exchange for a little execution time.  However, BUILDFIXED should not be
1413     used for threaded applications, since the rewriting of the tables and virgin
1414     may not be thread-safe.
1415     */
1416                      var virgin = true;
1417  
1418                      var lenfix, distfix; // We have no pointers in JS, so keep tables separate
1419  
1420  					function fixedtables( state ) {
1421                          /* build fixed huffman tables if first call (may not be thread safe) */
1422                          if ( virgin ) {
1423                              var sym;
1424  
1425                              lenfix = new utils.Buf32( 512 );
1426                              distfix = new utils.Buf32( 32 );
1427  
1428                              /* literal/length table */
1429                              sym = 0;
1430                              while ( sym < 144 ) {
1431                                  state.lens[ sym++ ] = 8;
1432                              }
1433                              while ( sym < 256 ) {
1434                                  state.lens[ sym++ ] = 9;
1435                              }
1436                              while ( sym < 280 ) {
1437                                  state.lens[ sym++ ] = 7;
1438                              }
1439                              while ( sym < 288 ) {
1440                                  state.lens[ sym++ ] = 8;
1441                              }
1442  
1443                              inflate_table(
1444                                  LENS,
1445                                  state.lens,
1446                                  0,
1447                                  288,
1448                                  lenfix,
1449                                  0,
1450                                  state.work,
1451                                  { bits: 9 }
1452                              );
1453  
1454                              /* distance table */
1455                              sym = 0;
1456                              while ( sym < 32 ) {
1457                                  state.lens[ sym++ ] = 5;
1458                              }
1459  
1460                              inflate_table(
1461                                  DISTS,
1462                                  state.lens,
1463                                  0,
1464                                  32,
1465                                  distfix,
1466                                  0,
1467                                  state.work,
1468                                  { bits: 5 }
1469                              );
1470  
1471                              /* do this just once */
1472                              virgin = false;
1473                          }
1474  
1475                          state.lencode = lenfix;
1476                          state.lenbits = 9;
1477                          state.distcode = distfix;
1478                          state.distbits = 5;
1479                      }
1480  
1481                      /*
1482     Update the window with the last wsize (normally 32K) bytes written before
1483     returning.  If window does not exist yet, create it.  This is only called
1484     when a window is already in use, or when output has been written during this
1485     inflate call, but the end of the deflate stream has not been reached yet.
1486     It is also called to create a window for dictionary data when a dictionary
1487     is loaded.
1488  
1489     Providing output buffers larger than 32K to inflate() should provide a speed
1490     advantage, since only the last 32K of output is copied to the sliding window
1491     upon return from inflate(), and since all distances after the first 32K of
1492     output will fall in the output data, making match copies simpler and faster.
1493     The advantage may be dependent on the size of the processor's data caches.
1494     */
1495  					function updatewindow( strm, src, end, copy ) {
1496                          var dist;
1497                          var state = strm.state;
1498  
1499                          /* if it hasn't been done already, allocate space for the window */
1500                          if ( state.window === null ) {
1501                              state.wsize = 1 << state.wbits;
1502                              state.wnext = 0;
1503                              state.whave = 0;
1504  
1505                              state.window = new utils.Buf8( state.wsize );
1506                          }
1507  
1508                          /* copy state->wsize or less output bytes into the circular window */
1509                          if ( copy >= state.wsize ) {
1510                              utils.arraySet(
1511                                  state.window,
1512                                  src,
1513                                  end - state.wsize,
1514                                  state.wsize,
1515                                  0
1516                              );
1517                              state.wnext = 0;
1518                              state.whave = state.wsize;
1519                          } else {
1520                              dist = state.wsize - state.wnext;
1521                              if ( dist > copy ) {
1522                                  dist = copy;
1523                              }
1524                              //zmemcpy(state->window + state->wnext, end - copy, dist);
1525                              utils.arraySet(
1526                                  state.window,
1527                                  src,
1528                                  end - copy,
1529                                  dist,
1530                                  state.wnext
1531                              );
1532                              copy -= dist;
1533                              if ( copy ) {
1534                                  //zmemcpy(state->window, end - copy, copy);
1535                                  utils.arraySet(
1536                                      state.window,
1537                                      src,
1538                                      end - copy,
1539                                      copy,
1540                                      0
1541                                  );
1542                                  state.wnext = copy;
1543                                  state.whave = state.wsize;
1544                              } else {
1545                                  state.wnext += dist;
1546                                  if ( state.wnext === state.wsize ) {
1547                                      state.wnext = 0;
1548                                  }
1549                                  if ( state.whave < state.wsize ) {
1550                                      state.whave += dist;
1551                                  }
1552                              }
1553                          }
1554                          return 0;
1555                      }
1556  
1557  					function inflate( strm, flush ) {
1558                          var state;
1559                          var input, output; // input/output buffers
1560                          var next; /* next input INDEX */
1561                          var put; /* next output INDEX */
1562                          var have, left; /* available input and output */
1563                          var hold; /* bit buffer */
1564                          var bits; /* bits in bit buffer */
1565                          var _in,
1566                              _out; /* save starting available input and output */
1567                          var copy; /* number of stored or match bytes to copy */
1568                          var from; /* where to copy match bytes from */
1569                          var from_source;
1570                          var here = 0; /* current decoding table entry */
1571                          var here_bits, here_op, here_val; // paked "here" denormalized (JS specific)
1572                          //var last;                   /* parent table entry */
1573                          var last_bits, last_op, last_val; // paked "last" denormalized (JS specific)
1574                          var len; /* length to copy for repeats, bits to drop */
1575                          var ret; /* return code */
1576                          var hbuf = new utils.Buf8(
1577                              4
1578                          ); /* buffer for gzip header crc calculation */
1579                          var opts;
1580  
1581                          var n; // temporary var for NEED_BITS
1582  
1583                          var order =
1584                              /* permutation of code lengths */
1585                              [
1586                                  16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3,
1587                                  13, 2, 14, 1, 15,
1588                              ];
1589  
1590                          if (
1591                              ! strm ||
1592                              ! strm.state ||
1593                              ! strm.output ||
1594                              ( ! strm.input && strm.avail_in !== 0 )
1595                          ) {
1596                              return Z_STREAM_ERROR;
1597                          }
1598  
1599                          state = strm.state;
1600                          if ( state.mode === TYPE ) {
1601                              state.mode = TYPEDO;
1602                          } /* skip check */
1603  
1604                          //--- LOAD() ---
1605                          put = strm.next_out;
1606                          output = strm.output;
1607                          left = strm.avail_out;
1608                          next = strm.next_in;
1609                          input = strm.input;
1610                          have = strm.avail_in;
1611                          hold = state.hold;
1612                          bits = state.bits;
1613                          //---
1614  
1615                          _in = have;
1616                          _out = left;
1617                          ret = Z_OK;
1618  
1619                          // goto emulation
1620                          inf_leave: for (;;) {
1621                              switch ( state.mode ) {
1622                                  case HEAD:
1623                                      if ( state.wrap === 0 ) {
1624                                          state.mode = TYPEDO;
1625                                          break;
1626                                      }
1627                                      //=== NEEDBITS(16);
1628                                      while ( bits < 16 ) {
1629                                          if ( have === 0 ) {
1630                                              break inf_leave;
1631                                          }
1632                                          have--;
1633                                          hold += input[ next++ ] << bits;
1634                                          bits += 8;
1635                                      }
1636                                      //===//
1637                                      if ( state.wrap & 2 && hold === 0x8b1f ) {
1638                                          /* gzip header */
1639                                          state.check = 0 /*crc32(0L, Z_NULL, 0)*/;
1640                                          //=== CRC2(state.check, hold);
1641                                          hbuf[ 0 ] = hold & 0xff;
1642                                          hbuf[ 1 ] = ( hold >>> 8 ) & 0xff;
1643                                          state.check = crc32(
1644                                              state.check,
1645                                              hbuf,
1646                                              2,
1647                                              0
1648                                          );
1649                                          //===//
1650  
1651                                          //=== INITBITS();
1652                                          hold = 0;
1653                                          bits = 0;
1654                                          //===//
1655                                          state.mode = FLAGS;
1656                                          break;
1657                                      }
1658                                      state.flags = 0; /* expect zlib header */
1659                                      if ( state.head ) {
1660                                          state.head.done = false;
1661                                      }
1662                                      if (
1663                                          ! (
1664                                              state.wrap & 1
1665                                          ) /* check if zlib header allowed */ ||
1666                                          ( ( ( hold & 0xff ) /*BITS(8)*/ << 8 ) +
1667                                              ( hold >> 8 ) ) %
1668                                              31
1669                                      ) {
1670                                          strm.msg = 'incorrect header check';
1671                                          state.mode = BAD;
1672                                          break;
1673                                      }
1674                                      if (
1675                                          ( hold & 0x0f ) /*BITS(4)*/ !==
1676                                          Z_DEFLATED
1677                                      ) {
1678                                          strm.msg = 'unknown compression method';
1679                                          state.mode = BAD;
1680                                          break;
1681                                      }
1682                                      //--- DROPBITS(4) ---//
1683                                      hold >>>= 4;
1684                                      bits -= 4;
1685                                      //---//
1686                                      len = ( hold & 0x0f ) /*BITS(4)*/ + 8;
1687                                      if ( state.wbits === 0 ) {
1688                                          state.wbits = len;
1689                                      } else if ( len > state.wbits ) {
1690                                          strm.msg = 'invalid window size';
1691                                          state.mode = BAD;
1692                                          break;
1693                                      }
1694                                      state.dmax = 1 << len;
1695                                      //Tracev((stderr, "inflate:   zlib header ok\n"));
1696                                      strm.adler =
1697                                          state.check = 1 /*adler32(0L, Z_NULL, 0)*/;
1698                                      state.mode = hold & 0x200 ? DICTID : TYPE;
1699                                      //=== INITBITS();
1700                                      hold = 0;
1701                                      bits = 0;
1702                                      //===//
1703                                      break;
1704                                  case FLAGS:
1705                                      //=== NEEDBITS(16); */
1706                                      while ( bits < 16 ) {
1707                                          if ( have === 0 ) {
1708                                              break inf_leave;
1709                                          }
1710                                          have--;
1711                                          hold += input[ next++ ] << bits;
1712                                          bits += 8;
1713                                      }
1714                                      //===//
1715                                      state.flags = hold;
1716                                      if (
1717                                          ( state.flags & 0xff ) !==
1718                                          Z_DEFLATED
1719                                      ) {
1720                                          strm.msg = 'unknown compression method';
1721                                          state.mode = BAD;
1722                                          break;
1723                                      }
1724                                      if ( state.flags & 0xe000 ) {
1725                                          strm.msg = 'unknown header flags set';
1726                                          state.mode = BAD;
1727                                          break;
1728                                      }
1729                                      if ( state.head ) {
1730                                          state.head.text = ( hold >> 8 ) & 1;
1731                                      }
1732                                      if ( state.flags & 0x0200 ) {
1733                                          //=== CRC2(state.check, hold);
1734                                          hbuf[ 0 ] = hold & 0xff;
1735                                          hbuf[ 1 ] = ( hold >>> 8 ) & 0xff;
1736                                          state.check = crc32(
1737                                              state.check,
1738                                              hbuf,
1739                                              2,
1740                                              0
1741                                          );
1742                                          //===//
1743                                      }
1744                                      //=== INITBITS();
1745                                      hold = 0;
1746                                      bits = 0;
1747                                      //===//
1748                                      state.mode = TIME;
1749                                  /* falls through */
1750                                  case TIME:
1751                                      //=== NEEDBITS(32); */
1752                                      while ( bits < 32 ) {
1753                                          if ( have === 0 ) {
1754                                              break inf_leave;
1755                                          }
1756                                          have--;
1757                                          hold += input[ next++ ] << bits;
1758                                          bits += 8;
1759                                      }
1760                                      //===//
1761                                      if ( state.head ) {
1762                                          state.head.time = hold;
1763                                      }
1764                                      if ( state.flags & 0x0200 ) {
1765                                          //=== CRC4(state.check, hold)
1766                                          hbuf[ 0 ] = hold & 0xff;
1767                                          hbuf[ 1 ] = ( hold >>> 8 ) & 0xff;
1768                                          hbuf[ 2 ] = ( hold >>> 16 ) & 0xff;
1769                                          hbuf[ 3 ] = ( hold >>> 24 ) & 0xff;
1770                                          state.check = crc32(
1771                                              state.check,
1772                                              hbuf,
1773                                              4,
1774                                              0
1775                                          );
1776                                          //===
1777                                      }
1778                                      //=== INITBITS();
1779                                      hold = 0;
1780                                      bits = 0;
1781                                      //===//
1782                                      state.mode = OS;
1783                                  /* falls through */
1784                                  case OS:
1785                                      //=== NEEDBITS(16); */
1786                                      while ( bits < 16 ) {
1787                                          if ( have === 0 ) {
1788                                              break inf_leave;
1789                                          }
1790                                          have--;
1791                                          hold += input[ next++ ] << bits;
1792                                          bits += 8;
1793                                      }
1794                                      //===//
1795                                      if ( state.head ) {
1796                                          state.head.xflags = hold & 0xff;
1797                                          state.head.os = hold >> 8;
1798                                      }
1799                                      if ( state.flags & 0x0200 ) {
1800                                          //=== CRC2(state.check, hold);
1801                                          hbuf[ 0 ] = hold & 0xff;
1802                                          hbuf[ 1 ] = ( hold >>> 8 ) & 0xff;
1803                                          state.check = crc32(
1804                                              state.check,
1805                                              hbuf,
1806                                              2,
1807                                              0
1808                                          );
1809                                          //===//
1810                                      }
1811                                      //=== INITBITS();
1812                                      hold = 0;
1813                                      bits = 0;
1814                                      //===//
1815                                      state.mode = EXLEN;
1816                                  /* falls through */
1817                                  case EXLEN:
1818                                      if ( state.flags & 0x0400 ) {
1819                                          //=== NEEDBITS(16); */
1820                                          while ( bits < 16 ) {
1821                                              if ( have === 0 ) {
1822                                                  break inf_leave;
1823                                              }
1824                                              have--;
1825                                              hold += input[ next++ ] << bits;
1826                                              bits += 8;
1827                                          }
1828                                          //===//
1829                                          state.length = hold;
1830                                          if ( state.head ) {
1831                                              state.head.extra_len = hold;
1832                                          }
1833                                          if ( state.flags & 0x0200 ) {
1834                                              //=== CRC2(state.check, hold);
1835                                              hbuf[ 0 ] = hold & 0xff;
1836                                              hbuf[ 1 ] = ( hold >>> 8 ) & 0xff;
1837                                              state.check = crc32(
1838                                                  state.check,
1839                                                  hbuf,
1840                                                  2,
1841                                                  0
1842                                              );
1843                                              //===//
1844                                          }
1845                                          //=== INITBITS();
1846                                          hold = 0;
1847                                          bits = 0;
1848                                          //===//
1849                                      } else if ( state.head ) {
1850                                          state.head.extra = null /*Z_NULL*/;
1851                                      }
1852                                      state.mode = EXTRA;
1853                                  /* falls through */
1854                                  case EXTRA:
1855                                      if ( state.flags & 0x0400 ) {
1856                                          copy = state.length;
1857                                          if ( copy > have ) {
1858                                              copy = have;
1859                                          }
1860                                          if ( copy ) {
1861                                              if ( state.head ) {
1862                                                  len =
1863                                                      state.head.extra_len -
1864                                                      state.length;
1865                                                  if ( ! state.head.extra ) {
1866                                                      // Use untyped array for more convenient processing later
1867                                                      state.head.extra =
1868                                                          new Array(
1869                                                              state.head.extra_len
1870                                                          );
1871                                                  }
1872                                                  utils.arraySet(
1873                                                      state.head.extra,
1874                                                      input,
1875                                                      next,
1876                                                      // extra field is limited to 65536 bytes
1877                                                      // - no need for additional size check
1878                                                      copy,
1879                                                      /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
1880                                                      len
1881                                                  );
1882                                                  //zmemcpy(state.head.extra + len, next,
1883                                                  //        len + copy > state.head.extra_max ?
1884                                                  //        state.head.extra_max - len : copy);
1885                                              }
1886                                              if ( state.flags & 0x0200 ) {
1887                                                  state.check = crc32(
1888                                                      state.check,
1889                                                      input,
1890                                                      copy,
1891                                                      next
1892                                                  );
1893                                              }
1894                                              have -= copy;
1895                                              next += copy;
1896                                              state.length -= copy;
1897                                          }
1898                                          if ( state.length ) {
1899                                              break inf_leave;
1900                                          }
1901                                      }
1902                                      state.length = 0;
1903                                      state.mode = NAME;
1904                                  /* falls through */
1905                                  case NAME:
1906                                      if ( state.flags & 0x0800 ) {
1907                                          if ( have === 0 ) {
1908                                              break inf_leave;
1909                                          }
1910                                          copy = 0;
1911                                          do {
1912                                              // TODO: 2 or 1 bytes?
1913                                              len = input[ next + copy++ ];
1914                                              /* use constant limit because in js we should not preallocate memory */
1915                                              if (
1916                                                  state.head &&
1917                                                  len &&
1918                                                  state.length <
1919                                                      65536 /*state.head.name_max*/
1920                                              ) {
1921                                                  state.head.name +=
1922                                                      String.fromCharCode( len );
1923                                              }
1924                                          } while ( len && copy < have );
1925  
1926                                          if ( state.flags & 0x0200 ) {
1927                                              state.check = crc32(
1928                                                  state.check,
1929                                                  input,
1930                                                  copy,
1931                                                  next
1932                                              );
1933                                          }
1934                                          have -= copy;
1935                                          next += copy;
1936                                          if ( len ) {
1937                                              break inf_leave;
1938                                          }
1939                                      } else if ( state.head ) {
1940                                          state.head.name = null;
1941                                      }
1942                                      state.length = 0;
1943                                      state.mode = COMMENT;
1944                                  /* falls through */
1945                                  case COMMENT:
1946                                      if ( state.flags & 0x1000 ) {
1947                                          if ( have === 0 ) {
1948                                              break inf_leave;
1949                                          }
1950                                          copy = 0;
1951                                          do {
1952                                              len = input[ next + copy++ ];
1953                                              /* use constant limit because in js we should not preallocate memory */
1954                                              if (
1955                                                  state.head &&
1956                                                  len &&
1957                                                  state.length <
1958                                                      65536 /*state.head.comm_max*/
1959                                              ) {
1960                                                  state.head.comment +=
1961                                                      String.fromCharCode( len );
1962                                              }
1963                                          } while ( len && copy < have );
1964                                          if ( state.flags & 0x0200 ) {
1965                                              state.check = crc32(
1966                                                  state.check,
1967                                                  input,
1968                                                  copy,
1969                                                  next
1970                                              );
1971                                          }
1972                                          have -= copy;
1973                                          next += copy;
1974                                          if ( len ) {
1975                                              break inf_leave;
1976                                          }
1977                                      } else if ( state.head ) {
1978                                          state.head.comment = null;
1979                                      }
1980                                      state.mode = HCRC;
1981                                  /* falls through */
1982                                  case HCRC:
1983                                      if ( state.flags & 0x0200 ) {
1984                                          //=== NEEDBITS(16); */
1985                                          while ( bits < 16 ) {
1986                                              if ( have === 0 ) {
1987                                                  break inf_leave;
1988                                              }
1989                                              have--;
1990                                              hold += input[ next++ ] << bits;
1991                                              bits += 8;
1992                                          }
1993                                          //===//
1994                                          if (
1995                                              hold !==
1996                                              ( state.check & 0xffff )
1997                                          ) {
1998                                              strm.msg = 'header crc mismatch';
1999                                              state.mode = BAD;
2000                                              break;
2001                                          }
2002                                          //=== INITBITS();
2003                                          hold = 0;
2004                                          bits = 0;
2005                                          //===//
2006                                      }
2007                                      if ( state.head ) {
2008                                          state.head.hcrc =
2009                                              ( state.flags >> 9 ) & 1;
2010                                          state.head.done = true;
2011                                      }
2012                                      strm.adler = state.check = 0;
2013                                      state.mode = TYPE;
2014                                      break;
2015                                  case DICTID:
2016                                      //=== NEEDBITS(32); */
2017                                      while ( bits < 32 ) {
2018                                          if ( have === 0 ) {
2019                                              break inf_leave;
2020                                          }
2021                                          have--;
2022                                          hold += input[ next++ ] << bits;
2023                                          bits += 8;
2024                                      }
2025                                      //===//
2026                                      strm.adler = state.check = zswap32( hold );
2027                                      //=== INITBITS();
2028                                      hold = 0;
2029                                      bits = 0;
2030                                      //===//
2031                                      state.mode = DICT;
2032                                  /* falls through */
2033                                  case DICT:
2034                                      if ( state.havedict === 0 ) {
2035                                          //--- RESTORE() ---
2036                                          strm.next_out = put;
2037                                          strm.avail_out = left;
2038                                          strm.next_in = next;
2039                                          strm.avail_in = have;
2040                                          state.hold = hold;
2041                                          state.bits = bits;
2042                                          //---
2043                                          return Z_NEED_DICT;
2044                                      }
2045                                      strm.adler =
2046                                          state.check = 1 /*adler32(0L, Z_NULL, 0)*/;
2047                                      state.mode = TYPE;
2048                                  /* falls through */
2049                                  case TYPE:
2050                                      if (
2051                                          flush === Z_BLOCK ||
2052                                          flush === Z_TREES
2053                                      ) {
2054                                          break inf_leave;
2055                                      }
2056                                  /* falls through */
2057                                  case TYPEDO:
2058                                      if ( state.last ) {
2059                                          //--- BYTEBITS() ---//
2060                                          hold >>>= bits & 7;
2061                                          bits -= bits & 7;
2062                                          //---//
2063                                          state.mode = CHECK;
2064                                          break;
2065                                      }
2066                                      //=== NEEDBITS(3); */
2067                                      while ( bits < 3 ) {
2068                                          if ( have === 0 ) {
2069                                              break inf_leave;
2070                                          }
2071                                          have--;
2072                                          hold += input[ next++ ] << bits;
2073                                          bits += 8;
2074                                      }
2075                                      //===//
2076                                      state.last = hold & 0x01 /*BITS(1)*/;
2077                                      //--- DROPBITS(1) ---//
2078                                      hold >>>= 1;
2079                                      bits -= 1;
2080                                      //---//
2081  
2082                                      switch ( hold & 0x03 /*BITS(2)*/ ) {
2083                                          case 0 /* stored block */:
2084                                              //Tracev((stderr, "inflate:     stored block%s\n",
2085                                              //        state.last ? " (last)" : ""));
2086                                              state.mode = STORED;
2087                                              break;
2088                                          case 1 /* fixed block */:
2089                                              fixedtables( state );
2090                                              //Tracev((stderr, "inflate:     fixed codes block%s\n",
2091                                              //        state.last ? " (last)" : ""));
2092                                              state.mode =
2093                                                  LEN_; /* decode codes */
2094                                              if ( flush === Z_TREES ) {
2095                                                  //--- DROPBITS(2) ---//
2096                                                  hold >>>= 2;
2097                                                  bits -= 2;
2098                                                  //---//
2099                                                  break inf_leave;
2100                                              }
2101                                              break;
2102                                          case 2 /* dynamic block */:
2103                                              //Tracev((stderr, "inflate:     dynamic codes block%s\n",
2104                                              //        state.last ? " (last)" : ""));
2105                                              state.mode = TABLE;
2106                                              break;
2107                                          case 3:
2108                                              strm.msg = 'invalid block type';
2109                                              state.mode = BAD;
2110                                      }
2111                                      //--- DROPBITS(2) ---//
2112                                      hold >>>= 2;
2113                                      bits -= 2;
2114                                      //---//
2115                                      break;
2116                                  case STORED:
2117                                      //--- BYTEBITS() ---// /* go to byte boundary */
2118                                      hold >>>= bits & 7;
2119                                      bits -= bits & 7;
2120                                      //---//
2121                                      //=== NEEDBITS(32); */
2122                                      while ( bits < 32 ) {
2123                                          if ( have === 0 ) {
2124                                              break inf_leave;
2125                                          }
2126                                          have--;
2127                                          hold += input[ next++ ] << bits;
2128                                          bits += 8;
2129                                      }
2130                                      //===//
2131                                      if (
2132                                          ( hold & 0xffff ) !==
2133                                          ( ( hold >>> 16 ) ^ 0xffff )
2134                                      ) {
2135                                          strm.msg =
2136                                              'invalid stored block lengths';
2137                                          state.mode = BAD;
2138                                          break;
2139                                      }
2140                                      state.length = hold & 0xffff;
2141                                      //Tracev((stderr, "inflate:       stored length %u\n",
2142                                      //        state.length));
2143                                      //=== INITBITS();
2144                                      hold = 0;
2145                                      bits = 0;
2146                                      //===//
2147                                      state.mode = COPY_;
2148                                      if ( flush === Z_TREES ) {
2149                                          break inf_leave;
2150                                      }
2151                                  /* falls through */
2152                                  case COPY_:
2153                                      state.mode = COPY;
2154                                  /* falls through */
2155                                  case COPY:
2156                                      copy = state.length;
2157                                      if ( copy ) {
2158                                          if ( copy > have ) {
2159                                              copy = have;
2160                                          }
2161                                          if ( copy > left ) {
2162                                              copy = left;
2163                                          }
2164                                          if ( copy === 0 ) {
2165                                              break inf_leave;
2166                                          }
2167                                          //--- zmemcpy(put, next, copy); ---
2168                                          utils.arraySet(
2169                                              output,
2170                                              input,
2171                                              next,
2172                                              copy,
2173                                              put
2174                                          );
2175                                          //---//
2176                                          have -= copy;
2177                                          next += copy;
2178                                          left -= copy;
2179                                          put += copy;
2180                                          state.length -= copy;
2181                                          break;
2182                                      }
2183                                      //Tracev((stderr, "inflate:       stored end\n"));
2184                                      state.mode = TYPE;
2185                                      break;
2186                                  case TABLE:
2187                                      //=== NEEDBITS(14); */
2188                                      while ( bits < 14 ) {
2189                                          if ( have === 0 ) {
2190                                              break inf_leave;
2191                                          }
2192                                          have--;
2193                                          hold += input[ next++ ] << bits;
2194                                          bits += 8;
2195                                      }
2196                                      //===//
2197                                      state.nlen =
2198                                          ( hold & 0x1f ) /*BITS(5)*/ + 257;
2199                                      //--- DROPBITS(5) ---//
2200                                      hold >>>= 5;
2201                                      bits -= 5;
2202                                      //---//
2203                                      state.ndist =
2204                                          ( hold & 0x1f ) /*BITS(5)*/ + 1;
2205                                      //--- DROPBITS(5) ---//
2206                                      hold >>>= 5;
2207                                      bits -= 5;
2208                                      //---//
2209                                      state.ncode =
2210                                          ( hold & 0x0f ) /*BITS(4)*/ + 4;
2211                                      //--- DROPBITS(4) ---//
2212                                      hold >>>= 4;
2213                                      bits -= 4;
2214                                      //---//
2215                                      //#ifndef PKZIP_BUG_WORKAROUND
2216                                      if (
2217                                          state.nlen > 286 ||
2218                                          state.ndist > 30
2219                                      ) {
2220                                          strm.msg =
2221                                              'too many length or distance symbols';
2222                                          state.mode = BAD;
2223                                          break;
2224                                      }
2225                                      //#endif
2226                                      //Tracev((stderr, "inflate:       table sizes ok\n"));
2227                                      state.have = 0;
2228                                      state.mode = LENLENS;
2229                                  /* falls through */
2230                                  case LENLENS:
2231                                      while ( state.have < state.ncode ) {
2232                                          //=== NEEDBITS(3);
2233                                          while ( bits < 3 ) {
2234                                              if ( have === 0 ) {
2235                                                  break inf_leave;
2236                                              }
2237                                              have--;
2238                                              hold += input[ next++ ] << bits;
2239                                              bits += 8;
2240                                          }
2241                                          //===//
2242                                          state.lens[ order[ state.have++ ] ] =
2243                                              hold & 0x07; //BITS(3);
2244                                          //--- DROPBITS(3) ---//
2245                                          hold >>>= 3;
2246                                          bits -= 3;
2247                                          //---//
2248                                      }
2249                                      while ( state.have < 19 ) {
2250                                          state.lens[ order[ state.have++ ] ] = 0;
2251                                      }
2252                                      // We have separate tables & no pointers. 2 commented lines below not needed.
2253                                      //state.next = state.codes;
2254                                      //state.lencode = state.next;
2255                                      // Switch to use dynamic table
2256                                      state.lencode = state.lendyn;
2257                                      state.lenbits = 7;
2258  
2259                                      opts = { bits: state.lenbits };
2260                                      ret = inflate_table(
2261                                          CODES,
2262                                          state.lens,
2263                                          0,
2264                                          19,
2265                                          state.lencode,
2266                                          0,
2267                                          state.work,
2268                                          opts
2269                                      );
2270                                      state.lenbits = opts.bits;
2271  
2272                                      if ( ret ) {
2273                                          strm.msg = 'invalid code lengths set';
2274                                          state.mode = BAD;
2275                                          break;
2276                                      }
2277                                      //Tracev((stderr, "inflate:       code lengths ok\n"));
2278                                      state.have = 0;
2279                                      state.mode = CODELENS;
2280                                  /* falls through */
2281                                  case CODELENS:
2282                                      while (
2283                                          state.have <
2284                                          state.nlen + state.ndist
2285                                      ) {
2286                                          for (;;) {
2287                                              here =
2288                                                  state.lencode[
2289                                                      hold &
2290                                                          ( ( 1 <<
2291                                                              state.lenbits ) -
2292                                                              1 )
2293                                                  ]; /*BITS(state.lenbits)*/
2294                                              here_bits = here >>> 24;
2295                                              here_op = ( here >>> 16 ) & 0xff;
2296                                              here_val = here & 0xffff;
2297  
2298                                              if ( here_bits <= bits ) {
2299                                                  break;
2300                                              }
2301                                              //--- PULLBYTE() ---//
2302                                              if ( have === 0 ) {
2303                                                  break inf_leave;
2304                                              }
2305                                              have--;
2306                                              hold += input[ next++ ] << bits;
2307                                              bits += 8;
2308                                              //---//
2309                                          }
2310                                          if ( here_val < 16 ) {
2311                                              //--- DROPBITS(here.bits) ---//
2312                                              hold >>>= here_bits;
2313                                              bits -= here_bits;
2314                                              //---//
2315                                              state.lens[ state.have++ ] =
2316                                                  here_val;
2317                                          } else {
2318                                              if ( here_val === 16 ) {
2319                                                  //=== NEEDBITS(here.bits + 2);
2320                                                  n = here_bits + 2;
2321                                                  while ( bits < n ) {
2322                                                      if ( have === 0 ) {
2323                                                          break inf_leave;
2324                                                      }
2325                                                      have--;
2326                                                      hold +=
2327                                                          input[ next++ ] << bits;
2328                                                      bits += 8;
2329                                                  }
2330                                                  //===//
2331                                                  //--- DROPBITS(here.bits) ---//
2332                                                  hold >>>= here_bits;
2333                                                  bits -= here_bits;
2334                                                  //---//
2335                                                  if ( state.have === 0 ) {
2336                                                      strm.msg =
2337                                                          'invalid bit length repeat';
2338                                                      state.mode = BAD;
2339                                                      break;
2340                                                  }
2341                                                  len =
2342                                                      state.lens[
2343                                                          state.have - 1
2344                                                      ];
2345                                                  copy = 3 + ( hold & 0x03 ); //BITS(2);
2346                                                  //--- DROPBITS(2) ---//
2347                                                  hold >>>= 2;
2348                                                  bits -= 2;
2349                                                  //---//
2350                                              } else if ( here_val === 17 ) {
2351                                                  //=== NEEDBITS(here.bits + 3);
2352                                                  n = here_bits + 3;
2353                                                  while ( bits < n ) {
2354                                                      if ( have === 0 ) {
2355                                                          break inf_leave;
2356                                                      }
2357                                                      have--;
2358                                                      hold +=
2359                                                          input[ next++ ] << bits;
2360                                                      bits += 8;
2361                                                  }
2362                                                  //===//
2363                                                  //--- DROPBITS(here.bits) ---//
2364                                                  hold >>>= here_bits;
2365                                                  bits -= here_bits;
2366                                                  //---//
2367                                                  len = 0;
2368                                                  copy = 3 + ( hold & 0x07 ); //BITS(3);
2369                                                  //--- DROPBITS(3) ---//
2370                                                  hold >>>= 3;
2371                                                  bits -= 3;
2372                                                  //---//
2373                                              } else {
2374                                                  //=== NEEDBITS(here.bits + 7);
2375                                                  n = here_bits + 7;
2376                                                  while ( bits < n ) {
2377                                                      if ( have === 0 ) {
2378                                                          break inf_leave;
2379                                                      }
2380                                                      have--;
2381                                                      hold +=
2382                                                          input[ next++ ] << bits;
2383                                                      bits += 8;
2384                                                  }
2385                                                  //===//
2386                                                  //--- DROPBITS(here.bits) ---//
2387                                                  hold >>>= here_bits;
2388                                                  bits -= here_bits;
2389                                                  //---//
2390                                                  len = 0;
2391                                                  copy = 11 + ( hold & 0x7f ); //BITS(7);
2392                                                  //--- DROPBITS(7) ---//
2393                                                  hold >>>= 7;
2394                                                  bits -= 7;
2395                                                  //---//
2396                                              }
2397                                              if (
2398                                                  state.have + copy >
2399                                                  state.nlen + state.ndist
2400                                              ) {
2401                                                  strm.msg =
2402                                                      'invalid bit length repeat';
2403                                                  state.mode = BAD;
2404                                                  break;
2405                                              }
2406                                              while ( copy-- ) {
2407                                                  state.lens[ state.have++ ] =
2408                                                      len;
2409                                              }
2410                                          }
2411                                      }
2412  
2413                                      /* handle error breaks in while */
2414                                      if ( state.mode === BAD ) {
2415                                          break;
2416                                      }
2417  
2418                                      /* check for end-of-block code (better have one) */
2419                                      if ( state.lens[ 256 ] === 0 ) {
2420                                          strm.msg =
2421                                              'invalid code -- missing end-of-block';
2422                                          state.mode = BAD;
2423                                          break;
2424                                      }
2425  
2426                                      /* build code tables -- note: do not change the lenbits or distbits
2427               values here (9 and 6) without reading the comments in inftrees.h
2428               concerning the ENOUGH constants, which depend on those values */
2429                                      state.lenbits = 9;
2430  
2431                                      opts = { bits: state.lenbits };
2432                                      ret = inflate_table(
2433                                          LENS,
2434                                          state.lens,
2435                                          0,
2436                                          state.nlen,
2437                                          state.lencode,
2438                                          0,
2439                                          state.work,
2440                                          opts
2441                                      );
2442                                      // We have separate tables & no pointers. 2 commented lines below not needed.
2443                                      // state.next_index = opts.table_index;
2444                                      state.lenbits = opts.bits;
2445                                      // state.lencode = state.next;
2446  
2447                                      if ( ret ) {
2448                                          strm.msg =
2449                                              'invalid literal/lengths set';
2450                                          state.mode = BAD;
2451                                          break;
2452                                      }
2453  
2454                                      state.distbits = 6;
2455                                      //state.distcode.copy(state.codes);
2456                                      // Switch to use dynamic table
2457                                      state.distcode = state.distdyn;
2458                                      opts = { bits: state.distbits };
2459                                      ret = inflate_table(
2460                                          DISTS,
2461                                          state.lens,
2462                                          state.nlen,
2463                                          state.ndist,
2464                                          state.distcode,
2465                                          0,
2466                                          state.work,
2467                                          opts
2468                                      );
2469                                      // We have separate tables & no pointers. 2 commented lines below not needed.
2470                                      // state.next_index = opts.table_index;
2471                                      state.distbits = opts.bits;
2472                                      // state.distcode = state.next;
2473  
2474                                      if ( ret ) {
2475                                          strm.msg = 'invalid distances set';
2476                                          state.mode = BAD;
2477                                          break;
2478                                      }
2479                                      //Tracev((stderr, 'inflate:       codes ok\n'));
2480                                      state.mode = LEN_;
2481                                      if ( flush === Z_TREES ) {
2482                                          break inf_leave;
2483                                      }
2484                                  /* falls through */
2485                                  case LEN_:
2486                                      state.mode = LEN;
2487                                  /* falls through */
2488                                  case LEN:
2489                                      if ( have >= 6 && left >= 258 ) {
2490                                          //--- RESTORE() ---
2491                                          strm.next_out = put;
2492                                          strm.avail_out = left;
2493                                          strm.next_in = next;
2494                                          strm.avail_in = have;
2495                                          state.hold = hold;
2496                                          state.bits = bits;
2497                                          //---
2498                                          inflate_fast( strm, _out );
2499                                          //--- LOAD() ---
2500                                          put = strm.next_out;
2501                                          output = strm.output;
2502                                          left = strm.avail_out;
2503                                          next = strm.next_in;
2504                                          input = strm.input;
2505                                          have = strm.avail_in;
2506                                          hold = state.hold;
2507                                          bits = state.bits;
2508                                          //---
2509  
2510                                          if ( state.mode === TYPE ) {
2511                                              state.back = -1;
2512                                          }
2513                                          break;
2514                                      }
2515                                      state.back = 0;
2516                                      for (;;) {
2517                                          here =
2518                                              state.lencode[
2519                                                  hold &
2520                                                      ( ( 1 << state.lenbits ) -
2521                                                          1 )
2522                                              ]; /*BITS(state.lenbits)*/
2523                                          here_bits = here >>> 24;
2524                                          here_op = ( here >>> 16 ) & 0xff;
2525                                          here_val = here & 0xffff;
2526  
2527                                          if ( here_bits <= bits ) {
2528                                              break;
2529                                          }
2530                                          //--- PULLBYTE() ---//
2531                                          if ( have === 0 ) {
2532                                              break inf_leave;
2533                                          }
2534                                          have--;
2535                                          hold += input[ next++ ] << bits;
2536                                          bits += 8;
2537                                          //---//
2538                                      }
2539                                      if ( here_op && ( here_op & 0xf0 ) === 0 ) {
2540                                          last_bits = here_bits;
2541                                          last_op = here_op;
2542                                          last_val = here_val;
2543                                          for (;;) {
2544                                              here =
2545                                                  state.lencode[
2546                                                      last_val +
2547                                                          ( ( hold &
2548                                                              ( ( 1 <<
2549                                                                  ( last_bits +
2550                                                                      last_op ) ) -
2551                                                                  1 ) ) /*BITS(last.bits + last.op)*/ >>
2552                                                              last_bits )
2553                                                  ];
2554                                              here_bits = here >>> 24;
2555                                              here_op = ( here >>> 16 ) & 0xff;
2556                                              here_val = here & 0xffff;
2557  
2558                                              if (
2559                                                  last_bits + here_bits <=
2560                                                  bits
2561                                              ) {
2562                                                  break;
2563                                              }
2564                                              //--- PULLBYTE() ---//
2565                                              if ( have === 0 ) {
2566                                                  break inf_leave;
2567                                              }
2568                                              have--;
2569                                              hold += input[ next++ ] << bits;
2570                                              bits += 8;
2571                                              //---//
2572                                          }
2573                                          //--- DROPBITS(last.bits) ---//
2574                                          hold >>>= last_bits;
2575                                          bits -= last_bits;
2576                                          //---//
2577                                          state.back += last_bits;
2578                                      }
2579                                      //--- DROPBITS(here.bits) ---//
2580                                      hold >>>= here_bits;
2581                                      bits -= here_bits;
2582                                      //---//
2583                                      state.back += here_bits;
2584                                      state.length = here_val;
2585                                      if ( here_op === 0 ) {
2586                                          //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
2587                                          //        "inflate:         literal '%c'\n" :
2588                                          //        "inflate:         literal 0x%02x\n", here.val));
2589                                          state.mode = LIT;
2590                                          break;
2591                                      }
2592                                      if ( here_op & 32 ) {
2593                                          //Tracevv((stderr, "inflate:         end of block\n"));
2594                                          state.back = -1;
2595                                          state.mode = TYPE;
2596                                          break;
2597                                      }
2598                                      if ( here_op & 64 ) {
2599                                          strm.msg =
2600                                              'invalid literal/length code';
2601                                          state.mode = BAD;
2602                                          break;
2603                                      }
2604                                      state.extra = here_op & 15;
2605                                      state.mode = LENEXT;
2606                                  /* falls through */
2607                                  case LENEXT:
2608                                      if ( state.extra ) {
2609                                          //=== NEEDBITS(state.extra);
2610                                          n = state.extra;
2611                                          while ( bits < n ) {
2612                                              if ( have === 0 ) {
2613                                                  break inf_leave;
2614                                              }
2615                                              have--;
2616                                              hold += input[ next++ ] << bits;
2617                                              bits += 8;
2618                                          }
2619                                          //===//
2620                                          state.length +=
2621                                              hold &
2622                                              ( ( 1 << state.extra ) -
2623                                                  1 ) /*BITS(state.extra)*/;
2624                                          //--- DROPBITS(state.extra) ---//
2625                                          hold >>>= state.extra;
2626                                          bits -= state.extra;
2627                                          //---//
2628                                          state.back += state.extra;
2629                                      }
2630                                      //Tracevv((stderr, "inflate:         length %u\n", state.length));
2631                                      state.was = state.length;
2632                                      state.mode = DIST;
2633                                  /* falls through */
2634                                  case DIST:
2635                                      for (;;) {
2636                                          here =
2637                                              state.distcode[
2638                                                  hold &
2639                                                      ( ( 1 << state.distbits ) -
2640                                                          1 )
2641                                              ]; /*BITS(state.distbits)*/
2642                                          here_bits = here >>> 24;
2643                                          here_op = ( here >>> 16 ) & 0xff;
2644                                          here_val = here & 0xffff;
2645  
2646                                          if ( here_bits <= bits ) {
2647                                              break;
2648                                          }
2649                                          //--- PULLBYTE() ---//
2650                                          if ( have === 0 ) {
2651                                              break inf_leave;
2652                                          }
2653                                          have--;
2654                                          hold += input[ next++ ] << bits;
2655                                          bits += 8;
2656                                          //---//
2657                                      }
2658                                      if ( ( here_op & 0xf0 ) === 0 ) {
2659                                          last_bits = here_bits;
2660                                          last_op = here_op;
2661                                          last_val = here_val;
2662                                          for (;;) {
2663                                              here =
2664                                                  state.distcode[
2665                                                      last_val +
2666                                                          ( ( hold &
2667                                                              ( ( 1 <<
2668                                                                  ( last_bits +
2669                                                                      last_op ) ) -
2670                                                                  1 ) ) /*BITS(last.bits + last.op)*/ >>
2671                                                              last_bits )
2672                                                  ];
2673                                              here_bits = here >>> 24;
2674                                              here_op = ( here >>> 16 ) & 0xff;
2675                                              here_val = here & 0xffff;
2676  
2677                                              if (
2678                                                  last_bits + here_bits <=
2679                                                  bits
2680                                              ) {
2681                                                  break;
2682                                              }
2683                                              //--- PULLBYTE() ---//
2684                                              if ( have === 0 ) {
2685                                                  break inf_leave;
2686                                              }
2687                                              have--;
2688                                              hold += input[ next++ ] << bits;
2689                                              bits += 8;
2690                                              //---//
2691                                          }
2692                                          //--- DROPBITS(last.bits) ---//
2693                                          hold >>>= last_bits;
2694                                          bits -= last_bits;
2695                                          //---//
2696                                          state.back += last_bits;
2697                                      }
2698                                      //--- DROPBITS(here.bits) ---//
2699                                      hold >>>= here_bits;
2700                                      bits -= here_bits;
2701                                      //---//
2702                                      state.back += here_bits;
2703                                      if ( here_op & 64 ) {
2704                                          strm.msg = 'invalid distance code';
2705                                          state.mode = BAD;
2706                                          break;
2707                                      }
2708                                      state.offset = here_val;
2709                                      state.extra = here_op & 15;
2710                                      state.mode = DISTEXT;
2711                                  /* falls through */
2712                                  case DISTEXT:
2713                                      if ( state.extra ) {
2714                                          //=== NEEDBITS(state.extra);
2715                                          n = state.extra;
2716                                          while ( bits < n ) {
2717                                              if ( have === 0 ) {
2718                                                  break inf_leave;
2719                                              }
2720                                              have--;
2721                                              hold += input[ next++ ] << bits;
2722                                              bits += 8;
2723                                          }
2724                                          //===//
2725                                          state.offset +=
2726                                              hold &
2727                                              ( ( 1 << state.extra ) -
2728                                                  1 ) /*BITS(state.extra)*/;
2729                                          //--- DROPBITS(state.extra) ---//
2730                                          hold >>>= state.extra;
2731                                          bits -= state.extra;
2732                                          //---//
2733                                          state.back += state.extra;
2734                                      }
2735                                      //#ifdef INFLATE_STRICT
2736                                      if ( state.offset > state.dmax ) {
2737                                          strm.msg =
2738                                              'invalid distance too far back';
2739                                          state.mode = BAD;
2740                                          break;
2741                                      }
2742                                      //#endif
2743                                      //Tracevv((stderr, "inflate:         distance %u\n", state.offset));
2744                                      state.mode = MATCH;
2745                                  /* falls through */
2746                                  case MATCH:
2747                                      if ( left === 0 ) {
2748                                          break inf_leave;
2749                                      }
2750                                      copy = _out - left;
2751                                      if ( state.offset > copy ) {
2752                                          /* copy from window */
2753                                          copy = state.offset - copy;
2754                                          if ( copy > state.whave ) {
2755                                              if ( state.sane ) {
2756                                                  strm.msg =
2757                                                      'invalid distance too far back';
2758                                                  state.mode = BAD;
2759                                                  break;
2760                                              }
2761                                              // (!) This block is disabled in zlib defaults,
2762                                              // don't enable it for binary compatibility
2763                                              //#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
2764                                              //          Trace((stderr, "inflate.c too far\n"));
2765                                              //          copy -= state.whave;
2766                                              //          if (copy > state.length) { copy = state.length; }
2767                                              //          if (copy > left) { copy = left; }
2768                                              //          left -= copy;
2769                                              //          state.length -= copy;
2770                                              //          do {
2771                                              //            output[put++] = 0;
2772                                              //          } while (--copy);
2773                                              //          if (state.length === 0) { state.mode = LEN; }
2774                                              //          break;
2775                                              //#endif
2776                                          }
2777                                          if ( copy > state.wnext ) {
2778                                              copy -= state.wnext;
2779                                              from = state.wsize - copy;
2780                                          } else {
2781                                              from = state.wnext - copy;
2782                                          }
2783                                          if ( copy > state.length ) {
2784                                              copy = state.length;
2785                                          }
2786                                          from_source = state.window;
2787                                      } else {
2788                                          /* copy from output */
2789                                          from_source = output;
2790                                          from = put - state.offset;
2791                                          copy = state.length;
2792                                      }
2793                                      if ( copy > left ) {
2794                                          copy = left;
2795                                      }
2796                                      left -= copy;
2797                                      state.length -= copy;
2798                                      do {
2799                                          output[ put++ ] = from_source[ from++ ];
2800                                      } while ( --copy );
2801                                      if ( state.length === 0 ) {
2802                                          state.mode = LEN;
2803                                      }
2804                                      break;
2805                                  case LIT:
2806                                      if ( left === 0 ) {
2807                                          break inf_leave;
2808                                      }
2809                                      output[ put++ ] = state.length;
2810                                      left--;
2811                                      state.mode = LEN;
2812                                      break;
2813                                  case CHECK:
2814                                      if ( state.wrap ) {
2815                                          //=== NEEDBITS(32);
2816                                          while ( bits < 32 ) {
2817                                              if ( have === 0 ) {
2818                                                  break inf_leave;
2819                                              }
2820                                              have--;
2821                                              // Use '|' instead of '+' to make sure that result is signed
2822                                              hold |= input[ next++ ] << bits;
2823                                              bits += 8;
2824                                          }
2825                                          //===//
2826                                          _out -= left;
2827                                          strm.total_out += _out;
2828                                          state.total += _out;
2829                                          if ( _out ) {
2830                                              strm.adler = state.check =
2831                                                  /*UPDATE(state.check, put - _out, _out);*/
2832                                                  state.flags
2833                                                      ? crc32(
2834                                                              state.check,
2835                                                              output,
2836                                                              _out,
2837                                                              put - _out
2838                                                        )
2839                                                      : adler32(
2840                                                              state.check,
2841                                                              output,
2842                                                              _out,
2843                                                              put - _out
2844                                                        );
2845                                          }
2846                                          _out = left;
2847                                          // NB: crc32 stored as signed 32-bit int, zswap32 returns signed too
2848                                          if (
2849                                              ( state.flags
2850                                                  ? hold
2851                                                  : zswap32( hold ) ) !==
2852                                              state.check
2853                                          ) {
2854                                              strm.msg = 'incorrect data check';
2855                                              state.mode = BAD;
2856                                              break;
2857                                          }
2858                                          //=== INITBITS();
2859                                          hold = 0;
2860                                          bits = 0;
2861                                          //===//
2862                                          //Tracev((stderr, "inflate:   check matches trailer\n"));
2863                                      }
2864                                      state.mode = LENGTH;
2865                                  /* falls through */
2866                                  case LENGTH:
2867                                      if ( state.wrap && state.flags ) {
2868                                          //=== NEEDBITS(32);
2869                                          while ( bits < 32 ) {
2870                                              if ( have === 0 ) {
2871                                                  break inf_leave;
2872                                              }
2873                                              have--;
2874                                              hold += input[ next++ ] << bits;
2875                                              bits += 8;
2876                                          }
2877                                          //===//
2878                                          if (
2879                                              hold !==
2880                                              ( state.total & 0xffffffff )
2881                                          ) {
2882                                              strm.msg = 'incorrect length check';
2883                                              state.mode = BAD;
2884                                              break;
2885                                          }
2886                                          //=== INITBITS();
2887                                          hold = 0;
2888                                          bits = 0;
2889                                          //===//
2890                                          //Tracev((stderr, "inflate:   length matches trailer\n"));
2891                                      }
2892                                      state.mode = DONE;
2893                                  /* falls through */
2894                                  case DONE:
2895                                      ret = Z_STREAM_END;
2896                                      break inf_leave;
2897                                  case BAD:
2898                                      ret = Z_DATA_ERROR;
2899                                      break inf_leave;
2900                                  case MEM:
2901                                      return Z_MEM_ERROR;
2902                                  case SYNC:
2903                                  /* falls through */
2904                                  default:
2905                                      return Z_STREAM_ERROR;
2906                              }
2907                          }
2908  
2909                          // inf_leave <- here is real place for "goto inf_leave", emulated via "break inf_leave"
2910  
2911                          /*
2912         Return from inflate(), updating the total counts and the check value.
2913         If there was no progress during the inflate() call, return a buffer
2914         error.  Call updatewindow() to create and/or update the window state.
2915         Note: a memory error from inflate() is non-recoverable.
2916       */
2917  
2918                          //--- RESTORE() ---
2919                          strm.next_out = put;
2920                          strm.avail_out = left;
2921                          strm.next_in = next;
2922                          strm.avail_in = have;
2923                          state.hold = hold;
2924                          state.bits = bits;
2925                          //---
2926  
2927                          if (
2928                              state.wsize ||
2929                              ( _out !== strm.avail_out &&
2930                                  state.mode < BAD &&
2931                                  ( state.mode < CHECK || flush !== Z_FINISH ) )
2932                          ) {
2933                              if (
2934                                  updatewindow(
2935                                      strm,
2936                                      strm.output,
2937                                      strm.next_out,
2938                                      _out - strm.avail_out
2939                                  )
2940                              ) {
2941                                  state.mode = MEM;
2942                                  return Z_MEM_ERROR;
2943                              }
2944                          }
2945                          _in -= strm.avail_in;
2946                          _out -= strm.avail_out;
2947                          strm.total_in += _in;
2948                          strm.total_out += _out;
2949                          state.total += _out;
2950                          if ( state.wrap && _out ) {
2951                              strm.adler = state.check =
2952                                  /*UPDATE(state.check, strm.next_out - _out, _out);*/
2953                                  state.flags
2954                                      ? crc32(
2955                                              state.check,
2956                                              output,
2957                                              _out,
2958                                              strm.next_out - _out
2959                                        )
2960                                      : adler32(
2961                                              state.check,
2962                                              output,
2963                                              _out,
2964                                              strm.next_out - _out
2965                                        );
2966                          }
2967                          strm.data_type =
2968                              state.bits +
2969                              ( state.last ? 64 : 0 ) +
2970                              ( state.mode === TYPE ? 128 : 0 ) +
2971                              ( state.mode === LEN_ || state.mode === COPY_
2972                                  ? 256
2973                                  : 0 );
2974                          if (
2975                              ( ( _in === 0 && _out === 0 ) ||
2976                                  flush === Z_FINISH ) &&
2977                              ret === Z_OK
2978                          ) {
2979                              ret = Z_BUF_ERROR;
2980                          }
2981                          return ret;
2982                      }
2983  
2984  					function inflateEnd( strm ) {
2985                          if (
2986                              ! strm ||
2987                              ! strm.state /*|| strm->zfree == (free_func)0*/
2988                          ) {
2989                              return Z_STREAM_ERROR;
2990                          }
2991  
2992                          var state = strm.state;
2993                          if ( state.window ) {
2994                              state.window = null;
2995                          }
2996                          strm.state = null;
2997                          return Z_OK;
2998                      }
2999  
3000  					function inflateGetHeader( strm, head ) {
3001                          var state;
3002  
3003                          /* check state */
3004                          if ( ! strm || ! strm.state ) {
3005                              return Z_STREAM_ERROR;
3006                          }
3007                          state = strm.state;
3008                          if ( ( state.wrap & 2 ) === 0 ) {
3009                              return Z_STREAM_ERROR;
3010                          }
3011  
3012                          /* save header structure */
3013                          state.head = head;
3014                          head.done = false;
3015                          return Z_OK;
3016                      }
3017  
3018  					function inflateSetDictionary( strm, dictionary ) {
3019                          var dictLength = dictionary.length;
3020  
3021                          var state;
3022                          var dictid;
3023                          var ret;
3024  
3025                          /* check state */
3026                          if (
3027                              ! strm /* == Z_NULL */ ||
3028                              ! strm.state /* == Z_NULL */
3029                          ) {
3030                              return Z_STREAM_ERROR;
3031                          }
3032                          state = strm.state;
3033  
3034                          if ( state.wrap !== 0 && state.mode !== DICT ) {
3035                              return Z_STREAM_ERROR;
3036                          }
3037  
3038                          /* check for correct dictionary identifier */
3039                          if ( state.mode === DICT ) {
3040                              dictid = 1; /* adler32(0, null, 0)*/
3041                              /* dictid = adler32(dictid, dictionary, dictLength); */
3042                              dictid = adler32(
3043                                  dictid,
3044                                  dictionary,
3045                                  dictLength,
3046                                  0
3047                              );
3048                              if ( dictid !== state.check ) {
3049                                  return Z_DATA_ERROR;
3050                              }
3051                          }
3052                          /* copy dictionary to window using updatewindow(), which will amend the
3053       existing dictionary if appropriate */
3054                          ret = updatewindow(
3055                              strm,
3056                              dictionary,
3057                              dictLength,
3058                              dictLength
3059                          );
3060                          if ( ret ) {
3061                              state.mode = MEM;
3062                              return Z_MEM_ERROR;
3063                          }
3064                          state.havedict = 1;
3065                          // Tracev((stderr, "inflate:   dictionary set\n"));
3066                          return Z_OK;
3067                      }
3068  
3069                      exports.inflateReset = inflateReset;
3070                      exports.inflateReset2 = inflateReset2;
3071                      exports.inflateResetKeep = inflateResetKeep;
3072                      exports.inflateInit = inflateInit;
3073                      exports.inflateInit2 = inflateInit2;
3074                      exports.inflate = inflate;
3075                      exports.inflateEnd = inflateEnd;
3076                      exports.inflateGetHeader = inflateGetHeader;
3077                      exports.inflateSetDictionary = inflateSetDictionary;
3078                      exports.inflateInfo = 'pako inflate (from Nodeca project)';
3079  
3080                      /* Not implemented
3081    exports.inflateCopy = inflateCopy;
3082    exports.inflateGetDictionary = inflateGetDictionary;
3083    exports.inflateMark = inflateMark;
3084    exports.inflatePrime = inflatePrime;
3085    exports.inflateSync = inflateSync;
3086    exports.inflateSyncPoint = inflateSyncPoint;
3087    exports.inflateUndermine = inflateUndermine;
3088    */
3089                  },
3090                  {
3091                      '../utils/common': 1,
3092                      './adler32': 3,
3093                      './crc32': 5,
3094                      './inffast': 7,
3095                      './inftrees': 9,
3096                  },
3097              ],
3098              9: [
3099                  function ( require, module, exports ) {
3100                      'use strict';
3101  
3102                      // (C) 1995-2013 Jean-loup Gailly and Mark Adler
3103                      // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
3104                      //
3105                      // This software is provided 'as-is', without any express or implied
3106                      // warranty. In no event will the authors be held liable for any damages
3107                      // arising from the use of this software.
3108                      //
3109                      // Permission is granted to anyone to use this software for any purpose,
3110                      // including commercial applications, and to alter it and redistribute it
3111                      // freely, subject to the following restrictions:
3112                      //
3113                      // 1. The origin of this software must not be misrepresented; you must not
3114                      //   claim that you wrote the original software. If you use this software
3115                      //   in a product, an acknowledgment in the product documentation would be
3116                      //   appreciated but is not required.
3117                      // 2. Altered source versions must be plainly marked as such, and must not be
3118                      //   misrepresented as being the original software.
3119                      // 3. This notice may not be removed or altered from any source distribution.
3120  
3121                      var utils = require( '../utils/common' );
3122  
3123                      var MAXBITS = 15;
3124                      var ENOUGH_LENS = 852;
3125                      var ENOUGH_DISTS = 592;
3126                      //var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
3127  
3128                      var CODES = 0;
3129                      var LENS = 1;
3130                      var DISTS = 2;
3131  
3132                      var lbase = [
3133                          /* Length codes 257..285 base */ 3, 4, 5, 6, 7, 8, 9,
3134                          10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67,
3135                          83, 99, 115, 131, 163, 195, 227, 258, 0, 0,
3136                      ];
3137  
3138                      var lext = [
3139                          /* Length codes 257..285 extra */ 16, 16, 16, 16, 16,
3140                          16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19,
3141                          19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78,
3142                      ];
3143  
3144                      var dbase = [
3145                          /* Distance codes 0..29 base */ 1, 2, 3, 4, 5, 7, 9, 13,
3146                          17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769,
3147                          1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385,
3148                          24577, 0, 0,
3149                      ];
3150  
3151                      var dext = [
3152                          /* Distance codes 0..29 extra */ 16, 16, 16, 16, 17, 17,
3153                          18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24,
3154                          25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 64, 64,
3155                      ];
3156  
3157                      module.exports = function inflate_table(
3158                          type,
3159                          lens,
3160                          lens_index,
3161                          codes,
3162                          table,
3163                          table_index,
3164                          work,
3165                          opts
3166                      ) {
3167                          var bits = opts.bits;
3168                          //here = opts.here; /* table entry for duplication */
3169  
3170                          var len = 0; /* a code's length in bits */
3171                          var sym = 0; /* index of code symbols */
3172                          var min = 0,
3173                              max = 0; /* minimum and maximum code lengths */
3174                          var root = 0; /* number of index bits for root table */
3175                          var curr = 0; /* number of index bits for current table */
3176                          var drop = 0; /* code bits to drop for sub-table */
3177                          var left = 0; /* number of prefix codes available */
3178                          var used = 0; /* code entries in table used */
3179                          var huff = 0; /* Huffman code */
3180                          var incr; /* for incrementing code, index */
3181                          var fill; /* index for replicating entries */
3182                          var low; /* low bits for current root entry */
3183                          var mask; /* mask for low root bits */
3184                          var next; /* next available space in table */
3185                          var base = null; /* base value table to use */
3186                          var base_index = 0;
3187                          //  var shoextra;    /* extra bits table to use */
3188                          var end; /* use base and extra for symbol > end */
3189                          var count = new utils.Buf16( MAXBITS + 1 ); //[MAXBITS+1];    /* number of codes of each length */
3190                          var offs = new utils.Buf16( MAXBITS + 1 ); //[MAXBITS+1];     /* offsets in table for each length */
3191                          var extra = null;
3192                          var extra_index = 0;
3193  
3194                          var here_bits, here_op, here_val;
3195  
3196                          /*
3197       Process a set of code lengths to create a canonical Huffman code.  The
3198       code lengths are lens[0..codes-1].  Each length corresponds to the
3199       symbols 0..codes-1.  The Huffman code is generated by first sorting the
3200       symbols by length from short to long, and retaining the symbol order
3201       for codes with equal lengths.  Then the code starts with all zero bits
3202       for the first code of the shortest length, and the codes are integer
3203       increments for the same length, and zeros are appended as the length
3204       increases.  For the deflate format, these bits are stored backwards
3205       from their more natural integer increment ordering, and so when the
3206       decoding tables are built in the large loop below, the integer codes
3207       are incremented backwards.
3208  
3209       This routine assumes, but does not check, that all of the entries in
3210       lens[] are in the range 0..MAXBITS.  The caller must assure this.
3211       1..MAXBITS is interpreted as that code length.  zero means that that
3212       symbol does not occur in this code.
3213  
3214       The codes are sorted by computing a count of codes for each length,
3215       creating from that a table of starting indices for each length in the
3216       sorted table, and then entering the symbols in order in the sorted
3217       table.  The sorted table is work[], with that space being provided by
3218       the caller.
3219  
3220       The length counts are used for other purposes as well, i.e. finding
3221       the minimum and maximum length codes, determining if there are any
3222       codes at all, checking for a valid set of lengths, and looking ahead
3223       at length counts to determine sub-table sizes when building the
3224       decoding tables.
3225       */
3226  
3227                          /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
3228                          for ( len = 0; len <= MAXBITS; len++ ) {
3229                              count[ len ] = 0;
3230                          }
3231                          for ( sym = 0; sym < codes; sym++ ) {
3232                              count[ lens[ lens_index + sym ] ]++;
3233                          }
3234  
3235                          /* bound code lengths, force root to be within code lengths */
3236                          root = bits;
3237                          for ( max = MAXBITS; max >= 1; max-- ) {
3238                              if ( count[ max ] !== 0 ) {
3239                                  break;
3240                              }
3241                          }
3242                          if ( root > max ) {
3243                              root = max;
3244                          }
3245                          if ( max === 0 ) {
3246                              /* no symbols to code at all */
3247                              //table.op[opts.table_index] = 64;  //here.op = (var char)64;    /* invalid code marker */
3248                              //table.bits[opts.table_index] = 1;   //here.bits = (var char)1;
3249                              //table.val[opts.table_index++] = 0;   //here.val = (var short)0;
3250                              table[ table_index++ ] =
3251                                  ( 1 << 24 ) | ( 64 << 16 ) | 0;
3252  
3253                              //table.op[opts.table_index] = 64;
3254                              //table.bits[opts.table_index] = 1;
3255                              //table.val[opts.table_index++] = 0;
3256                              table[ table_index++ ] =
3257                                  ( 1 << 24 ) | ( 64 << 16 ) | 0;
3258  
3259                              opts.bits = 1;
3260                              return 0; /* no symbols, but wait for decoding to report error */
3261                          }
3262                          for ( min = 1; min < max; min++ ) {
3263                              if ( count[ min ] !== 0 ) {
3264                                  break;
3265                              }
3266                          }
3267                          if ( root < min ) {
3268                              root = min;
3269                          }
3270  
3271                          /* check for an over-subscribed or incomplete set of lengths */
3272                          left = 1;
3273                          for ( len = 1; len <= MAXBITS; len++ ) {
3274                              left <<= 1;
3275                              left -= count[ len ];
3276                              if ( left < 0 ) {
3277                                  return -1;
3278                              } /* over-subscribed */
3279                          }
3280                          if ( left > 0 && ( type === CODES || max !== 1 ) ) {
3281                              return -1; /* incomplete set */
3282                          }
3283  
3284                          /* generate offsets into symbol table for each length for sorting */
3285                          offs[ 1 ] = 0;
3286                          for ( len = 1; len < MAXBITS; len++ ) {
3287                              offs[ len + 1 ] = offs[ len ] + count[ len ];
3288                          }
3289  
3290                          /* sort symbols by length, by symbol order within each length */
3291                          for ( sym = 0; sym < codes; sym++ ) {
3292                              if ( lens[ lens_index + sym ] !== 0 ) {
3293                                  work[ offs[ lens[ lens_index + sym ] ]++ ] =
3294                                      sym;
3295                              }
3296                          }
3297  
3298                          /*
3299       Create and fill in decoding tables.  In this loop, the table being
3300       filled is at next and has curr index bits.  The code being used is huff
3301       with length len.  That code is converted to an index by dropping drop
3302       bits off of the bottom.  For codes where len is less than drop + curr,
3303       those top drop + curr - len bits are incremented through all values to
3304       fill the table with replicated entries.
3305  
3306       root is the number of index bits for the root table.  When len exceeds
3307       root, sub-tables are created pointed to by the root entry with an index
3308       of the low root bits of huff.  This is saved in low to check for when a
3309       new sub-table should be started.  drop is zero when the root table is
3310       being filled, and drop is root when sub-tables are being filled.
3311  
3312       When a new sub-table is needed, it is necessary to look ahead in the
3313       code lengths to determine what size sub-table is needed.  The length
3314       counts are used for this, and so count[] is decremented as codes are
3315       entered in the tables.
3316  
3317       used keeps track of how many table entries have been allocated from the
3318       provided *table space.  It is checked for LENS and DIST tables against
3319       the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
3320       the initial root table size constants.  See the comments in inftrees.h
3321       for more information.
3322  
3323       sym increments through all symbols, and the loop terminates when
3324       all codes of length max, i.e. all codes, have been processed.  This
3325       routine permits incomplete codes, so another loop after this one fills
3326       in the rest of the decoding tables with invalid code markers.
3327       */
3328  
3329                          /* set up for code type */
3330                          // poor man optimization - use if-else instead of switch,
3331                          // to avoid deopts in old v8
3332                          if ( type === CODES ) {
3333                              base = extra = work; /* dummy value--not used */
3334                              end = 19;
3335                          } else if ( type === LENS ) {
3336                              base = lbase;
3337                              base_index -= 257;
3338                              extra = lext;
3339                              extra_index -= 257;
3340                              end = 256;
3341                          } else {
3342                              /* DISTS */
3343                              base = dbase;
3344                              extra = dext;
3345                              end = -1;
3346                          }
3347  
3348                          /* initialize opts for loop */
3349                          huff = 0; /* starting code */
3350                          sym = 0; /* starting code symbol */
3351                          len = min; /* starting code length */
3352                          next = table_index; /* current table to fill in */
3353                          curr = root; /* current table index bits */
3354                          drop = 0; /* current bits to drop from code for index */
3355                          low = -1; /* trigger new sub-table when len > root */
3356                          used = 1 << root; /* use root table entries */
3357                          mask = used - 1; /* mask for comparing low */
3358  
3359                          /* check available table space */
3360                          if (
3361                              ( type === LENS && used > ENOUGH_LENS ) ||
3362                              ( type === DISTS && used > ENOUGH_DISTS )
3363                          ) {
3364                              return 1;
3365                          }
3366  
3367                          /* process all codes and make table entries */
3368                          for (;;) {
3369                              /* create table entry */
3370                              here_bits = len - drop;
3371                              if ( work[ sym ] < end ) {
3372                                  here_op = 0;
3373                                  here_val = work[ sym ];
3374                              } else if ( work[ sym ] > end ) {
3375                                  here_op = extra[ extra_index + work[ sym ] ];
3376                                  here_val = base[ base_index + work[ sym ] ];
3377                              } else {
3378                                  here_op = 32 + 64; /* end of block */
3379                                  here_val = 0;
3380                              }
3381  
3382                              /* replicate for those indices with low len bits equal to huff */
3383                              incr = 1 << ( len - drop );
3384                              fill = 1 << curr;
3385                              min = fill; /* save offset to next table */
3386                              do {
3387                                  fill -= incr;
3388                                  table[ next + ( huff >> drop ) + fill ] =
3389                                      ( here_bits << 24 ) |
3390                                      ( here_op << 16 ) |
3391                                      here_val |
3392                                      0;
3393                              } while ( fill !== 0 );
3394  
3395                              /* backwards increment the len-bit code huff */
3396                              incr = 1 << ( len - 1 );
3397                              while ( huff & incr ) {
3398                                  incr >>= 1;
3399                              }
3400                              if ( incr !== 0 ) {
3401                                  huff &= incr - 1;
3402                                  huff += incr;
3403                              } else {
3404                                  huff = 0;
3405                              }
3406  
3407                              /* go to next symbol, update count, len */
3408                              sym++;
3409                              if ( --count[ len ] === 0 ) {
3410                                  if ( len === max ) {
3411                                      break;
3412                                  }
3413                                  len = lens[ lens_index + work[ sym ] ];
3414                              }
3415  
3416                              /* create new sub-table if needed */
3417                              if ( len > root && ( huff & mask ) !== low ) {
3418                                  /* if first time, transition to sub-tables */
3419                                  if ( drop === 0 ) {
3420                                      drop = root;
3421                                  }
3422  
3423                                  /* increment past last table */
3424                                  next += min; /* here min is 1 << curr */
3425  
3426                                  /* determine length of next table */
3427                                  curr = len - drop;
3428                                  left = 1 << curr;
3429                                  while ( curr + drop < max ) {
3430                                      left -= count[ curr + drop ];
3431                                      if ( left <= 0 ) {
3432                                          break;
3433                                      }
3434                                      curr++;
3435                                      left <<= 1;
3436                                  }
3437  
3438                                  /* check for enough space */
3439                                  used += 1 << curr;
3440                                  if (
3441                                      ( type === LENS && used > ENOUGH_LENS ) ||
3442                                      ( type === DISTS && used > ENOUGH_DISTS )
3443                                  ) {
3444                                      return 1;
3445                                  }
3446  
3447                                  /* point entry in root table to sub-table */
3448                                  low = huff & mask;
3449                                  /*table.op[low] = curr;
3450          table.bits[low] = root;
3451          table.val[low] = next - opts.table_index;*/
3452                                  table[ low ] =
3453                                      ( root << 24 ) |
3454                                      ( curr << 16 ) |
3455                                      ( next - table_index ) |
3456                                      0;
3457                              }
3458                          }
3459  
3460                          /* fill in remaining table entry if code is incomplete (guaranteed to have
3461       at most one remaining entry, since if the code is incomplete, the
3462       maximum code length that was allowed to get this far is one bit) */
3463                          if ( huff !== 0 ) {
3464                              //table.op[next + huff] = 64;            /* invalid code marker */
3465                              //table.bits[next + huff] = len - drop;
3466                              //table.val[next + huff] = 0;
3467                              table[ next + huff ] =
3468                                  ( ( len - drop ) << 24 ) | ( 64 << 16 ) | 0;
3469                          }
3470  
3471                          /* set return parameters */
3472                          //opts.table_index += used;
3473                          opts.bits = root;
3474                          return 0;
3475                      };
3476                  },
3477                  { '../utils/common': 1 },
3478              ],
3479              10: [
3480                  function ( require, module, exports ) {
3481                      'use strict';
3482  
3483                      // (C) 1995-2013 Jean-loup Gailly and Mark Adler
3484                      // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
3485                      //
3486                      // This software is provided 'as-is', without any express or implied
3487                      // warranty. In no event will the authors be held liable for any damages
3488                      // arising from the use of this software.
3489                      //
3490                      // Permission is granted to anyone to use this software for any purpose,
3491                      // including commercial applications, and to alter it and redistribute it
3492                      // freely, subject to the following restrictions:
3493                      //
3494                      // 1. The origin of this software must not be misrepresented; you must not
3495                      //   claim that you wrote the original software. If you use this software
3496                      //   in a product, an acknowledgment in the product documentation would be
3497                      //   appreciated but is not required.
3498                      // 2. Altered source versions must be plainly marked as such, and must not be
3499                      //   misrepresented as being the original software.
3500                      // 3. This notice may not be removed or altered from any source distribution.
3501  
3502                      module.exports = {
3503                          2: 'need dictionary' /* Z_NEED_DICT       2  */,
3504                          1: 'stream end' /* Z_STREAM_END      1  */,
3505                          0: '' /* Z_OK              0  */,
3506                          '-1': 'file error' /* Z_ERRNO         (-1) */,
3507                          '-2': 'stream error' /* Z_STREAM_ERROR  (-2) */,
3508                          '-3': 'data error' /* Z_DATA_ERROR    (-3) */,
3509                          '-4': 'insufficient memory' /* Z_MEM_ERROR     (-4) */,
3510                          '-5': 'buffer error' /* Z_BUF_ERROR     (-5) */,
3511                          '-6': 'incompatible version' /* Z_VERSION_ERROR (-6) */,
3512                      };
3513                  },
3514                  {},
3515              ],
3516              11: [
3517                  function ( require, module, exports ) {
3518                      'use strict';
3519  
3520                      // (C) 1995-2013 Jean-loup Gailly and Mark Adler
3521                      // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
3522                      //
3523                      // This software is provided 'as-is', without any express or implied
3524                      // warranty. In no event will the authors be held liable for any damages
3525                      // arising from the use of this software.
3526                      //
3527                      // Permission is granted to anyone to use this software for any purpose,
3528                      // including commercial applications, and to alter it and redistribute it
3529                      // freely, subject to the following restrictions:
3530                      //
3531                      // 1. The origin of this software must not be misrepresented; you must not
3532                      //   claim that you wrote the original software. If you use this software
3533                      //   in a product, an acknowledgment in the product documentation would be
3534                      //   appreciated but is not required.
3535                      // 2. Altered source versions must be plainly marked as such, and must not be
3536                      //   misrepresented as being the original software.
3537                      // 3. This notice may not be removed or altered from any source distribution.
3538  
3539  					function ZStream() {
3540                          /* next input byte */
3541                          this.input = null; // JS specific, because we have no pointers
3542                          this.next_in = 0;
3543                          /* number of bytes available at input */
3544                          this.avail_in = 0;
3545                          /* total number of input bytes read so far */
3546                          this.total_in = 0;
3547                          /* next output byte should be put there */
3548                          this.output = null; // JS specific, because we have no pointers
3549                          this.next_out = 0;
3550                          /* remaining free space at output */
3551                          this.avail_out = 0;
3552                          /* total number of bytes output so far */
3553                          this.total_out = 0;
3554                          /* last error message, NULL if no error */
3555                          this.msg = '' /*Z_NULL*/;
3556                          /* not visible by applications */
3557                          this.state = null;
3558                          /* best guess about the data type: binary or text */
3559                          this.data_type = 2 /*Z_UNKNOWN*/;
3560                          /* adler32 value of the uncompressed data */
3561                          this.adler = 0;
3562                      }
3563  
3564                      module.exports = ZStream;
3565                  },
3566                  {},
3567              ],
3568              '/lib/inflate.js': [
3569                  function ( require, module, exports ) {
3570                      'use strict';
3571  
3572                      var zlib_inflate = require( './zlib/inflate' );
3573                      var utils = require( './utils/common' );
3574                      var strings = require( './utils/strings' );
3575                      var c = require( './zlib/constants' );
3576                      var msg = require( './zlib/messages' );
3577                      var ZStream = require( './zlib/zstream' );
3578                      var GZheader = require( './zlib/gzheader' );
3579  
3580                      var toString = Object.prototype.toString;
3581  
3582                      /**
3583                       * class Inflate
3584                       *
3585                       * Generic JS-style wrapper for zlib calls. If you don't need
3586                       * streaming behaviour - use more simple functions: [[inflate]]
3587                       * and [[inflateRaw]].
3588                       **/
3589  
3590                      /* internal
3591                       * inflate.chunks -> Array
3592                       *
3593                       * Chunks of output data, if [[Inflate#onData]] not overridden.
3594                       **/
3595  
3596                      /**
3597                       * Inflate.result -> Uint8Array|Array|String
3598                       *
3599                       * Uncompressed result, generated by default [[Inflate#onData]]
3600                       * and [[Inflate#onEnd]] handlers. Filled after you push last chunk
3601                       * (call [[Inflate#push]] with `Z_FINISH` / `true` param) or if you
3602                       * push a chunk with explicit flush (call [[Inflate#push]] with
3603                       * `Z_SYNC_FLUSH` param).
3604                       **/
3605  
3606                      /**
3607                       * Inflate.err -> Number
3608                       *
3609                       * Error code after inflate finished. 0 (Z_OK) on success.
3610                       * Should be checked if broken data possible.
3611                       **/
3612  
3613                      /**
3614                       * Inflate.msg -> String
3615                       *
3616                       * Error message, if [[Inflate.err]] != 0
3617                       **/
3618  
3619                      /**
3620                       * new Inflate(options)
3621                       * - options (Object): zlib inflate options.
3622                       *
3623                       * Creates new inflator instance with specified params. Throws exception
3624                       * on bad params. Supported options:
3625                       *
3626                       * - `windowBits`
3627                       * - `dictionary`
3628                       *
3629                       * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
3630                       * for more information on these.
3631                       *
3632                       * Additional options, for internal needs:
3633                       *
3634                       * - `chunkSize` - size of generated data chunks (16K by default)
3635                       * - `raw` (Boolean) - do raw inflate
3636                       * - `to` (String) - if equal to 'string', then result will be converted
3637                       *   from utf8 to utf16 (javascript) string. When string output requested,
3638                       *   chunk length can differ from `chunkSize`, depending on content.
3639                       *
3640                       * By default, when no options set, autodetect deflate/gzip data format via
3641                       * wrapper header.
3642                       *
3643                       * ##### Example:
3644                       *
3645                       * ```javascript
3646                       * var pako = require('pako')
3647                       *   , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])
3648                       *   , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);
3649                       *
3650                       * var inflate = new pako.Inflate({ level: 3});
3651                       *
3652                       * inflate.push(chunk1, false);
3653                       * inflate.push(chunk2, true);  // true -> last chunk
3654                       *
3655                       * if (inflate.err) { throw new Error(inflate.err); }
3656                       *
3657                       * console.log(inflate.result);
3658                       * ```
3659                       **/
3660  					function Inflate( options ) {
3661                          if ( ! ( this instanceof Inflate ) )
3662                              return new Inflate( options );
3663  
3664                          this.options = utils.assign(
3665                              {
3666                                  chunkSize: 16384,
3667                                  windowBits: 0,
3668                                  to: '',
3669                              },
3670                              options || {}
3671                          );
3672  
3673                          var opt = this.options;
3674  
3675                          // Force window size for `raw` data, if not set directly,
3676                          // because we have no header for autodetect.
3677                          if (
3678                              opt.raw &&
3679                              opt.windowBits >= 0 &&
3680                              opt.windowBits < 16
3681                          ) {
3682                              opt.windowBits = -opt.windowBits;
3683                              if ( opt.windowBits === 0 ) {
3684                                  opt.windowBits = -15;
3685                              }
3686                          }
3687  
3688                          // If `windowBits` not defined (and mode not raw) - set autodetect flag for gzip/deflate
3689                          if (
3690                              opt.windowBits >= 0 &&
3691                              opt.windowBits < 16 &&
3692                              ! ( options && options.windowBits )
3693                          ) {
3694                              opt.windowBits += 32;
3695                          }
3696  
3697                          // Gzip header has no info about windows size, we can do autodetect only
3698                          // for deflate. So, if window size not set, force it to max when gzip possible
3699                          if ( opt.windowBits > 15 && opt.windowBits < 48 ) {
3700                              // bit 3 (16) -> gzipped data
3701                              // bit 4 (32) -> autodetect gzip/deflate
3702                              if ( ( opt.windowBits & 15 ) === 0 ) {
3703                                  opt.windowBits |= 15;
3704                              }
3705                          }
3706  
3707                          this.err = 0; // error code, if happens (0 = Z_OK)
3708                          this.msg = ''; // error message
3709                          this.ended = false; // used to avoid multiple onEnd() calls
3710                          this.chunks = []; // chunks of compressed data
3711  
3712                          this.strm = new ZStream();
3713                          this.strm.avail_out = 0;
3714  
3715                          var status = zlib_inflate.inflateInit2(
3716                              this.strm,
3717                              opt.windowBits
3718                          );
3719  
3720                          if ( status !== c.Z_OK ) {
3721                              throw new Error( msg[ status ] );
3722                          }
3723  
3724                          this.header = new GZheader();
3725  
3726                          zlib_inflate.inflateGetHeader( this.strm, this.header );
3727  
3728                          // Setup dictionary
3729                          if ( opt.dictionary ) {
3730                              // Convert data if needed
3731                              if ( typeof opt.dictionary === 'string' ) {
3732                                  opt.dictionary = strings.string2buf(
3733                                      opt.dictionary
3734                                  );
3735                              } else if (
3736                                  toString.call( opt.dictionary ) ===
3737                                  '[object ArrayBuffer]'
3738                              ) {
3739                                  opt.dictionary = new Uint8Array(
3740                                      opt.dictionary
3741                                  );
3742                              }
3743                              if ( opt.raw ) {
3744                                  //In raw mode we need to set the dictionary early
3745                                  status = zlib_inflate.inflateSetDictionary(
3746                                      this.strm,
3747                                      opt.dictionary
3748                                  );
3749                                  if ( status !== c.Z_OK ) {
3750                                      throw new Error( msg[ status ] );
3751                                  }
3752                              }
3753                          }
3754                      }
3755  
3756                      /**
3757                       * Inflate#push(data[, mode]) -> Boolean
3758                       * - data (Uint8Array|Array|ArrayBuffer|String): input data
3759                       * - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.
3760                       *   See constants. Skipped or `false` means Z_NO_FLUSH, `true` means Z_FINISH.
3761                       *
3762                       * Sends input data to inflate pipe, generating [[Inflate#onData]] calls with
3763                       * new output chunks. Returns `true` on success. The last data block must have
3764                       * mode Z_FINISH (or `true`). That will flush internal pending buffers and call
3765                       * [[Inflate#onEnd]]. For interim explicit flushes (without ending the stream) you
3766                       * can use mode Z_SYNC_FLUSH, keeping the decompression context.
3767                       *
3768                       * On fail call [[Inflate#onEnd]] with error code and return false.
3769                       *
3770                       * We strongly recommend to use `Uint8Array` on input for best speed (output
3771                       * format is detected automatically). Also, don't skip last param and always
3772                       * use the same type in your code (boolean or number). That will improve JS speed.
3773                       *
3774                       * For regular `Array`-s make sure all elements are [0..255].
3775                       *
3776                       * ##### Example
3777                       *
3778                       * ```javascript
3779                       * push(chunk, false); // push one of data chunks
3780                       * ...
3781                       * push(chunk, true);  // push last chunk
3782                       * ```
3783                       **/
3784                      Inflate.prototype.push = function ( data, mode ) {
3785                          var strm = this.strm;
3786                          var chunkSize = this.options.chunkSize;
3787                          var dictionary = this.options.dictionary;
3788                          var status, _mode;
3789                          var next_out_utf8, tail, utf8str;
3790  
3791                          // Flag to properly process Z_BUF_ERROR on testing inflate call
3792                          // when we check that all output data was flushed.
3793                          var allowBufError = false;
3794  
3795                          if ( this.ended ) {
3796                              return false;
3797                          }
3798                          _mode =
3799                              mode === ~~mode
3800                                  ? mode
3801                                  : mode === true
3802                                  ? c.Z_FINISH
3803                                  : c.Z_NO_FLUSH;
3804  
3805                          // Convert data if needed
3806                          if ( typeof data === 'string' ) {
3807                              // Only binary strings can be decompressed on practice
3808                              strm.input = strings.binstring2buf( data );
3809                          } else if (
3810                              toString.call( data ) === '[object ArrayBuffer]'
3811                          ) {
3812                              strm.input = new Uint8Array( data );
3813                          } else {
3814                              strm.input = data;
3815                          }
3816  
3817                          strm.next_in = 0;
3818                          strm.avail_in = strm.input.length;
3819  
3820                          do {
3821                              if ( strm.avail_out === 0 ) {
3822                                  strm.output = new utils.Buf8( chunkSize );
3823                                  strm.next_out = 0;
3824                                  strm.avail_out = chunkSize;
3825                              }
3826  
3827                              status = zlib_inflate.inflate(
3828                                  strm,
3829                                  c.Z_NO_FLUSH
3830                              ); /* no bad return value */
3831  
3832                              if ( status === c.Z_NEED_DICT && dictionary ) {
3833                                  status = zlib_inflate.inflateSetDictionary(
3834                                      this.strm,
3835                                      dictionary
3836                                  );
3837                              }
3838  
3839                              if (
3840                                  status === c.Z_BUF_ERROR &&
3841                                  allowBufError === true
3842                              ) {
3843                                  status = c.Z_OK;
3844                                  allowBufError = false;
3845                              }
3846  
3847                              if (
3848                                  status !== c.Z_STREAM_END &&
3849                                  status !== c.Z_OK
3850                              ) {
3851                                  this.onEnd( status );
3852                                  this.ended = true;
3853                                  return false;
3854                              }
3855  
3856                              if ( strm.next_out ) {
3857                                  if (
3858                                      strm.avail_out === 0 ||
3859                                      status === c.Z_STREAM_END ||
3860                                      ( strm.avail_in === 0 &&
3861                                          ( _mode === c.Z_FINISH ||
3862                                              _mode === c.Z_SYNC_FLUSH ) )
3863                                  ) {
3864                                      if ( this.options.to === 'string' ) {
3865                                          next_out_utf8 = strings.utf8border(
3866                                              strm.output,
3867                                              strm.next_out
3868                                          );
3869  
3870                                          tail = strm.next_out - next_out_utf8;
3871                                          utf8str = strings.buf2string(
3872                                              strm.output,
3873                                              next_out_utf8
3874                                          );
3875  
3876                                          // move tail
3877                                          strm.next_out = tail;
3878                                          strm.avail_out = chunkSize - tail;
3879                                          if ( tail ) {
3880                                              utils.arraySet(
3881                                                  strm.output,
3882                                                  strm.output,
3883                                                  next_out_utf8,
3884                                                  tail,
3885                                                  0
3886                                              );
3887                                          }
3888  
3889                                          this.onData( utf8str );
3890                                      } else {
3891                                          this.onData(
3892                                              utils.shrinkBuf(
3893                                                  strm.output,
3894                                                  strm.next_out
3895                                              )
3896                                          );
3897                                      }
3898                                  }
3899                              }
3900  
3901                              // When no more input data, we should check that internal inflate buffers
3902                              // are flushed. The only way to do it when avail_out = 0 - run one more
3903                              // inflate pass. But if output data not exists, inflate return Z_BUF_ERROR.
3904                              // Here we set flag to process this error properly.
3905                              //
3906                              // NOTE. Deflate does not return error in this case and does not needs such
3907                              // logic.
3908                              if ( strm.avail_in === 0 && strm.avail_out === 0 ) {
3909                                  allowBufError = true;
3910                              }
3911                          } while (
3912                              ( strm.avail_in > 0 || strm.avail_out === 0 ) &&
3913                              status !== c.Z_STREAM_END
3914                          );
3915  
3916                          if ( status === c.Z_STREAM_END ) {
3917                              _mode = c.Z_FINISH;
3918                          }
3919  
3920                          // Finalize on the last chunk.
3921                          if ( _mode === c.Z_FINISH ) {
3922                              status = zlib_inflate.inflateEnd( this.strm );
3923                              this.onEnd( status );
3924                              this.ended = true;
3925                              return status === c.Z_OK;
3926                          }
3927  
3928                          // callback interim results if Z_SYNC_FLUSH.
3929                          if ( _mode === c.Z_SYNC_FLUSH ) {
3930                              this.onEnd( c.Z_OK );
3931                              strm.avail_out = 0;
3932                              return true;
3933                          }
3934  
3935                          return true;
3936                      };
3937  
3938                      /**
3939                       * Inflate#onData(chunk) -> Void
3940                       * - chunk (Uint8Array|Array|String): output data. Type of array depends
3941                       *   on js engine support. When string output requested, each chunk
3942                       *   will be string.
3943                       *
3944                       * By default, stores data blocks in `chunks[]` property and glue
3945                       * those in `onEnd`. Override this handler, if you need another behaviour.
3946                       **/
3947                      Inflate.prototype.onData = function ( chunk ) {
3948                          this.chunks.push( chunk );
3949                      };
3950  
3951                      /**
3952                       * Inflate#onEnd(status) -> Void
3953                       * - status (Number): inflate status. 0 (Z_OK) on success,
3954                       *   other if not.
3955                       *
3956                       * Called either after you tell inflate that the input stream is
3957                       * complete (Z_FINISH) or should be flushed (Z_SYNC_FLUSH)
3958                       * or if an error happened. By default - join collected chunks,
3959                       * free memory and fill `results` / `err` properties.
3960                       **/
3961                      Inflate.prototype.onEnd = function ( status ) {
3962                          // On success - join
3963                          if ( status === c.Z_OK ) {
3964                              if ( this.options.to === 'string' ) {
3965                                  // Glue & convert here, until we teach pako to send
3966                                  // utf8 aligned strings to onData
3967                                  this.result = this.chunks.join( '' );
3968                              } else {
3969                                  this.result = utils.flattenChunks(
3970                                      this.chunks
3971                                  );
3972                              }
3973                          }
3974                          this.chunks = [];
3975                          this.err = status;
3976                          this.msg = this.strm.msg;
3977                      };
3978  
3979                      /**
3980                       * inflate(data[, options]) -> Uint8Array|Array|String
3981                       * - data (Uint8Array|Array|String): input data to decompress.
3982                       * - options (Object): zlib inflate options.
3983                       *
3984                       * Decompress `data` with inflate/ungzip and `options`. Autodetect
3985                       * format via wrapper header by default. That's why we don't provide
3986                       * separate `ungzip` method.
3987                       *
3988                       * Supported options are:
3989                       *
3990                       * - windowBits
3991                       *
3992                       * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
3993                       * for more information.
3994                       *
3995                       * Sugar (options):
3996                       *
3997                       * - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify
3998                       *   negative windowBits implicitly.
3999                       * - `to` (String) - if equal to 'string', then result will be converted
4000                       *   from utf8 to utf16 (javascript) string. When string output requested,
4001                       *   chunk length can differ from `chunkSize`, depending on content.
4002                       *
4003                       *
4004                       * ##### Example:
4005                       *
4006                       * ```javascript
4007                       * var pako = require('pako')
4008                       *   , input = pako.deflate([1,2,3,4,5,6,7,8,9])
4009                       *   , output;
4010                       *
4011                       * try {
4012                       *   output = pako.inflate(input);
4013                       * } catch (err)
4014                       *   console.log(err);
4015                       * }
4016                       * ```
4017                       **/
4018  					function inflate( input, options ) {
4019                          var inflator = new Inflate( options );
4020  
4021                          inflator.push( input, true );
4022  
4023                          // That will never happens, if you don't cheat with options :)
4024                          if ( inflator.err ) {
4025                              throw inflator.msg || msg[ inflator.err ];
4026                          }
4027  
4028                          return inflator.result;
4029                      }
4030  
4031                      /**
4032                       * inflateRaw(data[, options]) -> Uint8Array|Array|String
4033                       * - data (Uint8Array|Array|String): input data to decompress.
4034                       * - options (Object): zlib inflate options.
4035                       *
4036                       * The same as [[inflate]], but creates raw data, without wrapper
4037                       * (header and adler32 crc).
4038                       **/
4039  					function inflateRaw( input, options ) {
4040                          options = options || {};
4041                          options.raw = true;
4042                          return inflate( input, options );
4043                      }
4044  
4045                      /**
4046                       * ungzip(data[, options]) -> Uint8Array|Array|String
4047                       * - data (Uint8Array|Array|String): input data to decompress.
4048                       * - options (Object): zlib inflate options.
4049                       *
4050                       * Just shortcut to [[inflate]], because it autodetects format
4051                       * by header.content. Done for convenience.
4052                       **/
4053  
4054                      exports.Inflate = Inflate;
4055                      exports.inflate = inflate;
4056                      exports.inflateRaw = inflateRaw;
4057                      exports.ungzip = inflate;
4058                  },
4059                  {
4060                      './utils/common': 1,
4061                      './utils/strings': 2,
4062                      './zlib/constants': 4,
4063                      './zlib/gzheader': 6,
4064                      './zlib/inflate': 8,
4065                      './zlib/messages': 10,
4066                      './zlib/zstream': 11,
4067                  },
4068              ],
4069          },
4070          {},
4071          []
4072      )( '/lib/inflate.js' );
4073  } );
4074  /* eslint-enable */
4075  
4076  
4077  /***/ }),
4078  
4079  /***/ 8572:
4080  /***/ ((module) => {
4081  
4082  /* eslint eslint-comments/no-unlimited-disable: 0 */
4083  /* eslint-disable */
4084  ( function ( f ) {
4085      if ( true ) {
4086          module.exports = f();
4087      } else { var g; }
4088  } )( function () {
4089      var define, module, exports;
4090      return ( function () {
4091          function r( e, n, t ) {
4092              function o( i, f ) {
4093                  if ( ! n[ i ] ) {
4094                      if ( ! e[ i ] ) {
4095                          var c = undefined;
4096                          if ( ! f && c ) return require( i, ! 0 );
4097                          if ( u ) return u( i, ! 0 );
4098                          var a = new Error( "Cannot find module '" + i + "'" );
4099                          throw ( ( a.code = 'MODULE_NOT_FOUND' ), a );
4100                      }
4101                      var p = ( n[ i ] = { exports: {} } );
4102                      e[ i ][ 0 ].call(
4103                          p.exports,
4104                          function ( r ) {
4105                              var n = e[ i ][ 1 ][ r ];
4106                              return o( n || r );
4107                          },
4108                          p,
4109                          p.exports,
4110                          r,
4111                          e,
4112                          n,
4113                          t
4114                      );
4115                  }
4116                  return n[ i ].exports;
4117              }
4118              for (
4119                  var u = undefined, i = 0;
4120                  i < t.length;
4121                  i++
4122              )
4123                  o( t[ i ] );
4124              return o;
4125          }
4126          return r;
4127      } )()(
4128          {
4129              1: [
4130                  function ( require, module, exports ) {
4131                      /* Copyright 2013 Google Inc. All Rights Reserved.
4132  
4133     Licensed under the Apache License, Version 2.0 (the "License");
4134     you may not use this file except in compliance with the License.
4135     You may obtain a copy of the License at
4136  
4137     http://www.apache.org/licenses/LICENSE-2.0
4138  
4139     Unless required by applicable law or agreed to in writing, software
4140     distributed under the License is distributed on an "AS IS" BASIS,
4141     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
4142     See the License for the specific language governing permissions and
4143     limitations under the License.
4144  
4145     Bit reading helpers
4146  */
4147  
4148                      var BROTLI_READ_SIZE = 4096;
4149                      var BROTLI_IBUF_SIZE = 2 * BROTLI_READ_SIZE + 32;
4150                      var BROTLI_IBUF_MASK = 2 * BROTLI_READ_SIZE - 1;
4151  
4152                      var kBitMask = new Uint32Array( [
4153                          0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095,
4154                          8191, 16383, 32767, 65535, 131071, 262143, 524287,
4155                          1048575, 2097151, 4194303, 8388607, 16777215,
4156                      ] );
4157  
4158                      /* Input byte buffer, consist of a ringbuffer and a "slack" region where */
4159                      /* bytes from the start of the ringbuffer are copied. */
4160  					function BrotliBitReader( input ) {
4161                          this.buf_ = new Uint8Array( BROTLI_IBUF_SIZE );
4162                          this.input_ = input; /* input callback */
4163  
4164                          this.reset();
4165                      }
4166  
4167                      BrotliBitReader.READ_SIZE = BROTLI_READ_SIZE;
4168                      BrotliBitReader.IBUF_MASK = BROTLI_IBUF_MASK;
4169  
4170                      BrotliBitReader.prototype.reset = function () {
4171                          this.buf_ptr_ = 0; /* next input will write here */
4172                          this.val_ = 0; /* pre-fetched bits */
4173                          this.pos_ = 0; /* byte position in stream */
4174                          this.bit_pos_ = 0; /* current bit-reading position in val_ */
4175                          this.bit_end_pos_ = 0; /* bit-reading end position from LSB of val_ */
4176                          this.eos_ = 0; /* input stream is finished */
4177  
4178                          this.readMoreInput();
4179                          for ( var i = 0; i < 4; i++ ) {
4180                              this.val_ |= this.buf_[ this.pos_ ] << ( 8 * i );
4181                              ++this.pos_;
4182                          }
4183  
4184                          return this.bit_end_pos_ > 0;
4185                      };
4186  
4187                      /* Fills up the input ringbuffer by calling the input callback.
4188  
4189     Does nothing if there are at least 32 bytes present after current position.
4190  
4191     Returns 0 if either:
4192      - the input callback returned an error, or
4193      - there is no more input and the position is past the end of the stream.
4194  
4195     After encountering the end of the input stream, 32 additional zero bytes are
4196     copied to the ringbuffer, therefore it is safe to call this function after
4197     every 32 bytes of input is read.
4198  */
4199                      BrotliBitReader.prototype.readMoreInput = function () {
4200                          if ( this.bit_end_pos_ > 256 ) {
4201                              return;
4202                          } else if ( this.eos_ ) {
4203                              if ( this.bit_pos_ > this.bit_end_pos_ )
4204                                  throw new Error(
4205                                      'Unexpected end of input ' +
4206                                          this.bit_pos_ +
4207                                          ' ' +
4208                                          this.bit_end_pos_
4209                                  );
4210                          } else {
4211                              var dst = this.buf_ptr_;
4212                              var bytes_read = this.input_.read(
4213                                  this.buf_,
4214                                  dst,
4215                                  BROTLI_READ_SIZE
4216                              );
4217                              if ( bytes_read < 0 ) {
4218                                  throw new Error( 'Unexpected end of input' );
4219                              }
4220  
4221                              if ( bytes_read < BROTLI_READ_SIZE ) {
4222                                  this.eos_ = 1;
4223                                  /* Store 32 bytes of zero after the stream end. */
4224                                  for ( var p = 0; p < 32; p++ )
4225                                      this.buf_[ dst + bytes_read + p ] = 0;
4226                              }
4227  
4228                              if ( dst === 0 ) {
4229                                  /* Copy the head of the ringbuffer to the slack region. */
4230                                  for ( var p = 0; p < 32; p++ )
4231                                      this.buf_[ ( BROTLI_READ_SIZE << 1 ) + p ] =
4232                                          this.buf_[ p ];
4233  
4234                                  this.buf_ptr_ = BROTLI_READ_SIZE;
4235                              } else {
4236                                  this.buf_ptr_ = 0;
4237                              }
4238  
4239                              this.bit_end_pos_ += bytes_read << 3;
4240                          }
4241                      };
4242  
4243                      /* Guarantees that there are at least 24 bits in the buffer. */
4244                      BrotliBitReader.prototype.fillBitWindow = function () {
4245                          while ( this.bit_pos_ >= 8 ) {
4246                              this.val_ >>>= 8;
4247                              this.val_ |=
4248                                  this.buf_[ this.pos_ & BROTLI_IBUF_MASK ] << 24;
4249                              ++this.pos_;
4250                              this.bit_pos_ = ( this.bit_pos_ - 8 ) >>> 0;
4251                              this.bit_end_pos_ = ( this.bit_end_pos_ - 8 ) >>> 0;
4252                          }
4253                      };
4254  
4255                      /* Reads the specified number of bits from Read Buffer. */
4256                      BrotliBitReader.prototype.readBits = function ( n_bits ) {
4257                          if ( 32 - this.bit_pos_ < n_bits ) {
4258                              this.fillBitWindow();
4259                          }
4260  
4261                          var val =
4262                              ( this.val_ >>> this.bit_pos_ ) &
4263                              kBitMask[ n_bits ];
4264                          this.bit_pos_ += n_bits;
4265                          return val;
4266                      };
4267  
4268                      module.exports = BrotliBitReader;
4269                  },
4270                  {},
4271              ],
4272              2: [
4273                  function ( require, module, exports ) {
4274                      /* Copyright 2013 Google Inc. All Rights Reserved.
4275  
4276     Licensed under the Apache License, Version 2.0 (the "License");
4277     you may not use this file except in compliance with the License.
4278     You may obtain a copy of the License at
4279  
4280     http://www.apache.org/licenses/LICENSE-2.0
4281  
4282     Unless required by applicable law or agreed to in writing, software
4283     distributed under the License is distributed on an "AS IS" BASIS,
4284     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
4285     See the License for the specific language governing permissions and
4286     limitations under the License.
4287  
4288     Lookup table to map the previous two bytes to a context id.
4289  
4290     There are four different context modeling modes defined here:
4291       CONTEXT_LSB6: context id is the least significant 6 bits of the last byte,
4292       CONTEXT_MSB6: context id is the most significant 6 bits of the last byte,
4293       CONTEXT_UTF8: second-order context model tuned for UTF8-encoded text,
4294       CONTEXT_SIGNED: second-order context model tuned for signed integers.
4295  
4296     The context id for the UTF8 context model is calculated as follows. If p1
4297     and p2 are the previous two bytes, we calcualte the context as
4298  
4299       context = kContextLookup[p1] | kContextLookup[p2 + 256].
4300  
4301     If the previous two bytes are ASCII characters (i.e. < 128), this will be
4302     equivalent to
4303  
4304       context = 4 * context1(p1) + context2(p2),
4305  
4306     where context1 is based on the previous byte in the following way:
4307  
4308       0  : non-ASCII control
4309       1  : \t, \n, \r
4310       2  : space
4311       3  : other punctuation
4312       4  : " '
4313       5  : %
4314       6  : ( < [ {
4315       7  : ) > ] }
4316       8  : , ; :
4317       9  : .
4318       10 : =
4319       11 : number
4320       12 : upper-case vowel
4321       13 : upper-case consonant
4322       14 : lower-case vowel
4323       15 : lower-case consonant
4324  
4325     and context2 is based on the second last byte:
4326  
4327       0 : control, space
4328       1 : punctuation
4329       2 : upper-case letter, number
4330       3 : lower-case letter
4331  
4332     If the last byte is ASCII, and the second last byte is not (in a valid UTF8
4333     stream it will be a continuation byte, value between 128 and 191), the
4334     context is the same as if the second last byte was an ASCII control or space.
4335  
4336     If the last byte is a UTF8 lead byte (value >= 192), then the next byte will
4337     be a continuation byte and the context id is 2 or 3 depending on the LSB of
4338     the last byte and to a lesser extent on the second last byte if it is ASCII.
4339  
4340     If the last byte is a UTF8 continuation byte, the second last byte can be:
4341       - continuation byte: the next byte is probably ASCII or lead byte (assuming
4342         4-byte UTF8 characters are rare) and the context id is 0 or 1.
4343       - lead byte (192 - 207): next byte is ASCII or lead byte, context is 0 or 1
4344       - lead byte (208 - 255): next byte is continuation byte, context is 2 or 3
4345  
4346     The possible value combinations of the previous two bytes, the range of
4347     context ids and the type of the next byte is summarized in the table below:
4348  
4349     |--------\-----------------------------------------------------------------|
4350     |         \                         Last byte                              |
4351     | Second   \---------------------------------------------------------------|
4352     | last byte \    ASCII            |   cont. byte        |   lead byte      |
4353     |            \   (0-127)          |   (128-191)         |   (192-)         |
4354     |=============|===================|=====================|==================|
4355     |  ASCII      | next: ASCII/lead  |  not valid          |  next: cont.     |
4356     |  (0-127)    | context: 4 - 63   |                     |  context: 2 - 3  |
4357     |-------------|-------------------|---------------------|------------------|
4358     |  cont. byte | next: ASCII/lead  |  next: ASCII/lead   |  next: cont.     |
4359     |  (128-191)  | context: 4 - 63   |  context: 0 - 1     |  context: 2 - 3  |
4360     |-------------|-------------------|---------------------|------------------|
4361     |  lead byte  | not valid         |  next: ASCII/lead   |  not valid       |
4362     |  (192-207)  |                   |  context: 0 - 1     |                  |
4363     |-------------|-------------------|---------------------|------------------|
4364     |  lead byte  | not valid         |  next: cont.        |  not valid       |
4365     |  (208-)     |                   |  context: 2 - 3     |                  |
4366     |-------------|-------------------|---------------------|------------------|
4367  
4368     The context id for the signed context mode is calculated as:
4369  
4370       context = (kContextLookup[512 + p1] << 3) | kContextLookup[512 + p2].
4371  
4372     For any context modeling modes, the context ids can be calculated by |-ing
4373     together two lookups from one table using context model dependent offsets:
4374  
4375       context = kContextLookup[offset1 + p1] | kContextLookup[offset2 + p2].
4376  
4377     where offset1 and offset2 are dependent on the context mode.
4378  */
4379  
4380                      var CONTEXT_LSB6 = 0;
4381                      var CONTEXT_MSB6 = 1;
4382                      var CONTEXT_UTF8 = 2;
4383                      var CONTEXT_SIGNED = 3;
4384  
4385                      /* Common context lookup table for all context modes. */
4386                      exports.lookup = new Uint8Array( [
4387                          /* CONTEXT_UTF8, last byte. */
4388                          /* ASCII range. */
4389                          0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 4, 0, 0, 0, 0, 0,
4390                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 12, 16, 12,
4391                          12, 20, 12, 16, 24, 28, 12, 12, 32, 12, 36, 12, 44, 44,
4392                          44, 44, 44, 44, 44, 44, 44, 44, 32, 32, 24, 40, 28, 12,
4393                          12, 48, 52, 52, 52, 48, 52, 52, 52, 48, 52, 52, 52, 52,
4394                          52, 48, 52, 52, 52, 52, 52, 48, 52, 52, 52, 52, 52, 24,
4395                          12, 28, 12, 12, 12, 56, 60, 60, 60, 56, 60, 60, 60, 56,
4396                          60, 60, 60, 60, 60, 56, 60, 60, 60, 60, 60, 56, 60, 60,
4397                          60, 60, 60, 24, 12, 28, 12, 0,
4398                          /* UTF8 continuation byte range. */
4399                          0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
4400                          1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
4401                          0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
4402                          1, 0, 1, 0, 1, 0, 1, /* UTF8 lead byte range. */
4403                          2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2,
4404                          3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
4405                          2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2,
4406                          3, 2, 3, 2, 3, 2, 3,
4407                          /* CONTEXT_UTF8 second last byte. */
4408                          /* ASCII range. */
4409                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4410                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
4411                          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2,
4412                          2, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
4413                          2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1,
4414                          1, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
4415                          3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 1, 1, 1, 0,
4416                          /* UTF8 continuation byte range. */
4417                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4418                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4419                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4420                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4421                          0, 0, 0, 0, /* UTF8 lead byte range. */
4422                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2,
4423                          2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
4424                          2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
4425                          /* CONTEXT_SIGNED, second last byte. */
4426                          0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
4427                          2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
4428                          2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
4429                          2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
4430                          3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
4431                          3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
4432                          3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4,
4433                          4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4434                          4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4435                          4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4436                          4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
4437                          5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
4438                          5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6,
4439                          6, 6, 6, 6, 6, 6, 6, 6, 7,
4440                          /* CONTEXT_SIGNED, last byte, same as the above values shifted by 3 bits. */
4441                          0,
4442                          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 16, 16, 16,
4443                          16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
4444                          16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
4445                          16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
4446                          16, 16, 16, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
4447                          24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
4448                          24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
4449                          24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
4450                          24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 32, 32, 32,
4451                          32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
4452                          32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
4453                          32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
4454                          32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
4455                          32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40, 40,
4456                          40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
4457                          40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
4458                          40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 48, 48, 48,
4459                          48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 56,
4460                          /* CONTEXT_LSB6, last byte. */
4461                          0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
4462                          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
4463                          30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
4464                          44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4465                          58, 59, 60, 61, 62, 63, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
4466                          10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
4467                          24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
4468                          38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
4469                          52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 0, 1, 2,
4470                          3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
4471                          19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
4472                          33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
4473                          47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
4474                          61, 62, 63, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
4475                          13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
4476                          27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
4477                          41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
4478                          55, 56, 57, 58, 59, 60, 61, 62, 63,
4479                          /* CONTEXT_MSB6, last byte. */
4480                          0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,
4481                          4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9,
4482                          9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12,
4483                          13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16,
4484                          16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19,
4485                          20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 23, 23,
4486                          23, 23, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26, 26, 26,
4487                          27, 27, 27, 27, 28, 28, 28, 28, 29, 29, 29, 29, 30, 30,
4488                          30, 30, 31, 31, 31, 31, 32, 32, 32, 32, 33, 33, 33, 33,
4489                          34, 34, 34, 34, 35, 35, 35, 35, 36, 36, 36, 36, 37, 37,
4490                          37, 37, 38, 38, 38, 38, 39, 39, 39, 39, 40, 40, 40, 40,
4491                          41, 41, 41, 41, 42, 42, 42, 42, 43, 43, 43, 43, 44, 44,
4492                          44, 44, 45, 45, 45, 45, 46, 46, 46, 46, 47, 47, 47, 47,
4493                          48, 48, 48, 48, 49, 49, 49, 49, 50, 50, 50, 50, 51, 51,
4494                          51, 51, 52, 52, 52, 52, 53, 53, 53, 53, 54, 54, 54, 54,
4495                          55, 55, 55, 55, 56, 56, 56, 56, 57, 57, 57, 57, 58, 58,
4496                          58, 58, 59, 59, 59, 59, 60, 60, 60, 60, 61, 61, 61, 61,
4497                          62, 62, 62, 62, 63, 63, 63, 63,
4498                          /* CONTEXT_{M,L}SB6, second last byte, */
4499                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4500                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4501                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4502                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4503                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4504                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4505                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4506                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4507                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4508                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4509                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4510                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4511                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4512                          0, 0, 0, 0, 0, 0, 0, 0, 0,
4513                      ] );
4514  
4515                      exports.lookupOffsets = new Uint16Array( [
4516                          /* CONTEXT_LSB6 */
4517                          1024, 1536, /* CONTEXT_MSB6 */
4518                          1280, 1536, /* CONTEXT_UTF8 */
4519                          0, 256, /* CONTEXT_SIGNED */
4520                          768, 512,
4521                      ] );
4522                  },
4523                  {},
4524              ],
4525              3: [
4526                  function ( require, module, exports ) {
4527                      /* Copyright 2013 Google Inc. All Rights Reserved.
4528  
4529     Licensed under the Apache License, Version 2.0 (the "License");
4530     you may not use this file except in compliance with the License.
4531     You may obtain a copy of the License at
4532  
4533     http://www.apache.org/licenses/LICENSE-2.0
4534  
4535     Unless required by applicable law or agreed to in writing, software
4536     distributed under the License is distributed on an "AS IS" BASIS,
4537     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
4538     See the License for the specific language governing permissions and
4539     limitations under the License.
4540  */
4541  
4542                      var BrotliInput = require( './streams' ).BrotliInput;
4543                      var BrotliOutput = require( './streams' ).BrotliOutput;
4544                      var BrotliBitReader = require( './bit_reader' );
4545                      var BrotliDictionary = require( './dictionary' );
4546                      var HuffmanCode = require( './huffman' ).HuffmanCode;
4547                      var BrotliBuildHuffmanTable =
4548                          require( './huffman' ).BrotliBuildHuffmanTable;
4549                      var Context = require( './context' );
4550                      var Prefix = require( './prefix' );
4551                      var Transform = require( './transform' );
4552  
4553                      var kDefaultCodeLength = 8;
4554                      var kCodeLengthRepeatCode = 16;
4555                      var kNumLiteralCodes = 256;
4556                      var kNumInsertAndCopyCodes = 704;
4557                      var kNumBlockLengthCodes = 26;
4558                      var kLiteralContextBits = 6;
4559                      var kDistanceContextBits = 2;
4560  
4561                      var HUFFMAN_TABLE_BITS = 8;
4562                      var HUFFMAN_TABLE_MASK = 0xff;
4563                      /* Maximum possible Huffman table size for an alphabet size of 704, max code
4564                       * length 15 and root table bits 8. */
4565                      var HUFFMAN_MAX_TABLE_SIZE = 1080;
4566  
4567                      var CODE_LENGTH_CODES = 18;
4568                      var kCodeLengthCodeOrder = new Uint8Array( [
4569                          1, 2, 3, 4, 0, 5, 17, 6, 16, 7, 8, 9, 10, 11, 12, 13,
4570                          14, 15,
4571                      ] );
4572  
4573                      var NUM_DISTANCE_SHORT_CODES = 16;
4574                      var kDistanceShortCodeIndexOffset = new Uint8Array( [
4575                          3, 2, 1, 0, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2,
4576                      ] );
4577  
4578                      var kDistanceShortCodeValueOffset = new Int8Array( [
4579                          0, 0, 0, 0, -1, 1, -2, 2, -3, 3, -1, 1, -2, 2, -3, 3,
4580                      ] );
4581  
4582                      var kMaxHuffmanTableSize = new Uint16Array( [
4583                          256, 402, 436, 468, 500, 534, 566, 598, 630, 662, 694,
4584                          726, 758, 790, 822, 854, 886, 920, 952, 984, 1016, 1048,
4585                          1080,
4586                      ] );
4587  
4588  					function DecodeWindowBits( br ) {
4589                          var n;
4590                          if ( br.readBits( 1 ) === 0 ) {
4591                              return 16;
4592                          }
4593  
4594                          n = br.readBits( 3 );
4595                          if ( n > 0 ) {
4596                              return 17 + n;
4597                          }
4598  
4599                          n = br.readBits( 3 );
4600                          if ( n > 0 ) {
4601                              return 8 + n;
4602                          }
4603  
4604                          return 17;
4605                      }
4606  
4607                      /* Decodes a number in the range [0..255], by reading 1 - 11 bits. */
4608  					function DecodeVarLenUint8( br ) {
4609                          if ( br.readBits( 1 ) ) {
4610                              var nbits = br.readBits( 3 );
4611                              if ( nbits === 0 ) {
4612                                  return 1;
4613                              } else {
4614                                  return br.readBits( nbits ) + ( 1 << nbits );
4615                              }
4616                          }
4617                          return 0;
4618                      }
4619  
4620  					function MetaBlockLength() {
4621                          this.meta_block_length = 0;
4622                          this.input_end = 0;
4623                          this.is_uncompressed = 0;
4624                          this.is_metadata = false;
4625                      }
4626  
4627  					function DecodeMetaBlockLength( br ) {
4628                          var out = new MetaBlockLength();
4629                          var size_nibbles;
4630                          var size_bytes;
4631                          var i;
4632  
4633                          out.input_end = br.readBits( 1 );
4634                          if ( out.input_end && br.readBits( 1 ) ) {
4635                              return out;
4636                          }
4637  
4638                          size_nibbles = br.readBits( 2 ) + 4;
4639                          if ( size_nibbles === 7 ) {
4640                              out.is_metadata = true;
4641  
4642                              if ( br.readBits( 1 ) !== 0 )
4643                                  throw new Error( 'Invalid reserved bit' );
4644  
4645                              size_bytes = br.readBits( 2 );
4646                              if ( size_bytes === 0 ) return out;
4647  
4648                              for ( i = 0; i < size_bytes; i++ ) {
4649                                  var next_byte = br.readBits( 8 );
4650                                  if (
4651                                      i + 1 === size_bytes &&
4652                                      size_bytes > 1 &&
4653                                      next_byte === 0
4654                                  )
4655                                      throw new Error( 'Invalid size byte' );
4656  
4657                                  out.meta_block_length |= next_byte << ( i * 8 );
4658                              }
4659                          } else {
4660                              for ( i = 0; i < size_nibbles; ++i ) {
4661                                  var next_nibble = br.readBits( 4 );
4662                                  if (
4663                                      i + 1 === size_nibbles &&
4664                                      size_nibbles > 4 &&
4665                                      next_nibble === 0
4666                                  )
4667                                      throw new Error( 'Invalid size nibble' );
4668  
4669                                  out.meta_block_length |=
4670                                      next_nibble << ( i * 4 );
4671                              }
4672                          }
4673  
4674                          ++out.meta_block_length;
4675  
4676                          if ( ! out.input_end && ! out.is_metadata ) {
4677                              out.is_uncompressed = br.readBits( 1 );
4678                          }
4679  
4680                          return out;
4681                      }
4682  
4683                      /* Decodes the next Huffman code from bit-stream. */
4684  					function ReadSymbol( table, index, br ) {
4685                          var start_index = index;
4686  
4687                          var nbits;
4688                          br.fillBitWindow();
4689                          index +=
4690                              ( br.val_ >>> br.bit_pos_ ) & HUFFMAN_TABLE_MASK;
4691                          nbits = table[ index ].bits - HUFFMAN_TABLE_BITS;
4692                          if ( nbits > 0 ) {
4693                              br.bit_pos_ += HUFFMAN_TABLE_BITS;
4694                              index += table[ index ].value;
4695                              index +=
4696                                  ( br.val_ >>> br.bit_pos_ ) &
4697                                  ( ( 1 << nbits ) - 1 );
4698                          }
4699                          br.bit_pos_ += table[ index ].bits;
4700                          return table[ index ].value;
4701                      }
4702  
4703  					function ReadHuffmanCodeLengths(
4704                          code_length_code_lengths,
4705                          num_symbols,
4706                          code_lengths,
4707                          br
4708                      ) {
4709                          var symbol = 0;
4710                          var prev_code_len = kDefaultCodeLength;
4711                          var repeat = 0;
4712                          var repeat_code_len = 0;
4713                          var space = 32768;
4714  
4715                          var table = [];
4716                          for ( var i = 0; i < 32; i++ )
4717                              table.push( new HuffmanCode( 0, 0 ) );
4718  
4719                          BrotliBuildHuffmanTable(
4720                              table,
4721                              0,
4722                              5,
4723                              code_length_code_lengths,
4724                              CODE_LENGTH_CODES
4725                          );
4726  
4727                          while ( symbol < num_symbols && space > 0 ) {
4728                              var p = 0;
4729                              var code_len;
4730  
4731                              br.readMoreInput();
4732                              br.fillBitWindow();
4733                              p += ( br.val_ >>> br.bit_pos_ ) & 31;
4734                              br.bit_pos_ += table[ p ].bits;
4735                              code_len = table[ p ].value & 0xff;
4736                              if ( code_len < kCodeLengthRepeatCode ) {
4737                                  repeat = 0;
4738                                  code_lengths[ symbol++ ] = code_len;
4739                                  if ( code_len !== 0 ) {
4740                                      prev_code_len = code_len;
4741                                      space -= 32768 >> code_len;
4742                                  }
4743                              } else {
4744                                  var extra_bits = code_len - 14;
4745                                  var old_repeat;
4746                                  var repeat_delta;
4747                                  var new_len = 0;
4748                                  if ( code_len === kCodeLengthRepeatCode ) {
4749                                      new_len = prev_code_len;
4750                                  }
4751                                  if ( repeat_code_len !== new_len ) {
4752                                      repeat = 0;
4753                                      repeat_code_len = new_len;
4754                                  }
4755                                  old_repeat = repeat;
4756                                  if ( repeat > 0 ) {
4757                                      repeat -= 2;
4758                                      repeat <<= extra_bits;
4759                                  }
4760                                  repeat += br.readBits( extra_bits ) + 3;
4761                                  repeat_delta = repeat - old_repeat;
4762                                  if ( symbol + repeat_delta > num_symbols ) {
4763                                      throw new Error(
4764                                          '[ReadHuffmanCodeLengths] symbol + repeat_delta > num_symbols'
4765                                      );
4766                                  }
4767  
4768                                  for ( var x = 0; x < repeat_delta; x++ )
4769                                      code_lengths[ symbol + x ] =
4770                                          repeat_code_len;
4771  
4772                                  symbol += repeat_delta;
4773  
4774                                  if ( repeat_code_len !== 0 ) {
4775                                      space -=
4776                                          repeat_delta <<
4777                                          ( 15 - repeat_code_len );
4778                                  }
4779                              }
4780                          }
4781                          if ( space !== 0 ) {
4782                              throw new Error(
4783                                  '[ReadHuffmanCodeLengths] space = ' + space
4784                              );
4785                          }
4786  
4787                          for ( ; symbol < num_symbols; symbol++ )
4788                              code_lengths[ symbol ] = 0;
4789                      }
4790  
4791  					function ReadHuffmanCode(
4792                          alphabet_size,
4793                          tables,
4794                          table,
4795                          br
4796                      ) {
4797                          var table_size = 0;
4798                          var simple_code_or_skip;
4799                          var code_lengths = new Uint8Array( alphabet_size );
4800  
4801                          br.readMoreInput();
4802  
4803                          /* simple_code_or_skip is used as follows:
4804       1 for simple code;
4805       0 for no skipping, 2 skips 2 code lengths, 3 skips 3 code lengths */
4806                          simple_code_or_skip = br.readBits( 2 );
4807                          if ( simple_code_or_skip === 1 ) {
4808                              /* Read symbols, codes & code lengths directly. */
4809                              var i;
4810                              var max_bits_counter = alphabet_size - 1;
4811                              var max_bits = 0;
4812                              var symbols = new Int32Array( 4 );
4813                              var num_symbols = br.readBits( 2 ) + 1;
4814                              while ( max_bits_counter ) {
4815                                  max_bits_counter >>= 1;
4816                                  ++max_bits;
4817                              }
4818  
4819                              for ( i = 0; i < num_symbols; ++i ) {
4820                                  symbols[ i ] =
4821                                      br.readBits( max_bits ) % alphabet_size;
4822                                  code_lengths[ symbols[ i ] ] = 2;
4823                              }
4824                              code_lengths[ symbols[ 0 ] ] = 1;
4825                              switch ( num_symbols ) {
4826                                  case 1:
4827                                      break;
4828                                  case 3:
4829                                      if (
4830                                          symbols[ 0 ] === symbols[ 1 ] ||
4831                                          symbols[ 0 ] === symbols[ 2 ] ||
4832                                          symbols[ 1 ] === symbols[ 2 ]
4833                                      ) {
4834                                          throw new Error(
4835                                              '[ReadHuffmanCode] invalid symbols'
4836                                          );
4837                                      }
4838                                      break;
4839                                  case 2:
4840                                      if ( symbols[ 0 ] === symbols[ 1 ] ) {
4841                                          throw new Error(
4842                                              '[ReadHuffmanCode] invalid symbols'
4843                                          );
4844                                      }
4845  
4846                                      code_lengths[ symbols[ 1 ] ] = 1;
4847                                      break;
4848                                  case 4:
4849                                      if (
4850                                          symbols[ 0 ] === symbols[ 1 ] ||
4851                                          symbols[ 0 ] === symbols[ 2 ] ||
4852                                          symbols[ 0 ] === symbols[ 3 ] ||
4853                                          symbols[ 1 ] === symbols[ 2 ] ||
4854                                          symbols[ 1 ] === symbols[ 3 ] ||
4855                                          symbols[ 2 ] === symbols[ 3 ]
4856                                      ) {
4857                                          throw new Error(
4858                                              '[ReadHuffmanCode] invalid symbols'
4859                                          );
4860                                      }
4861  
4862                                      if ( br.readBits( 1 ) ) {
4863                                          code_lengths[ symbols[ 2 ] ] = 3;
4864                                          code_lengths[ symbols[ 3 ] ] = 3;
4865                                      } else {
4866                                          code_lengths[ symbols[ 0 ] ] = 2;
4867                                      }
4868                                      break;
4869                              }
4870                          } else {
4871                              /* Decode Huffman-coded code lengths. */
4872                              var i;
4873                              var code_length_code_lengths = new Uint8Array(
4874                                  CODE_LENGTH_CODES
4875                              );
4876                              var space = 32;
4877                              var num_codes = 0;
4878                              /* Static Huffman code for the code length code lengths */
4879                              var huff = [
4880                                  new HuffmanCode( 2, 0 ),
4881                                  new HuffmanCode( 2, 4 ),
4882                                  new HuffmanCode( 2, 3 ),
4883                                  new HuffmanCode( 3, 2 ),
4884                                  new HuffmanCode( 2, 0 ),
4885                                  new HuffmanCode( 2, 4 ),
4886                                  new HuffmanCode( 2, 3 ),
4887                                  new HuffmanCode( 4, 1 ),
4888                                  new HuffmanCode( 2, 0 ),
4889                                  new HuffmanCode( 2, 4 ),
4890                                  new HuffmanCode( 2, 3 ),
4891                                  new HuffmanCode( 3, 2 ),
4892                                  new HuffmanCode( 2, 0 ),
4893                                  new HuffmanCode( 2, 4 ),
4894                                  new HuffmanCode( 2, 3 ),
4895                                  new HuffmanCode( 4, 5 ),
4896                              ];
4897                              for (
4898                                  i = simple_code_or_skip;
4899                                  i < CODE_LENGTH_CODES && space > 0;
4900                                  ++i
4901                              ) {
4902                                  var code_len_idx = kCodeLengthCodeOrder[ i ];
4903                                  var p = 0;
4904                                  var v;
4905                                  br.fillBitWindow();
4906                                  p += ( br.val_ >>> br.bit_pos_ ) & 15;
4907                                  br.bit_pos_ += huff[ p ].bits;
4908                                  v = huff[ p ].value;
4909                                  code_length_code_lengths[ code_len_idx ] = v;
4910                                  if ( v !== 0 ) {
4911                                      space -= 32 >> v;
4912                                      ++num_codes;
4913                                  }
4914                              }
4915  
4916                              if ( ! ( num_codes === 1 || space === 0 ) )
4917                                  throw new Error(
4918                                      '[ReadHuffmanCode] invalid num_codes or space'
4919                                  );
4920  
4921                              ReadHuffmanCodeLengths(
4922                                  code_length_code_lengths,
4923                                  alphabet_size,
4924                                  code_lengths,
4925                                  br
4926                              );
4927                          }
4928  
4929                          table_size = BrotliBuildHuffmanTable(
4930                              tables,
4931                              table,
4932                              HUFFMAN_TABLE_BITS,
4933                              code_lengths,
4934                              alphabet_size
4935                          );
4936  
4937                          if ( table_size === 0 ) {
4938                              throw new Error(
4939                                  '[ReadHuffmanCode] BuildHuffmanTable failed: '
4940                              );
4941                          }
4942  
4943                          return table_size;
4944                      }
4945  
4946  					function ReadBlockLength( table, index, br ) {
4947                          var code;
4948                          var nbits;
4949                          code = ReadSymbol( table, index, br );
4950                          nbits = Prefix.kBlockLengthPrefixCode[ code ].nbits;
4951                          return (
4952                              Prefix.kBlockLengthPrefixCode[ code ].offset +
4953                              br.readBits( nbits )
4954                          );
4955                      }
4956  
4957  					function TranslateShortCodes( code, ringbuffer, index ) {
4958                          var val;
4959                          if ( code < NUM_DISTANCE_SHORT_CODES ) {
4960                              index += kDistanceShortCodeIndexOffset[ code ];
4961                              index &= 3;
4962                              val =
4963                                  ringbuffer[ index ] +
4964                                  kDistanceShortCodeValueOffset[ code ];
4965                          } else {
4966                              val = code - NUM_DISTANCE_SHORT_CODES + 1;
4967                          }
4968                          return val;
4969                      }
4970  
4971  					function MoveToFront( v, index ) {
4972                          var value = v[ index ];
4973                          var i = index;
4974                          for ( ; i; --i ) v[ i ] = v[ i - 1 ];
4975                          v[ 0 ] = value;
4976                      }
4977  
4978  					function InverseMoveToFrontTransform( v, v_len ) {
4979                          var mtf = new Uint8Array( 256 );
4980                          var i;
4981                          for ( i = 0; i < 256; ++i ) {
4982                              mtf[ i ] = i;
4983                          }
4984                          for ( i = 0; i < v_len; ++i ) {
4985                              var index = v[ i ];
4986                              v[ i ] = mtf[ index ];
4987                              if ( index ) MoveToFront( mtf, index );
4988                          }
4989                      }
4990  
4991                      /* Contains a collection of huffman trees with the same alphabet size. */
4992  					function HuffmanTreeGroup( alphabet_size, num_htrees ) {
4993                          this.alphabet_size = alphabet_size;
4994                          this.num_htrees = num_htrees;
4995                          this.codes = new Array(
4996                              num_htrees +
4997                                  num_htrees *
4998                                      kMaxHuffmanTableSize[
4999                                          ( alphabet_size + 31 ) >>> 5
5000                                      ]
5001                          );
5002                          this.htrees = new Uint32Array( num_htrees );
5003                      }
5004  
5005                      HuffmanTreeGroup.prototype.decode = function ( br ) {
5006                          var i;
5007                          var table_size;
5008                          var next = 0;
5009                          for ( i = 0; i < this.num_htrees; ++i ) {
5010                              this.htrees[ i ] = next;
5011                              table_size = ReadHuffmanCode(
5012                                  this.alphabet_size,
5013                                  this.codes,
5014                                  next,
5015                                  br
5016                              );
5017                              next += table_size;
5018                          }
5019                      };
5020  
5021  					function DecodeContextMap( context_map_size, br ) {
5022                          var out = { num_htrees: null, context_map: null };
5023                          var use_rle_for_zeros;
5024                          var max_run_length_prefix = 0;
5025                          var table;
5026                          var i;
5027  
5028                          br.readMoreInput();
5029                          var num_htrees = ( out.num_htrees =
5030                              DecodeVarLenUint8( br ) + 1 );
5031  
5032                          var context_map = ( out.context_map = new Uint8Array(
5033                              context_map_size
5034                          ) );
5035                          if ( num_htrees <= 1 ) {
5036                              return out;
5037                          }
5038  
5039                          use_rle_for_zeros = br.readBits( 1 );
5040                          if ( use_rle_for_zeros ) {
5041                              max_run_length_prefix = br.readBits( 4 ) + 1;
5042                          }
5043  
5044                          table = [];
5045                          for ( i = 0; i < HUFFMAN_MAX_TABLE_SIZE; i++ ) {
5046                              table[ i ] = new HuffmanCode( 0, 0 );
5047                          }
5048  
5049                          ReadHuffmanCode(
5050                              num_htrees + max_run_length_prefix,
5051                              table,
5052                              0,
5053                              br
5054                          );
5055  
5056                          for ( i = 0; i < context_map_size;  ) {
5057                              var code;
5058  
5059                              br.readMoreInput();
5060                              code = ReadSymbol( table, 0, br );
5061                              if ( code === 0 ) {
5062                                  context_map[ i ] = 0;
5063                                  ++i;
5064                              } else if ( code <= max_run_length_prefix ) {
5065                                  var reps =
5066                                      1 + ( 1 << code ) + br.readBits( code );
5067                                  while ( --reps ) {
5068                                      if ( i >= context_map_size ) {
5069                                          throw new Error(
5070                                              '[DecodeContextMap] i >= context_map_size'
5071                                          );
5072                                      }
5073                                      context_map[ i ] = 0;
5074                                      ++i;
5075                                  }
5076                              } else {
5077                                  context_map[ i ] = code - max_run_length_prefix;
5078                                  ++i;
5079                              }
5080                          }
5081                          if ( br.readBits( 1 ) ) {
5082                              InverseMoveToFrontTransform(
5083                                  context_map,
5084                                  context_map_size
5085                              );
5086                          }
5087  
5088                          return out;
5089                      }
5090  
5091  					function DecodeBlockType(
5092                          max_block_type,
5093                          trees,
5094                          tree_type,
5095                          block_types,
5096                          ringbuffers,
5097                          indexes,
5098                          br
5099                      ) {
5100                          var ringbuffer = tree_type * 2;
5101                          var index = tree_type;
5102                          var type_code = ReadSymbol(
5103                              trees,
5104                              tree_type * HUFFMAN_MAX_TABLE_SIZE,
5105                              br
5106                          );
5107                          var block_type;
5108                          if ( type_code === 0 ) {
5109                              block_type =
5110                                  ringbuffers[
5111                                      ringbuffer + ( indexes[ index ] & 1 )
5112                                  ];
5113                          } else if ( type_code === 1 ) {
5114                              block_type =
5115                                  ringbuffers[
5116                                      ringbuffer +
5117                                          ( ( indexes[ index ] - 1 ) & 1 )
5118                                  ] + 1;
5119                          } else {
5120                              block_type = type_code - 2;
5121                          }
5122                          if ( block_type >= max_block_type ) {
5123                              block_type -= max_block_type;
5124                          }
5125                          block_types[ tree_type ] = block_type;
5126                          ringbuffers[ ringbuffer + ( indexes[ index ] & 1 ) ] =
5127                              block_type;
5128                          ++indexes[ index ];
5129                      }
5130  
5131  					function CopyUncompressedBlockToOutput(
5132                          output,
5133                          len,
5134                          pos,
5135                          ringbuffer,
5136                          ringbuffer_mask,
5137                          br
5138                      ) {
5139                          var rb_size = ringbuffer_mask + 1;
5140                          var rb_pos = pos & ringbuffer_mask;
5141                          var br_pos = br.pos_ & BrotliBitReader.IBUF_MASK;
5142                          var nbytes;
5143  
5144                          /* For short lengths copy byte-by-byte */
5145                          if (
5146                              len < 8 ||
5147                              br.bit_pos_ + ( len << 3 ) < br.bit_end_pos_
5148                          ) {
5149                              while ( len-- > 0 ) {
5150                                  br.readMoreInput();
5151                                  ringbuffer[ rb_pos++ ] = br.readBits( 8 );
5152                                  if ( rb_pos === rb_size ) {
5153                                      output.write( ringbuffer, rb_size );
5154                                      rb_pos = 0;
5155                                  }
5156                              }
5157                              return;
5158                          }
5159  
5160                          if ( br.bit_end_pos_ < 32 ) {
5161                              throw new Error(
5162                                  '[CopyUncompressedBlockToOutput] br.bit_end_pos_ < 32'
5163                              );
5164                          }
5165  
5166                          /* Copy remaining 0-4 bytes from br.val_ to ringbuffer. */
5167                          while ( br.bit_pos_ < 32 ) {
5168                              ringbuffer[ rb_pos ] = br.val_ >>> br.bit_pos_;
5169                              br.bit_pos_ += 8;
5170                              ++rb_pos;
5171                              --len;
5172                          }
5173  
5174                          /* Copy remaining bytes from br.buf_ to ringbuffer. */
5175                          nbytes = ( br.bit_end_pos_ - br.bit_pos_ ) >> 3;
5176                          if ( br_pos + nbytes > BrotliBitReader.IBUF_MASK ) {
5177                              var tail = BrotliBitReader.IBUF_MASK + 1 - br_pos;
5178                              for ( var x = 0; x < tail; x++ )
5179                                  ringbuffer[ rb_pos + x ] =
5180                                      br.buf_[ br_pos + x ];
5181  
5182                              nbytes -= tail;
5183                              rb_pos += tail;
5184                              len -= tail;
5185                              br_pos = 0;
5186                          }
5187  
5188                          for ( var x = 0; x < nbytes; x++ )
5189                              ringbuffer[ rb_pos + x ] = br.buf_[ br_pos + x ];
5190  
5191                          rb_pos += nbytes;
5192                          len -= nbytes;
5193  
5194                          /* If we wrote past the logical end of the ringbuffer, copy the tail of the
5195       ringbuffer to its beginning and flush the ringbuffer to the output. */
5196                          if ( rb_pos >= rb_size ) {
5197                              output.write( ringbuffer, rb_size );
5198                              rb_pos -= rb_size;
5199                              for ( var x = 0; x < rb_pos; x++ )
5200                                  ringbuffer[ x ] = ringbuffer[ rb_size + x ];
5201                          }
5202  
5203                          /* If we have more to copy than the remaining size of the ringbuffer, then we
5204       first fill the ringbuffer from the input and then flush the ringbuffer to
5205       the output */
5206                          while ( rb_pos + len >= rb_size ) {
5207                              nbytes = rb_size - rb_pos;
5208                              if (
5209                                  br.input_.read( ringbuffer, rb_pos, nbytes ) <
5210                                  nbytes
5211                              ) {
5212                                  throw new Error(
5213                                      '[CopyUncompressedBlockToOutput] not enough bytes'
5214                                  );
5215                              }
5216                              output.write( ringbuffer, rb_size );
5217                              len -= nbytes;
5218                              rb_pos = 0;
5219                          }
5220  
5221                          /* Copy straight from the input onto the ringbuffer. The ringbuffer will be
5222       flushed to the output at a later time. */
5223                          if ( br.input_.read( ringbuffer, rb_pos, len ) < len ) {
5224                              throw new Error(
5225                                  '[CopyUncompressedBlockToOutput] not enough bytes'
5226                              );
5227                          }
5228  
5229                          /* Restore the state of the bit reader. */
5230                          br.reset();
5231                      }
5232  
5233                      /* Advances the bit reader position to the next byte boundary and verifies
5234     that any skipped bits are set to zero. */
5235  					function JumpToByteBoundary( br ) {
5236                          var new_bit_pos = ( br.bit_pos_ + 7 ) & ~7;
5237                          var pad_bits = br.readBits( new_bit_pos - br.bit_pos_ );
5238                          return pad_bits == 0;
5239                      }
5240  
5241  					function BrotliDecompressedSize( buffer ) {
5242                          var input = new BrotliInput( buffer );
5243                          var br = new BrotliBitReader( input );
5244                          DecodeWindowBits( br );
5245                          var out = DecodeMetaBlockLength( br );
5246                          return out.meta_block_length;
5247                      }
5248  
5249                      exports.BrotliDecompressedSize = BrotliDecompressedSize;
5250  
5251  					function BrotliDecompressBuffer( buffer, output_size ) {
5252                          var input = new BrotliInput( buffer );
5253  
5254                          if ( output_size == null ) {
5255                              output_size = BrotliDecompressedSize( buffer );
5256                          }
5257  
5258                          var output_buffer = new Uint8Array( output_size );
5259                          var output = new BrotliOutput( output_buffer );
5260  
5261                          BrotliDecompress( input, output );
5262  
5263                          if ( output.pos < output.buffer.length ) {
5264                              output.buffer = output.buffer.subarray(
5265                                  0,
5266                                  output.pos
5267                              );
5268                          }
5269  
5270                          return output.buffer;
5271                      }
5272  
5273                      exports.BrotliDecompressBuffer = BrotliDecompressBuffer;
5274  
5275  					function BrotliDecompress( input, output ) {
5276                          var i;
5277                          var pos = 0;
5278                          var input_end = 0;
5279                          var window_bits = 0;
5280                          var max_backward_distance;
5281                          var max_distance = 0;
5282                          var ringbuffer_size;
5283                          var ringbuffer_mask;
5284                          var ringbuffer;
5285                          var ringbuffer_end;
5286                          /* This ring buffer holds a few past copy distances that will be used by */
5287                          /* some special distance codes. */
5288                          var dist_rb = [ 16, 15, 11, 4 ];
5289                          var dist_rb_idx = 0;
5290                          /* The previous 2 bytes used for context. */
5291                          var prev_byte1 = 0;
5292                          var prev_byte2 = 0;
5293                          var hgroup = [
5294                              new HuffmanTreeGroup( 0, 0 ),
5295                              new HuffmanTreeGroup( 0, 0 ),
5296                              new HuffmanTreeGroup( 0, 0 ),
5297                          ];
5298                          var block_type_trees;
5299                          var block_len_trees;
5300                          var br;
5301  
5302                          /* We need the slack region for the following reasons:
5303         - always doing two 8-byte copies for fast backward copying
5304         - transforms
5305         - flushing the input ringbuffer when decoding uncompressed blocks */
5306                          var kRingBufferWriteAheadSlack =
5307                              128 + BrotliBitReader.READ_SIZE;
5308  
5309                          br = new BrotliBitReader( input );
5310  
5311                          /* Decode window size. */
5312                          window_bits = DecodeWindowBits( br );
5313                          max_backward_distance = ( 1 << window_bits ) - 16;
5314  
5315                          ringbuffer_size = 1 << window_bits;
5316                          ringbuffer_mask = ringbuffer_size - 1;
5317                          ringbuffer = new Uint8Array(
5318                              ringbuffer_size +
5319                                  kRingBufferWriteAheadSlack +
5320                                  BrotliDictionary.maxDictionaryWordLength
5321                          );
5322                          ringbuffer_end = ringbuffer_size;
5323  
5324                          block_type_trees = [];
5325                          block_len_trees = [];
5326                          for ( var x = 0; x < 3 * HUFFMAN_MAX_TABLE_SIZE; x++ ) {
5327                              block_type_trees[ x ] = new HuffmanCode( 0, 0 );
5328                              block_len_trees[ x ] = new HuffmanCode( 0, 0 );
5329                          }
5330  
5331                          while ( ! input_end ) {
5332                              var meta_block_remaining_len = 0;
5333                              var is_uncompressed;
5334                              var block_length = [ 1 << 28, 1 << 28, 1 << 28 ];
5335                              var block_type = [ 0 ];
5336                              var num_block_types = [ 1, 1, 1 ];
5337                              var block_type_rb = [ 0, 1, 0, 1, 0, 1 ];
5338                              var block_type_rb_index = [ 0 ];
5339                              var distance_postfix_bits;
5340                              var num_direct_distance_codes;
5341                              var distance_postfix_mask;
5342                              var num_distance_codes;
5343                              var context_map = null;
5344                              var context_modes = null;
5345                              var num_literal_htrees;
5346                              var dist_context_map = null;
5347                              var num_dist_htrees;
5348                              var context_offset = 0;
5349                              var context_map_slice = null;
5350                              var literal_htree_index = 0;
5351                              var dist_context_offset = 0;
5352                              var dist_context_map_slice = null;
5353                              var dist_htree_index = 0;
5354                              var context_lookup_offset1 = 0;
5355                              var context_lookup_offset2 = 0;
5356                              var context_mode;
5357                              var htree_command;
5358  
5359                              for ( i = 0; i < 3; ++i ) {
5360                                  hgroup[ i ].codes = null;
5361                                  hgroup[ i ].htrees = null;
5362                              }
5363  
5364                              br.readMoreInput();
5365  
5366                              var _out = DecodeMetaBlockLength( br );
5367                              meta_block_remaining_len = _out.meta_block_length;
5368                              if (
5369                                  pos + meta_block_remaining_len >
5370                                  output.buffer.length
5371                              ) {
5372                                  /* We need to grow the output buffer to fit the additional data. */
5373                                  var tmp = new Uint8Array(
5374                                      pos + meta_block_remaining_len
5375                                  );
5376                                  tmp.set( output.buffer );
5377                                  output.buffer = tmp;
5378                              }
5379                              input_end = _out.input_end;
5380                              is_uncompressed = _out.is_uncompressed;
5381  
5382                              if ( _out.is_metadata ) {
5383                                  JumpToByteBoundary( br );
5384  
5385                                  for (
5386                                      ;
5387                                      meta_block_remaining_len > 0;
5388                                      --meta_block_remaining_len
5389                                  ) {
5390                                      br.readMoreInput();
5391                                      /* Read one byte and ignore it. */
5392                                      br.readBits( 8 );
5393                                  }
5394  
5395                                  continue;
5396                              }
5397  
5398                              if ( meta_block_remaining_len === 0 ) {
5399                                  continue;
5400                              }
5401  
5402                              if ( is_uncompressed ) {
5403                                  br.bit_pos_ = ( br.bit_pos_ + 7 ) & ~7;
5404                                  CopyUncompressedBlockToOutput(
5405                                      output,
5406                                      meta_block_remaining_len,
5407                                      pos,
5408                                      ringbuffer,
5409                                      ringbuffer_mask,
5410                                      br
5411                                  );
5412                                  pos += meta_block_remaining_len;
5413                                  continue;
5414                              }
5415  
5416                              for ( i = 0; i < 3; ++i ) {
5417                                  num_block_types[ i ] =
5418                                      DecodeVarLenUint8( br ) + 1;
5419                                  if ( num_block_types[ i ] >= 2 ) {
5420                                      ReadHuffmanCode(
5421                                          num_block_types[ i ] + 2,
5422                                          block_type_trees,
5423                                          i * HUFFMAN_MAX_TABLE_SIZE,
5424                                          br
5425                                      );
5426                                      ReadHuffmanCode(
5427                                          kNumBlockLengthCodes,
5428                                          block_len_trees,
5429                                          i * HUFFMAN_MAX_TABLE_SIZE,
5430                                          br
5431                                      );
5432                                      block_length[ i ] = ReadBlockLength(
5433                                          block_len_trees,
5434                                          i * HUFFMAN_MAX_TABLE_SIZE,
5435                                          br
5436                                      );
5437                                      block_type_rb_index[ i ] = 1;
5438                                  }
5439                              }
5440  
5441                              br.readMoreInput();
5442  
5443                              distance_postfix_bits = br.readBits( 2 );
5444                              num_direct_distance_codes =
5445                                  NUM_DISTANCE_SHORT_CODES +
5446                                  ( br.readBits( 4 ) << distance_postfix_bits );
5447                              distance_postfix_mask =
5448                                  ( 1 << distance_postfix_bits ) - 1;
5449                              num_distance_codes =
5450                                  num_direct_distance_codes +
5451                                  ( 48 << distance_postfix_bits );
5452                              context_modes = new Uint8Array(
5453                                  num_block_types[ 0 ]
5454                              );
5455  
5456                              for ( i = 0; i < num_block_types[ 0 ]; ++i ) {
5457                                  br.readMoreInput();
5458                                  context_modes[ i ] = br.readBits( 2 ) << 1;
5459                              }
5460  
5461                              var _o1 = DecodeContextMap(
5462                                  num_block_types[ 0 ] << kLiteralContextBits,
5463                                  br
5464                              );
5465                              num_literal_htrees = _o1.num_htrees;
5466                              context_map = _o1.context_map;
5467  
5468                              var _o2 = DecodeContextMap(
5469                                  num_block_types[ 2 ] << kDistanceContextBits,
5470                                  br
5471                              );
5472                              num_dist_htrees = _o2.num_htrees;
5473                              dist_context_map = _o2.context_map;
5474  
5475                              hgroup[ 0 ] = new HuffmanTreeGroup(
5476                                  kNumLiteralCodes,
5477                                  num_literal_htrees
5478                              );
5479                              hgroup[ 1 ] = new HuffmanTreeGroup(
5480                                  kNumInsertAndCopyCodes,
5481                                  num_block_types[ 1 ]
5482                              );
5483                              hgroup[ 2 ] = new HuffmanTreeGroup(
5484                                  num_distance_codes,
5485                                  num_dist_htrees
5486                              );
5487  
5488                              for ( i = 0; i < 3; ++i ) {
5489                                  hgroup[ i ].decode( br );
5490                              }
5491  
5492                              context_map_slice = 0;
5493                              dist_context_map_slice = 0;
5494                              context_mode = context_modes[ block_type[ 0 ] ];
5495                              context_lookup_offset1 =
5496                                  Context.lookupOffsets[ context_mode ];
5497                              context_lookup_offset2 =
5498                                  Context.lookupOffsets[ context_mode + 1 ];
5499                              htree_command = hgroup[ 1 ].htrees[ 0 ];
5500  
5501                              while ( meta_block_remaining_len > 0 ) {
5502                                  var cmd_code;
5503                                  var range_idx;
5504                                  var insert_code;
5505                                  var copy_code;
5506                                  var insert_length;
5507                                  var copy_length;
5508                                  var distance_code;
5509                                  var distance;
5510                                  var context;
5511                                  var j;
5512                                  var copy_dst;
5513  
5514                                  br.readMoreInput();
5515  
5516                                  if ( block_length[ 1 ] === 0 ) {
5517                                      DecodeBlockType(
5518                                          num_block_types[ 1 ],
5519                                          block_type_trees,
5520                                          1,
5521                                          block_type,
5522                                          block_type_rb,
5523                                          block_type_rb_index,
5524                                          br
5525                                      );
5526                                      block_length[ 1 ] = ReadBlockLength(
5527                                          block_len_trees,
5528                                          HUFFMAN_MAX_TABLE_SIZE,
5529                                          br
5530                                      );
5531                                      htree_command =
5532                                          hgroup[ 1 ].htrees[ block_type[ 1 ] ];
5533                                  }
5534                                  --block_length[ 1 ];
5535                                  cmd_code = ReadSymbol(
5536                                      hgroup[ 1 ].codes,
5537                                      htree_command,
5538                                      br
5539                                  );
5540                                  range_idx = cmd_code >> 6;
5541                                  if ( range_idx >= 2 ) {
5542                                      range_idx -= 2;
5543                                      distance_code = -1;
5544                                  } else {
5545                                      distance_code = 0;
5546                                  }
5547                                  insert_code =
5548                                      Prefix.kInsertRangeLut[ range_idx ] +
5549                                      ( ( cmd_code >> 3 ) & 7 );
5550                                  copy_code =
5551                                      Prefix.kCopyRangeLut[ range_idx ] +
5552                                      ( cmd_code & 7 );
5553                                  insert_length =
5554                                      Prefix.kInsertLengthPrefixCode[
5555                                          insert_code
5556                                      ].offset +
5557                                      br.readBits(
5558                                          Prefix.kInsertLengthPrefixCode[
5559                                              insert_code
5560                                          ].nbits
5561                                      );
5562                                  copy_length =
5563                                      Prefix.kCopyLengthPrefixCode[ copy_code ]
5564                                          .offset +
5565                                      br.readBits(
5566                                          Prefix.kCopyLengthPrefixCode[
5567                                              copy_code
5568                                          ].nbits
5569                                      );
5570                                  prev_byte1 =
5571                                      ringbuffer[ ( pos - 1 ) & ringbuffer_mask ];
5572                                  prev_byte2 =
5573                                      ringbuffer[ ( pos - 2 ) & ringbuffer_mask ];
5574                                  for ( j = 0; j < insert_length; ++j ) {
5575                                      br.readMoreInput();
5576  
5577                                      if ( block_length[ 0 ] === 0 ) {
5578                                          DecodeBlockType(
5579                                              num_block_types[ 0 ],
5580                                              block_type_trees,
5581                                              0,
5582                                              block_type,
5583                                              block_type_rb,
5584                                              block_type_rb_index,
5585                                              br
5586                                          );
5587                                          block_length[ 0 ] = ReadBlockLength(
5588                                              block_len_trees,
5589                                              0,
5590                                              br
5591                                          );
5592                                          context_offset =
5593                                              block_type[ 0 ] <<
5594                                              kLiteralContextBits;
5595                                          context_map_slice = context_offset;
5596                                          context_mode =
5597                                              context_modes[ block_type[ 0 ] ];
5598                                          context_lookup_offset1 =
5599                                              Context.lookupOffsets[
5600                                                  context_mode
5601                                              ];
5602                                          context_lookup_offset2 =
5603                                              Context.lookupOffsets[
5604                                                  context_mode + 1
5605                                              ];
5606                                      }
5607                                      context =
5608                                          Context.lookup[
5609                                              context_lookup_offset1 + prev_byte1
5610                                          ] |
5611                                          Context.lookup[
5612                                              context_lookup_offset2 + prev_byte2
5613                                          ];
5614                                      literal_htree_index =
5615                                          context_map[
5616                                              context_map_slice + context
5617                                          ];
5618                                      --block_length[ 0 ];
5619                                      prev_byte2 = prev_byte1;
5620                                      prev_byte1 = ReadSymbol(
5621                                          hgroup[ 0 ].codes,
5622                                          hgroup[ 0 ].htrees[
5623                                              literal_htree_index
5624                                          ],
5625                                          br
5626                                      );
5627                                      ringbuffer[ pos & ringbuffer_mask ] =
5628                                          prev_byte1;
5629                                      if (
5630                                          ( pos & ringbuffer_mask ) ===
5631                                          ringbuffer_mask
5632                                      ) {
5633                                          output.write(
5634                                              ringbuffer,
5635                                              ringbuffer_size
5636                                          );
5637                                      }
5638                                      ++pos;
5639                                  }
5640                                  meta_block_remaining_len -= insert_length;
5641                                  if ( meta_block_remaining_len <= 0 ) break;
5642  
5643                                  if ( distance_code < 0 ) {
5644                                      var context;
5645  
5646                                      br.readMoreInput();
5647                                      if ( block_length[ 2 ] === 0 ) {
5648                                          DecodeBlockType(
5649                                              num_block_types[ 2 ],
5650                                              block_type_trees,
5651                                              2,
5652                                              block_type,
5653                                              block_type_rb,
5654                                              block_type_rb_index,
5655                                              br
5656                                          );
5657                                          block_length[ 2 ] = ReadBlockLength(
5658                                              block_len_trees,
5659                                              2 * HUFFMAN_MAX_TABLE_SIZE,
5660                                              br
5661                                          );
5662                                          dist_context_offset =
5663                                              block_type[ 2 ] <<
5664                                              kDistanceContextBits;
5665                                          dist_context_map_slice =
5666                                              dist_context_offset;
5667                                      }
5668                                      --block_length[ 2 ];
5669                                      context =
5670                                          ( copy_length > 4
5671                                              ? 3
5672                                              : copy_length - 2 ) & 0xff;
5673                                      dist_htree_index =
5674                                          dist_context_map[
5675                                              dist_context_map_slice + context
5676                                          ];
5677                                      distance_code = ReadSymbol(
5678                                          hgroup[ 2 ].codes,
5679                                          hgroup[ 2 ].htrees[ dist_htree_index ],
5680                                          br
5681                                      );
5682                                      if (
5683                                          distance_code >=
5684                                          num_direct_distance_codes
5685                                      ) {
5686                                          var nbits;
5687                                          var postfix;
5688                                          var offset;
5689                                          distance_code -=
5690                                              num_direct_distance_codes;
5691                                          postfix =
5692                                              distance_code &
5693                                              distance_postfix_mask;
5694                                          distance_code >>= distance_postfix_bits;
5695                                          nbits = ( distance_code >> 1 ) + 1;
5696                                          offset =
5697                                              ( ( 2 + ( distance_code & 1 ) ) <<
5698                                                  nbits ) -
5699                                              4;
5700                                          distance_code =
5701                                              num_direct_distance_codes +
5702                                              ( ( offset +
5703                                                  br.readBits( nbits ) ) <<
5704                                                  distance_postfix_bits ) +
5705                                              postfix;
5706                                      }
5707                                  }
5708  
5709                                  /* Convert the distance code to the actual distance by possibly looking */
5710                                  /* up past distnaces from the ringbuffer. */
5711                                  distance = TranslateShortCodes(
5712                                      distance_code,
5713                                      dist_rb,
5714                                      dist_rb_idx
5715                                  );
5716                                  if ( distance < 0 ) {
5717                                      throw new Error(
5718                                          '[BrotliDecompress] invalid distance'
5719                                      );
5720                                  }
5721  
5722                                  if (
5723                                      pos < max_backward_distance &&
5724                                      max_distance !== max_backward_distance
5725                                  ) {
5726                                      max_distance = pos;
5727                                  } else {
5728                                      max_distance = max_backward_distance;
5729                                  }
5730  
5731                                  copy_dst = pos & ringbuffer_mask;
5732  
5733                                  if ( distance > max_distance ) {
5734                                      if (
5735                                          copy_length >=
5736                                              BrotliDictionary.minDictionaryWordLength &&
5737                                          copy_length <=
5738                                              BrotliDictionary.maxDictionaryWordLength
5739                                      ) {
5740                                          var offset =
5741                                              BrotliDictionary.offsetsByLength[
5742                                                  copy_length
5743                                              ];
5744                                          var word_id =
5745                                              distance - max_distance - 1;
5746                                          var shift =
5747                                              BrotliDictionary.sizeBitsByLength[
5748                                                  copy_length
5749                                              ];
5750                                          var mask = ( 1 << shift ) - 1;
5751                                          var word_idx = word_id & mask;
5752                                          var transform_idx = word_id >> shift;
5753                                          offset += word_idx * copy_length;
5754                                          if (
5755                                              transform_idx <
5756                                              Transform.kNumTransforms
5757                                          ) {
5758                                              var len =
5759                                                  Transform.transformDictionaryWord(
5760                                                      ringbuffer,
5761                                                      copy_dst,
5762                                                      offset,
5763                                                      copy_length,
5764                                                      transform_idx
5765                                                  );
5766                                              copy_dst += len;
5767                                              pos += len;
5768                                              meta_block_remaining_len -= len;
5769                                              if ( copy_dst >= ringbuffer_end ) {
5770                                                  output.write(
5771                                                      ringbuffer,
5772                                                      ringbuffer_size
5773                                                  );
5774  
5775                                                  for (
5776                                                      var _x = 0;
5777                                                      _x <
5778                                                      copy_dst - ringbuffer_end;
5779                                                      _x++
5780                                                  )
5781                                                      ringbuffer[ _x ] =
5782                                                          ringbuffer[
5783                                                              ringbuffer_end + _x
5784                                                          ];
5785                                              }
5786                                          } else {
5787                                              throw new Error(
5788                                                  'Invalid backward reference. pos: ' +
5789                                                      pos +
5790                                                      ' distance: ' +
5791                                                      distance +
5792                                                      ' len: ' +
5793                                                      copy_length +
5794                                                      ' bytes left: ' +
5795                                                      meta_block_remaining_len
5796                                              );
5797                                          }
5798                                      } else {
5799                                          throw new Error(
5800                                              'Invalid backward reference. pos: ' +
5801                                                  pos +
5802                                                  ' distance: ' +
5803                                                  distance +
5804                                                  ' len: ' +
5805                                                  copy_length +
5806                                                  ' bytes left: ' +
5807                                                  meta_block_remaining_len
5808                                          );
5809                                      }
5810                                  } else {
5811                                      if ( distance_code > 0 ) {
5812                                          dist_rb[ dist_rb_idx & 3 ] = distance;
5813                                          ++dist_rb_idx;
5814                                      }
5815  
5816                                      if (
5817                                          copy_length > meta_block_remaining_len
5818                                      ) {
5819                                          throw new Error(
5820                                              'Invalid backward reference. pos: ' +
5821                                                  pos +
5822                                                  ' distance: ' +
5823                                                  distance +
5824                                                  ' len: ' +
5825                                                  copy_length +
5826                                                  ' bytes left: ' +
5827                                                  meta_block_remaining_len
5828                                          );
5829                                      }
5830  
5831                                      for ( j = 0; j < copy_length; ++j ) {
5832                                          ringbuffer[ pos & ringbuffer_mask ] =
5833                                              ringbuffer[
5834                                                  ( pos - distance ) &
5835                                                      ringbuffer_mask
5836                                              ];
5837                                          if (
5838                                              ( pos & ringbuffer_mask ) ===
5839                                              ringbuffer_mask
5840                                          ) {
5841                                              output.write(
5842                                                  ringbuffer,
5843                                                  ringbuffer_size
5844                                              );
5845                                          }
5846                                          ++pos;
5847                                          --meta_block_remaining_len;
5848                                      }
5849                                  }
5850  
5851                                  /* When we get here, we must have inserted at least one literal and */
5852                                  /* made a copy of at least length two, therefore accessing the last 2 */
5853                                  /* bytes is valid. */
5854                                  prev_byte1 =
5855                                      ringbuffer[ ( pos - 1 ) & ringbuffer_mask ];
5856                                  prev_byte2 =
5857                                      ringbuffer[ ( pos - 2 ) & ringbuffer_mask ];
5858                              }
5859  
5860                              /* Protect pos from overflow, wrap it around at every GB of input data */
5861                              pos &= 0x3fffffff;
5862                          }
5863  
5864                          output.write( ringbuffer, pos & ringbuffer_mask );
5865                      }
5866  
5867                      exports.BrotliDecompress = BrotliDecompress;
5868  
5869                      BrotliDictionary.init();
5870                  },
5871                  {
5872                      './bit_reader': 1,
5873                      './context': 2,
5874                      './dictionary': 6,
5875                      './huffman': 7,
5876                      './prefix': 9,
5877                      './streams': 10,
5878                      './transform': 11,
5879                  },
5880              ],
5881              4: [
5882                  function ( require, module, exports ) {
5883                      var base64 = require( 'base64-js' );
5884                      //var fs = require('fs');
5885  
5886                      /**
5887                       * The normal dictionary-data.js is quite large, which makes it
5888                       * unsuitable for browser usage. In order to make it smaller,
5889                       * we read dictionary.bin, which is a compressed version of
5890                       * the dictionary, and on initial load, Brotli decompresses
5891                       * it's own dictionary. 😜
5892                       */
5893                      exports.init = function () {
5894                          var BrotliDecompressBuffer =
5895                              require( './decode' ).BrotliDecompressBuffer;
5896                          var compressed = base64.toByteArray(
5897                              require( './dictionary.bin.js' )
5898                          );
5899                          return BrotliDecompressBuffer( compressed );
5900                      };
5901                  },
5902                  { './decode': 3, './dictionary.bin.js': 5, 'base64-js': 8 },
5903              ],
5904              5: [
5905                  function ( require, module, exports ) {
5906                      module.exports =
5907                          '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';
5908                  },
5909                  {},
5910              ],
5911              6: [
5912                  function ( require, module, exports ) {
5913                      /* Copyright 2013 Google Inc. All Rights Reserved.
5914  
5915     Licensed under the Apache License, Version 2.0 (the "License");
5916     you may not use this file except in compliance with the License.
5917     You may obtain a copy of the License at
5918  
5919     http://www.apache.org/licenses/LICENSE-2.0
5920  
5921     Unless required by applicable law or agreed to in writing, software
5922     distributed under the License is distributed on an "AS IS" BASIS,
5923     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
5924     See the License for the specific language governing permissions and
5925     limitations under the License.
5926  
5927     Collection of static dictionary words.
5928  */
5929  
5930                      var data = require( './dictionary-browser' );
5931                      exports.init = function () {
5932                          exports.dictionary = data.init();
5933                      };
5934  
5935                      exports.offsetsByLength = new Uint32Array( [
5936                          0, 0, 0, 0, 0, 4096, 9216, 21504, 35840, 44032, 53248,
5937                          63488, 74752, 87040, 93696, 100864, 104704, 106752,
5938                          108928, 113536, 115968, 118528, 119872, 121280, 122016,
5939                      ] );
5940  
5941                      exports.sizeBitsByLength = new Uint8Array( [
5942                          0, 0, 0, 0, 10, 10, 11, 11, 10, 10, 10, 10, 10, 9, 9, 8,
5943                          7, 7, 8, 7, 7, 6, 6, 5, 5,
5944                      ] );
5945  
5946                      exports.minDictionaryWordLength = 4;
5947                      exports.maxDictionaryWordLength = 24;
5948                  },
5949                  { './dictionary-browser': 4 },
5950              ],
5951              7: [
5952                  function ( require, module, exports ) {
5953  					function HuffmanCode( bits, value ) {
5954                          this.bits =
5955                              bits; /* number of bits used for this symbol */
5956                          this.value = value; /* symbol value or table offset */
5957                      }
5958  
5959                      exports.HuffmanCode = HuffmanCode;
5960  
5961                      var MAX_LENGTH = 15;
5962  
5963                      /* Returns reverse(reverse(key, len) + 1, len), where reverse(key, len) is the
5964     bit-wise reversal of the len least significant bits of key. */
5965  					function GetNextKey( key, len ) {
5966                          var step = 1 << ( len - 1 );
5967                          while ( key & step ) {
5968                              step >>= 1;
5969                          }
5970                          return ( key & ( step - 1 ) ) + step;
5971                      }
5972  
5973                      /* Stores code in table[0], table[step], table[2*step], ..., table[end] */
5974                      /* Assumes that end is an integer multiple of step */
5975  					function ReplicateValue( table, i, step, end, code ) {
5976                          do {
5977                              end -= step;
5978                              table[ i + end ] = new HuffmanCode(
5979                                  code.bits,
5980                                  code.value
5981                              );
5982                          } while ( end > 0 );
5983                      }
5984  
5985                      /* Returns the table width of the next 2nd level table. count is the histogram
5986     of bit lengths for the remaining symbols, len is the code length of the next
5987     processed symbol */
5988  					function NextTableBitSize( count, len, root_bits ) {
5989                          var left = 1 << ( len - root_bits );
5990                          while ( len < MAX_LENGTH ) {
5991                              left -= count[ len ];
5992                              if ( left <= 0 ) break;
5993                              ++len;
5994                              left <<= 1;
5995                          }
5996                          return len - root_bits;
5997                      }
5998  
5999                      exports.BrotliBuildHuffmanTable = function (
6000                          root_table,
6001                          table,
6002                          root_bits,
6003                          code_lengths,
6004                          code_lengths_size
6005                      ) {
6006                          var start_table = table;
6007                          var code; /* current table entry */
6008                          var len; /* current code length */
6009                          var symbol; /* symbol index in original or sorted table */
6010                          var key; /* reversed prefix code */
6011                          var step; /* step size to replicate values in current table */
6012                          var low; /* low bits for current root entry */
6013                          var mask; /* mask for low bits */
6014                          var table_bits; /* key length of current table */
6015                          var table_size; /* size of current table */
6016                          var total_size; /* sum of root table size and 2nd level table sizes */
6017                          var sorted; /* symbols sorted by code length */
6018                          var count = new Int32Array(
6019                              MAX_LENGTH + 1
6020                          ); /* number of codes of each length */
6021                          var offset = new Int32Array(
6022                              MAX_LENGTH + 1
6023                          ); /* offsets in sorted table for each length */
6024  
6025                          sorted = new Int32Array( code_lengths_size );
6026  
6027                          /* build histogram of code lengths */
6028                          for (
6029                              symbol = 0;
6030                              symbol < code_lengths_size;
6031                              symbol++
6032                          ) {
6033                              count[ code_lengths[ symbol ] ]++;
6034                          }
6035  
6036                          /* generate offsets into sorted symbol table by code length */
6037                          offset[ 1 ] = 0;
6038                          for ( len = 1; len < MAX_LENGTH; len++ ) {
6039                              offset[ len + 1 ] = offset[ len ] + count[ len ];
6040                          }
6041  
6042                          /* sort symbols by length, by symbol order within each length */
6043                          for (
6044                              symbol = 0;
6045                              symbol < code_lengths_size;
6046                              symbol++
6047                          ) {
6048                              if ( code_lengths[ symbol ] !== 0 ) {
6049                                  sorted[ offset[ code_lengths[ symbol ] ]++ ] =
6050                                      symbol;
6051                              }
6052                          }
6053  
6054                          table_bits = root_bits;
6055                          table_size = 1 << table_bits;
6056                          total_size = table_size;
6057  
6058                          /* special case code with only one value */
6059                          if ( offset[ MAX_LENGTH ] === 1 ) {
6060                              for ( key = 0; key < total_size; ++key ) {
6061                                  root_table[ table + key ] = new HuffmanCode(
6062                                      0,
6063                                      sorted[ 0 ] & 0xffff
6064                                  );
6065                              }
6066  
6067                              return total_size;
6068                          }
6069  
6070                          /* fill in root table */
6071                          key = 0;
6072                          symbol = 0;
6073                          for (
6074                              len = 1, step = 2;
6075                              len <= root_bits;
6076                              ++len, step <<= 1
6077                          ) {
6078                              for ( ; count[ len ] > 0; --count[ len ] ) {
6079                                  code = new HuffmanCode(
6080                                      len & 0xff,
6081                                      sorted[ symbol++ ] & 0xffff
6082                                  );
6083                                  ReplicateValue(
6084                                      root_table,
6085                                      table + key,
6086                                      step,
6087                                      table_size,
6088                                      code
6089                                  );
6090                                  key = GetNextKey( key, len );
6091                              }
6092                          }
6093  
6094                          /* fill in 2nd level tables and add pointers to root table */
6095                          mask = total_size - 1;
6096                          low = -1;
6097                          for (
6098                              len = root_bits + 1, step = 2;
6099                              len <= MAX_LENGTH;
6100                              ++len, step <<= 1
6101                          ) {
6102                              for ( ; count[ len ] > 0; --count[ len ] ) {
6103                                  if ( ( key & mask ) !== low ) {
6104                                      table += table_size;
6105                                      table_bits = NextTableBitSize(
6106                                          count,
6107                                          len,
6108                                          root_bits
6109                                      );
6110                                      table_size = 1 << table_bits;
6111                                      total_size += table_size;
6112                                      low = key & mask;
6113                                      root_table[ start_table + low ] =
6114                                          new HuffmanCode(
6115                                              ( table_bits + root_bits ) & 0xff,
6116                                              ( table - start_table - low ) &
6117                                                  0xffff
6118                                          );
6119                                  }
6120                                  code = new HuffmanCode(
6121                                      ( len - root_bits ) & 0xff,
6122                                      sorted[ symbol++ ] & 0xffff
6123                                  );
6124                                  ReplicateValue(
6125                                      root_table,
6126                                      table + ( key >> root_bits ),
6127                                      step,
6128                                      table_size,
6129                                      code
6130                                  );
6131                                  key = GetNextKey( key, len );
6132                              }
6133                          }
6134  
6135                          return total_size;
6136                      };
6137                  },
6138                  {},
6139              ],
6140              8: [
6141                  function ( require, module, exports ) {
6142                      'use strict';
6143  
6144                      exports.byteLength = byteLength;
6145                      exports.toByteArray = toByteArray;
6146                      exports.fromByteArray = fromByteArray;
6147  
6148                      var lookup = [];
6149                      var revLookup = [];
6150                      var Arr =
6151                          typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
6152  
6153                      var code =
6154                          'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
6155                      for ( var i = 0, len = code.length; i < len; ++i ) {
6156                          lookup[ i ] = code[ i ];
6157                          revLookup[ code.charCodeAt( i ) ] = i;
6158                      }
6159  
6160                      // Support decoding URL-safe base64 strings, as Node.js does.
6161                      // See: https://en.wikipedia.org/wiki/Base64#URL_applications
6162                      revLookup[ '-'.charCodeAt( 0 ) ] = 62;
6163                      revLookup[ '_'.charCodeAt( 0 ) ] = 63;
6164  
6165  					function getLens( b64 ) {
6166                          var len = b64.length;
6167  
6168                          if ( len % 4 > 0 ) {
6169                              throw new Error(
6170                                  'Invalid string. Length must be a multiple of 4'
6171                              );
6172                          }
6173  
6174                          // Trim off extra bytes after placeholder bytes are found
6175                          // See: https://github.com/beatgammit/base64-js/issues/42
6176                          var validLen = b64.indexOf( '=' );
6177                          if ( validLen === -1 ) validLen = len;
6178  
6179                          var placeHoldersLen =
6180                              validLen === len ? 0 : 4 - ( validLen % 4 );
6181  
6182                          return [ validLen, placeHoldersLen ];
6183                      }
6184  
6185                      // base64 is 4/3 + up to two characters of the original data
6186  					function byteLength( b64 ) {
6187                          var lens = getLens( b64 );
6188                          var validLen = lens[ 0 ];
6189                          var placeHoldersLen = lens[ 1 ];
6190                          return (
6191                              ( ( validLen + placeHoldersLen ) * 3 ) / 4 -
6192                              placeHoldersLen
6193                          );
6194                      }
6195  
6196  					function _byteLength( b64, validLen, placeHoldersLen ) {
6197                          return (
6198                              ( ( validLen + placeHoldersLen ) * 3 ) / 4 -
6199                              placeHoldersLen
6200                          );
6201                      }
6202  
6203  					function toByteArray( b64 ) {
6204                          var tmp;
6205                          var lens = getLens( b64 );
6206                          var validLen = lens[ 0 ];
6207                          var placeHoldersLen = lens[ 1 ];
6208  
6209                          var arr = new Arr(
6210                              _byteLength( b64, validLen, placeHoldersLen )
6211                          );
6212  
6213                          var curByte = 0;
6214  
6215                          // if there are placeholders, only get up to the last complete 4 chars
6216                          var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
6217  
6218                          for ( var i = 0; i < len; i += 4 ) {
6219                              tmp =
6220                                  ( revLookup[ b64.charCodeAt( i ) ] << 18 ) |
6221                                  ( revLookup[ b64.charCodeAt( i + 1 ) ] << 12 ) |
6222                                  ( revLookup[ b64.charCodeAt( i + 2 ) ] << 6 ) |
6223                                  revLookup[ b64.charCodeAt( i + 3 ) ];
6224                              arr[ curByte++ ] = ( tmp >> 16 ) & 0xff;
6225                              arr[ curByte++ ] = ( tmp >> 8 ) & 0xff;
6226                              arr[ curByte++ ] = tmp & 0xff;
6227                          }
6228  
6229                          if ( placeHoldersLen === 2 ) {
6230                              tmp =
6231                                  ( revLookup[ b64.charCodeAt( i ) ] << 2 ) |
6232                                  ( revLookup[ b64.charCodeAt( i + 1 ) ] >> 4 );
6233                              arr[ curByte++ ] = tmp & 0xff;
6234                          }
6235  
6236                          if ( placeHoldersLen === 1 ) {
6237                              tmp =
6238                                  ( revLookup[ b64.charCodeAt( i ) ] << 10 ) |
6239                                  ( revLookup[ b64.charCodeAt( i + 1 ) ] << 4 ) |
6240                                  ( revLookup[ b64.charCodeAt( i + 2 ) ] >> 2 );
6241                              arr[ curByte++ ] = ( tmp >> 8 ) & 0xff;
6242                              arr[ curByte++ ] = tmp & 0xff;
6243                          }
6244  
6245                          return arr;
6246                      }
6247  
6248  					function tripletToBase64( num ) {
6249                          return (
6250                              lookup[ ( num >> 18 ) & 0x3f ] +
6251                              lookup[ ( num >> 12 ) & 0x3f ] +
6252                              lookup[ ( num >> 6 ) & 0x3f ] +
6253                              lookup[ num & 0x3f ]
6254                          );
6255                      }
6256  
6257  					function encodeChunk( uint8, start, end ) {
6258                          var tmp;
6259                          var output = [];
6260                          for ( var i = start; i < end; i += 3 ) {
6261                              tmp =
6262                                  ( ( uint8[ i ] << 16 ) & 0xff0000 ) +
6263                                  ( ( uint8[ i + 1 ] << 8 ) & 0xff00 ) +
6264                                  ( uint8[ i + 2 ] & 0xff );
6265                              output.push( tripletToBase64( tmp ) );
6266                          }
6267                          return output.join( '' );
6268                      }
6269  
6270  					function fromByteArray( uint8 ) {
6271                          var tmp;
6272                          var len = uint8.length;
6273                          var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
6274                          var parts = [];
6275                          var maxChunkLength = 16383; // must be multiple of 3
6276  
6277                          // go through the array every three bytes, we'll deal with trailing stuff later
6278                          for (
6279                              var i = 0, len2 = len - extraBytes;
6280                              i < len2;
6281                              i += maxChunkLength
6282                          ) {
6283                              parts.push(
6284                                  encodeChunk(
6285                                      uint8,
6286                                      i,
6287                                      i + maxChunkLength > len2
6288                                          ? len2
6289                                          : i + maxChunkLength
6290                                  )
6291                              );
6292                          }
6293  
6294                          // pad the end with zeros, but make sure to not forget the extra bytes
6295                          if ( extraBytes === 1 ) {
6296                              tmp = uint8[ len - 1 ];
6297                              parts.push(
6298                                  lookup[ tmp >> 2 ] +
6299                                      lookup[ ( tmp << 4 ) & 0x3f ] +
6300                                      '=='
6301                              );
6302                          } else if ( extraBytes === 2 ) {
6303                              tmp = ( uint8[ len - 2 ] << 8 ) + uint8[ len - 1 ];
6304                              parts.push(
6305                                  lookup[ tmp >> 10 ] +
6306                                      lookup[ ( tmp >> 4 ) & 0x3f ] +
6307                                      lookup[ ( tmp << 2 ) & 0x3f ] +
6308                                      '='
6309                              );
6310                          }
6311  
6312                          return parts.join( '' );
6313                      }
6314                  },
6315                  {},
6316              ],
6317              9: [
6318                  function ( require, module, exports ) {
6319                      /* Copyright 2013 Google Inc. All Rights Reserved.
6320  
6321     Licensed under the Apache License, Version 2.0 (the "License");
6322     you may not use this file except in compliance with the License.
6323     You may obtain a copy of the License at
6324  
6325     http://www.apache.org/licenses/LICENSE-2.0
6326  
6327     Unless required by applicable law or agreed to in writing, software
6328     distributed under the License is distributed on an "AS IS" BASIS,
6329     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
6330     See the License for the specific language governing permissions and
6331     limitations under the License.
6332  
6333     Lookup tables to map prefix codes to value ranges. This is used during
6334     decoding of the block lengths, literal insertion lengths and copy lengths.
6335  */
6336  
6337                      /* Represents the range of values belonging to a prefix code: */
6338                      /* [offset, offset + 2^nbits) */
6339  					function PrefixCodeRange( offset, nbits ) {
6340                          this.offset = offset;
6341                          this.nbits = nbits;
6342                      }
6343  
6344                      exports.kBlockLengthPrefixCode = [
6345                          new PrefixCodeRange( 1, 2 ),
6346                          new PrefixCodeRange( 5, 2 ),
6347                          new PrefixCodeRange( 9, 2 ),
6348                          new PrefixCodeRange( 13, 2 ),
6349                          new PrefixCodeRange( 17, 3 ),
6350                          new PrefixCodeRange( 25, 3 ),
6351                          new PrefixCodeRange( 33, 3 ),
6352                          new PrefixCodeRange( 41, 3 ),
6353                          new PrefixCodeRange( 49, 4 ),
6354                          new PrefixCodeRange( 65, 4 ),
6355                          new PrefixCodeRange( 81, 4 ),
6356                          new PrefixCodeRange( 97, 4 ),
6357                          new PrefixCodeRange( 113, 5 ),
6358                          new PrefixCodeRange( 145, 5 ),
6359                          new PrefixCodeRange( 177, 5 ),
6360                          new PrefixCodeRange( 209, 5 ),
6361                          new PrefixCodeRange( 241, 6 ),
6362                          new PrefixCodeRange( 305, 6 ),
6363                          new PrefixCodeRange( 369, 7 ),
6364                          new PrefixCodeRange( 497, 8 ),
6365                          new PrefixCodeRange( 753, 9 ),
6366                          new PrefixCodeRange( 1265, 10 ),
6367                          new PrefixCodeRange( 2289, 11 ),
6368                          new PrefixCodeRange( 4337, 12 ),
6369                          new PrefixCodeRange( 8433, 13 ),
6370                          new PrefixCodeRange( 16625, 24 ),
6371                      ];
6372  
6373                      exports.kInsertLengthPrefixCode = [
6374                          new PrefixCodeRange( 0, 0 ),
6375                          new PrefixCodeRange( 1, 0 ),
6376                          new PrefixCodeRange( 2, 0 ),
6377                          new PrefixCodeRange( 3, 0 ),
6378                          new PrefixCodeRange( 4, 0 ),
6379                          new PrefixCodeRange( 5, 0 ),
6380                          new PrefixCodeRange( 6, 1 ),
6381                          new PrefixCodeRange( 8, 1 ),
6382                          new PrefixCodeRange( 10, 2 ),
6383                          new PrefixCodeRange( 14, 2 ),
6384                          new PrefixCodeRange( 18, 3 ),
6385                          new PrefixCodeRange( 26, 3 ),
6386                          new PrefixCodeRange( 34, 4 ),
6387                          new PrefixCodeRange( 50, 4 ),
6388                          new PrefixCodeRange( 66, 5 ),
6389                          new PrefixCodeRange( 98, 5 ),
6390                          new PrefixCodeRange( 130, 6 ),
6391                          new PrefixCodeRange( 194, 7 ),
6392                          new PrefixCodeRange( 322, 8 ),
6393                          new PrefixCodeRange( 578, 9 ),
6394                          new PrefixCodeRange( 1090, 10 ),
6395                          new PrefixCodeRange( 2114, 12 ),
6396                          new PrefixCodeRange( 6210, 14 ),
6397                          new PrefixCodeRange( 22594, 24 ),
6398                      ];
6399  
6400                      exports.kCopyLengthPrefixCode = [
6401                          new PrefixCodeRange( 2, 0 ),
6402                          new PrefixCodeRange( 3, 0 ),
6403                          new PrefixCodeRange( 4, 0 ),
6404                          new PrefixCodeRange( 5, 0 ),
6405                          new PrefixCodeRange( 6, 0 ),
6406                          new PrefixCodeRange( 7, 0 ),
6407                          new PrefixCodeRange( 8, 0 ),
6408                          new PrefixCodeRange( 9, 0 ),
6409                          new PrefixCodeRange( 10, 1 ),
6410                          new PrefixCodeRange( 12, 1 ),
6411                          new PrefixCodeRange( 14, 2 ),
6412                          new PrefixCodeRange( 18, 2 ),
6413                          new PrefixCodeRange( 22, 3 ),
6414                          new PrefixCodeRange( 30, 3 ),
6415                          new PrefixCodeRange( 38, 4 ),
6416                          new PrefixCodeRange( 54, 4 ),
6417                          new PrefixCodeRange( 70, 5 ),
6418                          new PrefixCodeRange( 102, 5 ),
6419                          new PrefixCodeRange( 134, 6 ),
6420                          new PrefixCodeRange( 198, 7 ),
6421                          new PrefixCodeRange( 326, 8 ),
6422                          new PrefixCodeRange( 582, 9 ),
6423                          new PrefixCodeRange( 1094, 10 ),
6424                          new PrefixCodeRange( 2118, 24 ),
6425                      ];
6426  
6427                      exports.kInsertRangeLut = [ 0, 0, 8, 8, 0, 16, 8, 16, 16 ];
6428  
6429                      exports.kCopyRangeLut = [ 0, 8, 0, 8, 16, 0, 16, 8, 16 ];
6430                  },
6431                  {},
6432              ],
6433              10: [
6434                  function ( require, module, exports ) {
6435  					function BrotliInput( buffer ) {
6436                          this.buffer = buffer;
6437                          this.pos = 0;
6438                      }
6439  
6440                      BrotliInput.prototype.read = function ( buf, i, count ) {
6441                          if ( this.pos + count > this.buffer.length ) {
6442                              count = this.buffer.length - this.pos;
6443                          }
6444  
6445                          for ( var p = 0; p < count; p++ )
6446                              buf[ i + p ] = this.buffer[ this.pos + p ];
6447  
6448                          this.pos += count;
6449                          return count;
6450                      };
6451  
6452                      exports.BrotliInput = BrotliInput;
6453  
6454  					function BrotliOutput( buf ) {
6455                          this.buffer = buf;
6456                          this.pos = 0;
6457                      }
6458  
6459                      BrotliOutput.prototype.write = function ( buf, count ) {
6460                          if ( this.pos + count > this.buffer.length )
6461                              throw new Error(
6462                                  'Output buffer is not large enough'
6463                              );
6464  
6465                          this.buffer.set( buf.subarray( 0, count ), this.pos );
6466                          this.pos += count;
6467                          return count;
6468                      };
6469  
6470                      exports.BrotliOutput = BrotliOutput;
6471                  },
6472                  {},
6473              ],
6474              11: [
6475                  function ( require, module, exports ) {
6476                      /* Copyright 2013 Google Inc. All Rights Reserved.
6477  
6478     Licensed under the Apache License, Version 2.0 (the "License");
6479     you may not use this file except in compliance with the License.
6480     You may obtain a copy of the License at
6481  
6482     http://www.apache.org/licenses/LICENSE-2.0
6483  
6484     Unless required by applicable law or agreed to in writing, software
6485     distributed under the License is distributed on an "AS IS" BASIS,
6486     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
6487     See the License for the specific language governing permissions and
6488     limitations under the License.
6489  
6490     Transformations on dictionary words.
6491  */
6492  
6493                      var BrotliDictionary = require( './dictionary' );
6494  
6495                      var kIdentity = 0;
6496                      var kOmitLast1 = 1;
6497                      var kOmitLast2 = 2;
6498                      var kOmitLast3 = 3;
6499                      var kOmitLast4 = 4;
6500                      var kOmitLast5 = 5;
6501                      var kOmitLast6 = 6;
6502                      var kOmitLast7 = 7;
6503                      var kOmitLast8 = 8;
6504                      var kOmitLast9 = 9;
6505                      var kUppercaseFirst = 10;
6506                      var kUppercaseAll = 11;
6507                      var kOmitFirst1 = 12;
6508                      var kOmitFirst2 = 13;
6509                      var kOmitFirst3 = 14;
6510                      var kOmitFirst4 = 15;
6511                      var kOmitFirst5 = 16;
6512                      var kOmitFirst6 = 17;
6513                      var kOmitFirst7 = 18;
6514                      var kOmitFirst8 = 19;
6515                      var kOmitFirst9 = 20;
6516  
6517  					function Transform( prefix, transform, suffix ) {
6518                          this.prefix = new Uint8Array( prefix.length );
6519                          this.transform = transform;
6520                          this.suffix = new Uint8Array( suffix.length );
6521  
6522                          for ( var i = 0; i < prefix.length; i++ )
6523                              this.prefix[ i ] = prefix.charCodeAt( i );
6524  
6525                          for ( var i = 0; i < suffix.length; i++ )
6526                              this.suffix[ i ] = suffix.charCodeAt( i );
6527                      }
6528  
6529                      var kTransforms = [
6530                          new Transform( '', kIdentity, '' ),
6531                          new Transform( '', kIdentity, ' ' ),
6532                          new Transform( ' ', kIdentity, ' ' ),
6533                          new Transform( '', kOmitFirst1, '' ),
6534                          new Transform( '', kUppercaseFirst, ' ' ),
6535                          new Transform( '', kIdentity, ' the ' ),
6536                          new Transform( ' ', kIdentity, '' ),
6537                          new Transform( 's ', kIdentity, ' ' ),
6538                          new Transform( '', kIdentity, ' of ' ),
6539                          new Transform( '', kUppercaseFirst, '' ),
6540                          new Transform( '', kIdentity, ' and ' ),
6541                          new Transform( '', kOmitFirst2, '' ),
6542                          new Transform( '', kOmitLast1, '' ),
6543                          new Transform( ', ', kIdentity, ' ' ),
6544                          new Transform( '', kIdentity, ', ' ),
6545                          new Transform( ' ', kUppercaseFirst, ' ' ),
6546                          new Transform( '', kIdentity, ' in ' ),
6547                          new Transform( '', kIdentity, ' to ' ),
6548                          new Transform( 'e ', kIdentity, ' ' ),
6549                          new Transform( '', kIdentity, '"' ),
6550                          new Transform( '', kIdentity, '.' ),
6551                          new Transform( '', kIdentity, '">' ),
6552                          new Transform( '', kIdentity, '\n' ),
6553                          new Transform( '', kOmitLast3, '' ),
6554                          new Transform( '', kIdentity, ']' ),
6555                          new Transform( '', kIdentity, ' for ' ),
6556                          new Transform( '', kOmitFirst3, '' ),
6557                          new Transform( '', kOmitLast2, '' ),
6558                          new Transform( '', kIdentity, ' a ' ),
6559                          new Transform( '', kIdentity, ' that ' ),
6560                          new Transform( ' ', kUppercaseFirst, '' ),
6561                          new Transform( '', kIdentity, '. ' ),
6562                          new Transform( '.', kIdentity, '' ),
6563                          new Transform( ' ', kIdentity, ', ' ),
6564                          new Transform( '', kOmitFirst4, '' ),
6565                          new Transform( '', kIdentity, ' with ' ),
6566                          new Transform( '', kIdentity, "'" ),
6567                          new Transform( '', kIdentity, ' from ' ),
6568                          new Transform( '', kIdentity, ' by ' ),
6569                          new Transform( '', kOmitFirst5, '' ),
6570                          new Transform( '', kOmitFirst6, '' ),
6571                          new Transform( ' the ', kIdentity, '' ),
6572                          new Transform( '', kOmitLast4, '' ),
6573                          new Transform( '', kIdentity, '. The ' ),
6574                          new Transform( '', kUppercaseAll, '' ),
6575                          new Transform( '', kIdentity, ' on ' ),
6576                          new Transform( '', kIdentity, ' as ' ),
6577                          new Transform( '', kIdentity, ' is ' ),
6578                          new Transform( '', kOmitLast7, '' ),
6579                          new Transform( '', kOmitLast1, 'ing ' ),
6580                          new Transform( '', kIdentity, '\n\t' ),
6581                          new Transform( '', kIdentity, ':' ),
6582                          new Transform( ' ', kIdentity, '. ' ),
6583                          new Transform( '', kIdentity, 'ed ' ),
6584                          new Transform( '', kOmitFirst9, '' ),
6585                          new Transform( '', kOmitFirst7, '' ),
6586                          new Transform( '', kOmitLast6, '' ),
6587                          new Transform( '', kIdentity, '(' ),
6588                          new Transform( '', kUppercaseFirst, ', ' ),
6589                          new Transform( '', kOmitLast8, '' ),
6590                          new Transform( '', kIdentity, ' at ' ),
6591                          new Transform( '', kIdentity, 'ly ' ),
6592                          new Transform( ' the ', kIdentity, ' of ' ),
6593                          new Transform( '', kOmitLast5, '' ),
6594                          new Transform( '', kOmitLast9, '' ),
6595                          new Transform( ' ', kUppercaseFirst, ', ' ),
6596                          new Transform( '', kUppercaseFirst, '"' ),
6597                          new Transform( '.', kIdentity, '(' ),
6598                          new Transform( '', kUppercaseAll, ' ' ),
6599                          new Transform( '', kUppercaseFirst, '">' ),
6600                          new Transform( '', kIdentity, '="' ),
6601                          new Transform( ' ', kIdentity, '.' ),
6602                          new Transform( '.com/', kIdentity, '' ),
6603                          new Transform( ' the ', kIdentity, ' of the ' ),
6604                          new Transform( '', kUppercaseFirst, "'" ),
6605                          new Transform( '', kIdentity, '. This ' ),
6606                          new Transform( '', kIdentity, ',' ),
6607                          new Transform( '.', kIdentity, ' ' ),
6608                          new Transform( '', kUppercaseFirst, '(' ),
6609                          new Transform( '', kUppercaseFirst, '.' ),
6610                          new Transform( '', kIdentity, ' not ' ),
6611                          new Transform( ' ', kIdentity, '="' ),
6612                          new Transform( '', kIdentity, 'er ' ),
6613                          new Transform( ' ', kUppercaseAll, ' ' ),
6614                          new Transform( '', kIdentity, 'al ' ),
6615                          new Transform( ' ', kUppercaseAll, '' ),
6616                          new Transform( '', kIdentity, "='" ),
6617                          new Transform( '', kUppercaseAll, '"' ),
6618                          new Transform( '', kUppercaseFirst, '. ' ),
6619                          new Transform( ' ', kIdentity, '(' ),
6620                          new Transform( '', kIdentity, 'ful ' ),
6621                          new Transform( ' ', kUppercaseFirst, '. ' ),
6622                          new Transform( '', kIdentity, 'ive ' ),
6623                          new Transform( '', kIdentity, 'less ' ),
6624                          new Transform( '', kUppercaseAll, "'" ),
6625                          new Transform( '', kIdentity, 'est ' ),
6626                          new Transform( ' ', kUppercaseFirst, '.' ),
6627                          new Transform( '', kUppercaseAll, '">' ),
6628                          new Transform( ' ', kIdentity, "='" ),
6629                          new Transform( '', kUppercaseFirst, ',' ),
6630                          new Transform( '', kIdentity, 'ize ' ),
6631                          new Transform( '', kUppercaseAll, '.' ),
6632                          new Transform( '\xc2\xa0', kIdentity, '' ),
6633                          new Transform( ' ', kIdentity, ',' ),
6634                          new Transform( '', kUppercaseFirst, '="' ),
6635                          new Transform( '', kUppercaseAll, '="' ),
6636                          new Transform( '', kIdentity, 'ous ' ),
6637                          new Transform( '', kUppercaseAll, ', ' ),
6638                          new Transform( '', kUppercaseFirst, "='" ),
6639                          new Transform( ' ', kUppercaseFirst, ',' ),
6640                          new Transform( ' ', kUppercaseAll, '="' ),
6641                          new Transform( ' ', kUppercaseAll, ', ' ),
6642                          new Transform( '', kUppercaseAll, ',' ),
6643                          new Transform( '', kUppercaseAll, '(' ),
6644                          new Transform( '', kUppercaseAll, '. ' ),
6645                          new Transform( ' ', kUppercaseAll, '.' ),
6646                          new Transform( '', kUppercaseAll, "='" ),
6647                          new Transform( ' ', kUppercaseAll, '. ' ),
6648                          new Transform( ' ', kUppercaseFirst, '="' ),
6649                          new Transform( ' ', kUppercaseAll, "='" ),
6650                          new Transform( ' ', kUppercaseFirst, "='" ),
6651                      ];
6652  
6653                      exports.kTransforms = kTransforms;
6654                      exports.kNumTransforms = kTransforms.length;
6655  
6656  					function ToUpperCase( p, i ) {
6657                          if ( p[ i ] < 0xc0 ) {
6658                              if ( p[ i ] >= 97 && p[ i ] <= 122 ) {
6659                                  p[ i ] ^= 32;
6660                              }
6661                              return 1;
6662                          }
6663  
6664                          /* An overly simplified uppercasing model for utf-8. */
6665                          if ( p[ i ] < 0xe0 ) {
6666                              p[ i + 1 ] ^= 32;
6667                              return 2;
6668                          }
6669  
6670                          /* An arbitrary transform for three byte characters. */
6671                          p[ i + 2 ] ^= 5;
6672                          return 3;
6673                      }
6674  
6675                      exports.transformDictionaryWord = function (
6676                          dst,
6677                          idx,
6678                          word,
6679                          len,
6680                          transform
6681                      ) {
6682                          var prefix = kTransforms[ transform ].prefix;
6683                          var suffix = kTransforms[ transform ].suffix;
6684                          var t = kTransforms[ transform ].transform;
6685                          var skip =
6686                              t < kOmitFirst1 ? 0 : t - ( kOmitFirst1 - 1 );
6687                          var i = 0;
6688                          var start_idx = idx;
6689                          var uppercase;
6690  
6691                          if ( skip > len ) {
6692                              skip = len;
6693                          }
6694  
6695                          var prefix_pos = 0;
6696                          while ( prefix_pos < prefix.length ) {
6697                              dst[ idx++ ] = prefix[ prefix_pos++ ];
6698                          }
6699  
6700                          word += skip;
6701                          len -= skip;
6702  
6703                          if ( t <= kOmitLast9 ) {
6704                              len -= t;
6705                          }
6706  
6707                          for ( i = 0; i < len; i++ ) {
6708                              dst[ idx++ ] =
6709                                  BrotliDictionary.dictionary[ word + i ];
6710                          }
6711  
6712                          uppercase = idx - len;
6713  
6714                          if ( t === kUppercaseFirst ) {
6715                              ToUpperCase( dst, uppercase );
6716                          } else if ( t === kUppercaseAll ) {
6717                              while ( len > 0 ) {
6718                                  var step = ToUpperCase( dst, uppercase );
6719                                  uppercase += step;
6720                                  len -= step;
6721                              }
6722                          }
6723  
6724                          var suffix_pos = 0;
6725                          while ( suffix_pos < suffix.length ) {
6726                              dst[ idx++ ] = suffix[ suffix_pos++ ];
6727                          }
6728  
6729                          return idx - start_idx;
6730                      };
6731                  },
6732                  { './dictionary': 6 },
6733              ],
6734              12: [
6735                  function ( require, module, exports ) {
6736                      module.exports =
6737                          require( './dec/decode' ).BrotliDecompressBuffer;
6738                  },
6739                  { './dec/decode': 3 },
6740              ],
6741          },
6742          {},
6743          [ 12 ]
6744      )( 12 );
6745  } );
6746  /* eslint-enable */
6747  
6748  
6749  /***/ }),
6750  
6751  /***/ 9681:
6752  /***/ ((module) => {
6753  
6754  var characterMap = {
6755      "À": "A",
6756      "Á": "A",
6757      "Â": "A",
6758      "Ã": "A",
6759      "Ä": "A",
6760      "Å": "A",
6761      "Ấ": "A",
6762      "Ắ": "A",
6763      "Ẳ": "A",
6764      "Ẵ": "A",
6765      "Ặ": "A",
6766      "Æ": "AE",
6767      "Ầ": "A",
6768      "Ằ": "A",
6769      "Ȃ": "A",
6770      "Ả": "A",
6771      "Ạ": "A",
6772      "Ẩ": "A",
6773      "Ẫ": "A",
6774      "Ậ": "A",
6775      "Ç": "C",
6776      "Ḉ": "C",
6777      "È": "E",
6778      "É": "E",
6779      "Ê": "E",
6780      "Ë": "E",
6781      "Ế": "E",
6782      "Ḗ": "E",
6783      "Ề": "E",
6784      "Ḕ": "E",
6785      "Ḝ": "E",
6786      "Ȇ": "E",
6787      "Ẻ": "E",
6788      "Ẽ": "E",
6789      "Ẹ": "E",
6790      "Ể": "E",
6791      "Ễ": "E",
6792      "Ệ": "E",
6793      "Ì": "I",
6794      "Í": "I",
6795      "Î": "I",
6796      "Ï": "I",
6797      "Ḯ": "I",
6798      "Ȋ": "I",
6799      "Ỉ": "I",
6800      "Ị": "I",
6801      "Ð": "D",
6802      "Ñ": "N",
6803      "Ò": "O",
6804      "Ó": "O",
6805      "Ô": "O",
6806      "Õ": "O",
6807      "Ö": "O",
6808      "Ø": "O",
6809      "Ố": "O",
6810      "Ṍ": "O",
6811      "Ṓ": "O",
6812      "Ȏ": "O",
6813      "Ỏ": "O",
6814      "Ọ": "O",
6815      "Ổ": "O",
6816      "Ỗ": "O",
6817      "Ộ": "O",
6818      "Ờ": "O",
6819      "Ở": "O",
6820      "Ỡ": "O",
6821      "Ớ": "O",
6822      "Ợ": "O",
6823      "Ù": "U",
6824      "Ú": "U",
6825      "Û": "U",
6826      "Ü": "U",
6827      "Ủ": "U",
6828      "Ụ": "U",
6829      "Ử": "U",
6830      "Ữ": "U",
6831      "Ự": "U",
6832      "Ý": "Y",
6833      "à": "a",
6834      "á": "a",
6835      "â": "a",
6836      "ã": "a",
6837      "ä": "a",
6838      "å": "a",
6839      "ấ": "a",
6840      "ắ": "a",
6841      "ẳ": "a",
6842      "ẵ": "a",
6843      "ặ": "a",
6844      "æ": "ae",
6845      "ầ": "a",
6846      "ằ": "a",
6847      "ȃ": "a",
6848      "ả": "a",
6849      "ạ": "a",
6850      "ẩ": "a",
6851      "ẫ": "a",
6852      "ậ": "a",
6853      "ç": "c",
6854      "ḉ": "c",
6855      "è": "e",
6856      "é": "e",
6857      "ê": "e",
6858      "ë": "e",
6859      "ế": "e",
6860      "ḗ": "e",
6861      "ề": "e",
6862      "ḕ": "e",
6863      "ḝ": "e",
6864      "ȇ": "e",
6865      "ẻ": "e",
6866      "ẽ": "e",
6867      "ẹ": "e",
6868      "ể": "e",
6869      "ễ": "e",
6870      "ệ": "e",
6871      "ì": "i",
6872      "í": "i",
6873      "î": "i",
6874      "ï": "i",
6875      "ḯ": "i",
6876      "ȋ": "i",
6877      "ỉ": "i",
6878      "ị": "i",
6879      "ð": "d",
6880      "ñ": "n",
6881      "ò": "o",
6882      "ó": "o",
6883      "ô": "o",
6884      "õ": "o",
6885      "ö": "o",
6886      "ø": "o",
6887      "ố": "o",
6888      "ṍ": "o",
6889      "ṓ": "o",
6890      "ȏ": "o",
6891      "ỏ": "o",
6892      "ọ": "o",
6893      "ổ": "o",
6894      "ỗ": "o",
6895      "ộ": "o",
6896      "ờ": "o",
6897      "ở": "o",
6898      "ỡ": "o",
6899      "ớ": "o",
6900      "ợ": "o",
6901      "ù": "u",
6902      "ú": "u",
6903      "û": "u",
6904      "ü": "u",
6905      "ủ": "u",
6906      "ụ": "u",
6907      "ử": "u",
6908      "ữ": "u",
6909      "ự": "u",
6910      "ý": "y",
6911      "ÿ": "y",
6912      "Ā": "A",
6913      "ā": "a",
6914      "Ă": "A",
6915      "ă": "a",
6916      "Ą": "A",
6917      "ą": "a",
6918      "Ć": "C",
6919      "ć": "c",
6920      "Ĉ": "C",
6921      "ĉ": "c",
6922      "Ċ": "C",
6923      "ċ": "c",
6924      "Č": "C",
6925      "č": "c",
6926      "C̆": "C",
6927      "c̆": "c",
6928      "Ď": "D",
6929      "ď": "d",
6930      "Đ": "D",
6931      "đ": "d",
6932      "Ē": "E",
6933      "ē": "e",
6934      "Ĕ": "E",
6935      "ĕ": "e",
6936      "Ė": "E",
6937      "ė": "e",
6938      "Ę": "E",
6939      "ę": "e",
6940      "Ě": "E",
6941      "ě": "e",
6942      "Ĝ": "G",
6943      "Ǵ": "G",
6944      "ĝ": "g",
6945      "ǵ": "g",
6946      "Ğ": "G",
6947      "ğ": "g",
6948      "Ġ": "G",
6949      "ġ": "g",
6950      "Ģ": "G",
6951      "ģ": "g",
6952      "Ĥ": "H",
6953      "ĥ": "h",
6954      "Ħ": "H",
6955      "ħ": "h",
6956      "Ḫ": "H",
6957      "ḫ": "h",
6958      "Ĩ": "I",
6959      "ĩ": "i",
6960      "Ī": "I",
6961      "ī": "i",
6962      "Ĭ": "I",
6963      "ĭ": "i",
6964      "Į": "I",
6965      "į": "i",
6966      "İ": "I",
6967      "ı": "i",
6968      "IJ": "IJ",
6969      "ij": "ij",
6970      "Ĵ": "J",
6971      "ĵ": "j",
6972      "Ķ": "K",
6973      "ķ": "k",
6974      "Ḱ": "K",
6975      "ḱ": "k",
6976      "K̆": "K",
6977      "k̆": "k",
6978      "Ĺ": "L",
6979      "ĺ": "l",
6980      "Ļ": "L",
6981      "ļ": "l",
6982      "Ľ": "L",
6983      "ľ": "l",
6984      "Ŀ": "L",
6985      "ŀ": "l",
6986      "Ł": "l",
6987      "ł": "l",
6988      "Ḿ": "M",
6989      "ḿ": "m",
6990      "M̆": "M",
6991      "m̆": "m",
6992      "Ń": "N",
6993      "ń": "n",
6994      "Ņ": "N",
6995      "ņ": "n",
6996      "Ň": "N",
6997      "ň": "n",
6998      "ʼn": "n",
6999      "N̆": "N",
7000      "n̆": "n",
7001      "Ō": "O",
7002      "ō": "o",
7003      "Ŏ": "O",
7004      "ŏ": "o",
7005      "Ő": "O",
7006      "ő": "o",
7007      "Œ": "OE",
7008      "œ": "oe",
7009      "P̆": "P",
7010      "p̆": "p",
7011      "Ŕ": "R",
7012      "ŕ": "r",
7013      "Ŗ": "R",
7014      "ŗ": "r",
7015      "Ř": "R",
7016      "ř": "r",
7017      "R̆": "R",
7018      "r̆": "r",
7019      "Ȓ": "R",
7020      "ȓ": "r",
7021      "Ś": "S",
7022      "ś": "s",
7023      "Ŝ": "S",
7024      "ŝ": "s",
7025      "Ş": "S",
7026      "Ș": "S",
7027      "ș": "s",
7028      "ş": "s",
7029      "Š": "S",
7030      "š": "s",
7031      "Ţ": "T",
7032      "ţ": "t",
7033      "ț": "t",
7034      "Ț": "T",
7035      "Ť": "T",
7036      "ť": "t",
7037      "Ŧ": "T",
7038      "ŧ": "t",
7039      "T̆": "T",
7040      "t̆": "t",
7041      "Ũ": "U",
7042      "ũ": "u",
7043      "Ū": "U",
7044      "ū": "u",
7045      "Ŭ": "U",
7046      "ŭ": "u",
7047      "Ů": "U",
7048      "ů": "u",
7049      "Ű": "U",
7050      "ű": "u",
7051      "Ų": "U",
7052      "ų": "u",
7053      "Ȗ": "U",
7054      "ȗ": "u",
7055      "V̆": "V",
7056      "v̆": "v",
7057      "Ŵ": "W",
7058      "ŵ": "w",
7059      "Ẃ": "W",
7060      "ẃ": "w",
7061      "X̆": "X",
7062      "x̆": "x",
7063      "Ŷ": "Y",
7064      "ŷ": "y",
7065      "Ÿ": "Y",
7066      "Y̆": "Y",
7067      "y̆": "y",
7068      "Ź": "Z",
7069      "ź": "z",
7070      "Ż": "Z",
7071      "ż": "z",
7072      "Ž": "Z",
7073      "ž": "z",
7074      "ſ": "s",
7075      "ƒ": "f",
7076      "Ơ": "O",
7077      "ơ": "o",
7078      "Ư": "U",
7079      "ư": "u",
7080      "Ǎ": "A",
7081      "ǎ": "a",
7082      "Ǐ": "I",
7083      "ǐ": "i",
7084      "Ǒ": "O",
7085      "ǒ": "o",
7086      "Ǔ": "U",
7087      "ǔ": "u",
7088      "Ǖ": "U",
7089      "ǖ": "u",
7090      "Ǘ": "U",
7091      "ǘ": "u",
7092      "Ǚ": "U",
7093      "ǚ": "u",
7094      "Ǜ": "U",
7095      "ǜ": "u",
7096      "Ứ": "U",
7097      "ứ": "u",
7098      "Ṹ": "U",
7099      "ṹ": "u",
7100      "Ǻ": "A",
7101      "ǻ": "a",
7102      "Ǽ": "AE",
7103      "ǽ": "ae",
7104      "Ǿ": "O",
7105      "ǿ": "o",
7106      "Þ": "TH",
7107      "þ": "th",
7108      "Ṕ": "P",
7109      "ṕ": "p",
7110      "Ṥ": "S",
7111      "ṥ": "s",
7112      "X́": "X",
7113      "x́": "x",
7114      "Ѓ": "Г",
7115      "ѓ": "г",
7116      "Ќ": "К",
7117      "ќ": "к",
7118      "A̋": "A",
7119      "a̋": "a",
7120      "E̋": "E",
7121      "e̋": "e",
7122      "I̋": "I",
7123      "i̋": "i",
7124      "Ǹ": "N",
7125      "ǹ": "n",
7126      "Ồ": "O",
7127      "ồ": "o",
7128      "Ṑ": "O",
7129      "ṑ": "o",
7130      "Ừ": "U",
7131      "ừ": "u",
7132      "Ẁ": "W",
7133      "ẁ": "w",
7134      "Ỳ": "Y",
7135      "ỳ": "y",
7136      "Ȁ": "A",
7137      "ȁ": "a",
7138      "Ȅ": "E",
7139      "ȅ": "e",
7140      "Ȉ": "I",
7141      "ȉ": "i",
7142      "Ȍ": "O",
7143      "ȍ": "o",
7144      "Ȑ": "R",
7145      "ȑ": "r",
7146      "Ȕ": "U",
7147      "ȕ": "u",
7148      "B̌": "B",
7149      "b̌": "b",
7150      "Č̣": "C",
7151      "č̣": "c",
7152      "Ê̌": "E",
7153      "ê̌": "e",
7154      "F̌": "F",
7155      "f̌": "f",
7156      "Ǧ": "G",
7157      "ǧ": "g",
7158      "Ȟ": "H",
7159      "ȟ": "h",
7160      "J̌": "J",
7161      "ǰ": "j",
7162      "Ǩ": "K",
7163      "ǩ": "k",
7164      "M̌": "M",
7165      "m̌": "m",
7166      "P̌": "P",
7167      "p̌": "p",
7168      "Q̌": "Q",
7169      "q̌": "q",
7170      "Ř̩": "R",
7171      "ř̩": "r",
7172      "Ṧ": "S",
7173      "ṧ": "s",
7174      "V̌": "V",
7175      "v̌": "v",
7176      "W̌": "W",
7177      "w̌": "w",
7178      "X̌": "X",
7179      "x̌": "x",
7180      "Y̌": "Y",
7181      "y̌": "y",
7182      "A̧": "A",
7183      "a̧": "a",
7184      "B̧": "B",
7185      "b̧": "b",
7186      "Ḑ": "D",
7187      "ḑ": "d",
7188      "Ȩ": "E",
7189      "ȩ": "e",
7190      "Ɛ̧": "E",
7191      "ɛ̧": "e",
7192      "Ḩ": "H",
7193      "ḩ": "h",
7194      "I̧": "I",
7195      "i̧": "i",
7196      "Ɨ̧": "I",
7197      "ɨ̧": "i",
7198      "M̧": "M",
7199      "m̧": "m",
7200      "O̧": "O",
7201      "o̧": "o",
7202      "Q̧": "Q",
7203      "q̧": "q",
7204      "U̧": "U",
7205      "u̧": "u",
7206      "X̧": "X",
7207      "x̧": "x",
7208      "Z̧": "Z",
7209      "z̧": "z",
7210      "й":"и",
7211      "Й":"И",
7212      "ё":"е",
7213      "Ё":"Е",
7214  };
7215  
7216  var chars = Object.keys(characterMap).join('|');
7217  var allAccents = new RegExp(chars, 'g');
7218  var firstAccent = new RegExp(chars, '');
7219  
7220  function matcher(match) {
7221      return characterMap[match];
7222  }
7223  
7224  var removeAccents = function(string) {
7225      return string.replace(allAccents, matcher);
7226  };
7227  
7228  var hasAccents = function(string) {
7229      return !!string.match(firstAccent);
7230  };
7231  
7232  module.exports = removeAccents;
7233  module.exports.has = hasAccents;
7234  module.exports.remove = removeAccents;
7235  
7236  
7237  /***/ }),
7238  
7239  /***/ 8477:
7240  /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
7241  
7242  "use strict";
7243  /**
7244   * @license React
7245   * use-sync-external-store-shim.production.min.js
7246   *
7247   * Copyright (c) Facebook, Inc. and its affiliates.
7248   *
7249   * This source code is licensed under the MIT license found in the
7250   * LICENSE file in the root directory of this source tree.
7251   */
7252  var e=__webpack_require__(1609);function h(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var k="function"===typeof Object.is?Object.is:h,l=e.useState,m=e.useEffect,n=e.useLayoutEffect,p=e.useDebugValue;function q(a,b){var d=b(),f=l({inst:{value:d,getSnapshot:b}}),c=f[0].inst,g=f[1];n(function(){c.value=d;c.getSnapshot=b;r(c)&&g({inst:c})},[a,d,b]);m(function(){r(c)&&g({inst:c});return a(function(){r(c)&&g({inst:c})})},[a]);p(d);return d}
7253  function r(a){var b=a.getSnapshot;a=a.value;try{var d=b();return!k(a,d)}catch(f){return!0}}function t(a,b){return b()}var u="undefined"===typeof window||"undefined"===typeof window.document||"undefined"===typeof window.document.createElement?t:q;exports.useSyncExternalStore=void 0!==e.useSyncExternalStore?e.useSyncExternalStore:u;
7254  
7255  
7256  /***/ }),
7257  
7258  /***/ 422:
7259  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
7260  
7261  "use strict";
7262  
7263  
7264  if (true) {
7265    module.exports = __webpack_require__(8477);
7266  } else {}
7267  
7268  
7269  /***/ }),
7270  
7271  /***/ 1609:
7272  /***/ ((module) => {
7273  
7274  "use strict";
7275  module.exports = window["React"];
7276  
7277  /***/ })
7278  
7279  /******/     });
7280  /************************************************************************/
7281  /******/     // The module cache
7282  /******/     var __webpack_module_cache__ = {};
7283  /******/     
7284  /******/     // The require function
7285  /******/ 	function __webpack_require__(moduleId) {
7286  /******/         // Check if module is in cache
7287  /******/         var cachedModule = __webpack_module_cache__[moduleId];
7288  /******/         if (cachedModule !== undefined) {
7289  /******/             return cachedModule.exports;
7290  /******/         }
7291  /******/         // Create a new module (and put it into the cache)
7292  /******/         var module = __webpack_module_cache__[moduleId] = {
7293  /******/             // no module.id needed
7294  /******/             // no module.loaded needed
7295  /******/             exports: {}
7296  /******/         };
7297  /******/     
7298  /******/         // Execute the module function
7299  /******/         __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
7300  /******/     
7301  /******/         // Return the exports of the module
7302  /******/         return module.exports;
7303  /******/     }
7304  /******/     
7305  /************************************************************************/
7306  /******/     /* webpack/runtime/compat get default export */
7307  /******/     (() => {
7308  /******/         // getDefaultExport function for compatibility with non-harmony modules
7309  /******/         __webpack_require__.n = (module) => {
7310  /******/             var getter = module && module.__esModule ?
7311  /******/                 () => (module['default']) :
7312  /******/                 () => (module);
7313  /******/             __webpack_require__.d(getter, { a: getter });
7314  /******/             return getter;
7315  /******/         };
7316  /******/     })();
7317  /******/     
7318  /******/     /* webpack/runtime/create fake namespace object */
7319  /******/     (() => {
7320  /******/         var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);
7321  /******/         var leafPrototypes;
7322  /******/         // create a fake namespace object
7323  /******/         // mode & 1: value is a module id, require it
7324  /******/         // mode & 2: merge all properties of value into the ns
7325  /******/         // mode & 4: return value when already ns object
7326  /******/         // mode & 16: return value when it's Promise-like
7327  /******/         // mode & 8|1: behave like require
7328  /******/         __webpack_require__.t = function(value, mode) {
7329  /******/             if(mode & 1) value = this(value);
7330  /******/             if(mode & 8) return value;
7331  /******/             if(typeof value === 'object' && value) {
7332  /******/                 if((mode & 4) && value.__esModule) return value;
7333  /******/                 if((mode & 16) && typeof value.then === 'function') return value;
7334  /******/             }
7335  /******/             var ns = Object.create(null);
7336  /******/             __webpack_require__.r(ns);
7337  /******/             var def = {};
7338  /******/             leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];
7339  /******/             for(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {
7340  /******/                 Object.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));
7341  /******/             }
7342  /******/             def['default'] = () => (value);
7343  /******/             __webpack_require__.d(ns, def);
7344  /******/             return ns;
7345  /******/         };
7346  /******/     })();
7347  /******/     
7348  /******/     /* webpack/runtime/define property getters */
7349  /******/     (() => {
7350  /******/         // define getter functions for harmony exports
7351  /******/         __webpack_require__.d = (exports, definition) => {
7352  /******/             for(var key in definition) {
7353  /******/                 if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
7354  /******/                     Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
7355  /******/                 }
7356  /******/             }
7357  /******/         };
7358  /******/     })();
7359  /******/     
7360  /******/     /* webpack/runtime/hasOwnProperty shorthand */
7361  /******/     (() => {
7362  /******/         __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
7363  /******/     })();
7364  /******/     
7365  /******/     /* webpack/runtime/make namespace object */
7366  /******/     (() => {
7367  /******/         // define __esModule on exports
7368  /******/         __webpack_require__.r = (exports) => {
7369  /******/             if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
7370  /******/                 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
7371  /******/             }
7372  /******/             Object.defineProperty(exports, '__esModule', { value: true });
7373  /******/         };
7374  /******/     })();
7375  /******/     
7376  /************************************************************************/
7377  var __webpack_exports__ = {};
7378  // This entry need to be wrapped in an IIFE because it need to be in strict mode.
7379  (() => {
7380  "use strict";
7381  // ESM COMPAT FLAG
7382  __webpack_require__.r(__webpack_exports__);
7383  
7384  // EXPORTS
7385  __webpack_require__.d(__webpack_exports__, {
7386    PluginMoreMenuItem: () => (/* reexport */ PluginMoreMenuItem),
7387    PluginSidebar: () => (/* reexport */ PluginSidebar),
7388    PluginSidebarMoreMenuItem: () => (/* reexport */ PluginSidebarMoreMenuItem),
7389    PluginTemplateSettingPanel: () => (/* reexport */ plugin_template_setting_panel),
7390    initializeEditor: () => (/* binding */ initializeEditor),
7391    reinitializeEditor: () => (/* binding */ reinitializeEditor),
7392    store: () => (/* reexport */ store)
7393  });
7394  
7395  // NAMESPACE OBJECT: ./node_modules/@wordpress/edit-site/build-module/store/actions.js
7396  var actions_namespaceObject = {};
7397  __webpack_require__.r(actions_namespaceObject);
7398  __webpack_require__.d(actions_namespaceObject, {
7399    __experimentalSetPreviewDeviceType: () => (__experimentalSetPreviewDeviceType),
7400    addTemplate: () => (addTemplate),
7401    closeGeneralSidebar: () => (closeGeneralSidebar),
7402    openGeneralSidebar: () => (openGeneralSidebar),
7403    openNavigationPanelToMenu: () => (openNavigationPanelToMenu),
7404    removeTemplate: () => (removeTemplate),
7405    revertTemplate: () => (revertTemplate),
7406    setEditedEntity: () => (setEditedEntity),
7407    setEditedPostContext: () => (setEditedPostContext),
7408    setHasPageContentFocus: () => (setHasPageContentFocus),
7409    setHomeTemplateId: () => (setHomeTemplateId),
7410    setIsInserterOpened: () => (setIsInserterOpened),
7411    setIsListViewOpened: () => (setIsListViewOpened),
7412    setIsNavigationPanelOpened: () => (setIsNavigationPanelOpened),
7413    setIsSaveViewOpened: () => (setIsSaveViewOpened),
7414    setNavigationMenu: () => (setNavigationMenu),
7415    setNavigationPanelActiveMenu: () => (setNavigationPanelActiveMenu),
7416    setPage: () => (setPage),
7417    setTemplate: () => (setTemplate),
7418    setTemplatePart: () => (setTemplatePart),
7419    switchEditorMode: () => (switchEditorMode),
7420    toggleDistractionFree: () => (toggleDistractionFree),
7421    toggleFeature: () => (toggleFeature),
7422    updateSettings: () => (updateSettings)
7423  });
7424  
7425  // NAMESPACE OBJECT: ./node_modules/@wordpress/edit-site/build-module/store/private-actions.js
7426  var private_actions_namespaceObject = {};
7427  __webpack_require__.r(private_actions_namespaceObject);
7428  __webpack_require__.d(private_actions_namespaceObject, {
7429    setCanvasMode: () => (setCanvasMode),
7430    setEditorCanvasContainerView: () => (setEditorCanvasContainerView)
7431  });
7432  
7433  // NAMESPACE OBJECT: ./node_modules/@wordpress/edit-site/build-module/store/selectors.js
7434  var selectors_namespaceObject = {};
7435  __webpack_require__.r(selectors_namespaceObject);
7436  __webpack_require__.d(selectors_namespaceObject, {
7437    __experimentalGetInsertionPoint: () => (__experimentalGetInsertionPoint),
7438    __experimentalGetPreviewDeviceType: () => (__experimentalGetPreviewDeviceType),
7439    getCanUserCreateMedia: () => (getCanUserCreateMedia),
7440    getCurrentTemplateNavigationPanelSubMenu: () => (getCurrentTemplateNavigationPanelSubMenu),
7441    getCurrentTemplateTemplateParts: () => (getCurrentTemplateTemplateParts),
7442    getEditedPostContext: () => (getEditedPostContext),
7443    getEditedPostId: () => (getEditedPostId),
7444    getEditedPostType: () => (getEditedPostType),
7445    getEditorMode: () => (getEditorMode),
7446    getHomeTemplateId: () => (getHomeTemplateId),
7447    getNavigationPanelActiveMenu: () => (getNavigationPanelActiveMenu),
7448    getPage: () => (getPage),
7449    getReusableBlocks: () => (getReusableBlocks),
7450    getSettings: () => (getSettings),
7451    hasPageContentFocus: () => (hasPageContentFocus),
7452    isFeatureActive: () => (isFeatureActive),
7453    isInserterOpened: () => (isInserterOpened),
7454    isListViewOpened: () => (isListViewOpened),
7455    isNavigationOpened: () => (isNavigationOpened),
7456    isPage: () => (isPage),
7457    isSaveViewOpened: () => (isSaveViewOpened)
7458  });
7459  
7460  // NAMESPACE OBJECT: ./node_modules/@wordpress/edit-site/build-module/store/private-selectors.js
7461  var private_selectors_namespaceObject = {};
7462  __webpack_require__.r(private_selectors_namespaceObject);
7463  __webpack_require__.d(private_selectors_namespaceObject, {
7464    getCanvasMode: () => (getCanvasMode),
7465    getEditorCanvasContainerView: () => (getEditorCanvasContainerView)
7466  });
7467  
7468  ;// CONCATENATED MODULE: external ["wp","blocks"]
7469  const external_wp_blocks_namespaceObject = window["wp"]["blocks"];
7470  ;// CONCATENATED MODULE: external ["wp","blockLibrary"]
7471  const external_wp_blockLibrary_namespaceObject = window["wp"]["blockLibrary"];
7472  ;// CONCATENATED MODULE: external ["wp","data"]
7473  const external_wp_data_namespaceObject = window["wp"]["data"];
7474  ;// CONCATENATED MODULE: external ["wp","deprecated"]
7475  const external_wp_deprecated_namespaceObject = window["wp"]["deprecated"];
7476  var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject);
7477  ;// CONCATENATED MODULE: external ["wp","element"]
7478  const external_wp_element_namespaceObject = window["wp"]["element"];
7479  ;// CONCATENATED MODULE: external ["wp","editor"]
7480  const external_wp_editor_namespaceObject = window["wp"]["editor"];
7481  ;// CONCATENATED MODULE: external ["wp","preferences"]
7482  const external_wp_preferences_namespaceObject = window["wp"]["preferences"];
7483  ;// CONCATENATED MODULE: external ["wp","widgets"]
7484  const external_wp_widgets_namespaceObject = window["wp"]["widgets"];
7485  ;// CONCATENATED MODULE: external ["wp","hooks"]
7486  const external_wp_hooks_namespaceObject = window["wp"]["hooks"];
7487  ;// CONCATENATED MODULE: external ["wp","compose"]
7488  const external_wp_compose_namespaceObject = window["wp"]["compose"];
7489  ;// CONCATENATED MODULE: external ["wp","blockEditor"]
7490  const external_wp_blockEditor_namespaceObject = window["wp"]["blockEditor"];
7491  ;// CONCATENATED MODULE: external ["wp","components"]
7492  const external_wp_components_namespaceObject = window["wp"]["components"];
7493  ;// CONCATENATED MODULE: external ["wp","i18n"]
7494  const external_wp_i18n_namespaceObject = window["wp"]["i18n"];
7495  ;// CONCATENATED MODULE: external ["wp","notices"]
7496  const external_wp_notices_namespaceObject = window["wp"]["notices"];
7497  ;// CONCATENATED MODULE: external ["wp","coreData"]
7498  const external_wp_coreData_namespaceObject = window["wp"]["coreData"];
7499  ;// CONCATENATED MODULE: ./node_modules/colord/index.mjs
7500  var r={grad:.9,turn:360,rad:360/(2*Math.PI)},t=function(r){return"string"==typeof r?r.length>0:"number"==typeof r},n=function(r,t,n){return void 0===t&&(t=0),void 0===n&&(n=Math.pow(10,t)),Math.round(n*r)/n+0},e=function(r,t,n){return void 0===t&&(t=0),void 0===n&&(n=1),r>n?n:r>t?r:t},u=function(r){return(r=isFinite(r)?r%360:0)>0?r:r+360},a=function(r){return{r:e(r.r,0,255),g:e(r.g,0,255),b:e(r.b,0,255),a:e(r.a)}},o=function(r){return{r:n(r.r),g:n(r.g),b:n(r.b),a:n(r.a,3)}},i=/^#([0-9a-f]{3,8})$/i,s=function(r){var t=r.toString(16);return t.length<2?"0"+t:t},h=function(r){var t=r.r,n=r.g,e=r.b,u=r.a,a=Math.max(t,n,e),o=a-Math.min(t,n,e),i=o?a===t?(n-e)/o:a===n?2+(e-t)/o:4+(t-n)/o:0;return{h:60*(i<0?i+6:i),s:a?o/a*100:0,v:a/255*100,a:u}},b=function(r){var t=r.h,n=r.s,e=r.v,u=r.a;t=t/360*6,n/=100,e/=100;var a=Math.floor(t),o=e*(1-n),i=e*(1-(t-a)*n),s=e*(1-(1-t+a)*n),h=a%6;return{r:255*[e,i,o,o,s,e][h],g:255*[s,e,e,i,o,o][h],b:255*[o,o,s,e,e,i][h],a:u}},g=function(r){return{h:u(r.h),s:e(r.s,0,100),l:e(r.l,0,100),a:e(r.a)}},d=function(r){return{h:n(r.h),s:n(r.s),l:n(r.l),a:n(r.a,3)}},f=function(r){return b((n=(t=r).s,{h:t.h,s:(n*=((e=t.l)<50?e:100-e)/100)>0?2*n/(e+n)*100:0,v:e+n,a:t.a}));var t,n,e},c=function(r){return{h:(t=h(r)).h,s:(u=(200-(n=t.s))*(e=t.v)/100)>0&&u<200?n*e/100/(u<=100?u:200-u)*100:0,l:u/2,a:t.a};var t,n,e,u},l=/^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s*,\s*([+-]?\d*\.?\d+)%\s*,\s*([+-]?\d*\.?\d+)%\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,colord_p=/^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s+([+-]?\d*\.?\d+)%\s+([+-]?\d*\.?\d+)%\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,v=/^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,m=/^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,y={string:[[function(r){var t=i.exec(r);return t?(r=t[1]).length<=4?{r:parseInt(r[0]+r[0],16),g:parseInt(r[1]+r[1],16),b:parseInt(r[2]+r[2],16),a:4===r.length?n(parseInt(r[3]+r[3],16)/255,2):1}:6===r.length||8===r.length?{r:parseInt(r.substr(0,2),16),g:parseInt(r.substr(2,2),16),b:parseInt(r.substr(4,2),16),a:8===r.length?n(parseInt(r.substr(6,2),16)/255,2):1}:null:null},"hex"],[function(r){var t=v.exec(r)||m.exec(r);return t?t[2]!==t[4]||t[4]!==t[6]?null:a({r:Number(t[1])/(t[2]?100/255:1),g:Number(t[3])/(t[4]?100/255:1),b:Number(t[5])/(t[6]?100/255:1),a:void 0===t[7]?1:Number(t[7])/(t[8]?100:1)}):null},"rgb"],[function(t){var n=l.exec(t)||colord_p.exec(t);if(!n)return null;var e,u,a=g({h:(e=n[1],u=n[2],void 0===u&&(u="deg"),Number(e)*(r[u]||1)),s:Number(n[3]),l:Number(n[4]),a:void 0===n[5]?1:Number(n[5])/(n[6]?100:1)});return f(a)},"hsl"]],object:[[function(r){var n=r.r,e=r.g,u=r.b,o=r.a,i=void 0===o?1:o;return t(n)&&t(e)&&t(u)?a({r:Number(n),g:Number(e),b:Number(u),a:Number(i)}):null},"rgb"],[function(r){var n=r.h,e=r.s,u=r.l,a=r.a,o=void 0===a?1:a;if(!t(n)||!t(e)||!t(u))return null;var i=g({h:Number(n),s:Number(e),l:Number(u),a:Number(o)});return f(i)},"hsl"],[function(r){var n=r.h,a=r.s,o=r.v,i=r.a,s=void 0===i?1:i;if(!t(n)||!t(a)||!t(o))return null;var h=function(r){return{h:u(r.h),s:e(r.s,0,100),v:e(r.v,0,100),a:e(r.a)}}({h:Number(n),s:Number(a),v:Number(o),a:Number(s)});return b(h)},"hsv"]]},N=function(r,t){for(var n=0;n<t.length;n++){var e=t[n][0](r);if(e)return[e,t[n][1]]}return[null,void 0]},x=function(r){return"string"==typeof r?N(r.trim(),y.string):"object"==typeof r&&null!==r?N(r,y.object):[null,void 0]},I=function(r){return x(r)[1]},M=function(r,t){var n=c(r);return{h:n.h,s:e(n.s+100*t,0,100),l:n.l,a:n.a}},H=function(r){return(299*r.r+587*r.g+114*r.b)/1e3/255},$=function(r,t){var n=c(r);return{h:n.h,s:n.s,l:e(n.l+100*t,0,100),a:n.a}},colord_j=function(){function r(r){this.parsed=x(r)[0],this.rgba=this.parsed||{r:0,g:0,b:0,a:1}}return r.prototype.isValid=function(){return null!==this.parsed},r.prototype.brightness=function(){return n(H(this.rgba),2)},r.prototype.isDark=function(){return H(this.rgba)<.5},r.prototype.isLight=function(){return H(this.rgba)>=.5},r.prototype.toHex=function(){return r=o(this.rgba),t=r.r,e=r.g,u=r.b,i=(a=r.a)<1?s(n(255*a)):"","#"+s(t)+s(e)+s(u)+i;var r,t,e,u,a,i},r.prototype.toRgb=function(){return o(this.rgba)},r.prototype.toRgbString=function(){return r=o(this.rgba),t=r.r,n=r.g,e=r.b,(u=r.a)<1?"rgba("+t+", "+n+", "+e+", "+u+")":"rgb("+t+", "+n+", "+e+")";var r,t,n,e,u},r.prototype.toHsl=function(){return d(c(this.rgba))},r.prototype.toHslString=function(){return r=d(c(this.rgba)),t=r.h,n=r.s,e=r.l,(u=r.a)<1?"hsla("+t+", "+n+"%, "+e+"%, "+u+")":"hsl("+t+", "+n+"%, "+e+"%)";var r,t,n,e,u},r.prototype.toHsv=function(){return r=h(this.rgba),{h:n(r.h),s:n(r.s),v:n(r.v),a:n(r.a,3)};var r},r.prototype.invert=function(){return w({r:255-(r=this.rgba).r,g:255-r.g,b:255-r.b,a:r.a});var r},r.prototype.saturate=function(r){return void 0===r&&(r=.1),w(M(this.rgba,r))},r.prototype.desaturate=function(r){return void 0===r&&(r=.1),w(M(this.rgba,-r))},r.prototype.grayscale=function(){return w(M(this.rgba,-1))},r.prototype.lighten=function(r){return void 0===r&&(r=.1),w($(this.rgba,r))},r.prototype.darken=function(r){return void 0===r&&(r=.1),w($(this.rgba,-r))},r.prototype.rotate=function(r){return void 0===r&&(r=15),this.hue(this.hue()+r)},r.prototype.alpha=function(r){return"number"==typeof r?w({r:(t=this.rgba).r,g:t.g,b:t.b,a:r}):n(this.rgba.a,3);var t},r.prototype.hue=function(r){var t=c(this.rgba);return"number"==typeof r?w({h:r,s:t.s,l:t.l,a:t.a}):n(t.h)},r.prototype.isEqual=function(r){return this.toHex()===w(r).toHex()},r}(),w=function(r){return r instanceof colord_j?r:new colord_j(r)},S=[],k=function(r){r.forEach(function(r){S.indexOf(r)<0&&(r(colord_j,y),S.push(r))})},E=function(){return new colord_j({r:255*Math.random(),g:255*Math.random(),b:255*Math.random()})};
7501  
7502  ;// CONCATENATED MODULE: ./node_modules/colord/plugins/a11y.mjs
7503  var a11y_o=function(o){var t=o/255;return t<.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)},a11y_t=function(t){return.2126*a11y_o(t.r)+.7152*a11y_o(t.g)+.0722*a11y_o(t.b)};/* harmony default export */ function a11y(o){o.prototype.luminance=function(){return o=a11y_t(this.rgba),void 0===(r=2)&&(r=0),void 0===n&&(n=Math.pow(10,r)),Math.round(n*o)/n+0;var o,r,n},o.prototype.contrast=function(r){void 0===r&&(r="#FFF");var n,a,i,e,v,u,d,c=r instanceof o?r:new o(r);return e=this.rgba,v=c.toRgb(),u=a11y_t(e),d=a11y_t(v),n=u>d?(u+.05)/(d+.05):(d+.05)/(u+.05),void 0===(a=2)&&(a=0),void 0===i&&(i=Math.pow(10,a)),Math.floor(i*n)/i+0},o.prototype.isReadable=function(o,t){return void 0===o&&(o="#FFF"),void 0===t&&(t={}),this.contrast(o)>=(e=void 0===(i=(r=t).size)?"normal":i,"AAA"===(a=void 0===(n=r.level)?"AA":n)&&"normal"===e?7:"AA"===a&&"large"===e?3:4.5);var r,n,a,i,e}}
7504  
7505  ;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-site/build-module/utils/clone-deep.js
7506  /**
7507   * Makes a copy of an object without storing any references to the original object.
7508   * @param {Object} object
7509   * @return {Object} The cloned object.
7510   */
7511  function cloneDeep(object) {
7512    return !object ? {} : JSON.parse(JSON.stringify(object));
7513  }
7514  
7515  ;// CONCATENATED MODULE: external ["wp","privateApis"]
7516  const external_wp_privateApis_namespaceObject = window["wp"]["privateApis"];
7517  ;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-site/build-module/lock-unlock.js
7518  /**
7519   * WordPress dependencies
7520   */
7521  
7522  const {
7523    lock,
7524    unlock: lock_unlock_unlock
7525  } = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)('I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.', '@wordpress/edit-site');
7526  
7527  ;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-site/build-module/hooks/use-theme-style-variations/use-theme-style-variations-by-property.js
7528  /**
7529   * WordPress dependencies
7530   */
7531  
7532  
7533  
7534  
7535  
7536  
7537  
7538  /**
7539   * Internal dependencies
7540   */
7541  
7542  
7543  const {
7544    GlobalStylesContext
7545  } = lock_unlock_unlock(external_wp_blockEditor_namespaceObject.privateApis);
7546  const {
7547    mergeBaseAndUserConfigs
7548  } = lock_unlock_unlock(external_wp_editor_namespaceObject.privateApis);
7549  
7550  /**
7551   * Removes all instances of a property from an object.
7552   *
7553   * @param {Object} object   The object to remove the property from.
7554   * @param {string} property The property to remove.
7555   * @return {Object} The modified object.
7556   */
7557  function removePropertyFromObject(object, property) {
7558    if (!property || typeof property !== 'string') {
7559      return object;
7560    }
7561    if (typeof object !== 'object' || !object || !Object.keys(object).length) {
7562      return object;
7563    }
7564    for (const key in object) {
7565      if (key === property) {
7566        delete object[key];
7567      } else if (typeof object[key] === 'object') {
7568        removePropertyFromObject(object[key], property);
7569      }
7570    }
7571    return object;
7572  }
7573  
7574  /**
7575   * Fetches the current theme style variations that contain only the specified property
7576   * and merges them with the user config.
7577   *
7578   * @param {Object} props          Object of hook args.
7579   * @param {string} props.property The property to filter by.
7580   * @return {Object[]|*} The merged object.
7581   */
7582  function useCurrentMergeThemeStyleVariationsWithUserConfig({
7583    property
7584  }) {
7585    const {
7586      variationsFromTheme
7587    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
7588      const _variationsFromTheme = select(external_wp_coreData_namespaceObject.store).__experimentalGetCurrentThemeGlobalStylesVariations();
7589      return {
7590        variationsFromTheme: _variationsFromTheme || []
7591      };
7592    }, []);
7593    const {
7594      user: userVariation
7595    } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext);
7596    return (0,external_wp_element_namespaceObject.useMemo)(() => {
7597      const clonedUserVariation = cloneDeep(userVariation);
7598  
7599      // Get user variation and remove the settings for the given property.
7600      const userVariationWithoutProperty = removePropertyFromObject(clonedUserVariation, property);
7601      userVariationWithoutProperty.title = (0,external_wp_i18n_namespaceObject.__)('Default');
7602      const variationsWithSinglePropertyAndBase = variationsFromTheme.filter(variation => {
7603        return isVariationWithSingleProperty(variation, property);
7604      }).map(variation => {
7605        return mergeBaseAndUserConfigs(userVariationWithoutProperty, variation);
7606      });
7607      return [userVariationWithoutProperty, ...variationsWithSinglePropertyAndBase];
7608    }, [property, userVariation, variationsFromTheme]);
7609  }
7610  
7611  /**
7612   * Returns a new object, with properties specified in `property`,
7613   * maintain the original object tree structure.
7614   * The function is recursive, so it will perform a deep search for the given property.
7615   * E.g., the function will return `{ a: { b: { c: { test: 1 } } } }` if the property is `test`.
7616   *
7617   * @param {Object} object   The object to filter
7618   * @param {Object} property The property to filter by
7619   * @return {Object} The merged object.
7620   */
7621  const filterObjectByProperty = (object, property) => {
7622    if (!object) {
7623      return {};
7624    }
7625    const newObject = {};
7626    Object.keys(object).forEach(key => {
7627      if (key === property) {
7628        newObject[key] = object[key];
7629      } else if (typeof object[key] === 'object') {
7630        const newFilter = filterObjectByProperty(object[key], property);
7631        if (Object.keys(newFilter).length) {
7632          newObject[key] = newFilter;
7633        }
7634      }
7635    });
7636    return newObject;
7637  };
7638  
7639  /**
7640   * Compares a style variation to the same variation filtered by a single property.
7641   * Returns true if the variation contains only the property specified.
7642   *
7643   * @param {Object} variation The variation to compare.
7644   * @param {string} property  The property to compare.
7645   * @return {boolean} Whether the variation contains only a single property.
7646   */
7647  function isVariationWithSingleProperty(variation, property) {
7648    const variationWithProperty = filterObjectByProperty(cloneDeep(variation), property);
7649    return JSON.stringify(variationWithProperty?.styles) === JSON.stringify(variation?.styles) && JSON.stringify(variationWithProperty?.settings) === JSON.stringify(variation?.settings);
7650  }
7651  
7652  ;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-site/build-module/components/global-styles/hooks.js
7653  /**
7654   * External dependencies
7655   */
7656  
7657  
7658  
7659  /**
7660   * WordPress dependencies
7661   */
7662  
7663  
7664  
7665  
7666  /**
7667   * Internal dependencies
7668   */
7669  
7670  
7671  
7672  const {
7673    useGlobalSetting,
7674    useGlobalStyle
7675  } = lock_unlock_unlock(external_wp_blockEditor_namespaceObject.privateApis);
7676  
7677  // Enable colord's a11y plugin.
7678  k([a11y]);
7679  function useColorRandomizer(name) {
7680    const [themeColors, setThemeColors] = useGlobalSetting('color.palette.theme', name);
7681    function randomizeColors() {
7682      /* eslint-disable no-restricted-syntax */
7683      const randomRotationValue = Math.floor(Math.random() * 225);
7684      /* eslint-enable no-restricted-syntax */
7685  
7686      const newColors = themeColors.map(colorObject => {
7687        const {
7688          color
7689        } = colorObject;
7690        const newColor = w(color).rotate(randomRotationValue).toHex();
7691        return {
7692          ...colorObject,
7693          color: newColor
7694        };
7695      });
7696      setThemeColors(newColors);
7697    }
7698    return window.__experimentalEnableColorRandomizer ? [randomizeColors] : [];
7699  }
7700  function useStylesPreviewColors() {
7701    const [textColor = 'black'] = useGlobalStyle('color.text');
7702    const [backgroundColor = 'white'] = useGlobalStyle('color.background');
7703    const [headingColor = textColor] = useGlobalStyle('elements.h1.color.text');
7704    const [linkColor = headingColor] = useGlobalStyle('elements.link.color.text');
7705    const [buttonBackgroundColor = linkColor] = useGlobalStyle('elements.button.color.background');
7706    const [coreColors] = useGlobalSetting('color.palette.core');
7707    const [themeColors] = useGlobalSetting('color.palette.theme');
7708    const [customColors] = useGlobalSetting('color.palette.custom');
7709    const paletteColors = (themeColors !== null && themeColors !== void 0 ? themeColors : []).concat(customColors !== null && customColors !== void 0 ? customColors : []).concat(coreColors !== null && coreColors !== void 0 ? coreColors : []);
7710    const textColorObject = paletteColors.filter(({
7711      color
7712    }) => color === textColor);
7713    const buttonBackgroundColorObject = paletteColors.filter(({
7714      color
7715    }) => color === buttonBackgroundColor);
7716    const highlightedColors = textColorObject.concat(buttonBackgroundColorObject).concat(paletteColors).filter(
7717    // we exclude these background color because it is already visible in the preview.
7718    ({
7719      color
7720    }) => color !== backgroundColor).slice(0, 2);
7721    return {
7722      paletteColors,
7723      highlightedColors
7724    };
7725  }
7726  function useSupportedStyles(name, element) {
7727    const {
7728      supportedPanels
7729    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
7730      return {
7731        supportedPanels: lock_unlock_unlock(select(external_wp_blocks_namespaceObject.store)).getSupportedStyles(name, element)
7732      };
7733    }, [name, element]);
7734    return supportedPanels;
7735  }
7736  function useColorVariations() {
7737    const colorVariations = useCurrentMergeThemeStyleVariationsWithUserConfig({
7738      property: 'color'
7739    });
7740    /*
7741     * Filter out variations with no settings or styles.
7742     */
7743    return colorVariations?.length ? colorVariations.filter(variation => {
7744      const {
7745        settings,
7746        styles,
7747        title
7748      } = variation;
7749      return title === (0,external_wp_i18n_namespaceObject.__)('Default') ||
7750      // Always preseve the default variation.
7751      Object.keys(settings).length > 0 || Object.keys(styles).length > 0;
7752    }) : [];
7753  }
7754  function useTypographyVariations() {
7755    const typographyVariations = useCurrentMergeThemeStyleVariationsWithUserConfig({
7756      property: 'typography'
7757    });
7758    /*
7759     * Filter out variations with no settings or styles.
7760     */
7761    return typographyVariations?.length ? typographyVariations.filter(variation => {
7762      const {
7763        settings,
7764        styles,
7765        title
7766      } = variation;
7767      return title === (0,external_wp_i18n_namespaceObject.__)('Default') ||
7768      // Always preseve the default variation.
7769      Object.keys(settings).length > 0 || Object.keys(styles).length > 0;
7770    }) : [];
7771  }
7772  
7773  ;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-site/build-module/utils/set-nested-value.js
7774  /**
7775   * Sets the value at path of object.
7776   * If a portion of path doesn’t exist, it’s created.
7777   * Arrays are created for missing index properties while objects are created
7778   * for all other missing properties.
7779   *
7780   * This function intentionally mutates the input object.
7781   *
7782   * Inspired by _.set().
7783   *
7784   * @see https://lodash.com/docs/4.17.15#set
7785   *
7786   * @todo Needs to be deduplicated with its copy in `@wordpress/core-data`.
7787   *
7788   * @param {Object} object Object to modify
7789   * @param {Array}  path   Path of the property to set.
7790   * @param {*}      value  Value to set.
7791   */
7792  function setNestedValue(object, path, value) {
7793    if (!object || typeof object !== 'object') {
7794      return object;
7795    }
7796    path.reduce((acc, key, idx) => {
7797      if (acc[key] === undefined) {
7798        if (Number.isInteger(path[idx + 1])) {
7799          acc[key] = [];
7800        } else {
7801          acc[key] = {};
7802        }
7803      }
7804      if (idx === path.length - 1) {
7805        acc[key] = value;
7806      }
7807      return acc[key];
7808    }, object);
7809    return object;
7810  }
7811  
7812  ;// CONCATENATED MODULE: external "ReactJSXRuntime"
7813  const external_ReactJSXRuntime_namespaceObject = window["ReactJSXRuntime"];
7814  ;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-site/build-module/hooks/push-changes-to-global-styles/index.js
7815  /**
7816   * WordPress dependencies
7817   */
7818  
7819  
7820  
7821  
7822  
7823  
7824  
7825  
7826  
7827  
7828  
7829  /**
7830   * Internal dependencies
7831   */
7832  
7833  
7834  
7835  
7836  
7837  
7838  
7839  const {
7840    cleanEmptyObject,
7841    GlobalStylesContext: push_changes_to_global_styles_GlobalStylesContext
7842  } = lock_unlock_unlock(external_wp_blockEditor_namespaceObject.privateApis);
7843  
7844  // Block Gap is a special case and isn't defined within the blocks
7845  // style properties config. We'll add it here to allow it to be pushed
7846  // to global styles as well.
7847  const STYLE_PROPERTY = {
7848    ...external_wp_blocks_namespaceObject.__EXPERIMENTAL_STYLE_PROPERTY,
7849    blockGap: {
7850      value: ['spacing', 'blockGap']
7851    }
7852  };
7853  
7854  // TODO: Temporary duplication of constant in @wordpress/block-editor. Can be
7855  // removed by moving PushChangesToGlobalStylesControl to
7856  // @wordpress/block-editor.
7857  const STYLE_PATH_TO_CSS_VAR_INFIX = {
7858    'border.color': 'color',
7859    'color.background': 'color',
7860    'color.text': 'color',
7861    'elements.link.color.text': 'color',
7862    'elements.link.:hover.color.text': 'color',
7863    'elements.link.typography.fontFamily': 'font-family',
7864    'elements.link.typography.fontSize': 'font-size',
7865    'elements.button.color.text': 'color',
7866    'elements.button.color.background': 'color',
7867    'elements.button.typography.fontFamily': 'font-family',
7868    'elements.button.typography.fontSize': 'font-size',
7869    'elements.caption.color.text': 'color',
7870    'elements.heading.color': 'color',
7871    'elements.heading.color.background': 'color',
7872    'elements.heading.typography.fontFamily': 'font-family',
7873    'elements.heading.gradient': 'gradient',
7874    'elements.heading.color.gradient': 'gradient',
7875    'elements.h1.color': 'color',
7876    'elements.h1.color.background': 'color',
7877    'elements.h1.typography.fontFamily': 'font-family',
7878    'elements.h1.color.gradient': 'gradient',
7879    'elements.h2.color': 'color',
7880    'elements.h2.color.background': 'color',
7881    'elements.h2.typography.fontFamily': 'font-family',
7882    'elements.h2.color.gradient': 'gradient',
7883    'elements.h3.color': 'color',
7884    'elements.h3.color.background': 'color',
7885    'elements.h3.typography.fontFamily': 'font-family',
7886    'elements.h3.color.gradient': 'gradient',
7887    'elements.h4.color': 'color',
7888    'elements.h4.color.background': 'color',
7889    'elements.h4.typography.fontFamily': 'font-family',
7890    'elements.h4.color.gradient': 'gradient',
7891    'elements.h5.color': 'color',
7892    'elements.h5.color.background': 'color',
7893    'elements.h5.typography.fontFamily': 'font-family',
7894    'elements.h5.color.gradient': 'gradient',
7895    'elements.h6.color': 'color',
7896    'elements.h6.color.background': 'color',
7897    'elements.h6.typography.fontFamily': 'font-family',
7898    'elements.h6.color.gradient': 'gradient',
7899    'color.gradient': 'gradient',
7900    blockGap: 'spacing',
7901    'typography.fontSize': 'font-size',
7902    'typography.fontFamily': 'font-family'
7903  };
7904  
7905  // TODO: Temporary duplication of constant in @wordpress/block-editor. Can be
7906  // removed by moving PushChangesToGlobalStylesControl to
7907