brotli-lib 0.0.2 → 0.0.4

package/README.md

@@ -58,38 +58,40 @@ class BrotliEncoder {
 }
 ```
 
+FONT mode uses distance coding parameters optimized for transformed font data. It doesn't improve compression on raw TTF/OTF files - the gains come from WOFF2's font-specific transforms (glyf, loca, hmtx) applied before brotli compression
+
 ## Performance
 
 ### Decode
 
-|  | brotli-lib | brotli.js | Google brotli |
+|  | brotli-lib | brotli.js | Google decode.ts |
 |--|------------|-----------|---------------|
-| Speed (vs Google) | 1.0x | 0.5-0.6x | 1x |
+| Speed (vs Google) | 1.05-1.1x | 0.5-0.6x | 1x |
 | Custom dictionary | yes | no | yes |
 | Compressed static dict | yes | yes | no |
 
 Decode times (Apple M2 Max, Node 22):
 
-| File | brotli-lib | brotli.js | Google brotli |
+| File | brotli-lib | brotli.js | Google decode.ts |
 |------|------------|-----------|---------------|
-| enc-ttf (305 KB) | 3.0 ms | 5.2 ms | 3.1 ms |
-| enc-otf (253 KB) | 3.0 ms | 5.2 ms | 3.1 ms |
-| enc-var-ttf (788 KB) | 7.5 ms | 13.8 ms | 7.8 ms |
-| noto-tc (7 MB) | 61 ms | 106 ms | 63 ms |
+| enc-ttf (305 KB) | 2.5 ms | 4.5 ms | 2.8 ms |
+| enc-otf (253 KB) | 2.5 ms | 4.3 ms | 2.7 ms |
+| enc-var-ttf (788 KB) | 6.8 ms | 11.8 ms | 7.1 ms |
+| noto-tc (7 MB) | 55 ms | 90 ms | 57 ms |
 
-1.7x faster than brotli.js, on par with or slightly faster than Google's JS decoder
+1.7x faster than brotli.js, 5-10% faster than Google's JS decoder
 
 ### Encode
 
 Encoder vs Node.js native `zlib.brotliCompressSync` (quality 11):
 
-| Input | brotli-lib | node:zlib |
-|-------|-----------|-----------|
-| 13 B | 0.0004 ms | 0.22 ms |
-| 4.5 KB | 0.38 ms | 0.43 ms |
-| 45 KB | 3.5 ms | 1.6 ms |
+| Input | brotli-lib | node:zlib | vs native |
+|-------|-----------|-----------|-----------|
+| 13 B | 0.001 ms | 0.16 ms | 160x faster |
+| 4.5 KB | 0.27 ms | 0.33 ms | 1.2x faster |
+| 45 KB | 3.0 ms | 1.4 ms | 2x slower |
 
-Much faster for tiny inputs (no native binding overhead), faster for medium, 2x slower for large
+Much faster for tiny inputs (no native binding overhead), faster for medium, ~2x slower for large
 
 Run `npm run bench` to reproduce
 
@@ -97,11 +99,11 @@ Run `npm run bench` to reproduce
 
 | Import | Export size (gzip) |
 |--------|--------------------|
+| `brotli-lib/encode` | 25 KB |
 | `brotli-lib/decode` | 66 KB |
-| `brotli-lib/encode` | 16 KB |
-| `brotli-lib` | 82 KB |
+| `brotli-lib` | 90 KB |
 
-The 122 KB static dictionary is compressed to 52 KB and bootstrapped at runtime (à la Devon Govett's brotli.js)
+The 122 KB static dictionary is compressed to 52 KB and bootstrapped at runtime (à la Devon Govett's brotli.js).
 
 ## License
 

package/dist/decode/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/decode/engine.ts"],"names":[],"mappings":"AASA,UAAU,mBAAmB;IAC3B,gBAAgB,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,IAAI,CAAC;IACjD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAuGD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAMlD;AAGD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAMlD;AAonDD,cAAM,KAAK;IACT,UAAU,EAAE,UAAU,CAAqB;IAC3C,YAAY,yBAAoB;IAChC,UAAU,yBAAoB;IAC9B,cAAc,yBAAoB;IAClC,aAAa,yBAAoB;IACjC,MAAM,EAAE,UAAU,CAAqB;IACvC,UAAU,yBAAoB;IAC9B,YAAY,2BAAsB;IAClC,WAAW,0BAAqB;IAChC,SAAS,0BAAqB;IAC9B,KAAK,0BAAqB;IAC1B,UAAU,0BAAqB;IAC/B,gBAAgB,0BAAqB;IACrC,gBAAgB,0BAAqB;IACrC,iBAAiB,0BAAqB;IACtC,UAAU,0BAAqB;IAC/B,aAAa,SAAK;IAClB,YAAY,SAAK;IACjB,gBAAgB,SAAK;IACrB,aAAa,SAAK;IAClB,SAAS,SAAK;IACd,UAAU,SAAK;IACf,SAAS,SAAK;IACd,kBAAkB,SAAK;IACvB,eAAe,SAAK;IACpB,QAAQ,SAAK;IACb,cAAc,SAAK;IACnB,UAAU,SAAK;IACf,kBAAkB,SAAK;IACvB,oBAAoB,SAAK;IACzB,kBAAkB,SAAK;IACvB,oBAAoB,SAAK;IACzB,mBAAmB,SAAK;IACxB,qBAAqB,SAAK;IAC1B,GAAG,SAAK;IACR,WAAW,SAAK;IAChB,SAAS,SAAK;IACd,qBAAqB,SAAK;IAC1B,cAAc,SAAK;IACnB,cAAc,SAAK;IACnB,CAAC,SAAK;IACN,YAAY,SAAK;IACjB,eAAe,SAAK;IACpB,mBAAmB,SAAK;IACxB,oBAAoB,SAAK;IACzB,oBAAoB,SAAK;IACzB,YAAY,SAAK;IACjB,sBAAsB,SAAK;IAC3B,mBAAmB,SAAK;IACxB,QAAQ,SAAK;IACb,UAAU,SAAK;IACf,mBAAmB,SAAK;IACxB,iBAAiB,SAAK;IACtB,cAAc,SAAK;IACnB,iBAAiB,SAAK;IACtB,YAAY,SAAK;IACjB,YAAY,SAAK;IACjB,UAAU,SAAK;IACf,sBAAsB,SAAK;IAC3B,oBAAoB,SAAK;IACzB,OAAO,SAAK;IACZ,aAAa,SAAK;IAClB,WAAW,SAAK;IAChB,WAAW,SAAK;IAChB,SAAS,SAAK;IACd,UAAU,SAAK;IACf,UAAU,SAAK;IACf,UAAU,SAAK;IACf,QAAQ,QAAgB;IACxB,cAAc,0BAAqB;IACnC,WAAW,SAAK;IAChB,UAAU,yBAAoB;IAC9B,KAAK,cAAqC;;CAS3C;AAmDD,cAAM,WAAW;IACf,IAAI,EAAE,UAAU,GAAG,SAAS,CAAqB;IACjD,MAAM,SAAK;gBACE,IAAI,EAAE,UAAU,GAAG,SAAS;CAG1C;AAuCD;;GAEG;AACH,wBAAgB,YAAY,CACxB,KAAK,EAAE,UAAU,GAAG,SAAS,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,UAAU,CAsD5E"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/decode/engine.ts"],"names":[],"mappings":"AASA,UAAU,mBAAmB;IAC3B,gBAAgB,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,IAAI,CAAC;IACjD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAiHD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAMlD;AAGD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAMlD;AAurDD,cAAM,KAAK;IACT,UAAU,EAAE,UAAU,CAAqB;IAC3C,YAAY,yBAAoB;IAChC,UAAU,yBAAoB;IAC9B,cAAc,yBAAoB;IAClC,aAAa,yBAAoB;IACjC,MAAM,EAAE,UAAU,CAAqB;IACvC,UAAU,yBAAoB;IAC9B,YAAY,2BAAsB;IAClC,WAAW,0BAAqB;IAChC,SAAS,0BAAqB;IAC9B,KAAK,0BAAqB;IAC1B,UAAU,0BAAqB;IAC/B,gBAAgB,0BAAqB;IACrC,gBAAgB,0BAAqB;IACrC,iBAAiB,0BAAqB;IACtC,UAAU,0BAAqB;IAC/B,aAAa,SAAK;IAClB,YAAY,SAAK;IACjB,gBAAgB,SAAK;IACrB,aAAa,SAAK;IAClB,SAAS,SAAK;IACd,UAAU,SAAK;IACf,SAAS,SAAK;IACd,kBAAkB,SAAK;IACvB,eAAe,SAAK;IACpB,QAAQ,SAAK;IACb,cAAc,SAAK;IACnB,UAAU,SAAK;IACf,kBAAkB,SAAK;IACvB,oBAAoB,SAAK;IACzB,kBAAkB,SAAK;IACvB,oBAAoB,SAAK;IACzB,mBAAmB,SAAK;IACxB,qBAAqB,SAAK;IAC1B,GAAG,SAAK;IACR,WAAW,SAAK;IAChB,SAAS,SAAK;IACd,qBAAqB,SAAK;IAC1B,cAAc,SAAK;IACnB,cAAc,SAAK;IACnB,CAAC,SAAK;IACN,YAAY,SAAK;IACjB,eAAe,SAAK;IACpB,mBAAmB,SAAK;IACxB,oBAAoB,SAAK;IACzB,oBAAoB,SAAK;IACzB,YAAY,SAAK;IACjB,sBAAsB,SAAK;IAC3B,mBAAmB,SAAK;IACxB,QAAQ,SAAK;IACb,UAAU,SAAK;IACf,mBAAmB,SAAK;IACxB,iBAAiB,SAAK;IACtB,cAAc,SAAK;IACnB,iBAAiB,SAAK;IACtB,YAAY,SAAK;IACjB,YAAY,SAAK;IACjB,UAAU,SAAK;IACf,sBAAsB,SAAK;IAC3B,oBAAoB,SAAK;IACzB,OAAO,SAAK;IACZ,aAAa,SAAK;IAClB,WAAW,SAAK;IAChB,WAAW,SAAK;IAChB,SAAS,SAAK;IACd,UAAU,SAAK;IACf,UAAU,SAAK;IACf,UAAU,SAAK;IACf,QAAQ,QAAgB;IACxB,cAAc,0BAAqB;IACnC,WAAW,SAAK;IAChB,UAAU,yBAAoB;IAC9B,KAAK,cAAqC;;CAS3C;AAmDD,cAAM,WAAW;IACf,IAAI,EAAE,UAAU,GAAG,SAAS,CAAqB;IACjD,MAAM,SAAK;gBACE,IAAI,EAAE,UAAU,GAAG,SAAS;CAG1C;AAuCD;;GAEG;AACH,wBAAgB,YAAY,CACxB,KAAK,EAAE,UAAU,GAAG,SAAS,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,UAAU,CA2D5E"}

package/dist/decode.cjs

@@ -478,6 +478,15 @@ const COPY_LENGTH_N_BITS = Int16Array.from([
 const CMD_LOOKUP = new Int16Array(2816);
 unpackCommandLookupTable(CMD_LOOKUP);
 const IS_LITTLE_ENDIAN = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
+const _scratchCount = new Int32Array(16);
+const _scratchOffset = new Int32Array(16);
+const _scratchSorted = new Int32Array(1080);
+const _scratchHCLTable = new Int32Array(33);
+const _scratchCLCL = new Int32Array(18);
+const _scratchCodeLengths = new Int32Array(1080);
+const _scratchSymbols = new Int32Array(4);
+const _scratchMtf = new Int32Array(256);
+const _scratchCtxMapTable = new Int32Array(1081);
 function log2floor(i) {
 	let result = -1;
 	let step = 16;
@@ -667,16 +676,12 @@ function readBlockLength(tableGroup, tableIdx, s) {
 	return BLOCK_LENGTH_OFFSET[code] + (n <= 16 ? readFewBits(s, n) : readManyBits(s, n));
 }
 function moveToFront(v, index) {
-	let i = index;
-	const value = v[i];
-	while (i > 0) {
-		v[i] = v[i - 1];
-		i--;
-	}
+	const value = v[index];
+	v.copyWithin(1, 0, index);
 	v[0] = value;
 }
 function inverseMoveToFrontTransform(v, vLen) {
-	const mtf = new Int32Array(256);
+	const mtf = _scratchMtf;
 	for (let i = 0; i < 256; ++i) mtf[i] = i;
 	for (let i = 0; i < vLen; ++i) {
 		const index = v[i] & 255;
@@ -690,8 +695,8 @@ function readHuffmanCodeLengths(codeLengthCodeLengths, numSymbols, codeLengths,
 	let repeat = 0;
 	let repeatCodeLen = 0;
 	let space = 32768;
-	const table = new Int32Array(33);
-	buildHuffmanTable(table, table.length - 1, 5, codeLengthCodeLengths, 18);
+	const table = _scratchHCLTable;
+	buildHuffmanTable(table, 32, 5, codeLengthCodeLengths, 18);
 	while (symbol < numSymbols && space > 0) {
 		if (s.halfOffset > 2030) {
 			const result = readMoreInput(s);
@@ -731,7 +736,8 @@ function readHuffmanCodeLengths(codeLengthCodeLengths, numSymbols, codeLengths,
 			repeat += readFewBits(s, extraBits) + 3;
 			const repeatDelta = repeat - oldRepeat;
 			if (symbol + repeatDelta > numSymbols) return makeError(s, -2);
-			for (let i = 0; i < repeatDelta; ++i) codeLengths[symbol++] = repeatCodeLen;
+			codeLengths.fill(repeatCodeLen, symbol, symbol + repeatDelta);
+			symbol += repeatDelta;
 			if (repeatCodeLen !== 0) space -= repeatDelta << 15 - repeatCodeLen;
 		}
 	}
@@ -744,8 +750,9 @@ function checkDupes(s, symbols, length) {
 	return 0;
 }
 function readSimpleHuffmanCode(alphabetSizeMax, alphabetSizeLimit, tableGroup, tableIdx, s) {
-	const codeLengths = new Int32Array(alphabetSizeLimit);
-	const symbols = new Int32Array(4);
+	const codeLengths = _scratchCodeLengths;
+	codeLengths.fill(0, 0, alphabetSizeLimit);
+	const symbols = _scratchSymbols;
 	const maxBits = 1 + log2floor(alphabetSizeMax - 1);
 	const numSymbols = readFewBits(s, 2) + 1;
 	for (let i = 0; i < numSymbols; ++i) {
@@ -791,8 +798,10 @@ function readSimpleHuffmanCode(alphabetSizeMax, alphabetSizeLimit, tableGroup, t
 	return buildHuffmanTable(tableGroup, tableIdx, 8, codeLengths, alphabetSizeLimit);
 }
 function readComplexHuffmanCode(alphabetSizeLimit, skip, tableGroup, tableIdx, s) {
-	const codeLengths = new Int32Array(alphabetSizeLimit);
-	const codeLengthCodeLengths = new Int32Array(18);
+	const codeLengths = _scratchCodeLengths;
+	codeLengths.fill(0, 0, alphabetSizeLimit);
+	const codeLengthCodeLengths = _scratchCLCL;
+	codeLengthCodeLengths.fill(0);
 	let space = 32;
 	let numCodes = 0;
 	for (let i = skip; i < 18; ++i) {
@@ -849,8 +858,8 @@ function decodeContextMap(contextMapSize, contextMap, s) {
 	if (useRleForZeros !== 0) maxRunLengthPrefix = readFewBits(s, 4) + 1;
 	const alphabetSize = numTrees + maxRunLengthPrefix;
 	const tableSize = MAX_HUFFMAN_TABLE_SIZE[alphabetSize + 31 >> 5];
-	const table = new Int32Array(tableSize + 1);
-	const tableIdx = table.length - 1;
+	const table = _scratchCtxMapTable;
+	const tableIdx = tableSize;
 	result = readHuffmanCode(alphabetSize, alphabetSize, table, tableIdx, s);
 	if (result < 0) return result;
 	let i = 0;
@@ -873,12 +882,9 @@ function decodeContextMap(contextMapSize, contextMap, s) {
 				s.bitOffset -= 16;
 			}
 			let reps = (1 << code) + readFewBits(s, code);
-			while (reps !== 0) {
-				if (i >= contextMapSize) return makeError(s, -3);
-				contextMap[i] = 0;
-				i++;
-				reps--;
-			}
+			if (i + reps > contextMapSize) return makeError(s, -3);
+			contextMap.fill(0, i, i + reps);
+			i += reps;
 		} else {
 			contextMap[i] = code - maxRunLengthPrefix;
 			i++;
@@ -1296,55 +1302,136 @@ function decompress(s) {
 			s.runningState = 7;
 			continue;
 		case 7:
-			if (s.trivialLiteralContext !== 0) while (s.j < s.insertLength) {
-				if (s.halfOffset > 2030) {
-					result = readMoreInput(s);
-					if (result < 0) return result;
-				}
-				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;
-					break;
-				}
-			}
-			else {
-				let prevByte1 = ringBuffer[s.pos - 1 & ringBufferMask];
-				let prevByte2 = ringBuffer[s.pos - 2 & ringBufferMask];
-				while (s.j < s.insertLength) {
-					if (s.halfOffset > 2030) {
-						result = readMoreInput(s);
-						if (result < 0) return result;
-					}
-					if (s.literalBlockLength === 0) decodeLiteralBlockSwitch(s);
-					const literalContext = LOOKUP[s.contextLookupOffset1 + prevByte1] | LOOKUP[s.contextLookupOffset2 + prevByte2];
-					const literalTreeIdx = s.contextMap[s.contextMapSlice + literalContext] & 255;
-					s.literalBlockLength--;
-					prevByte2 = prevByte1;
-					if (s.bitOffset >= 16) {
-						s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
-						s.bitOffset -= 16;
+			{
+				let _bo = s.bitOffset;
+				let _ac = s.accumulator32;
+				let _ho = s.halfOffset;
+				let _pos = s.pos;
+				let _j = s.j;
+				let _lbl = s.literalBlockLength;
+				const _sb = s.shortBuffer;
+				const _ltg = s.literalTreeGroup;
+				const _il = s.insertLength;
+				if (s.trivialLiteralContext !== 0) {
+					let _lti = s.literalTreeIdx;
+					while (_j < _il) {
+						if (_ho > 2030) {
+							s.halfOffset = _ho;
+							result = readMoreInput(s);
+							if (result < 0) return result;
+							_ho = s.halfOffset;
+						}
+						if (_lbl === 0) {
+							s.bitOffset = _bo;
+							s.accumulator32 = _ac;
+							s.halfOffset = _ho;
+							decodeLiteralBlockSwitch(s);
+							_bo = s.bitOffset;
+							_ac = s.accumulator32;
+							_ho = s.halfOffset;
+							_lbl = s.literalBlockLength;
+							_lti = s.literalTreeIdx;
+						}
+						_lbl--;
+						if (_bo >= 16) {
+							_ac = _sb[_ho++] << 16 | _ac >>> 16;
+							_bo -= 16;
+						}
+						let _rsOff = _ltg[_lti];
+						const _rsV = _ac >>> _bo;
+						_rsOff += _rsV & 255;
+						const _rsE0 = _ltg[_rsOff];
+						const _rsBits = _rsE0 >> 16;
+						if (_rsBits <= 8) {
+							_bo += _rsBits;
+							ringBuffer[_pos] = _rsE0 & 65535;
+						} else {
+							_rsOff += _rsE0 & 65535;
+							_rsOff += (_rsV & (1 << _rsBits) - 1) >>> 8;
+							const _rsE1 = _ltg[_rsOff];
+							_bo += (_rsE1 >> 16) + 8;
+							ringBuffer[_pos] = _rsE1 & 65535;
+						}
+						_pos++;
+						_j++;
+						if (_pos >= fence) {
+							s.nextRunningState = 7;
+							s.runningState = 12;
+							break;
+						}
 					}
-					prevByte1 = readSymbol(s.literalTreeGroup, literalTreeIdx, s);
-					ringBuffer[s.pos] = prevByte1;
-					s.pos++;
-					s.j++;
-					if (s.pos >= fence) {
-						s.nextRunningState = 7;
-						s.runningState = 12;
-						break;
+				} else {
+					let prevByte1 = ringBuffer[_pos - 1 & ringBufferMask];
+					let prevByte2 = ringBuffer[_pos - 2 & ringBufferMask];
+					let _cms = s.contextMapSlice;
+					let _clo1 = s.contextLookupOffset1;
+					let _clo2 = s.contextLookupOffset2;
+					const _cm = s.contextMap;
+					while (_j < _il) {
+						if (_ho > 2030) {
+							s.halfOffset = _ho;
+							result = readMoreInput(s);
+							if (result < 0) return result;
+							_ho = s.halfOffset;
+						}
+						if (_lbl === 0) {
+							s.bitOffset = _bo;
+							s.accumulator32 = _ac;
+							s.halfOffset = _ho;
+							s.contextMapSlice = _cms;
+							decodeLiteralBlockSwitch(s);
+							_bo = s.bitOffset;
+							_ac = s.accumulator32;
+							_ho = s.halfOffset;
+							_lbl = s.literalBlockLength;
+							_cms = s.contextMapSlice;
+							_clo1 = s.contextLookupOffset1;
+							_clo2 = s.contextLookupOffset2;
+						}
+						const literalContext = LOOKUP[_clo1 + prevByte1] | LOOKUP[_clo2 + prevByte2];
+						const literalTreeIdx = _cm[_cms + literalContext] & 255;
+						_lbl--;
+						prevByte2 = prevByte1;
+						if (_bo >= 16) {
+							_ac = _sb[_ho++] << 16 | _ac >>> 16;
+							_bo -= 16;
+						}
+						{
+							let _rsOff = _ltg[literalTreeIdx];
+							const _rsV = _ac >>> _bo;
+							_rsOff += _rsV & 255;
+							const _rsE0 = _ltg[_rsOff];
+							const _rsBits = _rsE0 >> 16;
+							if (_rsBits <= 8) {
+								_bo += _rsBits;
+								prevByte1 = _rsE0 & 65535;
+							} else {
+								_rsOff += _rsE0 & 65535;
+								_rsOff += (_rsV & (1 << _rsBits) - 1) >>> 8;
+								const _rsE1 = _ltg[_rsOff];
+								_bo += (_rsE1 >> 16) + 8;
+								prevByte1 = _rsE1 & 65535;
+							}
+						}
+						ringBuffer[_pos] = prevByte1;
+						_pos++;
+						_j++;
+						if (_pos >= fence) {
+							s.nextRunningState = 7;
+							s.runningState = 12;
+							break;
+						}
 					}
+					s.contextMapSlice = _cms;
 				}
+				s.bitOffset = _bo;
+				s.accumulator32 = _ac;
+				s.halfOffset = _ho;
+				s.pos = _pos;
+				s.j = _j;
+				s.literalBlockLength = _lbl;
+				if (s.runningState !== 7) continue;
 			}
-			if (s.runningState !== 7) continue;
 			s.metaBlockLength -= s.insertLength;
 			if (s.metaBlockLength <= 0) {
 				s.runningState = 4;
@@ -1404,7 +1491,8 @@ function decompress(s) {
 			const srcEnd = src + copyLength;
 			const dstEnd = dst + copyLength;
 			if (srcEnd < ringBufferMask && dstEnd < ringBufferMask) {
-				if (s.distance === 4 && copyLength >= 8) {
+				if (s.distance === 1) ringBuffer.fill(ringBuffer[src], dst, dstEnd);
+				else if (s.distance === 4 && copyLength >= 8) {
 					ringBuffer[dst] = ringBuffer[src];
 					ringBuffer[dst + 1] = ringBuffer[src + 1];
 					ringBuffer[dst + 2] = ringBuffer[src + 2];
@@ -1642,9 +1730,11 @@ function nextTableBitSize(count, len, rootBits) {
 }
 function buildHuffmanTable(tableGroup, tableIdx, rootBits, codeLengths, codeLengthsSize) {
 	const tableOffset = tableGroup[tableIdx];
-	const sorted = new Int32Array(codeLengthsSize);
-	const count = new Int32Array(16);
-	const offset = new Int32Array(16);
+	const sorted = _scratchSorted;
+	const count = _scratchCount;
+	const offset = _scratchOffset;
+	count.fill(0);
+	offset.fill(0);
 	for (let sym = 0; sym < codeLengthsSize; ++sym) count[codeLengths[sym]]++;
 	offset[1] = 0;
 	for (let len = 1; len < 15; ++len) offset[len + 1] = offset[len] + count[len];
@@ -1653,7 +1743,7 @@ function buildHuffmanTable(tableGroup, tableIdx, rootBits, codeLengths, codeLeng
 	let tableSize = 1 << tableBits;
 	let totalSize = tableSize;
 	if (offset[15] === 1) {
-		for (let k = 0; k < totalSize; ++k) tableGroup[tableOffset + k] = sorted[0];
+		tableGroup.fill(sorted[0], tableOffset, tableOffset + totalSize);
 		return totalSize;
 	}
 	let key = 0;
@@ -2037,17 +2127,21 @@ function brotliDecode$1(bytes, options) {
 		return result;
 	}
 	let totalOutput = 0;
+	let chunkSize = 16384;
 	const chunks = [];
+	const chunkSizes = [];
 	while (true) {
-		const chunk = new Uint8Array(16384);
+		const chunk = new Uint8Array(chunkSize);
 		chunks.push(chunk);
+		chunkSizes.push(chunkSize);
 		s.output = chunk;
 		s.outputOffset = 0;
-		s.outputLength = 16384;
+		s.outputLength = chunkSize;
 		s.outputUsed = 0;
 		decompress(s);
 		totalOutput += s.outputUsed;
-		if (s.outputUsed < 16384) break;
+		if (s.outputUsed < chunkSize) break;
+		if (chunkSize < 4194304) chunkSize *= 2;
 	}
 	close(s);
 	closeInput(s);
@@ -2055,8 +2149,9 @@ function brotliDecode$1(bytes, options) {
 	let offset = 0;
 	for (let i = 0; i < chunks.length; ++i) {
 		const chunk = chunks[i];
-		const len = Math.min(totalOutput, offset + 16384) - offset;
-		if (len < 16384) result.set(chunk.subarray(0, len), offset);
+		const sz = chunkSizes[i];
+		const len = Math.min(totalOutput, offset + sz) - offset;
+		if (len < sz) result.set(chunk.subarray(0, len), offset);
 		else result.set(chunk, offset);
 		offset += len;
 	}