zstdify 1.2.0 → 1.3.1

package/dist/encode/compressedBlock.js

@@ -1,7 +1,7 @@
-import { BitWriter } from '../bitstream/bitWriter.js';
-import { buildFSEDecodeTable } from '../entropy/fse.js';
-import { buildHuffmanDecodeTable, weightsToNumBits } from '../entropy/huffman.js';
+import { encodeReverseBitstream } from '../bitstream/reverseBitWriter.js';
+import { buildFSEDecodeTable, normalizeCountsForTable, writeNCount } from '../entropy/fse.js';
 import { LITERALS_LENGTH_DEFAULT_DISTRIBUTION, LITERALS_LENGTH_TABLE_LOG, MATCH_LENGTH_DEFAULT_DISTRIBUTION, MATCH_LENGTH_TABLE_LOG, OFFSET_CODE_DEFAULT_DISTRIBUTION, OFFSET_CODE_TABLE_LOG, } from '../entropy/predefined.js';
+import { buildGeneralCompressedLiteralsForBench, encodeLiteralsSection, } from './literalsEncoder.js';
 // Predefined FSE tables built once and reused for sequence encoding.
 let cachedLLTable = null;
 let cachedOFTable = null;
@@ -34,32 +34,168 @@ function writeU24LE(arr, offset, value) {
     arr[offset + 1] = (value >> 8) & 0xff;
     arr[offset + 2] = (value >> 16) & 0xff;
 }
