@loaders.gl/compression 3.3.0-alpha.5 → 3.3.0-alpha.6

package/dist/es5/brotli/decode.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.BrotliDecode = void 0;
+
 var Options;
 
 var makeBrotliDecode = function makeBrotliDecode() {
@@ -25,57 +26,45 @@ var makeBrotliDecode = function makeBrotliDecode() {
   {
     unpackCommandLookupTable(CMD_LOOKUP);
   }
-
   function log2floor(i) {
     var result = -1;
     var step = 16;
-
     while (step > 0) {
       if (i >>> step != 0) {
         result += step;
         i = i >>> step;
       }
-
       step = step >> 1;
     }
-
     return result + i;
   }
-
   function calculateDistanceAlphabetSize(npostfix, ndirect, maxndistbits) {
     return 16 + ndirect + 2 * (maxndistbits << npostfix);
   }
-
   function calculateDistanceAlphabetLimit(maxDistance, npostfix, ndirect) {
     if (maxDistance < ndirect + (2 << npostfix)) {
       throw 'maxDistance is too small';
     }
-
     var offset = (maxDistance - ndirect >> npostfix) + 4;
     var ndistbits = log2floor(offset) - 1;
     var group = ndistbits - 1 << 1 | offset >> ndistbits & 1;
     return (group - 1 << npostfix) + (1 << npostfix) + ndirect + 16;
   }
-
   function unpackCommandLookupTable(cmdLookup) {
     var insertLengthOffsets = new Int16Array(24);
     var copyLengthOffsets = new Int16Array(24);
     copyLengthOffsets[0] = 2;
-
     for (var i = 0; i < 23; ++i) {
       insertLengthOffsets[i + 1] = insertLengthOffsets[i] + (1 << INSERT_LENGTH_N_BITS[i]);
       copyLengthOffsets[i + 1] = copyLengthOffsets[i] + (1 << COPY_LENGTH_N_BITS[i]);
     }
-
     for (var cmdCode = 0; cmdCode < 704; ++cmdCode) {
       var rangeIdx = cmdCode >>> 6;
       var distanceContextOffset = -4;
-
       if (rangeIdx >= 2) {
         rangeIdx -= 2;
         distanceContextOffset = 0;
       }
-
       var insertCode = (0x29850 >>> rangeIdx * 2 & 0x3) << 3 | cmdCode >>> 3 & 7;
       var copyCode = (0x26244 >>> rangeIdx * 2 & 0x3) << 3 | cmdCode & 7;
       var copyLengthOffset = copyLengthOffsets[copyCode];
@@ -87,97 +76,74 @@ var makeBrotliDecode = function makeBrotliDecode() {
       cmdLookup[index + 3] = distanceContext;
     }
   }
-
   function decodeWindowBits(s) {
     var largeWindowEnabled = s.isLargeWindow;
     s.isLargeWindow = 0;
-
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     if (readFewBits(s, 1) == 0) {
       return 16;
     }
-
     var n = readFewBits(s, 3);
-
     if (n != 0) {
       return 17 + n;
     }
-
     n = readFewBits(s, 3);
-
     if (n != 0) {
       if (n == 1) {
         if (largeWindowEnabled == 0) {
           return -1;
         }
-
         s.isLargeWindow = 1;
-
         if (readFewBits(s, 1) == 1) {
           return -1;
         }
-
         n = readFewBits(s, 6);
-
         if (n < 10 || n > 30) {
           return -1;
         }
-
         return n;
       } else {
         return 8 + n;
       }
     }
-
     return 17;
   }
-
   function enableEagerOutput(s) {
     if (s.runningState != 1) {
       throw 'State MUST be freshly initialized';
     }
-
     s.isEager = 1;
   }
-
   function enableLargeWindow(s) {
     if (s.runningState != 1) {
       throw 'State MUST be freshly initialized';
     }
-
     s.isLargeWindow = 1;
   }
-
   function attachDictionaryChunk(s, data) {
     if (s.runningState != 1) {
       throw 'State MUST be freshly initialized';
     }
-
     if (s.cdNumChunks == 0) {
       s.cdChunks = new Array(16);
       s.cdChunkOffsets = new Int32Array(16);
       s.cdBlockBits = -1;
     }
-
     if (s.cdNumChunks == 15) {
       throw 'Too many dictionary chunks';
     }
-
     s.cdChunks[s.cdNumChunks] = data;
     s.cdNumChunks++;
     s.cdTotalSize += data.length;
     s.cdChunkOffsets[s.cdNumChunks] = s.cdTotalSize;
   }
-
   function initState(s, input) {
     if (s.runningState != 0) {
       throw 'State MUST be uninitialized';
     }
-
     s.blockTrees = new Int32Array(3091);
     s.blockTrees[0] = 7;
     s.distRbIdx = 3;
@@ -188,85 +154,65 @@ var makeBrotliDecode = function makeBrotliDecode() {
     initBitReader(s);
     s.runningState = 1;
   }
-
   function close(s) {
     if (s.runningState == 0) {
       throw 'State MUST be initialized';
     }
-
     if (s.runningState == 11) {
       return;
     }
-
     s.runningState = 11;
-
     if (s.input != null) {
       closeInput(s.input);
       s.input = null;
     }
   }
-
   function decodeVarLenUnsignedByte(s) {
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     if (readFewBits(s, 1) != 0) {
       var n = readFewBits(s, 3);
-
       if (n == 0) {
         return 1;
       } else {
         return readFewBits(s, n) + (1 << n);
       }
     }
-
     return 0;
   }
-
   function decodeMetaBlockLength(s) {
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     s.inputEnd = readFewBits(s, 1);
     s.metaBlockLength = 0;
     s.isUncompressed = 0;
     s.isMetadata = 0;
-
     if (s.inputEnd != 0 && readFewBits(s, 1) != 0) {
       return;
     }
-
     var sizeNibbles = readFewBits(s, 2) + 4;
-
     if (sizeNibbles == 7) {
       s.isMetadata = 1;
-
       if (readFewBits(s, 1) != 0) {
         throw 'Corrupted reserved bit';
       }
-
       var sizeBytes = readFewBits(s, 2);
-
       if (sizeBytes == 0) {
         return;
       }
-
       for (var i = 0; i < sizeBytes; i++) {
         if (s.bitOffset >= 16) {
           s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
           s.bitOffset -= 16;
         }
-
         var bits = readFewBits(s, 8);
-
         if (bits == 0 && i + 1 == sizeBytes && sizeBytes > 1) {
           throw 'Exuberant nibble';
         }
-
         s.metaBlockLength |= bits << i * 8;
       }
     } else {
@@ -275,87 +221,67 @@ var makeBrotliDecode = function makeBrotliDecode() {
           s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
           s.bitOffset -= 16;
         }
-
         var _bits = readFewBits(s, 4);
-
         if (_bits == 0 && _i + 1 == sizeNibbles && sizeNibbles > 4) {
           throw 'Exuberant nibble';
         }
-
         s.metaBlockLength |= _bits << _i * 4;
       }
     }
-
     s.metaBlockLength++;
-
     if (s.inputEnd == 0) {
       s.isUncompressed = readFewBits(s, 1);
     }
   }
-
   function readSymbol(tableGroup, tableIdx, s) {
     var offset = tableGroup[tableIdx];
     var val = s.accumulator32 >>> s.bitOffset;
     offset += val & 0xff;
     var bits = tableGroup[offset] >> 16;
     var sym = tableGroup[offset] & 0xffff;
-
     if (bits <= 8) {
       s.bitOffset += bits;
       return sym;
     }
-
     offset += sym;
     var mask = (1 << bits) - 1;
     offset += (val & mask) >>> 8;
     s.bitOffset += (tableGroup[offset] >> 16) + 8;
     return tableGroup[offset] & 0xffff;
   }
-
   function readBlockLength(tableGroup, tableIdx, s) {
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     var code = readSymbol(tableGroup, tableIdx, s);
     var n = BLOCK_LENGTH_N_BITS[code];
-
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     return BLOCK_LENGTH_OFFSET[code] + (n <= 16 ? readFewBits(s, n) : readManyBits(s, n));
   }
-
   function moveToFront(v, index) {
     var value = v[index];
-
     for (; index > 0; index--) {
       v[index] = v[index - 1];
     }
-
     v[0] = value;
   }
-
   function inverseMoveToFrontTransform(v, vLen) {
     var mtf = new Int32Array(256);
-
     for (var i = 0; i < 256; i++) {
       mtf[i] = i;
     }
-
     for (var _i2 = 0; _i2 < vLen; _i2++) {
       var index = v[_i2] & 0xff;
       v[_i2] = mtf[index];
-
       if (index != 0) {
         moveToFront(mtf, index);
       }
     }
   }
-
   function readHuffmanCodeLengths(codeLengthCodeLengths, numSymbols, codeLengths, s) {
     var symbol = 0;
     var prevCodeLen = 8;
@@ -365,25 +291,20 @@ var makeBrotliDecode = function makeBrotliDecode() {
     var table = new Int32Array(32 + 1);
     var tableIdx = table.length - 1;
     buildHuffmanTable(table, tableIdx, 5, codeLengthCodeLengths, 18);
-
     while (symbol < numSymbols && space > 0) {
       if (s.halfOffset > 2030) {
         doReadMoreInput(s);
       }
-
       if (s.bitOffset >= 16) {
         s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
         s.bitOffset -= 16;
       }
-
       var p = s.accumulator32 >>> s.bitOffset & 31;
       s.bitOffset += table[p] >> 16;
       var codeLen = table[p] & 0xffff;
-
       if (codeLen < 16) {
         repeat = 0;
         codeLengths[symbol++] = codeLen;
-
         if (codeLen != 0) {
           prevCodeLen = codeLen;
           space -= 32768 >> codeLen;
@@ -391,52 +312,40 @@ var makeBrotliDecode = function makeBrotliDecode() {
       } else {
         var extraBits = codeLen - 14;
         var newLen = 0;
-
         if (codeLen == 16) {
           newLen = prevCodeLen;
         }
-
         if (repeatCodeLen != newLen) {
           repeat = 0;
           repeatCodeLen = newLen;
         }
-
         var oldRepeat = repeat;
-
         if (repeat > 0) {
           repeat -= 2;
           repeat <<= extraBits;
         }
-
         if (s.bitOffset >= 16) {
           s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
           s.bitOffset -= 16;
         }
-
         repeat += readFewBits(s, extraBits) + 3;
         var repeatDelta = repeat - oldRepeat;
-
         if (symbol + repeatDelta > numSymbols) {
           throw 'symbol + repeatDelta > numSymbols';
         }
-
         for (var i = 0; i < repeatDelta; i++) {
           codeLengths[symbol++] = repeatCodeLen;
         }
-
         if (repeatCodeLen != 0) {
           space -= repeatDelta << 15 - repeatCodeLen;
         }
       }
     }
-
     if (space != 0) {
       throw 'Unused space';
     }
-
     codeLengths.fill(0, symbol, numSymbols);
   }
-
   function checkDupes(symbols, length) {
     for (var i = 0; i < length - 1; ++i) {
       for (var j = i + 1; j < length; ++j) {
@@ -446,166 +355,130 @@ var makeBrotliDecode = function makeBrotliDecode() {
       }
     }
   }
-
   function readSimpleHuffmanCode(alphabetSizeMax, alphabetSizeLimit, tableGroup, tableIdx, s) {
     var codeLengths = new Int32Array(alphabetSizeLimit);
     var symbols = new Int32Array(4);
     var maxBits = 1 + log2floor(alphabetSizeMax - 1);
     var numSymbols = readFewBits(s, 2) + 1;
-
     for (var i = 0; i < numSymbols; i++) {
       if (s.bitOffset >= 16) {
         s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
         s.bitOffset -= 16;
       }
-
       var symbol = readFewBits(s, maxBits);
-
       if (symbol >= alphabetSizeLimit) {
         throw "Can't readHuffmanCode";
       }
-
       symbols[i] = symbol;
     }
-
     checkDupes(symbols, numSymbols);
     var histogramId = numSymbols;
-
     if (numSymbols == 4) {
       histogramId += readFewBits(s, 1);
     }
-
     switch (histogramId) {
       case 1:
         codeLengths[symbols[0]] = 1;
         break;
-
       case 2:
         codeLengths[symbols[0]] = 1;
         codeLengths[symbols[1]] = 1;
         break;
-
       case 3:
         codeLengths[symbols[0]] = 1;
         codeLengths[symbols[1]] = 2;
         codeLengths[symbols[2]] = 2;
         break;
-
       case 4:
         codeLengths[symbols[0]] = 2;
         codeLengths[symbols[1]] = 2;
         codeLengths[symbols[2]] = 2;
         codeLengths[symbols[3]] = 2;
         break;
-
       case 5:
         codeLengths[symbols[0]] = 1;
         codeLengths[symbols[1]] = 2;
         codeLengths[symbols[2]] = 3;
         codeLengths[symbols[3]] = 3;
         break;
-
       default:
         break;
     }
-
     return buildHuffmanTable(tableGroup, tableIdx, 8, codeLengths, alphabetSizeLimit);
   }
-
   function readComplexHuffmanCode(alphabetSizeLimit, skip, tableGroup, tableIdx, s) {
     var codeLengths = new Int32Array(alphabetSizeLimit);
     var codeLengthCodeLengths = new Int32Array(18);
     var space = 32;
     var numCodes = 0;
-
     for (var i = skip; i < 18 && space > 0; i++) {
       var codeLenIdx = CODE_LENGTH_CODE_ORDER[i];
-
       if (s.bitOffset >= 16) {
         s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
         s.bitOffset -= 16;
       }
-
       var p = s.accumulator32 >>> s.bitOffset & 15;
       s.bitOffset += FIXED_TABLE[p] >> 16;
       var v = FIXED_TABLE[p] & 0xffff;
       codeLengthCodeLengths[codeLenIdx] = v;
-
       if (v != 0) {
         space -= 32 >> v;
         numCodes++;
       }
     }
-
     if (space != 0 && numCodes != 1) {
       throw 'Corrupted Huffman code histogram';
     }
-
     readHuffmanCodeLengths(codeLengthCodeLengths, alphabetSizeLimit, codeLengths, s);
     return buildHuffmanTable(tableGroup, tableIdx, 8, codeLengths, alphabetSizeLimit);
   }
-
   function readHuffmanCode(alphabetSizeMax, alphabetSizeLimit, tableGroup, tableIdx, s) {
     if (s.halfOffset > 2030) {
       doReadMoreInput(s);
     }
-
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     var simpleCodeOrSkip = readFewBits(s, 2);
-
     if (simpleCodeOrSkip == 1) {
       return readSimpleHuffmanCode(alphabetSizeMax, alphabetSizeLimit, tableGroup, tableIdx, s);
     } else {
       return readComplexHuffmanCode(alphabetSizeLimit, simpleCodeOrSkip, tableGroup, tableIdx, s);
     }
   }
-
   function decodeContextMap(contextMapSize, contextMap, s) {
     if (s.halfOffset > 2030) {
       doReadMoreInput(s);
     }
-
     var numTrees = decodeVarLenUnsignedByte(s) + 1;
-
     if (numTrees == 1) {
       contextMap.fill(0, 0, contextMapSize);
       return numTrees;
     }
-
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     var useRleForZeros = readFewBits(s, 1);
     var maxRunLengthPrefix = 0;
-
     if (useRleForZeros != 0) {
       maxRunLengthPrefix = readFewBits(s, 4) + 1;
     }
-
     var alphabetSize = numTrees + maxRunLengthPrefix;
     var tableSize = MAX_HUFFMAN_TABLE_SIZE[alphabetSize + 31 >> 5];
     var table = new Int32Array(tableSize + 1);
     var tableIdx = table.length - 1;
     readHuffmanCode(alphabetSize, alphabetSize, table, tableIdx, s);
-
     for (var i = 0; i < contextMapSize;) {
       if (s.halfOffset > 2030) {
         doReadMoreInput(s);
       }
-
       if (s.bitOffset >= 16) {
         s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
         s.bitOffset -= 16;
       }
-
       var code = readSymbol(table, tableIdx, s);
-
       if (code == 0) {
         contextMap[i] = 0;
         i++;
@@ -614,14 +487,11 @@ var makeBrotliDecode = function makeBrotliDecode() {
           s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
           s.bitOffset -= 16;
         }
-
         var reps = (1 << code) + readFewBits(s, code);
-
         while (reps != 0) {
           if (i >= contextMapSize) {
             throw 'Corrupted context map';
           }
-
           contextMap[i] = 0;
           i++;
           reps--;
@@ -631,31 +501,24 @@ var makeBrotliDecode = function makeBrotliDecode() {
         i++;
       }
     }
-
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     if (readFewBits(s, 1) == 1) {
       inverseMoveToFrontTransform(contextMap, contextMapSize);
     }
-
     return numTrees;
   }
-
   function decodeBlockTypeAndLength(s, treeType, numBlockTypes) {
     var ringBuffers = s.rings;
     var offset = 4 + treeType * 2;
-
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     var blockType = readSymbol(s.blockTrees, 2 * treeType, s);
     var result = readBlockLength(s.blockTrees, 2 * treeType + 1, s);
-
     if (blockType == 1) {
       blockType = ringBuffers[offset + 1] + 1;
     } else if (blockType == 0) {
@@ -663,16 +526,13 @@ var makeBrotliDecode = function makeBrotliDecode() {
     } else {
       blockType -= 2;
     }
-
     if (blockType >= numBlockTypes) {
       blockType -= numBlockTypes;
     }
-
     ringBuffers[offset] = ringBuffers[offset + 1];
     ringBuffers[offset + 1] = blockType;
     return result;
   }
-
   function decodeLiteralBlockSwitch(s) {
     s.literalBlockLength = decodeBlockTypeAndLength(s, 0, s.numLiteralBlockTypes);
     var literalBlockType = s.rings[5];
@@ -682,99 +542,76 @@ var makeBrotliDecode = function makeBrotliDecode() {
     s.contextLookupOffset1 = contextMode << 9;
     s.contextLookupOffset2 = s.contextLookupOffset1 + 256;
   }
-
   function decodeCommandBlockSwitch(s) {
     s.commandBlockLength = decodeBlockTypeAndLength(s, 1, s.numCommandBlockTypes);
     s.commandTreeIdx = s.rings[7];
   }
-
   function decodeDistanceBlockSwitch(s) {
     s.distanceBlockLength = decodeBlockTypeAndLength(s, 2, s.numDistanceBlockTypes);
     s.distContextMapSlice = s.rings[9] << 2;
   }
-
   function maybeReallocateRingBuffer(s) {
     var newSize = s.maxRingBufferSize;
-
     if (newSize > s.expectedTotalSize) {
       var minimalNewSize = s.expectedTotalSize;
-
       while (newSize >> 1 > minimalNewSize) {
         newSize >>= 1;
       }
-
       if (s.inputEnd == 0 && newSize < 16384 && s.maxRingBufferSize >= 16384) {
         newSize = 16384;
       }
     }
-
     if (newSize <= s.ringBufferSize) {
       return;
     }
-
     var ringBufferSizeWithSlack = newSize + 37;
     var newBuffer = new Int8Array(ringBufferSizeWithSlack);
-
     if (s.ringBuffer.length != 0) {
       newBuffer.set(s.ringBuffer.subarray(0, 0 + s.ringBufferSize), 0);
     }
-
     s.ringBuffer = newBuffer;
     s.ringBufferSize = newSize;
   }
-
   function readNextMetablockHeader(s) {
     if (s.inputEnd != 0) {
       s.nextRunningState = 10;
       s.runningState = 12;
       return;
     }
-
     s.literalTreeGroup = new Int32Array(0);
     s.commandTreeGroup = new Int32Array(0);
     s.distanceTreeGroup = new Int32Array(0);
-
     if (s.halfOffset > 2030) {
       doReadMoreInput(s);
     }
-
     decodeMetaBlockLength(s);
-
     if (s.metaBlockLength == 0 && s.isMetadata == 0) {
       return;
     }
-
     if (s.isUncompressed != 0 || s.isMetadata != 0) {
       jumpToByteBoundary(s);
       s.runningState = s.isMetadata != 0 ? 5 : 6;
     } else {
       s.runningState = 3;
     }
-
     if (s.isMetadata != 0) {
       return;
     }
-
     s.expectedTotalSize += s.metaBlockLength;
-
     if (s.expectedTotalSize > 1 << 30) {
       s.expectedTotalSize = 1 << 30;
     }
-
     if (s.ringBufferSize < s.maxRingBufferSize) {
       maybeReallocateRingBuffer(s);
     }
   }
-
   function readMetablockPartition(s, treeType, numBlockTypes) {
     var offset = s.blockTrees[2 * treeType];
-
     if (numBlockTypes <= 1) {
       s.blockTrees[2 * treeType + 1] = offset;
       s.blockTrees[2 * treeType + 2] = offset;
       return 1 << 28;
     }
-
     var blockTypeAlphabetSize = numBlockTypes + 2;
     offset += readHuffmanCode(blockTypeAlphabetSize, blockTypeAlphabetSize, s.blockTrees, 2 * treeType, s);
     s.blockTrees[2 * treeType + 1] = offset;
@@ -783,7 +620,6 @@ var makeBrotliDecode = function makeBrotliDecode() {
     s.blockTrees[2 * treeType + 2] = offset;
     return readBlockLength(s.blockTrees, 2 * treeType + 1, s);
   }
-
   function calculateDistanceLut(s, alphabetSizeLimit) {
     var distExtraBits = s.distExtraBits;
     var distOffset = s.distOffset;
@@ -793,27 +629,22 @@ var makeBrotliDecode = function makeBrotliDecode() {
     var bits = 1;
     var half = 0;
     var i = 16;
-
     for (var j = 0; j < ndirect; ++j) {
       distExtraBits[i] = 0;
       distOffset[i] = j + 1;
       ++i;
     }
-
     while (i < alphabetSizeLimit) {
       var base = ndirect + ((2 + half << bits) - 4 << npostfix) + 1;
-
       for (var _j = 0; _j < postfix; ++_j) {
         distExtraBits[i] = bits;
         distOffset[i] = base + _j;
         ++i;
       }
-
       bits = bits + half;
       half = half ^ 1;
     }
   }
-
   function readMetablockHuffmanCodesAndContextMaps(s) {
     s.numLiteralBlockTypes = decodeVarLenUnsignedByte(s) + 1;
     s.literalBlockLength = readMetablockPartition(s, 0, s.numLiteralBlockTypes);
@@ -821,60 +652,48 @@ var makeBrotliDecode = function makeBrotliDecode() {
     s.commandBlockLength = readMetablockPartition(s, 1, s.numCommandBlockTypes);
     s.numDistanceBlockTypes = decodeVarLenUnsignedByte(s) + 1;
     s.distanceBlockLength = readMetablockPartition(s, 2, s.numDistanceBlockTypes);
-
     if (s.halfOffset > 2030) {
       doReadMoreInput(s);
     }
-
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     s.distancePostfixBits = readFewBits(s, 2);
     s.numDirectDistanceCodes = readFewBits(s, 4) << s.distancePostfixBits;
     s.contextModes = new Int8Array(s.numLiteralBlockTypes);
-
     for (var i = 0; i < s.numLiteralBlockTypes;) {
       var limit = min(i + 96, s.numLiteralBlockTypes);
-
       for (; i < limit; ++i) {
         if (s.bitOffset >= 16) {
           s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
           s.bitOffset -= 16;
         }
-
         s.contextModes[i] = readFewBits(s, 2);
       }
-
       if (s.halfOffset > 2030) {
         doReadMoreInput(s);
       }
     }
-
     s.contextMap = new Int8Array(s.numLiteralBlockTypes << 6);
     var numLiteralTrees = decodeContextMap(s.numLiteralBlockTypes << 6, s.contextMap, s);
     s.trivialLiteralContext = 1;
-
     for (var j = 0; j < s.numLiteralBlockTypes << 6; j++) {
       if (s.contextMap[j] != j >> 6) {
         s.trivialLiteralContext = 0;
         break;
       }
     }
-
     s.distContextMap = new Int8Array(s.numDistanceBlockTypes << 2);
     var numDistTrees = decodeContextMap(s.numDistanceBlockTypes << 2, s.distContextMap, s);
     s.literalTreeGroup = decodeHuffmanTreeGroup(256, 256, numLiteralTrees, s);
     s.commandTreeGroup = decodeHuffmanTreeGroup(704, 704, s.numCommandBlockTypes, s);
     var distanceAlphabetSizeMax = calculateDistanceAlphabetSize(s.distancePostfixBits, s.numDirectDistanceCodes, 24);
     var distanceAlphabetSizeLimit = distanceAlphabetSizeMax;
-
     if (s.isLargeWindow == 1) {
       distanceAlphabetSizeMax = calculateDistanceAlphabetSize(s.distancePostfixBits, s.numDirectDistanceCodes, 62);
       distanceAlphabetSizeLimit = calculateDistanceAlphabetLimit(0x7ffffffc, s.distancePostfixBits, s.numDirectDistanceCodes);
     }
-
     s.distanceTreeGroup = decodeHuffmanTreeGroup(distanceAlphabetSizeMax, distanceAlphabetSizeLimit, numDistTrees, s);
     calculateDistanceLut(s, distanceAlphabetSizeLimit);
     s.contextMapSlice = 0;
@@ -890,157 +709,122 @@ var makeBrotliDecode = function makeBrotliDecode() {
     s.rings[8] = 1;
     s.rings[9] = 0;
   }
-
   function copyUncompressedData(s) {
     var ringBuffer = s.ringBuffer;
-
     if (s.metaBlockLength <= 0) {
       reload(s);
       s.runningState = 2;
       return;
     }
-
     var chunkLength = min(s.ringBufferSize - s.pos, s.metaBlockLength);
     copyRawBytes(s, ringBuffer, s.pos, chunkLength);
     s.metaBlockLength -= chunkLength;
     s.pos += chunkLength;
-
     if (s.pos == s.ringBufferSize) {
       s.nextRunningState = 6;
       s.runningState = 12;
       return;
     }
-
     reload(s);
     s.runningState = 2;
   }
-
   function writeRingBuffer(s) {
     var toWrite = min(s.outputLength - s.outputUsed, s.ringBufferBytesReady - s.ringBufferBytesWritten);
-
     if (toWrite != 0) {
       s.output.set(s.ringBuffer.subarray(s.ringBufferBytesWritten, s.ringBufferBytesWritten + toWrite), s.outputOffset + s.outputUsed);
       s.outputUsed += toWrite;
       s.ringBufferBytesWritten += toWrite;
     }
-
     if (s.outputUsed < s.outputLength) {
       return 1;
     } else {
       return 0;
     }
   }
-
   function decodeHuffmanTreeGroup(alphabetSizeMax, alphabetSizeLimit, n, s) {
     var maxTableSize = MAX_HUFFMAN_TABLE_SIZE[alphabetSizeLimit + 31 >> 5];
     var group = new Int32Array(n + n * maxTableSize);
     var next = n;
-
     for (var i = 0; i < n; ++i) {
       group[i] = next;
       next += readHuffmanCode(alphabetSizeMax, alphabetSizeLimit, group, i, s);
     }
-
     return group;
   }
-
   function calculateFence(s) {
     var result = s.ringBufferSize;
-
     if (s.isEager != 0) {
       result = min(result, s.ringBufferBytesWritten + s.outputLength - s.outputUsed);
     }
-
     return result;
   }
-
   function doUseDictionary(s, fence) {
     if (s.distance > 0x7ffffffc) {
       throw 'Invalid backward reference';
     }
-
     var address = s.distance - s.maxDistance - 1 - s.cdTotalSize;
-
     if (address < 0) {
       initializeCompoundDictionaryCopy(s, -address - 1, s.copyLength);
       s.runningState = 14;
     } else {
       var dictionaryData = data;
       var wordLength = s.copyLength;
-
       if (wordLength > 31) {
         throw 'Invalid backward reference';
       }
-
       var shift = sizeBits[wordLength];
-
       if (shift == 0) {
         throw 'Invalid backward reference';
       }
-
       var offset = offsets[wordLength];
       var mask = (1 << shift) - 1;
       var wordIdx = address & mask;
       var transformIdx = address >>> shift;
       offset += wordIdx * wordLength;
       var transforms = RFC_TRANSFORMS;
-
       if (transformIdx >= transforms.numTransforms) {
         throw 'Invalid backward reference';
       }
-
       var len = transformDictionaryWord(s.ringBuffer, s.pos, dictionaryData, offset, wordLength, transforms, transformIdx);
       s.pos += len;
       s.metaBlockLength -= len;
-
       if (s.pos >= fence) {
         s.nextRunningState = 4;
         s.runningState = 12;
         return;
       }
-
       s.runningState = 4;
     }
   }
-
   function initializeCompoundDictionary(s) {
     s.cdBlockMap = new Int8Array(256);
     var blockBits = 8;
-
     while (s.cdTotalSize - 1 >>> blockBits != 0) {
       blockBits++;
     }
-
     blockBits -= 8;
     s.cdBlockBits = blockBits;
     var cursor = 0;
     var index = 0;
-
     while (cursor < s.cdTotalSize) {
       while (s.cdChunkOffsets[index + 1] < cursor) {
         index++;
       }
-
       s.cdBlockMap[cursor >>> blockBits] = index;
       cursor += 1 << blockBits;
     }
   }
-
   function initializeCompoundDictionaryCopy(s, address, length) {
     if (s.cdBlockBits == -1) {
       initializeCompoundDictionary(s);
     }
-
     var index = s.cdBlockMap[address >>> s.cdBlockBits];
-
     while (address >= s.cdChunkOffsets[index + 1]) {
       index++;
     }
-
     if (s.cdTotalSize > address + length) {
       throw 'Invalid backward reference';
     }
-
     s.distRbIdx = s.distRbIdx + 1 & 0x3;
     s.rings[s.distRbIdx] = s.distance;
     s.metaBlockLength -= length;
@@ -1049,152 +833,119 @@ var makeBrotliDecode = function makeBrotliDecode() {
     s.cdBrLength = length;
     s.cdBrCopied = 0;
   }
-
   function copyFromCompoundDictionary(s, fence) {
     var pos = s.pos;
     var origPos = pos;
-
     while (s.cdBrLength != s.cdBrCopied) {
       var space = fence - pos;
       var chunkLength = s.cdChunkOffsets[s.cdBrIndex + 1] - s.cdChunkOffsets[s.cdBrIndex];
       var remChunkLength = chunkLength - s.cdBrOffset;
       var length = s.cdBrLength - s.cdBrCopied;
-
       if (length > remChunkLength) {
         length = remChunkLength;
       }
-
       if (length > space) {
         length = space;
       }
-
       copyBytes(s.ringBuffer, pos, s.cdChunks[s.cdBrIndex], s.cdBrOffset, s.cdBrOffset + length);
       pos += length;
       s.cdBrOffset += length;
       s.cdBrCopied += length;
-
       if (length == remChunkLength) {
         s.cdBrIndex++;
         s.cdBrOffset = 0;
       }
-
       if (pos >= fence) {
         break;
       }
     }
-
     return pos - origPos;
   }
-
   function decompress(s) {
     if (s.runningState == 0) {
       throw "Can't decompress until initialized";
     }
-
     if (s.runningState == 11) {
       throw "Can't decompress after close";
     }
-
     if (s.runningState == 1) {
       var windowBits = decodeWindowBits(s);
-
       if (windowBits == -1) {
         throw "Invalid 'windowBits' code";
       }
-
       s.maxRingBufferSize = 1 << windowBits;
       s.maxBackwardDistance = s.maxRingBufferSize - 16;
       s.runningState = 2;
     }
-
     var fence = calculateFence(s);
     var ringBufferMask = s.ringBufferSize - 1;
     var ringBuffer = s.ringBuffer;
-
     while (s.runningState != 10) {
       switch (s.runningState) {
         case 2:
           if (s.metaBlockLength < 0) {
             throw 'Invalid metablock length';
           }
-
           readNextMetablockHeader(s);
           fence = calculateFence(s);
           ringBufferMask = s.ringBufferSize - 1;
           ringBuffer = s.ringBuffer;
           continue;
-
         case 3:
           readMetablockHuffmanCodesAndContextMaps(s);
           s.runningState = 4;
-
         case 4:
           if (s.metaBlockLength <= 0) {
             s.runningState = 2;
             continue;
           }
-
           if (s.halfOffset > 2030) {
             doReadMoreInput(s);
           }
-
           if (s.commandBlockLength == 0) {
             decodeCommandBlockSwitch(s);
           }
-
           s.commandBlockLength--;
-
           if (s.bitOffset >= 16) {
             s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
             s.bitOffset -= 16;
           }
-
           var cmdCode = readSymbol(s.commandTreeGroup, s.commandTreeIdx, s) << 2;
           var insertAndCopyExtraBits = CMD_LOOKUP[cmdCode];
           var insertLengthOffset = CMD_LOOKUP[cmdCode + 1];
           var copyLengthOffset = CMD_LOOKUP[cmdCode + 2];
           s.distanceCode = CMD_LOOKUP[cmdCode + 3];
-
           if (s.bitOffset >= 16) {
             s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
             s.bitOffset -= 16;
           }
-
           var insertLengthExtraBits = insertAndCopyExtraBits & 0xff;
           s.insertLength = insertLengthOffset + (insertLengthExtraBits <= 16 ? readFewBits(s, insertLengthExtraBits) : readManyBits(s, insertLengthExtraBits));
-
           if (s.bitOffset >= 16) {
             s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
             s.bitOffset -= 16;
           }
-
           var copyLengthExtraBits = insertAndCopyExtraBits >> 8;
           s.copyLength = copyLengthOffset + (copyLengthExtraBits <= 16 ? readFewBits(s, copyLengthExtraBits) : readManyBits(s, copyLengthExtraBits));
           s.j = 0;
           s.runningState = 7;
-
         case 7:
           if (s.trivialLiteralContext != 0) {
             while (s.j < s.insertLength) {
               if (s.halfOffset > 2030) {
                 doReadMoreInput(s);
               }
-
               if (s.literalBlockLength == 0) {
                 decodeLiteralBlockSwitch(s);
               }
-
               s.literalBlockLength--;
-
               if (s.bitOffset >= 16) {
                 s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
                 s.bitOffset -= 16;
               }
-
               ringBuffer[s.pos] = readSymbol(s.literalTreeGroup, s.literalTreeIdx, s);
               s.pos++;
               s.j++;
-
               if (s.pos >= fence) {
                 s.nextRunningState = 7;
                 s.runningState = 12;
@@ -1204,31 +955,25 @@ var makeBrotliDecode = function makeBrotliDecode() {
           } else {
             var prevByte1 = ringBuffer[s.pos - 1 & ringBufferMask] & 0xff;
             var prevByte2 = ringBuffer[s.pos - 2 & ringBufferMask] & 0xff;
-
             while (s.j < s.insertLength) {
               if (s.halfOffset > 2030) {
                 doReadMoreInput(s);
               }
-
               if (s.literalBlockLength == 0) {
                 decodeLiteralBlockSwitch(s);
               }
-
               var literalContext = LOOKUP[s.contextLookupOffset1 + prevByte1] | LOOKUP[s.contextLookupOffset2 + prevByte2];
               var literalTreeIdx = s.contextMap[s.contextMapSlice + literalContext] & 0xff;
               s.literalBlockLength--;
               prevByte2 = prevByte1;
-
               if (s.bitOffset >= 16) {
                 s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
                 s.bitOffset -= 16;
               }
-
               prevByte1 = readSymbol(s.literalTreeGroup, literalTreeIdx, s);
               ringBuffer[s.pos] = prevByte1;
               s.pos++;
               s.j++;
-
               if (s.pos >= fence) {
                 s.nextRunningState = 7;
                 s.runningState = 12;
@@ -1236,52 +981,40 @@ var makeBrotliDecode = function makeBrotliDecode() {
               }
             }
           }
-
           if (s.runningState != 7) {
             continue;
           }
-
           s.metaBlockLength -= s.insertLength;
-
           if (s.metaBlockLength <= 0) {
             s.runningState = 4;
             continue;
           }
-
           var distanceCode = s.distanceCode;
-
           if (distanceCode < 0) {
             s.distance = s.rings[s.distRbIdx];
           } else {
             if (s.halfOffset > 2030) {
               doReadMoreInput(s);
             }
-
             if (s.distanceBlockLength == 0) {
               decodeDistanceBlockSwitch(s);
             }
-
             s.distanceBlockLength--;
-
             if (s.bitOffset >= 16) {
               s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
               s.bitOffset -= 16;
             }
-
             var distTreeIdx = s.distContextMap[s.distContextMapSlice + distanceCode] & 0xff;
             distanceCode = readSymbol(s.distanceTreeGroup, distTreeIdx, s);
-
             if (distanceCode < 16) {
               var index = s.distRbIdx + DISTANCE_SHORT_CODE_INDEX_OFFSET[distanceCode] & 0x3;
               s.distance = s.rings[index] + DISTANCE_SHORT_CODE_VALUE_OFFSET[distanceCode];
-
               if (s.distance < 0) {
                 throw 'Negative distance';
               }
             } else {
               var extraBits = s.distExtraBits[distanceCode];
               var bits = void 0;
-
               if (s.bitOffset + extraBits <= 32) {
                 bits = readFewBits(s, extraBits);
               } else {
@@ -1289,44 +1022,35 @@ var makeBrotliDecode = function makeBrotliDecode() {
                   s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
                   s.bitOffset -= 16;
                 }
-
                 bits = extraBits <= 16 ? readFewBits(s, extraBits) : readManyBits(s, extraBits);
               }
-
               s.distance = s.distOffset[distanceCode] + (bits << s.distancePostfixBits);
             }
           }
-
           if (s.maxDistance != s.maxBackwardDistance && s.pos < s.maxBackwardDistance) {
             s.maxDistance = s.pos;
           } else {
             s.maxDistance = s.maxBackwardDistance;
           }
-
           if (s.distance > s.maxDistance) {
             s.runningState = 9;
             continue;
           }
-
           if (distanceCode > 0) {
             s.distRbIdx = s.distRbIdx + 1 & 0x3;
             s.rings[s.distRbIdx] = s.distance;
           }
-
           if (s.copyLength > s.metaBlockLength) {
             throw 'Invalid backward reference';
           }
-
           s.j = 0;
           s.runningState = 8;
-
         case 8:
           var src = s.pos - s.distance & ringBufferMask;
           var dst = s.pos;
           var copyLength = s.copyLength - s.j;
           var srcEnd = src + copyLength;
           var dstEnd = dst + copyLength;
-
           if (srcEnd < ringBufferMask && dstEnd < ringBufferMask) {
             if (copyLength < 12 || srcEnd > dst && dstEnd > src) {
               for (var k = 0; k < copyLength; k += 4) {
@@ -1338,7 +1062,6 @@ var makeBrotliDecode = function makeBrotliDecode() {
             } else {
               ringBuffer.copyWithin(dst, src, srcEnd);
             }
-
             s.j += copyLength;
             s.metaBlockLength -= copyLength;
             s.pos += copyLength;
@@ -1348,7 +1071,6 @@ var makeBrotliDecode = function makeBrotliDecode() {
               s.metaBlockLength--;
               s.pos++;
               s.j++;
-
               if (s.pos >= fence) {
                 s.nextRunningState = 8;
                 s.runningState = 12;
@@ -1356,86 +1078,66 @@ var makeBrotliDecode = function makeBrotliDecode() {
               }
             }
           }
-
           if (s.runningState == 8) {
             s.runningState = 4;
           }
-
           continue;
-
         case 9:
           doUseDictionary(s, fence);
           continue;
-
         case 14:
           s.pos += copyFromCompoundDictionary(s, fence);
-
           if (s.pos >= fence) {
             s.nextRunningState = 14;
             s.runningState = 12;
             return;
           }
-
           s.runningState = 4;
           continue;
-
         case 5:
           while (s.metaBlockLength > 0) {
             if (s.halfOffset > 2030) {
               doReadMoreInput(s);
             }
-
             if (s.bitOffset >= 16) {
               s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
               s.bitOffset -= 16;
             }
-
             readFewBits(s, 8);
             s.metaBlockLength--;
           }
-
           s.runningState = 2;
           continue;
-
         case 6:
           copyUncompressedData(s);
           continue;
-
         case 12:
           s.ringBufferBytesReady = min(s.pos, s.ringBufferSize);
           s.runningState = 13;
-
         case 13:
           if (writeRingBuffer(s) == 0) {
             return;
           }
-
           if (s.pos >= s.maxBackwardDistance) {
             s.maxDistance = s.maxBackwardDistance;
           }
-
           if (s.pos >= s.ringBufferSize) {
             if (s.pos > s.ringBufferSize) {
               ringBuffer.copyWithin(0, s.ringBufferSize, s.pos);
             }
-
             s.pos &= ringBufferMask;
             s.ringBufferBytesWritten = 0;
           }
-
           s.runningState = s.nextRunningState;
           continue;
-
         default:
           throw 'Unexpected state ' + s.runningState;
       }
     }
-
     if (s.runningState == 10) {
       if (s.metaBlockLength < 0) {
         throw 'Invalid metablock length';
       }
-
       jumpToByteBoundary(s);
       checkHealth(s, 1);
     }
@@ -1455,31 +1157,25 @@ var makeBrotliDecode = function makeBrotliDecode() {
   }
 
   var RFC_TRANSFORMS = new Transforms(121, 167, 50);
-
   function unpackTransforms(prefixSuffix, prefixSuffixHeads, transforms, prefixSuffixSrc, transformsSrc) {
     var n = prefixSuffixSrc.length;
     var index = 1;
     var j = 0;
-
     for (var i = 0; i < n; ++i) {
       var c = prefixSuffixSrc.charCodeAt(i);
-
       if (c == 35) {
         prefixSuffixHeads[index++] = j;
       } else {
         prefixSuffix[j++] = c;
       }
     }
-
     for (var _i3 = 0; _i3 < 363; ++_i3) {
       transforms[_i3] = transformsSrc.charCodeAt(_i3) - 32;
     }
   }
-
   {
     unpackTransforms(RFC_TRANSFORMS.prefixSuffixStorage, RFC_TRANSFORMS.prefixSuffixHeads, RFC_TRANSFORMS.triplets, '# #s #, #e #.# the #.com/#\xC2\xA0# of # and # in # to #"#">#\n#]# for # a # that #. # with #\'# from # by #. The # on # as # is #ing #\n\t#:#ed #(# at #ly #="# of the #. This #,# not #er #al #=\'#ful #ive #less #est #ize #ous #', '     !! ! ,  *!  &!  " !  ) *   * -  ! # !  #!*!  +  ,$ !  -  %  .  / #   0  1 .  "   2  3!*   4%  ! # /   5  6  7  8 0  1 &   $   9 +   :  ;  < \'  !=  >  ?! 4  @ 4  2  &   A *# (   B  C& ) %  ) !*# *-% A +! *.  D! %\'  & E *6  F  G% ! *A *%  H! D  I!+!  J!+   K +- *4! A  L!*4  M  N +6  O!*% +.! K *G  P +%(  ! G *D +D  Q +# *K!*G!+D!+# +G +A +4!+% +K!+4!*D!+K!*K');
   }
-
   function transformDictionaryWord(dst, dstOffset, src, srcOffset, len, transforms, transformIndex) {
     var offset = dstOffset;
     var triplets = transforms.triplets;
@@ -1495,48 +1191,37 @@ var makeBrotliDecode = function makeBrotliDecode() {
     var suffixEnd = prefixSuffixHeads[suffixIdx + 1];
     var omitFirst = transformType - 11;
     var omitLast = transformType - 0;
-
     if (omitFirst < 1 || omitFirst > 9) {
       omitFirst = 0;
     }
-
     if (omitLast < 1 || omitLast > 9) {
       omitLast = 0;
     }
-
     while (prefix != prefixEnd) {
       dst[offset++] = prefixSuffixStorage[prefix++];
     }
-
     if (omitFirst > len) {
       omitFirst = len;
     }
-
     srcOffset += omitFirst;
     len -= omitFirst;
     len -= omitLast;
     var i = len;
-
     while (i > 0) {
       dst[offset++] = src[srcOffset++];
       i--;
     }
-
     if (transformType == 10 || transformType == 11) {
       var uppercaseOffset = offset - len;
-
       if (transformType == 10) {
         len = 1;
       }
-
       while (len > 0) {
         var c0 = dst[uppercaseOffset] & 0xff;
-
         if (c0 < 0xc0) {
           if (c0 >= 97 && c0 <= 122) {
             dst[uppercaseOffset] ^= 32;
           }
-
           uppercaseOffset += 1;
           len -= 1;
         } else if (c0 < 0xe0) {
@@ -1553,12 +1238,9 @@ var makeBrotliDecode = function makeBrotliDecode() {
       var shiftOffset = offset - len;
       var param = transforms.params[transformIndex];
       var scalar = (param & 0x7fff) + (0x1000000 - (param & 0x8000));
-
       while (len > 0) {
         var step = 1;
-
         var _c = dst[shiftOffset] & 0xff;
-
         if (_c < 0x80) {
           scalar += _c;
           dst[shiftOffset] = scalar & 0x7f;
@@ -1599,57 +1281,44 @@ var makeBrotliDecode = function makeBrotliDecode() {
             step = len;
           }
         }
-
         shiftOffset += step;
         len -= step;
-
         if (transformType == 21) {
           len = 0;
         }
       }
     }
-
     while (suffix != suffixEnd) {
       dst[offset++] = prefixSuffixStorage[suffix++];
     }
-
     return offset - dstOffset;
   }
 
   function getNextKey(key, len) {
     var step = 1 << len - 1;
-
     while ((key & step) != 0) {
       step >>= 1;
     }
-
     return (key & step - 1) + step;
   }
-
   function replicateValue(table, offset, step, end, item) {
     do {
       end -= step;
       table[offset + end] = item;
     } while (end > 0);
   }
-
   function nextTableBitSize(count, len, rootBits) {
     var left = 1 << len - rootBits;
-
     while (len < 15) {
       left -= count[len];
-
       if (left <= 0) {
         break;
       }
-
       len++;
       left <<= 1;
     }
-
     return len - rootBits;
   }
-
   function buildHuffmanTable(tableGroup, tableIdx, rootBits, codeLengths, codeLengthsSize) {
     var tableOffset = tableGroup[tableIdx];
     var key;
@@ -1657,49 +1326,38 @@ var makeBrotliDecode = function makeBrotliDecode() {
     var count = new Int32Array(16);
     var offset = new Int32Array(16);
     var symbol;
-
     for (symbol = 0; symbol < codeLengthsSize; symbol++) {
       count[codeLengths[symbol]]++;
     }
-
     offset[1] = 0;
-
     for (var len = 1; len < 15; len++) {
       offset[len + 1] = offset[len] + count[len];
     }
-
     for (symbol = 0; symbol < codeLengthsSize; symbol++) {
       if (codeLengths[symbol] != 0) {
         sorted[offset[codeLengths[symbol]]++] = symbol;
       }
     }
-
     var tableBits = rootBits;
     var tableSize = 1 << tableBits;
     var totalSize = tableSize;
-
     if (offset[15] == 1) {
       for (key = 0; key < totalSize; key++) {
         tableGroup[tableOffset + key] = sorted[0];
       }
-
       return totalSize;
     }
-
     key = 0;
     symbol = 0;
-
     for (var _len = 1, step = 2; _len <= rootBits; _len++, step <<= 1) {
       for (; count[_len] > 0; count[_len]--) {
         replicateValue(tableGroup, tableOffset + key, step, tableSize, _len << 16 | sorted[symbol++]);
         key = getNextKey(key, _len);
       }
     }
-
     var mask = totalSize - 1;
     var low = -1;
     var currentOffset = tableOffset;
-
     for (var _len2 = rootBits + 1, _step = 2; _len2 <= 15; _len2++, _step <<= 1) {
       for (; count[_len2] > 0; count[_len2]--) {
         if ((key & mask) != low) {
@@ -1710,12 +1368,10 @@ var makeBrotliDecode = function makeBrotliDecode() {
           low = key & mask;
           tableGroup[tableOffset + low] = tableBits + rootBits << 16 | currentOffset - tableOffset - low;
         }
-
         replicateValue(tableGroup, currentOffset + (key >> rootBits), _step, tableSize, _len2 - rootBits << 16 | sorted[symbol++]);
         key = getNextKey(key, _len2);
       }
     }
-
     return totalSize;
   }
 
@@ -1724,67 +1380,53 @@ var makeBrotliDecode = function makeBrotliDecode() {
       if (halfAvailable(s) >= -2) {
         return;
       }
-
       throw 'No more input';
     }
-
     var readOffset = s.halfOffset << 1;
     var bytesInBuffer = 4096 - readOffset;
     s.byteBuffer.copyWithin(0, readOffset, 4096);
     s.halfOffset = 0;
-
     while (bytesInBuffer < 4096) {
       var spaceLeft = 4096 - bytesInBuffer;
       var len = readInput(s.input, s.byteBuffer, bytesInBuffer, spaceLeft);
-
       if (len <= 0) {
         s.endOfStreamReached = 1;
         s.tailBytes = bytesInBuffer;
         bytesInBuffer += 1;
         break;
       }
-
       bytesInBuffer += len;
     }
-
     bytesToNibbles(s, bytesInBuffer);
   }
-
   function checkHealth(s, endOfStream) {
     if (s.endOfStreamReached == 0) {
       return;
     }
-
     var byteOffset = (s.halfOffset << 1) + (s.bitOffset + 7 >> 3) - 4;
-
     if (byteOffset > s.tailBytes) {
       throw 'Read after end';
     }
-
     if (endOfStream != 0 && byteOffset != s.tailBytes) {
       throw 'Unused bytes after end';
     }
   }
-
   function assertAccumulatorHealthy(s) {
     if (s.bitOffset > 32) {
       throw 'Accumulator underloaded: ' + s.bitOffset;
     }
   }
-
   function readFewBits(s, n) {
     var val = s.accumulator32 >>> s.bitOffset & (1 << n) - 1;
     s.bitOffset += n;
     return val;
   }
-
   function readManyBits(s, n) {
     var low = readFewBits(s, 16);
     s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
     s.bitOffset -= 16;
     return low | readFewBits(s, n - 16) << 16;
   }
-
   function initBitReader(s) {
     s.byteBuffer = new Int8Array(4160);
     s.accumulator32 = 0;
@@ -1794,64 +1436,50 @@ var makeBrotliDecode = function makeBrotliDecode() {
     s.endOfStreamReached = 0;
     prepare(s);
   }
-
   function prepare(s) {
     if (s.halfOffset > 2030) {
       doReadMoreInput(s);
     }
-
     checkHealth(s, 0);
     s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
     s.bitOffset -= 16;
     s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
     s.bitOffset -= 16;
   }
-
   function reload(s) {
     if (s.bitOffset == 32) {
       prepare(s);
     }
   }
-
   function jumpToByteBoundary(s) {
     var padding = 32 - s.bitOffset & 7;
-
     if (padding != 0) {
       var paddingBits = readFewBits(s, padding);
-
       if (paddingBits != 0) {
         throw 'Corrupted padding bits';
       }
     }
   }
-
   function halfAvailable(s) {
     var limit = 2048;
-
     if (s.endOfStreamReached != 0) {
       limit = s.tailBytes + 1 >> 1;
     }
-
     return limit - s.halfOffset;
   }
-
   function copyRawBytes(s, data, offset, length) {
     if ((s.bitOffset & 7) != 0) {
       throw 'Unaligned copyBytes';
     }
-
     while (s.bitOffset != 32 && length != 0) {
       data[offset++] = s.accumulator32 >>> s.bitOffset;
       s.bitOffset += 8;
       length--;
     }
-
     if (length == 0) {
       return;
     }
-
     var copyNibbles = min(halfAvailable(s), length >> 1);
-
     if (copyNibbles > 0) {
       var readOffset = s.halfOffset << 1;
       var delta = copyNibbles << 1;
@@ -1860,91 +1488,72 @@ var makeBrotliDecode = function makeBrotliDecode() {
       length -= delta;
       s.halfOffset += copyNibbles;
     }
-
     if (length == 0) {
       return;
     }
-
     if (halfAvailable(s) > 0) {
       if (s.bitOffset >= 16) {
         s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
         s.bitOffset -= 16;
       }
-
       while (length != 0) {
         data[offset++] = s.accumulator32 >>> s.bitOffset;
         s.bitOffset += 8;
         length--;
       }
-
       checkHealth(s, 0);
       return;
     }
-
     while (length > 0) {
       var len = readInput(s.input, data, offset, length);
-
       if (len == -1) {
         throw 'Unexpected end of input';
       }
-
       offset += len;
       length -= len;
     }
   }
-
   function bytesToNibbles(s, byteLen) {
     var byteBuffer = s.byteBuffer;
     var halfLen = byteLen >> 1;
     var shortBuffer = s.shortBuffer;
-
     for (var i = 0; i < halfLen; ++i) {
       shortBuffer[i] = byteBuffer[i * 2] & 0xff | (byteBuffer[i * 2 + 1] & 0xff) << 8;
     }
   }
 
   var LOOKUP = new Int32Array(2048);
-
   function unpackLookupTable(lookup, map, rle) {
     for (var i = 0; i < 256; ++i) {
       lookup[i] = i & 0x3f;
       lookup[512 + i] = i >> 2;
       lookup[1792 + i] = 2 + (i >> 6);
     }
-
     for (var _i4 = 0; _i4 < 128; ++_i4) {
       lookup[1024 + _i4] = 4 * (map.charCodeAt(_i4) - 32);
     }
-
     for (var _i5 = 0; _i5 < 64; ++_i5) {
       lookup[1152 + _i5] = _i5 & 1;
       lookup[1216 + _i5] = 2 + (_i5 & 1);
     }
-
     var offset = 1280;
-
     for (var k = 0; k < 19; ++k) {
       var value = k & 3;
       var rep = rle.charCodeAt(k) - 32;
-
       for (var _i6 = 0; _i6 < rep; ++_i6) {
         lookup[offset++] = value;
       }
     }
-
     for (var _i7 = 0; _i7 < 16; ++_i7) {
       lookup[1792 + _i7] = 1;
       lookup[2032 + _i7] = 6;
     }
-
     lookup[1792] = 0;
     lookup[2047] = 7;
-
     for (var _i8 = 0; _i8 < 256; ++_i8) {
       lookup[1536 + _i8] = lookup[1792 + _i8] << 3;
     }
   }
-
   {
     unpackLookupTable(LOOKUP, "         !!  !                  \"#$##%#$&'##(#)#++++++++++((&*'##,---,---,-----,-----,-----&#'###.///.///./////./////./////&#'# ", "A/*  ':  & : $  \x81 @");
   }
@@ -2032,88 +1641,69 @@ var makeBrotliDecode = function makeBrotliDecode() {
   var data = null;
   var offsets = new Int32Array(32);
   var sizeBits = new Int32Array(32);
-
   function setData(newData, newSizeBits) {
     if (isDirect(newData) == 0 || isReadOnly(newData) == 0) {
       throw 'newData must be a direct read-only byte buffer';
     }
-
     if (newSizeBits.length > 31) {
       throw 'sizeBits length must be at most ' + 31;
     }
-
     for (var i = 0; i < 4; ++i) {
       if (newSizeBits[i] != 0) {
         throw 'first ' + 4 + ' must be 0';
       }
     }
-
     var dictionaryOffsets = offsets;
     var dictionarySizeBits = sizeBits;
     dictionarySizeBits.set(newSizeBits.subarray(0, 0 + newSizeBits.length), 0);
     var pos = 0;
     var limit = newData.length;
-
     for (var _i9 = 0; _i9 < newSizeBits.length; ++_i9) {
       dictionaryOffsets[_i9] = pos;
       var bits = dictionarySizeBits[_i9];
-
       if (bits != 0) {
         if (bits >= 31) {
           throw 'newSizeBits values must be less than 31';
         }
-
         pos += _i9 << bits;
-
         if (pos <= 0 || pos > limit) {
           throw 'newSizeBits is inconsistent: overflow';
         }
       }
     }
-
     for (var _i10 = newSizeBits.length; _i10 < 32; ++_i10) {
       dictionaryOffsets[_i10] = pos;
     }
-
     if (pos != limit) {
       throw 'newSizeBits is inconsistent: underflow';
     }
-
     data = newData;
   }
 
   function unpackDictionaryData(dictionary, data0, data1, skipFlip, sizeBits, sizeBitsData) {
     var dict = toUsAsciiBytes(data0 + data1);
-
     if (dict.length != dictionary.length) {
       throw 'Corrupted brotli dictionary';
     }
-
     var offset = 0;
     var n = skipFlip.length;
-
     for (var i = 0; i < n; i += 2) {
       var skip = skipFlip.charCodeAt(i) - 36;
       var flip = skipFlip.charCodeAt(i + 1) - 36;
-
       for (var j = 0; j < skip; ++j) {
         dict[offset] ^= 3;
         offset++;
       }
-
       for (var _j2 = 0; _j2 < flip; ++_j2) {
         dict[offset] ^= 236;
         offset++;
       }
     }
-
     for (var _i11 = 0; _i11 < sizeBitsData.length; ++_i11) {
       sizeBits[_i11] = sizeBitsData.charCodeAt(_i11) - 65;
     }
-
     dictionary.set(dict);
   }
-
   {
     var dictionaryData = new Int8Array(122784);
     var dictionarySizeBits = new Int32Array(25);
@@ -2155,31 +1745,27 @@ var makeBrotliDecode = function makeBrotliDecode() {
     return 1;
   }
 
-  function flipBuffer(buffer) {}
+  function flipBuffer(buffer) {
+  }
 
   function toUsAsciiBytes(src) {
     var n = src.length;
     var result = new Int8Array(n);
-
     for (var i = 0; i < n; ++i) {
       result[i] = src.charCodeAt(i);
     }
-
     return result;
   }
 
   function decode(bytes, options) {
     var s = new State();
     initState(s, new InputStream(bytes));
-
     if (options) {
       var customDictionary = options['customDictionary'];
       if (customDictionary) attachDictionaryChunk(s, customDictionary);
     }
-
     var totalOutput = 0;
     var chunks = [];
-
     while (true) {
       var chunk = new Int8Array(16384);
       chunks.push(chunk);
@@ -2191,28 +1777,22 @@ var makeBrotliDecode = function makeBrotliDecode() {
       totalOutput += s.outputUsed;
       if (s.outputUsed < 16384) break;
     }
-
     close(s);
     var result = new Int8Array(totalOutput);
     var offset = 0;
-
     for (var i = 0; i < chunks.length; ++i) {
       var _chunk = chunks[i];
       var end = min(totalOutput, offset + 16384);
       var len = end - offset;
-
       if (len < 16384) {
         result.set(_chunk.subarray(0, len), offset);
       } else {
         result.set(_chunk, offset);
       }
-
       offset += len;
     }
-
     return result;
   }
-
   return decode;
 };