-function encodeReverseBitstream(bitCounts, bitValues) {
-    const bits = [];
-    const writeBitsLSB = (n, value) => {
-        for (let i = 0; i < n; i++) {
-            bits.push((value >>> i) & 1);
+const U32_ALL_BITS = 0xffff_ffff >>> 0;
+const pathTableCache = new WeakMap();
+let pathMasksScratch = null;
+let pathNextChoiceScratch = null;
+let sequenceReadCountsScratch = null;
+let sequenceReadValuesScratch = null;
+function rangeMask(startBit, endBit) {
+    if (startBit === 0 && endBit === 31)
+        return U32_ALL_BITS;
+    const startMask = (U32_ALL_BITS << startBit) >>> 0;
+    const endMask = endBit === 31 ? U32_ALL_BITS : ((1 << (endBit + 1)) - 1) >>> 0;
+    return (startMask & endMask) >>> 0;
+}
+function setMaskBit(mask, maskOffset, bit) {
+    const word = bit >>> 5;
+    mask[maskOffset + word] = (mask[maskOffset + word] | (1 << (bit & 31))) >>> 0;
+}
+function isMaskEmpty(mask, maskOffset, wordCount) {
+    for (let i = 0; i < wordCount; i++) {
+        if ((mask[maskOffset + i] ?? 0) !== 0)
+            return false;
+    }
+    return true;
+}
+function firstBitInWord(word) {
+    const normalized = word >>> 0;
+    const lsb = (normalized & -normalized) >>> 0;
+    return 31 - Math.clz32(lsb);
+}
+function findFirstSetBit(mask, maskOffset, wordCount) {
+    for (let wi = 0; wi < wordCount; wi++) {
+        const word = mask[maskOffset + wi] ?? 0;
+        if (word !== 0) {
+            return (wi << 5) + firstBitInWord(word);
         }
-    };
-    for (let i = bitCounts.length - 1; i >= 0; i--) {
-        const n = bitCounts[i] ?? 0;
-        if (n <= 0)
+    }
+    return -1;
+}
+function codesAreUniform(codes) {
+    if (codes.length === 0)
+        return -1;
+    const first = codes[0] ?? -1;
+    for (let i = 1; i < codes.length; i++) {
+        if ((codes[i] ?? -1) !== first)
+            return -1;
+    }
+    return first;
+}
+function findFirstSetBitInRange(mask, maskOffset, wordCount, minState, maxState) {
+    if (wordCount <= 0)
+        return -1;
+    let min = minState;
+    let max = maxState;
+    const maxBit = (wordCount << 5) - 1;
+    if (min < 0)
+        min = 0;
+    if (max > maxBit)
+        max = maxBit;
+    if (min > max)
+        return -1;
+    const startWord = min >>> 5;
+    const endWord = max >>> 5;
+    if (startWord === endWord) {
+        const masked = ((mask[maskOffset + startWord] ?? 0) & rangeMask(min & 31, max & 31)) >>> 0;
+        if (masked === 0)
+            return -1;
+        return (startWord << 5) + firstBitInWord(masked);
+    }
+    const firstMasked = ((mask[maskOffset + startWord] ?? 0) & rangeMask(min & 31, 31)) >>> 0;
+    if (firstMasked !== 0) {
+        return (startWord << 5) + firstBitInWord(firstMasked);
+    }
+    for (let wi = startWord + 1; wi < endWord; wi++) {
+        const word = mask[maskOffset + wi] ?? 0;
+        if (word !== 0)
+            return (wi << 5) + firstBitInWord(word);
+    }
+    const lastMasked = ((mask[maskOffset + endWord] ?? 0) & rangeMask(0, max & 31)) >>> 0;
+    if (lastMasked === 0)
+        return -1;
+    return (endWord << 5) + firstBitInWord(lastMasked);
+}
+function getPrecomputedPathTable(table) {
+    const cached = pathTableCache.get(table);
+    if (cached)
+        return cached;
+    const tableSize = table.length;
+    const wordCount = Math.max(1, Math.ceil(tableSize / 32));
+    const baselineByState = new Int32Array(tableSize);
+    const minNextByState = new Int32Array(tableSize);
+    const maxNextByState = new Int32Array(tableSize);
+    let maxSymbol = -1;
+    for (let s = 0; s < tableSize; s++) {
+        const baseline = table.baseline[s];
+        const bits = table.numBits[s];
+        baselineByState[s] = baseline;
+        const width = bits > 0 ? 1 << bits : 1;
+        const minNext = baseline;
+        const maxNext = baseline + width - 1;
+        minNextByState[s] = minNext < 0 ? 0 : minNext;
+        maxNextByState[s] = maxNext >= tableSize ? tableSize - 1 : maxNext;
+        const symbol = table.symbol[s];
+        if (symbol > maxSymbol)
+            maxSymbol = symbol;
+    }
+    const statesBySymbol = Array.from({ length: maxSymbol + 1 }, () => []);
+    const symbolMasks = Array.from({ length: maxSymbol + 1 }, () => new Uint32Array(wordCount));
+    const bitTotalsBySymbol = new Float64Array(maxSymbol + 1);
+    const stateCountsBySymbol = new Uint32Array(maxSymbol + 1);
+    for (let s = 0; s < tableSize; s++) {
+        const sym = table.symbol[s];
+        const stateList = statesBySymbol[sym];
+        const stateMask = symbolMasks[sym];
+        if (!stateList || !stateMask)
             continue;
-        writeBitsLSB(n, bitValues[i] ?? 0);
-    }
-    // Append end marker, then zero-fill above marker so decoder skips them.
-    bits.push(1);
-    while ((bits.length & 7) !== 0) {
-        bits.push(0);
-    }
-    const out = new Uint8Array(Math.ceil(bits.length / 8));
-    for (let i = 0; i < bits.length; i++) {
-        if ((bits[i] ?? 0) !== 0) {
-            const idx = i >>> 3;
-            out[idx] = ((out[idx] ?? 0) | (1 << (i & 7))) & 0xff;
-        }
+        stateList.push(s);
+        stateMask[s >>> 5] = (stateMask[s >>> 5] | (1 << (s & 31))) >>> 0;
+        bitTotalsBySymbol[sym] = (bitTotalsBySymbol[sym] ?? 0) + (table.numBits[s] ?? 0);
+        stateCountsBySymbol[sym] = (stateCountsBySymbol[sym] ?? 0) + 1;
     }
-    return out;
+    const avgBitsBySymbol = new Float64Array(maxSymbol + 1);
+    for (let sym = 0; sym < avgBitsBySymbol.length; sym++) {
+        const count = stateCountsBySymbol[sym] ?? 0;
+        avgBitsBySymbol[sym] = count > 0 ? (bitTotalsBySymbol[sym] ?? 0) / count : Number.POSITIVE_INFINITY;
+    }
+    const precomputed = {
+        tableSize,
+        wordCount,
+        statesBySymbol,
+        symbolMasks,
+        avgBitsBySymbol,
+        baselineByState,
+        minNextByState,
+        maxNextByState,
+    };
+    pathTableCache.set(table, precomputed);
+    return precomputed;
+}
+function getPathMasksScratch(requiredLength) {
+    if (!pathMasksScratch || pathMasksScratch.length < requiredLength) {
+        pathMasksScratch = new Uint32Array(requiredLength);
+    }
+    pathMasksScratch.fill(0, 0, requiredLength);
+    return pathMasksScratch;
+}
+function getPathNextChoiceScratch(requiredLength) {
+    if (!pathNextChoiceScratch || pathNextChoiceScratch.length < requiredLength) {
+        pathNextChoiceScratch = new Int32Array(requiredLength);
+    }
+    return pathNextChoiceScratch;
+}
+function getSequenceReadCountsScratch(requiredLength) {
+    if (!sequenceReadCountsScratch || sequenceReadCountsScratch.length < requiredLength) {
+        sequenceReadCountsScratch = new Uint8Array(requiredLength);
+    }
+    return sequenceReadCountsScratch;
+}
+function getSequenceReadValuesScratch(requiredLength) {
+    if (!sequenceReadValuesScratch || sequenceReadValuesScratch.length < requiredLength) {
+        sequenceReadValuesScratch = new Uint32Array(requiredLength);
+    }
+    return sequenceReadValuesScratch;
 }
 function findLengthCode(value, baseline, extraBits, directMax, directBias) {
     if (value <= directMax) {
@@ -77,211 +213,6 @@ function findLengthCode(value, baseline, extraBits, directMax, directBias) {
     }
     return null;
 }
-function buildSingleSymbolCompressedLiterals(literals) {
-    if (literals.length === 0 || literals.length > 1023)
-        return null;
-    const sym = literals[0] ?? 0;
-    for (let i = 1; i < literals.length; i++) {
-        if ((literals[i] ?? 0) !== sym)
-            return null;
-    }
-    if (sym > 127)
-        return null;
-    const numWeights = sym + 1;
-    if (numWeights < 1 || numWeights > 128)
-        return null;
-    const weights = new Array(numWeights).fill(0);
-    weights[sym] = 1;
-    let partialSum = 0;
-    for (const w of weights) {
-        if (w > 0)
-            partialSum += 1 << (w - 1);
-    }
-    if (partialSum === 0)
-        return null;
-    const maxNumBits = 32 - Math.clz32(partialSum);
-    const total = 1 << maxNumBits;
-    const remainder = total - partialSum;
-    if (remainder <= 0 || (remainder & (remainder - 1)) !== 0)
-        return null;
-    const lastWeight = 32 - Math.clz32(remainder);
-    const fullWeights = [...weights, lastWeight];
-    while (fullWeights.length < 256)
-        fullWeights.push(0);
-    const numBits = weightsToNumBits(fullWeights, maxNumBits);
-    const table = buildHuffmanDecodeTable(numBits, maxNumBits);
-    const symbolCode = table.findIndex((row) => row?.symbol === sym);
-    if (symbolCode < 0)
-        return null;
-    const bitCounts = new Uint8Array(literals.length);
-    bitCounts.fill(maxNumBits);
-    const bitValues = new Uint16Array(literals.length);
-    bitValues.fill(symbolCode);
-    const stream = encodeReverseBitstream(bitCounts, bitValues);
-    const directHeader = 127 + numWeights;
-    const weightWriter = new BitWriter();
-    for (let i = 0; i < weights.length; i += 2) {
-        const hi = weights[i] ?? 0;
-        const lo = weights[i + 1] ?? 0;
-        weightWriter.writeBits(8, ((hi & 0xf) << 4) | (lo & 0xf));
-    }
-    const weightBytes = weightWriter.flush();
-    const compressedSize = 1 + weightBytes.length + stream.length;
-    if (compressedSize > 1023)
-        return null;
-    const b0 = (2 | (0 << 2) | ((literals.length & 0x0f) << 4)) & 0xff;
-    const b1 = (((literals.length >> 4) & 0x3f) | ((compressedSize & 0x03) << 6)) & 0xff;
-    const b2 = (compressedSize >> 2) & 0xff;
-    const out = new Uint8Array(3 + 1 + weightBytes.length + stream.length);
-    out[0] = b0;
-    out[1] = b1;
-    out[2] = b2;
-    out[3] = directHeader & 0xff;
-    out.set(weightBytes, 4);
-    out.set(stream, 4 + weightBytes.length);
-    return out;
-}
-function splitPowerTerms(targetSum, count) {
-    if (count < 1 || count > targetSum)
-        return null;
-    const terms = [];
-    for (let bit = 31; bit >= 0; bit--) {
-        const value = 1 << bit;
-        if ((targetSum & value) !== 0) {
-            terms.push(value);
-        }
-    }
-    while (terms.length < count) {
-        let splitIndex = -1;
-        let largest = 0;
-        for (let i = 0; i < terms.length; i++) {
-            const term = terms[i] ?? 0;
-            if (term > largest) {
-                largest = term;
-                splitIndex = i;
-            }
-        }
-        if (splitIndex < 0 || largest <= 1) {
-            return null;
-        }
-        const half = largest >>> 1;
-        terms.splice(splitIndex, 1, half, half);
-    }
-    return terms;
-}
-function buildGeneralCompressedLiterals(literals) {
-    if (literals.length === 0 || literals.length > 1023)
-        return null;
-    const seen = new Uint8Array(256);
-    let numSymbols = 0;
-    let maxSymbol = 0;
-    for (let i = 0; i < literals.length; i++) {
-        const b = literals[i];
-        if (seen[b] === 0) {
-            seen[b] = 1;
-            numSymbols++;
-            if (b > maxSymbol)
-                maxSymbol = b;
-        }
-    }
-    if (numSymbols === 0 || numSymbols > 128)
-        return null;
-    if (maxSymbol > 127)
-        return null;
-    const sortedSymbols = [];
-    for (let s = 0; s <= maxSymbol; s++) {
-        if (seen[s] !== 0)
-            sortedSymbols.push(s);
-    }
-    // Construct a valid direct-weight table over symbols <= 127.
-    const partialTarget = 128; // maxNumBits=8 => total 256, remainder is 128 (power of two).
-    const contributions = splitPowerTerms(partialTarget, sortedSymbols.length);
-    if (!contributions)
-        return null;
-    contributions.sort((a, b) => b - a);
-    const weights = new Array(maxSymbol + 1).fill(0);
-    for (let i = 0; i < sortedSymbols.length; i++) {
-        const symbol = sortedSymbols[i] ?? 0;
-        const contribution = contributions[i] ?? 1;
-        const weight = 32 - Math.clz32(contribution);
-        if (weight < 1 || weight > 15)
-            return null;
-        weights[symbol] = weight;
-    }
-    const fullWeights = [...weights, 8];
-    while (fullWeights.length < 256)
-        fullWeights.push(0);
-    const numBits = weightsToNumBits(fullWeights, 8);
-    const table = buildHuffmanDecodeTable(numBits, 8);
-    const codeBySymbol = new Int32Array(256).fill(-1);
-    for (let i = 0; i < sortedSymbols.length; i++) {
-        const symbol = sortedSymbols[i];
-        const code = table.findIndex((row) => row?.symbol === symbol);
-        if (code < 0)
-            return null;
-        codeBySymbol[symbol] = code;
-    }
-    const readCounts = new Uint8Array(literals.length);
-    const readValues = new Uint16Array(literals.length);
-    for (let i = 0; i < literals.length; i++) {
-        const code = codeBySymbol[literals[i]];
-        if (code < 0)
-            return null;
-        readCounts[i] = 8;
-        readValues[i] = code;
-    }
-    const stream = encodeReverseBitstream(readCounts, readValues);
-    const numWeights = weights.length;
-    if (numWeights < 1 || numWeights > 128)
-        return null;
-    const directHeader = 127 + numWeights;
-    const weightWriter = new BitWriter();
-    for (let i = 0; i < weights.length; i += 2) {
-        const hi = weights[i] ?? 0;
-        const lo = weights[i + 1] ?? 0;
-        weightWriter.writeBits(8, ((hi & 0xf) << 4) | (lo & 0xf));
-    }
-    const weightBytes = weightWriter.flush();
-    const compressedSize = 1 + weightBytes.length + stream.length;
-    if (compressedSize > 1023)
-        return null;
-    const b0 = (2 | (0 << 2) | ((literals.length & 0x0f) << 4)) & 0xff;
-    const b1 = (((literals.length >> 4) & 0x3f) | ((compressedSize & 0x03) << 6)) & 0xff;
-    const b2 = (compressedSize >> 2) & 0xff;
-    const out = new Uint8Array(3 + 1 + weightBytes.length + stream.length);
-    out[0] = b0;
-    out[1] = b1;
-    out[2] = b2;
-    out[3] = directHeader & 0xff;
-    out.set(weightBytes, 4);
-    out.set(stream, 4 + weightBytes.length);
-    return out;
-}
-function buildRawLiteralsSection(literals) {
-    const size = literals.length;
-    if (size <= 31) {
-        const out = new Uint8Array(1 + size);
-        out[0] = (size << 3) | 0;
-        out.set(literals, 1);
-        return out;
-    }
-    if (size <= 0x0fff) {
-        const out = new Uint8Array(2 + size);
-        out[0] = ((size & 0x0f) << 4) | (1 << 2);
-        out[1] = (size >>> 4) & 0xff;
-        out.set(literals, 2);
-        return out;
-    }
-    if (size <= 0x0f_ffff) {
-        const out = new Uint8Array(3 + size);
-        out[0] = ((size & 0x0f) << 4) | (3 << 2);
-        out[1] = (size >>> 4) & 0xff;
-        out[2] = (size >>> 12) & 0xff;
-        out.set(literals, 3);
-        return out;
-    }
-    return null;
-}
 function encodeNumSequences(numSequences) {
     if (numSequences < 0 || numSequences > 0xffff + 0x7f00)
         return null;
@@ -299,103 +230,268 @@ function encodeNumSequences(numSequences) {
 function buildStatePath(codes, table) {
     if (codes.length === 0)
         return { states: [], updateBits: [] };
-    const tableSize = table.length;
-    const statesByCode = [];
-    for (let s = 0; s < tableSize; s++) {
-        const row = table[s];
-        if (!row)
-            continue;
-        const sym = row.symbol;
-        if (!statesByCode[sym])
-            statesByCode[sym] = [];
-        statesByCode[sym].push(s);
-    }
-    const possible = Array.from({ length: codes.length }, () => []);
-    const nextChoice = Array.from({ length: codes.length }, () => new Int32Array(tableSize).fill(-1));
-    const lastCode = codes[codes.length - 1] ?? -1;
-    const lastCandidates = statesByCode[lastCode] ?? [];
-    const lastArr = possible[codes.length - 1];
-    if (!lastArr)
+    const pre = getPrecomputedPathTable(table);
+    const { tableSize, wordCount, statesBySymbol, symbolMasks, minNextByState, maxNextByState, baselineByState } = pre;
+    if (tableSize <= 0)
         return null;
-    for (let j = 0; j < lastCandidates.length; j++) {
-        lastArr.push(lastCandidates[j]);
+    const rowCount = codes.length;
+    if (rowCount === 1) {
+        const onlyCode = codes[0] ?? -1;
+        if (onlyCode < 0 || onlyCode >= statesBySymbol.length)
+            return null;
+        const onlyStates = statesBySymbol[onlyCode];
+        if (!onlyStates || onlyStates.length === 0)
+            return null;
+        const firstState = onlyStates[0];
+        if (firstState === undefined)
+            return null;
+        return { states: [firstState], updateBits: [] };
     }
-    if (lastArr.length === 0)
-        return null;
-    if (codes.length === 1) {
-        return { states: [lastArr[0]], updateBits: [] };
-    }
-    for (let i = codes.length - 2; i >= 0; i--) {
-        const candidates = statesByCode[codes[i] ?? -1] ?? [];
-        const nextArr = possible[i + 1];
-        const curArr = possible[i];
-        const curNext = nextChoice[i];
-        const nextPresent = new Uint8Array(tableSize);
-        for (let j = 0; j < nextArr.length; j++) {
-            nextPresent[nextArr[j]] = 1;
-        }
-        const nextFrom = new Int32Array(tableSize + 1);
-        nextFrom[tableSize] = -1;
-        for (let s = tableSize - 1; s >= 0; s--) {
-            nextFrom[s] = nextPresent[s] !== 0 ? s : nextFrom[s + 1];
-        }
-        for (let si = 0; si < candidates.length; si++) {
-            const s = candidates[si];
-            const row = table[s];
-            if (!row)
-                continue;
-            const width = row.numBits > 0 ? 1 << row.numBits : 1;
-            const minNext = row.baseline;
-            const maxNext = row.baseline + width - 1;
-            if (maxNext < 0 || minNext >= tableSize)
+    const uniformCode = codesAreUniform(codes);
+    if (uniformCode >= 0 && uniformCode < statesBySymbol.length) {
+        const candidateStates = statesBySymbol[uniformCode];
+        const candidateMask = symbolMasks[uniformCode];
+        if (!candidateStates || candidateStates.length === 0 || !candidateMask)
+            return null;
+        for (let startIndex = 0; startIndex < candidateStates.length; startIndex++) {
+            const startState = candidateStates[startIndex];
+            if (startState === undefined)
                 continue;
-            const start = minNext < 0 ? 0 : minNext;
-            const chosen = nextFrom[start];
-            if (chosen >= 0) {
-                if (chosen <= maxNext) {
-                    curArr.push(s);
-                    curNext[s] = chosen;
+            const states = new Array(rowCount);
+            const updateBits = new Array(rowCount - 1);
+            states[0] = startState;
+            let state = startState;
+            let valid = true;
+            for (let row = 0; row < rowCount - 1; row++) {
+                const nextState = findFirstSetBitInRange(candidateMask, 0, wordCount, minNextByState[state], maxNextByState[state]);
+                if (nextState < 0) {
+                    valid = false;
+                    break;
                 }
+                states[row + 1] = nextState;
+                updateBits[row] = nextState - baselineByState[state];
+                state = nextState;
             }
+            if (valid)
+                return { states, updateBits };
         }
-        if (curArr.length === 0)
-            return null;
     }
-    const states = new Array(codes.length);
-    const updateBits = new Array(Math.max(0, codes.length - 1));
-    const firstArr = possible[0];
-    if (!firstArr || firstArr.length === 0)
+    const masks = getPathMasksScratch(rowCount * wordCount);
+    const nextChoice = getPathNextChoiceScratch(Math.max(0, rowCount - 1) * tableSize);
+    const maskOffset = (rowIndex) => rowIndex * wordCount;
+    const nextChoiceOffset = (rowIndex) => rowIndex * tableSize;
+    const lastCode = codes[rowCount - 1] ?? -1;
+    if (lastCode < 0 || lastCode >= symbolMasks.length)
+        return null;
+    const lastMask = symbolMasks[lastCode];
+    if (!lastMask)
+        return null;
+    const lastMaskOffset = maskOffset(rowCount - 1);
+    for (let wi = 0; wi < wordCount; wi++) {
+        masks[lastMaskOffset + wi] = lastMask[wi];
+    }
+    if (isMaskEmpty(masks, lastMaskOffset, wordCount))
         return null;
-    states[0] = firstArr[0];
-    for (let i = 0; i < codes.length - 1; i++) {
-        const cur = states[i];
-        const next = nextChoice[i][cur];
-        if (next === undefined || next < 0)
+    for (let i = rowCount - 2; i >= 0; i--) {
+        const code = codes[i] ?? -1;
+        if (code < 0 || code >= statesBySymbol.length)
             return null;
-        states[i + 1] = next;
-        const row = table[cur];
-        if (!row)
+        const candidates = statesBySymbol[code];
+        if (!candidates || candidates.length === 0)
+            return null;
+        const curMaskOffset = maskOffset(i);
+        const nextMaskOffset = maskOffset(i + 1);
+        const curNextOffset = nextChoiceOffset(i);
+        for (let ci = 0; ci < candidates.length; ci++) {
+            const state = candidates[ci];
+            if (state === undefined)
+                continue;
+            const chosenNext = findFirstSetBitInRange(masks, nextMaskOffset, wordCount, minNextByState[state], maxNextByState[state]);
+            if (chosenNext >= 0) {
+                setMaskBit(masks, curMaskOffset, state);
+                nextChoice[curNextOffset + state] = chosenNext;
+            }
+        }
+        if (isMaskEmpty(masks, curMaskOffset, wordCount))
             return null;
-        updateBits[i] = next - row.baseline;
+    }
+    const states = new Array(rowCount);
+    const updateBits = new Array(Math.max(0, rowCount - 1));
+    let state = findFirstSetBit(masks, maskOffset(0), wordCount);
+    if (state < 0)
+        return null;
+    states[0] = state;
+    for (let i = 0; i < rowCount - 1; i++) {
+        const nextState = nextChoice[nextChoiceOffset(i) + state];
+        states[i + 1] = nextState;
+        updateBits[i] = nextState - baselineByState[state];
+        state = nextState;
     }
     return { states, updateBits };
 }
-function buildPredefinedSequenceSection(sequences) {
+let symbolizedScratch = null;
+function ensureSymbolizedScratch(minLength) {
+    const existing = symbolizedScratch;
+    if (existing && existing.llCodes.length >= minLength) {
+        return existing;
+    }
+    let capacity = existing?.llCodes.length ?? 0;
+    if (capacity === 0)
+        capacity = 32;
+    while (capacity < minLength)
+        capacity *= 2;
+    symbolizedScratch = {
+        llCodes: new Uint8Array(capacity),
+        llExtraN: new Uint8Array(capacity),
+        llExtraValue: new Uint32Array(capacity),
+        mlCodes: new Uint8Array(capacity),
+        mlExtraN: new Uint8Array(capacity),
+        mlExtraValue: new Uint32Array(capacity),
+        ofCodes: new Uint8Array(capacity),
+        ofExtraN: new Uint8Array(capacity),
+        ofExtraValue: new Uint32Array(capacity),
+    };
+    return symbolizedScratch;
+}
+function symbolRange(codes) {
+    let max = 0;
+    for (let i = 0; i < codes.length; i++) {
+        const value = codes[i] ?? 0;
+        if (value > max)
+            max = value;
+    }
+    return max + 1;
+}
+function buildHistogram(codes, alphabetSize) {
+    const out = new Uint32Array(alphabetSize);
+    for (let i = 0; i < codes.length; i++) {
+        const c = codes[i] ?? 0;
+        if (c < 0 || c >= alphabetSize)
+            continue;
+        out[c] = (out[c] ?? 0) + 1;
+    }
+    return out;
+}
+function scorePath(path, table, tableLog) {
+    if (path.states.length === 0)
+        return 0;
+    let bits = tableLog;
+    for (let i = 0; i < path.states.length - 1; i++) {
+        const state = path.states[i] ?? -1;
+        if (state < 0 || state >= table.length)
+            return Number.POSITIVE_INFINITY;
+        bits += table.numBits[state];
+    }
+    return bits;
+}
+function estimatePathBitsFromHistogram(histogram, table, tableLog, extraHeaderBits) {
+    const pre = getPrecomputedPathTable(table);
+    const avgBits = pre.avgBitsBySymbol;
+    let bits = tableLog + extraHeaderBits;
+    for (let sym = 0; sym < histogram.length; sym++) {
+        const freq = histogram[sym] ?? 0;
+        if (freq <= 0)
+            continue;
+        const avg = avgBits[sym] ?? Number.POSITIVE_INFINITY;
+        if (!Number.isFinite(avg)) {
+            return Number.POSITIVE_INFINITY;
+        }
+        bits += avg * freq;
+    }
+    return bits;
+}
+const normalizedTableCache = new Map();
+function hashHistogram(histogram) {
+    let hash = 2166136261 >>> 0;
+    for (let i = 0; i < histogram.length; i++) {
+        hash ^= histogram[i] ?? 0;
+        hash = Math.imul(hash, 16777619) >>> 0;
+    }
+    return hash >>> 0;
+}
+function histogramsEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if ((a[i] ?? 0) !== (b[i] ?? 0))
+            return false;
+    }
+    return true;
+}
+function getNormalizedTableCandidates(codes, maxTableLog) {
+    const alphabetSize = symbolRange(codes);
+    if (alphabetSize <= 0)
+        return [];
+    const histogram = buildHistogram(codes, alphabetSize);
+    let distinct = 0;
+    for (let i = 0; i < histogram.length; i++) {
+        if ((histogram[i] ?? 0) > 0)
+            distinct++;
+    }
+    if (distinct <= 1)
+        return [];
+    let minTableLog = 5;
+    while (1 << minTableLog < distinct && minTableLog < maxTableLog)
+        minTableLog++;
+    if (1 << minTableLog < distinct)
+        return [];
+    const maxLogFromSamples = codes.length > 1 ? 31 - Math.clz32(codes.length - 1) : 5;
+    const limit = Math.max(minTableLog, Math.min(maxTableLog, maxLogFromSamples + 1));
+    const results = [];
+    const histogramHash = hashHistogram(histogram);
+    for (let tableLog = minTableLog; tableLog <= limit; tableLog++) {
+        const key = `${tableLog}:${alphabetSize}:${histogramHash}`;
+        const cachedBucket = normalizedTableCache.get(key);
+        if (cachedBucket) {
+            let matched = false;
+            for (const cached of cachedBucket) {
+                if (histogramsEqual(cached.histogram, histogram)) {
+                    results.push(cached);
+                    matched = true;
+                    break;
+                }
+            }
+            if (matched)
+                continue;
+        }
+        try {
+            const { normalizedCounter, maxSymbolValue } = normalizeCountsForTable(Array.from(histogram), tableLog);
+            const header = writeNCount(normalizedCounter, maxSymbolValue, tableLog);
+            const table = buildFSEDecodeTable(normalizedCounter, tableLog);
+            const out = {
+                histogram: histogram.slice(0),
+                table,
+                tableLog,
+                header,
+            };
+            if (!cachedBucket) {
+                normalizedTableCache.set(key, [out]);
+            }
+            else {
+                cachedBucket.push(out);
+            }
+            results.push(out);
+        }
+        catch {
+            // Skip invalid normalizations for this table log.
+        }
+    }
+    return results;
+}
+function symbolizedSequences(sequences) {
     if (sequences.length === 0)
         return null;
     const numSequences = sequences.length;
-    const numSequencesBytes = encodeNumSequences(numSequences);
-    if (!numSequencesBytes)
-        return null;
-    const llCodes = new Uint8Array(numSequences);
-    const llExtraN = new Uint8Array(numSequences);
-    const llExtraValue = new Uint32Array(numSequences);
-    const mlCodes = new Uint8Array(numSequences);
-    const mlExtraN = new Uint8Array(numSequences);
-    const mlExtraValue = new Uint32Array(numSequences);
-    const ofCodes = new Uint8Array(numSequences);
-    const ofExtraN = new Uint8Array(numSequences);
-    const ofExtraValue = new Uint32Array(numSequences);
+    const scratch = ensureSymbolizedScratch(numSequences);
+    const llCodes = scratch.llCodes.subarray(0, numSequences);
+    const llExtraN = scratch.llExtraN.subarray(0, numSequences);
+    const llExtraValue = scratch.llExtraValue.subarray(0, numSequences);
+    const mlCodes = scratch.mlCodes.subarray(0, numSequences);
+    const mlExtraN = scratch.mlExtraN.subarray(0, numSequences);
+    const mlExtraValue = scratch.mlExtraValue.subarray(0, numSequences);
+    const ofCodes = scratch.ofCodes.subarray(0, numSequences);
+    const ofExtraN = scratch.ofExtraN.subarray(0, numSequences);
+    const ofExtraValue = scratch.ofExtraValue.subarray(0, numSequences);
     for (let i = 0; i < numSequences; i++) {
         const sequence = sequences[i];
         const ll = findLengthCode(sequence.literalsLength, LL_BASELINE, LL_NUMBITS, 15, 0);
@@ -419,77 +515,180 @@ function buildPredefinedSequenceSection(sequences) {
         ofExtraN[i] = ofCode;
         ofExtraValue[i] = ofEx;
     }
+    return { llCodes, llExtraN, llExtraValue, mlCodes, mlExtraN, mlExtraValue, ofCodes, ofExtraN, ofExtraValue };
+}
+function chooseStreamMode(codes, predefinedTable, predefinedTableLog, maxTableLog, prevTable, prevTableLog) {
+    const alphabetSize = symbolRange(codes);
+    const histogram = alphabetSize > 0 ? buildHistogram(codes, alphabetSize) : new Uint32Array(0);
+    const predefinedPath = buildStatePath(codes, predefinedTable);
+    if (!predefinedPath)
+        return null;
+    let best = {
+        mode: 0,
+        table: predefinedTable,
+        tableLog: predefinedTableLog,
+        path: predefinedPath,
+        tableHeader: new Uint8Array(0),
+    };
+    let bestScore = scorePath(predefinedPath, predefinedTable, predefinedTableLog);
+    if (prevTable && prevTableLog !== null) {
+        const repeatEstimate = estimatePathBitsFromHistogram(histogram, prevTable, prevTableLog, 0);
+        if (repeatEstimate < bestScore + 16) {
+            const repeatPath = buildStatePath(codes, prevTable);
+            if (repeatPath) {
+                const repeatScore = scorePath(repeatPath, prevTable, prevTableLog);
+                if (repeatScore < bestScore) {
+                    best = {
+                        mode: 3,
+                        table: prevTable,
+                        tableLog: prevTableLog,
+                        path: repeatPath,
+                        tableHeader: new Uint8Array(0),
+                    };
+                    bestScore = repeatScore;
+                }
+            }
+        }
+    }
+    const compressedCandidates = getNormalizedTableCandidates(codes, maxTableLog);
+    if (compressedCandidates.length > 0) {
+        const ranked = compressedCandidates
+            .map((compressed) => ({
+            compressed,
+            estimate: estimatePathBitsFromHistogram(histogram, compressed.table, compressed.tableLog, compressed.header.length * 8),
+        }))
+            .sort((a, b) => a.estimate - b.estimate);
+        const evalCount = Math.min(2, ranked.length);
+        for (let i = 0; i < evalCount; i++) {
+            const candidate = ranked[i];
+            if (!candidate || candidate.estimate >= bestScore + 16)
+                continue;
+            const compressedPath = buildStatePath(codes, candidate.compressed.table);
+            if (compressedPath) {
+                const compressedScore = scorePath(compressedPath, candidate.compressed.table, candidate.compressed.tableLog) +
+                    candidate.compressed.header.length * 8;
+                if (compressedScore < bestScore) {
+                    best = {
+                        mode: 2,
+                        table: candidate.compressed.table,
+                        tableLog: candidate.compressed.tableLog,
+                        path: compressedPath,
+                        tableHeader: candidate.compressed.header,
+                    };
+                    bestScore = compressedScore;
+                }
+            }
+        }
+    }
+    return best;
+}
+function buildSequenceSection(sequences, context) {
+    const encoded = symbolizedSequences(sequences);
+    if (!encoded)
+        return null;
+    const numSequences = sequences.length;
+    const numSequencesBytes = encodeNumSequences(numSequences);
+    if (!numSequencesBytes)
+        return null;
     const { ll: llTable, of: ofTable, ml: mlTable } = getPredefinedFSETables();
-    const llPath = buildStatePath(llCodes, llTable);
-    const ofPath = buildStatePath(ofCodes, ofTable);
-    const mlPath = buildStatePath(mlCodes, mlTable);
-    if (!llPath || !ofPath || !mlPath)
+    const llChoice = chooseStreamMode(encoded.llCodes, llTable, LITERALS_LENGTH_TABLE_LOG, 9, context?.prevTables?.llTable ?? null, context?.prevTables?.llTableLog ?? null);
+    const ofChoice = chooseStreamMode(encoded.ofCodes, ofTable, OFFSET_CODE_TABLE_LOG, 8, context?.prevTables?.ofTable ?? null, context?.prevTables?.ofTableLog ?? null);
+    const mlChoice = chooseStreamMode(encoded.mlCodes, mlTable, MATCH_LENGTH_TABLE_LOG, 9, context?.prevTables?.mlTable ?? null, context?.prevTables?.mlTableLog ?? null);
+    if (!llChoice || !ofChoice || !mlChoice)
         return null;
     const chunkCount = numSequences * 6;
-    const readCounts = new Uint8Array(chunkCount);
-    const readValues = new Uint32Array(chunkCount);
+    const readCounts = getSequenceReadCountsScratch(chunkCount).subarray(0, chunkCount);
+    const readValues = getSequenceReadValuesScratch(chunkCount).subarray(0, chunkCount);
+    const llStates = llChoice.path.states;
+    const llUpdates = llChoice.path.updateBits;
+    const ofStates = ofChoice.path.states;
+    const ofUpdates = ofChoice.path.updateBits;
+    const mlStates = mlChoice.path.states;
+    const mlUpdates = mlChoice.path.updateBits;
+    const ofExtraN = encoded.ofExtraN;
+    const ofExtraValue = encoded.ofExtraValue;
+    const mlExtraN = encoded.mlExtraN;
+    const mlExtraValue = encoded.mlExtraValue;
+    const llExtraN = encoded.llExtraN;
+    const llExtraValue = encoded.llExtraValue;
     let readPos = 0;
-    readCounts[readPos] = LITERALS_LENGTH_TABLE_LOG;
-    readValues[readPos++] = llPath.states[0] ?? 0;
-    readCounts[readPos] = OFFSET_CODE_TABLE_LOG;
-    readValues[readPos++] = ofPath.states[0] ?? 0;
-    readCounts[readPos] = MATCH_LENGTH_TABLE_LOG;
-    readValues[readPos++] = mlPath.states[0] ?? 0;
+    readCounts[readPos] = llChoice.tableLog;
+    readValues[readPos++] = llStates[0];
+    readCounts[readPos] = ofChoice.tableLog;
+    readValues[readPos++] = ofStates[0];
+    readCounts[readPos] = mlChoice.tableLog;
+    readValues[readPos++] = mlStates[0];
     for (let i = 0; i < numSequences; i++) {
-        readCounts[readPos] = ofExtraN[i] ?? 0;
-        readValues[readPos++] = ofExtraValue[i] ?? 0;
-        readCounts[readPos] = mlExtraN[i] ?? 0;
-        readValues[readPos++] = mlExtraValue[i] ?? 0;
-        readCounts[readPos] = llExtraN[i] ?? 0;
-        readValues[readPos++] = llExtraValue[i] ?? 0;
+        readCounts[readPos] = ofExtraN[i];
+        readValues[readPos++] = ofExtraValue[i];
+        readCounts[readPos] = mlExtraN[i];
+        readValues[readPos++] = mlExtraValue[i];
+        readCounts[readPos] = llExtraN[i];
+        readValues[readPos++] = llExtraValue[i];
         if (i !== numSequences - 1) {
-            const llState = llPath.states[i] ?? 0;
-            const mlState = mlPath.states[i] ?? 0;
-            const ofState = ofPath.states[i] ?? 0;
-            const llRow = llTable[llState];
-            const mlRow = mlTable[mlState];
-            const ofRow = ofTable[ofState];
-            if (!llRow || !mlRow || !ofRow)
+            const llState = llStates[i];
+            const mlState = mlStates[i];
+            const ofState = ofStates[i];
+            if (llState < 0 ||
+                llState >= llChoice.table.length ||
+                mlState < 0 ||
+                mlState >= mlChoice.table.length ||
+                ofState < 0 ||
+                ofState >= ofChoice.table.length) {
                 return null;
-            readCounts[readPos] = llRow.numBits;
-            readValues[readPos++] = llPath.updateBits[i] ?? 0;
-            readCounts[readPos] = mlRow.numBits;
-            readValues[readPos++] = mlPath.updateBits[i] ?? 0;
-            readCounts[readPos] = ofRow.numBits;
-            readValues[readPos++] = ofPath.updateBits[i] ?? 0;
+            }
+            readCounts[readPos] = llChoice.table.numBits[llState];
+            readValues[readPos++] = llUpdates[i];
+            readCounts[readPos] = mlChoice.table.numBits[mlState];
+            readValues[readPos++] = mlUpdates[i];
+            readCounts[readPos] = ofChoice.table.numBits[ofState];
+            readValues[readPos++] = ofUpdates[i];
         }
     }
     const bitstream = encodeReverseBitstream(readCounts, readValues);
-    const out = new Uint8Array(numSequencesBytes.length + 1 + bitstream.length);
+    const tableHeaderSize = llChoice.tableHeader.length + ofChoice.tableHeader.length + mlChoice.tableHeader.length;
+    const out = new Uint8Array(numSequencesBytes.length + 1 + tableHeaderSize + bitstream.length);
     out.set(numSequencesBytes, 0);
-    out[numSequencesBytes.length] = 0x00; // predefined LL/OF/ML modes
-    out.set(bitstream, numSequencesBytes.length + 1);
-    return out;
+    const modeByte = (llChoice.mode << 6) | (ofChoice.mode << 4) | (mlChoice.mode << 2);
+    out[numSequencesBytes.length] = modeByte & 0xff;
+    let pos = numSequencesBytes.length + 1;
+    out.set(llChoice.tableHeader, pos);
+    pos += llChoice.tableHeader.length;
+    out.set(ofChoice.tableHeader, pos);
+    pos += ofChoice.tableHeader.length;
+    out.set(mlChoice.tableHeader, pos);
+    pos += mlChoice.tableHeader.length;
+    out.set(bitstream, pos);
+    return {
+        section: out,
+        tables: {
+            llTable: llChoice.table,
+            llTableLog: llChoice.tableLog,
+            ofTable: ofChoice.table,
+            ofTableLog: ofChoice.tableLog,
+            mlTable: mlChoice.table,
+            mlTableLog: mlChoice.tableLog,
+        },
+    };
 }
-export function buildCompressedBlockPayload(literals, sequences) {
-    const literalsLength = literals.length;
-    const rawSection = buildRawLiteralsSection(literals);
-    if (!rawSection)
+export function buildCompressedBlockPayload(literals, sequences, context) {
+    const literalsContext = {
+        prevTable: context?.prevLiteralsTable ?? null,
+    };
+    const encodedLiterals = encodeLiteralsSection(literals, literalsContext);
+    if (!encodedLiterals)
         return null;
-    let literalsSection = rawSection;
-    if (literalsLength >= 8 && literalsLength <= 1023) {
-        const single = buildSingleSymbolCompressedLiterals(literals);
-        if (single && single.length < literalsSection.length) {
-            literalsSection = single;
-        }
-    }
-    if (literalsLength >= 16 && literalsLength <= 1023) {
-        const general = buildGeneralCompressedLiterals(literals);
-        if (general && general.length < literalsSection.length) {
-            literalsSection = general;
-        }
-    }
-    const seqSection = buildPredefinedSequenceSection(sequences);
+    const literalsSection = encodedLiterals.section;
+    const seqSection = buildSequenceSection(sequences, context);
     if (!seqSection)
         return null;
-    const out = new Uint8Array(literalsSection.length + seqSection.length);
+    const out = new Uint8Array(literalsSection.length + seqSection.section.length);
     out.set(literalsSection, 0);
-    out.set(seqSection, literalsSection.length);
+    out.set(seqSection.section, literalsSection.length);
+    if (context) {
+        context.prevTables = seqSection.tables;
+        context.prevLiteralsTable = encodedLiterals.table;
+    }
     return out;
 }
 export function writeCompressedBlock(payload, last) {
@@ -501,4 +700,11 @@ export function writeCompressedBlock(payload, last) {
     out.set(payload, 3);
     return out;
 }
+// Internal benchmark hooks for hot-path profiling.
+export const __benchInternals = {
+    encodeReverseBitstream,
+    buildGeneralCompressedLiterals: buildGeneralCompressedLiteralsForBench,
+    buildPredefinedSequenceSection: (sequences) => buildSequenceSection(sequences)?.section ?? null,
+    buildSequenceSection,
+};
 //# sourceMappingURL=compressedBlock.js.map