@maplibre/mlt 1.1.6 → 1.1.8

package/dist/encoding/fastPforEncoder.js

@@ -0,0 +1,310 @@
+import { MASKS, DEFAULT_PAGE_SIZE, BLOCK_SIZE, greatestMultiple, roundUpToMultipleOf32, normalizePageSize, } from "../decoding/fastPforShared";
+const EXCEPTION_OVERHEAD_BITS = 8;
+const MAX_BIT_WIDTH = 32;
+const BIT_WIDTH_SLOTS = MAX_BIT_WIDTH + 1;
+const PAGE_SIZE = normalizePageSize(DEFAULT_PAGE_SIZE);
+const INITIAL_PACKED_BUFFER_SIZE_WORDS = (PAGE_SIZE / 32) * 4;
+const BYTE_CONTAINER_SIZE = ((3 * PAGE_SIZE) / BLOCK_SIZE + PAGE_SIZE) | 0;
+function requiredBits(value) {
+    return 32 - Math.clz32(value >>> 0);
+}
+function ensureInt32Capacity(buffer, requiredLength) {
+    if (requiredLength <= buffer.length)
+        return buffer;
+    let newLength = buffer.length === 0 ? 1 : buffer.length;
+    while (newLength < requiredLength) {
+        newLength *= 2;
+    }
+    const next = new Uint32Array(newLength);
+    next.set(buffer);
+    return next;
+}
+function ensureUint8Capacity(buffer, requiredLength) {
+    if (requiredLength <= buffer.length)
+        return buffer;
+    let newLength = buffer.length === 0 ? 1 : buffer.length;
+    while (newLength < requiredLength) {
+        newLength *= 2;
+    }
+    const next = new Uint8Array(newLength);
+    next.set(buffer);
+    return next;
+}
+export function fastPack32(inValues, inPos, out, outPos, bitWidth) {
+    if (bitWidth === 0)
+        return;
+    if (bitWidth === 32) {
+        out.set(inValues.subarray(inPos, inPos + 32), outPos);
+        return;
+    }
+    const mask = MASKS[bitWidth] >>> 0;
+    let outputWordIndex = outPos;
+    let bitOffset = 0;
+    let currentWord = 0;
+    for (let i = 0; i < 32; i++) {
+        const value = (inValues[inPos + i] >>> 0) & mask;
+        if (bitOffset + bitWidth <= 32) {
+            currentWord |= value << bitOffset;
+            bitOffset += bitWidth;
+            if (bitOffset === 32) {
+                out[outputWordIndex++] = currentWord | 0;
+                bitOffset = 0;
+                currentWord = 0;
+            }
+        }
+        else {
+            const lowBits = 32 - bitOffset;
+            const lowMask = MASKS[lowBits] >>> 0;
+            currentWord |= (value & lowMask) << bitOffset;
+            out[outputWordIndex++] = currentWord | 0;
+            currentWord = value >>> lowBits;
+            bitOffset = bitWidth - lowBits;
+        }
+    }
+}
+export function createFastPforEncoderWorkspace() {
+    const dataToBePacked = new Array(BIT_WIDTH_SLOTS);
+    for (let k = 1; k < BIT_WIDTH_SLOTS; k++) {
+        dataToBePacked[k] = new Uint32Array(INITIAL_PACKED_BUFFER_SIZE_WORDS);
+    }
+    return {
+        dataToBePacked,
+        dataPointers: new Int32Array(BIT_WIDTH_SLOTS),
+        byteContainer: new Uint8Array(BYTE_CONTAINER_SIZE),
+        bitWidthFrequencies: new Int32Array(BIT_WIDTH_SLOTS),
+        bestBitWidthPlan: new Int32Array(3),
+    };
+}
+function computeBestBitWidthPlan(inValues, pos, workspace) {
+    const bitWidthFrequencies = workspace.bitWidthFrequencies;
+    const bestBitWidthPlan = workspace.bestBitWidthPlan;
+    bitWidthFrequencies.fill(0);
+    for (let k = pos, kEnd = pos + BLOCK_SIZE; k < kEnd; k++) {
+        bitWidthFrequencies[requiredBits(inValues[k])]++;
+    }
+    let maxBitWidth = MAX_BIT_WIDTH;
+    while (bitWidthFrequencies[maxBitWidth] === 0)
+        maxBitWidth--;
+    let bestBitWidth = maxBitWidth;
+    let bestCost = maxBitWidth * BLOCK_SIZE;
+    let exceptionCount = 0;
+    let bestExceptionCount = exceptionCount;
+    for (let candidateBitWidth = maxBitWidth - 1; candidateBitWidth >= 0; candidateBitWidth--) {
+        exceptionCount += bitWidthFrequencies[candidateBitWidth + 1];
+        if (exceptionCount === BLOCK_SIZE)
+            break;
+        let candidateCost = exceptionCount * EXCEPTION_OVERHEAD_BITS +
+            exceptionCount * (maxBitWidth - candidateBitWidth) +
+            candidateBitWidth * BLOCK_SIZE +
+            8;
+        if (maxBitWidth - candidateBitWidth === 1)
+            candidateCost -= exceptionCount;
+        if (candidateCost < bestCost) {
+            bestCost = candidateCost;
+            bestBitWidth = candidateBitWidth;
+            bestExceptionCount = exceptionCount;
+        }
+    }
+    bestBitWidthPlan[0] = bestBitWidth;
+    bestBitWidthPlan[1] = bestExceptionCount;
+    bestBitWidthPlan[2] = maxBitWidth;
+}
+function writeByte(workspace, byteContainerPos, byteValue) {
+    if (byteContainerPos >= workspace.byteContainer.length) {
+        workspace.byteContainer = ensureUint8Capacity(workspace.byteContainer, byteContainerPos + 1);
+    }
+    workspace.byteContainer[byteContainerPos] = byteValue & 0xff;
+    return byteContainerPos + 1;
+}
+function ensureExceptionValuesCapacity(dataToBePacked, dataPointers, exceptionBitWidth, exceptionCount) {
+    if (exceptionBitWidth === 1)
+        return;
+    const needed = dataPointers[exceptionBitWidth] + exceptionCount;
+    const currentExceptionValues = dataToBePacked[exceptionBitWidth];
+    if (!currentExceptionValues || needed >= currentExceptionValues.length) {
+        let newSize = 2 * needed;
+        newSize = roundUpToMultipleOf32(newSize);
+        const next = new Uint32Array(newSize);
+        if (currentExceptionValues)
+            next.set(currentExceptionValues);
+        dataToBePacked[exceptionBitWidth] = next;
+    }
+}
+function writeBlockHeader(workspace, byteContainerPos, bitWidth, exceptionCount, maxBitWidth) {
+    byteContainerPos = writeByte(workspace, byteContainerPos, bitWidth);
+    byteContainerPos = writeByte(workspace, byteContainerPos, exceptionCount);
+    if (exceptionCount > 0) {
+        byteContainerPos = writeByte(workspace, byteContainerPos, maxBitWidth);
+    }
+    return byteContainerPos;
+}
+function recordBlockExceptions(workspace, inValues, blockPos, bitWidth, exceptionCount, exceptionBitWidth, byteContainerPos) {
+    if (exceptionCount === 0)
+        return byteContainerPos;
+    const dataToBePacked = workspace.dataToBePacked;
+    const dataPointers = workspace.dataPointers;
+    ensureExceptionValuesCapacity(dataToBePacked, dataPointers, exceptionBitWidth, exceptionCount);
+    for (let k = 0; k < BLOCK_SIZE; k++) {
+        const value = inValues[blockPos + k] >>> 0;
+        if (value >>> bitWidth !== 0) {
+            byteContainerPos = writeByte(workspace, byteContainerPos, k);
+            if (exceptionBitWidth !== 1) {
+                const exceptionValues = dataToBePacked[exceptionBitWidth];
+                exceptionValues[dataPointers[exceptionBitWidth]++] = (value >>> bitWidth) | 0;
+            }
+        }
+    }
+    return byteContainerPos;
+}
+function packBlock(inValues, blockPos, bitWidth, state) {
+    for (let k = 0; k < BLOCK_SIZE; k += 32) {
+        state.out = ensureInt32Capacity(state.out, state.outPos + bitWidth);
+        fastPack32(inValues, blockPos + k, state.out, state.outPos, bitWidth);
+        state.outPos += bitWidth;
+    }
+}
+function padByteContainerToInt32(workspace, byteContainerPos) {
+    while ((byteContainerPos & 3) !== 0) {
+        byteContainerPos = writeByte(workspace, byteContainerPos, 0);
+    }
+    return byteContainerPos;
+}
+function writeByteContainerInts(workspace, state, byteContainerPos) {
+    const howManyInts = byteContainerPos / 4;
+    state.out = ensureInt32Capacity(state.out, state.outPos + howManyInts);
+    const byteContainer = workspace.byteContainer;
+    for (let i = 0; i < howManyInts; i++) {
+        const base = i * 4;
+        const packedWord = byteContainer[base] |
+            (byteContainer[base + 1] << 8) |
+            (byteContainer[base + 2] << 16) |
+            (byteContainer[base + 3] << 24) |
+            0;
+        state.out[state.outPos + i] = packedWord;
+    }
+    state.outPos += howManyInts;
+}
+function computeExceptionBitmap(dataPointers) {
+    let bitmap = 0;
+    for (let k = 2; k <= MAX_BIT_WIDTH; k++) {
+        if (dataPointers[k] !== 0) {
+            bitmap |= k === MAX_BIT_WIDTH ? 0x80000000 : 1 << (k - 1);
+        }
+    }
+    return bitmap;
+}
+function writeExceptionStreams(workspace, state) {
+    const dataPointers = workspace.dataPointers;
+    const dataToBePacked = workspace.dataToBePacked;
+    const bitmap = computeExceptionBitmap(dataPointers);
+    state.out = ensureInt32Capacity(state.out, state.outPos + 1);
+    state.out[state.outPos++] = bitmap;
+    for (let k = 2; k <= MAX_BIT_WIDTH; k++) {
+        const size = dataPointers[k];
+        if (size !== 0) {
+            state.out = ensureInt32Capacity(state.out, state.outPos + 1);
+            state.out[state.outPos++] = size | 0;
+            let j = 0;
+            for (; j < size; j += 32) {
+                const exceptionValues = dataToBePacked[k];
+                state.out = ensureInt32Capacity(state.out, state.outPos + k);
+                fastPack32(exceptionValues, j, state.out, state.outPos, k);
+                state.outPos += k;
+            }
+            const overflow = j - size;
+            state.outPos -= (overflow * k) >>> 5;
+        }
+    }
+}
+function encodePage(inValues, thisSize, state, workspace) {
+    const headerPos = state.outPos;
+    state.out = ensureInt32Capacity(state.out, headerPos + 1);
+    state.outPos = (state.outPos + 1) | 0;
+    const dataPointers = workspace.dataPointers;
+    dataPointers.fill(0);
+    let byteContainerPos = 0;
+    let tmpInPos = state.inPos;
+    const finalInPos = tmpInPos + thisSize - BLOCK_SIZE;
+    for (; tmpInPos <= finalInPos; tmpInPos += BLOCK_SIZE) {
+        computeBestBitWidthPlan(inValues, tmpInPos, workspace);
+        const bestBitWidthPlan = workspace.bestBitWidthPlan;
+        const bitWidth = bestBitWidthPlan[0];
+        const exceptionCount = bestBitWidthPlan[1];
+        const maxBitWidth = bestBitWidthPlan[2];
+        const exceptionBitWidth = exceptionCount > 0 ? maxBitWidth - bitWidth : 0;
+        byteContainerPos = writeBlockHeader(workspace, byteContainerPos, bitWidth, exceptionCount, maxBitWidth);
+        byteContainerPos = recordBlockExceptions(workspace, inValues, tmpInPos, bitWidth, exceptionCount, exceptionBitWidth, byteContainerPos);
+        packBlock(inValues, tmpInPos, bitWidth, state);
+    }
+    const pageEndOutPos = state.outPos;
+    state.inPos = tmpInPos;
+    state.out[headerPos] = (pageEndOutPos - headerPos) | 0;
+    const byteSize = byteContainerPos;
+    byteContainerPos = padByteContainerToInt32(workspace, byteContainerPos);
+    state.out = ensureInt32Capacity(state.out, state.outPos + 1);
+    state.out[state.outPos++] = byteSize | 0;
+    writeByteContainerInts(workspace, state, byteContainerPos);
+    writeExceptionStreams(workspace, state);
+}
+function encodeAlignedPages(inValues, inLength, state, workspace) {
+    const alignedLength = greatestMultiple(inLength, BLOCK_SIZE);
+    const finalInPos = state.inPos + alignedLength;
+    while (state.inPos !== finalInPos) {
+        const thisSize = Math.min(PAGE_SIZE, finalInPos - state.inPos);
+        encodePage(inValues, thisSize, state, workspace);
+    }
+}
+function encode(inValues, inLength, state, workspace) {
+    const alignedLength = greatestMultiple(inLength, BLOCK_SIZE);
+    state.out = ensureInt32Capacity(state.out, state.outPos + 1);
+    state.out[state.outPos++] = alignedLength;
+    if (alignedLength === 0)
+        return;
+    encodeAlignedPages(inValues, alignedLength, state, workspace);
+}
+/**
+ * VByte encoding for FastPFOR tail values (MSB=1 terminator).
+ * Note: Inverts standard Protobuf Varint (MSB=0 terminator), so we cannot reuse generic methods.
+ */
+function encodeVByte(inValues, inLength, state, workspace) {
+    if (inLength === 0)
+        return;
+    const requiredBytes = inLength * 5 + 3;
+    workspace.byteContainer = ensureUint8Capacity(workspace.byteContainer, requiredBytes);
+    const start = state.inPos;
+    let bytePos = 0;
+    for (let k = start; k < start + inLength; k++) {
+        let value = inValues[k] >>> 0;
+        while (value >= 0x80) {
+            workspace.byteContainer[bytePos++] = value & 0x7f;
+            value >>>= 7;
+        }
+        workspace.byteContainer[bytePos++] = (value | 0x80) & 0xff;
+    }
+    while ((bytePos & 3) !== 0)
+        workspace.byteContainer[bytePos++] = 0;
+    const intsToWrite = bytePos / 4;
+    state.out = ensureInt32Capacity(state.out, state.outPos + intsToWrite);
+    let outIdx = state.outPos;
+    for (let i = 0; i < bytePos; i += 4) {
+        const packedWord = workspace.byteContainer[i] |
+            (workspace.byteContainer[i + 1] << 8) |
+            (workspace.byteContainer[i + 2] << 16) |
+            (workspace.byteContainer[i + 3] << 24) |
+            0;
+        state.out[outIdx++] = packedWord;
+    }
+    state.outPos = outIdx;
+    state.inPos = (state.inPos + inLength) | 0;
+}
+/**
+ * Encodes an int32 stream using the FastPFOR wire format (pages + VByte tail).
+ */
+export function encodeFastPforInt32WithWorkspace(values, workspace) {
+    const state = { inPos: 0, outPos: 0, out: new Uint32Array(values.length + 1024) };
+    encode(values, values.length, state, workspace);
+    const remaining = values.length - state.inPos;
+    encodeVByte(values, remaining, state, workspace);
+    return state.out.subarray(0, state.outPos);
+}
+//# sourceMappingURL=fastPforEncoder.js.map

package/dist/encoding/fastPforEncoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fastPforEncoder.js","sourceRoot":"","sources":["../../src/encoding/fastPforEncoder.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    MASKS,\n    DEFAULT_PAGE_SIZE,\n    BLOCK_SIZE,\n    greatestMultiple,\n    roundUpToMultipleOf32,\n    normalizePageSize,\n} from \"../decoding/fastPforShared\";\n\nconst EXCEPTION_OVERHEAD_BITS = 8;\nconst MAX_BIT_WIDTH = 32;\nconst BIT_WIDTH_SLOTS = MAX_BIT_WIDTH + 1;\nconst PAGE_SIZE = normalizePageSize(DEFAULT_PAGE_SIZE);\nconst INITIAL_PACKED_BUFFER_SIZE_WORDS = (PAGE_SIZE / 32) * 4;\nconst BYTE_CONTAINER_SIZE = ((3 * PAGE_SIZE) / BLOCK_SIZE + PAGE_SIZE) | 0;\n\nfunction requiredBits(value: number): number {\n    return 32 - Math.clz32(value >>> 0);\n}\n\nfunction ensureInt32Capacity(buffer: Uint32Array, requiredLength: number): Uint32Array {\n    if (requiredLength <= buffer.length) return buffer;\n\n    let newLength = buffer.length === 0 ? 1 : buffer.length;\n    while (newLength < requiredLength) {\n        newLength *= 2;\n    }\n\n    const next = new Uint32Array(newLength);\n    next.set(buffer);\n    return next;\n}\n\nfunction ensureUint8Capacity(buffer: Uint8Array, requiredLength: number): Uint8Array {\n    if (requiredLength <= buffer.length) return buffer;\n\n    let newLength = buffer.length === 0 ? 1 : buffer.length;\n    while (newLength < requiredLength) {\n        newLength *= 2;\n    }\n\n    const next = new Uint8Array(newLength);\n    next.set(buffer);\n    return next;\n}\n\n/**\n * Internal workspace for the FastPFOR encoder.\n * Exposed so callers can avoid allocations.\n * Use one workspace per concurrent encode call.\n */\nexport type FastPforEncoderWorkspace = {\n    dataToBePacked: Array<Uint32Array | undefined>;\n    dataPointers: Int32Array;\n    byteContainer: Uint8Array;\n    bitWidthFrequencies: Int32Array;\n    bestBitWidthPlan: Int32Array;\n};\n\nexport function fastPack32(\n    inValues: Uint32Array,\n    inPos: number,\n    out: Uint32Array,\n    outPos: number,\n    bitWidth: number,\n): void {\n    if (bitWidth === 0) return;\n    if (bitWidth === 32) {\n        out.set(inValues.subarray(inPos, inPos + 32), outPos);\n        return;\n    }\n\n    const mask = MASKS[bitWidth] >>> 0;\n    let outputWordIndex = outPos;\n    let bitOffset = 0;\n    let currentWord = 0;\n\n    for (let i = 0; i < 32; i++) {\n        const value = (inValues[inPos + i] >>> 0) & mask;\n\n        if (bitOffset + bitWidth <= 32) {\n            currentWord |= value << bitOffset;\n            bitOffset += bitWidth;\n\n            if (bitOffset === 32) {\n                out[outputWordIndex++] = currentWord | 0;\n                bitOffset = 0;\n                currentWord = 0;\n            }\n        } else {\n            const lowBits = 32 - bitOffset;\n            const lowMask = MASKS[lowBits] >>> 0;\n            currentWord |= (value & lowMask) << bitOffset;\n            out[outputWordIndex++] = currentWord | 0;\n            currentWord = value >>> lowBits;\n            bitOffset = bitWidth - lowBits;\n        }\n    }\n}\n\nexport function createFastPforEncoderWorkspace(): FastPforEncoderWorkspace {\n    const dataToBePacked: Array<Uint32Array | undefined> = new Array(BIT_WIDTH_SLOTS);\n    for (let k = 1; k < BIT_WIDTH_SLOTS; k++) {\n        dataToBePacked[k] = new Uint32Array(INITIAL_PACKED_BUFFER_SIZE_WORDS);\n    }\n\n    return {\n        dataToBePacked,\n        dataPointers: new Int32Array(BIT_WIDTH_SLOTS),\n        byteContainer: new Uint8Array(BYTE_CONTAINER_SIZE),\n        bitWidthFrequencies: new Int32Array(BIT_WIDTH_SLOTS),\n        bestBitWidthPlan: new Int32Array(3),\n    };\n}\n\nfunction computeBestBitWidthPlan(inValues: Uint32Array, pos: number, workspace: FastPforEncoderWorkspace): void {\n    const bitWidthFrequencies = workspace.bitWidthFrequencies;\n    const bestBitWidthPlan = workspace.bestBitWidthPlan;\n    bitWidthFrequencies.fill(0);\n    for (let k = pos, kEnd = pos + BLOCK_SIZE; k < kEnd; k++) {\n        bitWidthFrequencies[requiredBits(inValues[k])]++;\n    }\n\n    let maxBitWidth = MAX_BIT_WIDTH;\n    while (bitWidthFrequencies[maxBitWidth] === 0) maxBitWidth--;\n\n    let bestBitWidth = maxBitWidth;\n    let bestCost = maxBitWidth * BLOCK_SIZE;\n    let exceptionCount = 0;\n    let bestExceptionCount = exceptionCount;\n\n    for (let candidateBitWidth = maxBitWidth - 1; candidateBitWidth >= 0; candidateBitWidth--) {\n        exceptionCount += bitWidthFrequencies[candidateBitWidth + 1];\n        if (exceptionCount === BLOCK_SIZE) break;\n\n        let candidateCost =\n            exceptionCount * EXCEPTION_OVERHEAD_BITS +\n            exceptionCount * (maxBitWidth - candidateBitWidth) +\n            candidateBitWidth * BLOCK_SIZE +\n            8;\n        if (maxBitWidth - candidateBitWidth === 1) candidateCost -= exceptionCount;\n\n        if (candidateCost < bestCost) {\n            bestCost = candidateCost;\n            bestBitWidth = candidateBitWidth;\n            bestExceptionCount = exceptionCount;\n        }\n    }\n\n    bestBitWidthPlan[0] = bestBitWidth;\n    bestBitWidthPlan[1] = bestExceptionCount;\n    bestBitWidthPlan[2] = maxBitWidth;\n}\n\nfunction writeByte(workspace: FastPforEncoderWorkspace, byteContainerPos: number, byteValue: number): number {\n    if (byteContainerPos >= workspace.byteContainer.length) {\n        workspace.byteContainer = ensureUint8Capacity(workspace.byteContainer, byteContainerPos + 1);\n    }\n    workspace.byteContainer[byteContainerPos] = byteValue & 0xff;\n    return byteContainerPos + 1;\n}\n\nfunction ensureExceptionValuesCapacity(\n    dataToBePacked: Array<Uint32Array | undefined>,\n    dataPointers: Int32Array,\n    exceptionBitWidth: number,\n    exceptionCount: number,\n): void {\n    if (exceptionBitWidth === 1) return;\n\n    const needed = dataPointers[exceptionBitWidth] + exceptionCount;\n    const currentExceptionValues = dataToBePacked[exceptionBitWidth];\n    if (!currentExceptionValues || needed >= currentExceptionValues.length) {\n        let newSize = 2 * needed;\n        newSize = roundUpToMultipleOf32(newSize);\n        const next = new Uint32Array(newSize);\n        if (currentExceptionValues) next.set(currentExceptionValues);\n        dataToBePacked[exceptionBitWidth] = next;\n    }\n}\n\nfunction writeBlockHeader(\n    workspace: FastPforEncoderWorkspace,\n    byteContainerPos: number,\n    bitWidth: number,\n    exceptionCount: number,\n    maxBitWidth: number,\n): number {\n    byteContainerPos = writeByte(workspace, byteContainerPos, bitWidth);\n    byteContainerPos = writeByte(workspace, byteContainerPos, exceptionCount);\n    if (exceptionCount > 0) {\n        byteContainerPos = writeByte(workspace, byteContainerPos, maxBitWidth);\n    }\n    return byteContainerPos;\n}\n\nfunction recordBlockExceptions(\n    workspace: FastPforEncoderWorkspace,\n    inValues: Uint32Array,\n    blockPos: number,\n    bitWidth: number,\n    exceptionCount: number,\n    exceptionBitWidth: number,\n    byteContainerPos: number,\n): number {\n    if (exceptionCount === 0) return byteContainerPos;\n\n    const dataToBePacked = workspace.dataToBePacked;\n    const dataPointers = workspace.dataPointers;\n\n    ensureExceptionValuesCapacity(dataToBePacked, dataPointers, exceptionBitWidth, exceptionCount);\n\n    for (let k = 0; k < BLOCK_SIZE; k++) {\n        const value = inValues[blockPos + k] >>> 0;\n        if (value >>> bitWidth !== 0) {\n            byteContainerPos = writeByte(workspace, byteContainerPos, k);\n            if (exceptionBitWidth !== 1) {\n                const exceptionValues = dataToBePacked[exceptionBitWidth];\n                exceptionValues[dataPointers[exceptionBitWidth]++] = (value >>> bitWidth) | 0;\n            }\n        }\n    }\n\n    return byteContainerPos;\n}\n\ntype EncodeState = { inPos: number; out: Uint32Array; outPos: number };\n\nfunction packBlock(inValues: Uint32Array, blockPos: number, bitWidth: number, state: EncodeState): void {\n    for (let k = 0; k < BLOCK_SIZE; k += 32) {\n        state.out = ensureInt32Capacity(state.out, state.outPos + bitWidth);\n        fastPack32(inValues, blockPos + k, state.out, state.outPos, bitWidth);\n        state.outPos += bitWidth;\n    }\n}\n\nfunction padByteContainerToInt32(workspace: FastPforEncoderWorkspace, byteContainerPos: number): number {\n    while ((byteContainerPos & 3) !== 0) {\n        byteContainerPos = writeByte(workspace, byteContainerPos, 0);\n    }\n    return byteContainerPos;\n}\n\nfunction writeByteContainerInts(\n    workspace: FastPforEncoderWorkspace,\n    state: EncodeState,\n    byteContainerPos: number,\n): void {\n    const howManyInts = byteContainerPos / 4;\n    state.out = ensureInt32Capacity(state.out, state.outPos + howManyInts);\n\n    const byteContainer = workspace.byteContainer;\n    for (let i = 0; i < howManyInts; i++) {\n        const base = i * 4;\n        const packedWord =\n            byteContainer[base] |\n            (byteContainer[base + 1] << 8) |\n            (byteContainer[base + 2] << 16) |\n            (byteContainer[base + 3] << 24) |\n            0;\n        state.out[state.outPos + i] = packedWord;\n    }\n\n    state.outPos += howManyInts;\n}\n\nfunction computeExceptionBitmap(dataPointers: Int32Array): number {\n    let bitmap = 0;\n    for (let k = 2; k <= MAX_BIT_WIDTH; k++) {\n        if (dataPointers[k] !== 0) {\n            bitmap |= k === MAX_BIT_WIDTH ? 0x80000000 : 1 << (k - 1);\n        }\n    }\n    return bitmap;\n}\n\nfunction writeExceptionStreams(workspace: FastPforEncoderWorkspace, state: EncodeState): void {\n    const dataPointers = workspace.dataPointers;\n    const dataToBePacked = workspace.dataToBePacked;\n\n    const bitmap = computeExceptionBitmap(dataPointers);\n    state.out = ensureInt32Capacity(state.out, state.outPos + 1);\n    state.out[state.outPos++] = bitmap;\n\n    for (let k = 2; k <= MAX_BIT_WIDTH; k++) {\n        const size = dataPointers[k];\n        if (size !== 0) {\n            state.out = ensureInt32Capacity(state.out, state.outPos + 1);\n            state.out[state.outPos++] = size | 0;\n\n            let j = 0;\n            for (; j < size; j += 32) {\n                const exceptionValues = dataToBePacked[k];\n                state.out = ensureInt32Capacity(state.out, state.outPos + k);\n                fastPack32(exceptionValues, j, state.out, state.outPos, k);\n                state.outPos += k;\n            }\n\n            const overflow = j - size;\n            state.outPos -= (overflow * k) >>> 5;\n        }\n    }\n}\n\nfunction encodePage(\n    inValues: Uint32Array,\n    thisSize: number,\n    state: EncodeState,\n    workspace: FastPforEncoderWorkspace,\n): void {\n    const headerPos = state.outPos;\n    state.out = ensureInt32Capacity(state.out, headerPos + 1);\n    state.outPos = (state.outPos + 1) | 0;\n\n    const dataPointers = workspace.dataPointers;\n    dataPointers.fill(0);\n\n    let byteContainerPos = 0;\n\n    let tmpInPos = state.inPos;\n    const finalInPos = tmpInPos + thisSize - BLOCK_SIZE;\n\n    for (; tmpInPos <= finalInPos; tmpInPos += BLOCK_SIZE) {\n        computeBestBitWidthPlan(inValues, tmpInPos, workspace);\n\n        const bestBitWidthPlan = workspace.bestBitWidthPlan;\n        const bitWidth = bestBitWidthPlan[0];\n        const exceptionCount = bestBitWidthPlan[1];\n        const maxBitWidth = bestBitWidthPlan[2];\n\n        const exceptionBitWidth = exceptionCount > 0 ? maxBitWidth - bitWidth : 0;\n        byteContainerPos = writeBlockHeader(workspace, byteContainerPos, bitWidth, exceptionCount, maxBitWidth);\n        byteContainerPos = recordBlockExceptions(\n            workspace,\n            inValues,\n            tmpInPos,\n            bitWidth,\n            exceptionCount,\n            exceptionBitWidth,\n            byteContainerPos,\n        );\n\n        packBlock(inValues, tmpInPos, bitWidth, state);\n    }\n\n    const pageEndOutPos = state.outPos;\n    state.inPos = tmpInPos;\n    state.out[headerPos] = (pageEndOutPos - headerPos) | 0;\n\n    const byteSize = byteContainerPos;\n    byteContainerPos = padByteContainerToInt32(workspace, byteContainerPos);\n\n    state.out = ensureInt32Capacity(state.out, state.outPos + 1);\n    state.out[state.outPos++] = byteSize | 0;\n\n    writeByteContainerInts(workspace, state, byteContainerPos);\n\n    writeExceptionStreams(workspace, state);\n}\n\nfunction encodeAlignedPages(\n    inValues: Uint32Array,\n    inLength: number,\n    state: EncodeState,\n    workspace: FastPforEncoderWorkspace,\n): void {\n    const alignedLength = greatestMultiple(inLength, BLOCK_SIZE);\n    const finalInPos = state.inPos + alignedLength;\n\n    while (state.inPos !== finalInPos) {\n        const thisSize = Math.min(PAGE_SIZE, finalInPos - state.inPos);\n        encodePage(inValues, thisSize, state, workspace);\n    }\n}\n\nfunction encode(\n    inValues: Uint32Array,\n    inLength: number,\n    state: EncodeState,\n    workspace: FastPforEncoderWorkspace,\n): void {\n    const alignedLength = greatestMultiple(inLength, BLOCK_SIZE);\n    state.out = ensureInt32Capacity(state.out, state.outPos + 1);\n    state.out[state.outPos++] = alignedLength;\n\n    if (alignedLength === 0) return;\n    encodeAlignedPages(inValues, alignedLength, state, workspace);\n}\n\n/**\n * VByte encoding for FastPFOR tail values (MSB=1 terminator).\n * Note: Inverts standard Protobuf Varint (MSB=0 terminator), so we cannot reuse generic methods.\n */\nfunction encodeVByte(\n    inValues: Uint32Array,\n    inLength: number,\n    state: EncodeState,\n    workspace: FastPforEncoderWorkspace,\n): void {\n    if (inLength === 0) return;\n\n    const requiredBytes = inLength * 5 + 3;\n    workspace.byteContainer = ensureUint8Capacity(workspace.byteContainer, requiredBytes);\n\n    const start = state.inPos;\n    let bytePos = 0;\n    for (let k = start; k < start + inLength; k++) {\n        let value = inValues[k] >>> 0;\n        while (value >= 0x80) {\n            workspace.byteContainer[bytePos++] = value & 0x7f;\n            value >>>= 7;\n        }\n        workspace.byteContainer[bytePos++] = (value | 0x80) & 0xff;\n    }\n\n    while ((bytePos & 3) !== 0) workspace.byteContainer[bytePos++] = 0;\n\n    const intsToWrite = bytePos / 4;\n    state.out = ensureInt32Capacity(state.out, state.outPos + intsToWrite);\n\n    let outIdx = state.outPos;\n    for (let i = 0; i < bytePos; i += 4) {\n        const packedWord =\n            workspace.byteContainer[i] |\n            (workspace.byteContainer[i + 1] << 8) |\n            (workspace.byteContainer[i + 2] << 16) |\n            (workspace.byteContainer[i + 3] << 24) |\n            0;\n        state.out[outIdx++] = packedWord;\n    }\n\n    state.outPos = outIdx;\n    state.inPos = (state.inPos + inLength) | 0;\n}\n\n/**\n * Encodes an int32 stream using the FastPFOR wire format (pages + VByte tail).\n */\nexport function encodeFastPforInt32WithWorkspace(\n    values: Uint32Array,\n    workspace: FastPforEncoderWorkspace,\n): Uint32Array {\n    const state: EncodeState = { inPos: 0, outPos: 0, out: new Uint32Array(values.length + 1024) };\n\n    encode(values, values.length, state, workspace);\n\n    const remaining = values.length - state.inPos;\n    encodeVByte(values, remaining, state, workspace);\n\n    return state.out.subarray(0, state.outPos);\n}\n"]}

package/dist/encoding/integerEncodingUtils.d.ts

@@ -1,37 +1,37 @@
 import IntWrapper from "../decoding/intWrapper";
 export declare function encodeVarintInt32Value(value: number, dst: Uint8Array, offset: IntWrapper): void;
-export declare function encodeVarintInt32(values: Int32Array): Uint8Array;
-export declare function encodeVarintInt64(values: BigInt64Array): Uint8Array;
+export declare function encodeVarintInt32(values: Uint32Array): Uint8Array;
+export declare function encodeVarintInt64(values: BigUint64Array): Uint8Array;
 export declare function encodeVarintFloat64(values: Float64Array): Uint8Array;
-export declare function encodeFastPfor(data: Int32Array): Uint8Array;
+export declare function encodeFastPfor(values: Uint32Array): Uint8Array;
 export declare function encodeZigZagInt32Value(value: number): number;
 export declare function encodeZigZagInt64Value(value: bigint): bigint;
 export declare function encodeZigZagFloat64Value(n: number): number;
-export declare function encodeZigZagInt32(data: Int32Array): void;
-export declare function encodeZigZagInt64(data: BigInt64Array): void;
+export declare function encodeZigZagInt32(data: Int32Array): Uint32Array;
+export declare function encodeZigZagInt64(data: BigInt64Array): BigUint64Array;
 export declare function encodeZigZagFloat64(data: Float64Array): void;
-export declare function encodeUnsignedRleInt32(input: Int32Array): {
-    data: Int32Array;
+export declare function encodeUnsignedRleInt32(input: Uint32Array): {
+    data: Uint32Array;
     runs: number;
 };
 export declare function encodeUnsignedRleInt64(input: BigInt64Array): {
-    data: BigInt64Array;
+    data: BigUint64Array;
     runs: number;
 };
 export declare function encodeUnsignedRleFloat64(input: Float64Array): {
     data: Float64Array;
     runs: number;
 };
-export declare function encodeZigZagDeltaInt32(data: Int32Array): void;
-export declare function encodeZigZagDeltaInt64(data: BigInt64Array): void;
+export declare function encodeZigZagDeltaInt32(data: Int32Array): Uint32Array;
+export declare function encodeZigZagDeltaInt64(data: BigInt64Array): BigUint64Array;
 export declare function encodeZigZagDeltaFloat64(data: Float64Array): void;
 export declare function encodeZigZagRleInt32(input: Int32Array): {
-    data: Int32Array;
+    data: Uint32Array;
     runs: number;
     numTotalValues: number;
 };
 export declare function encodeZigZagRleInt64(input: BigInt64Array): {
-    data: BigInt64Array;
+    data: BigUint64Array;
     runs: number;
     numTotalValues: number;
 };
@@ -43,26 +43,26 @@ export declare function encodeZigZagRleFloat64(input: Float64Array): {
 /**
  * This is not really a encode, but more of a decode method...
  */
-export declare function encodeDeltaInt32(data: Int32Array): void;
-export declare function encodeComponentwiseDeltaVec2(data: Int32Array): void;
-export declare function encodeComponentwiseDeltaVec2Scaled(data: Int32Array, scale: number): void;
+export declare function encodeDeltaInt32(data: Int32Array | Uint32Array): void;
+export declare function encodeComponentwiseDeltaVec2(data: Int32Array): Uint32Array;
+export declare function encodeComponentwiseDeltaVec2Scaled(data: Int32Array, scale: number): Uint32Array;
 export declare function encodeZigZagRleDeltaInt32(values: Int32Array | number[]): {
-    data: Int32Array;
+    data: Uint32Array;
     runs: number;
     numTotalValues: number;
 };
-export declare function encodeRleDeltaInt32(values: Int32Array | number[]): {
-    data: Int32Array;
+export declare function encodeRleDeltaInt32(values: Uint32Array | number[]): {
+    data: Uint32Array;
     runs: number;
     numTotalValues: number;
 };
 export declare function encodeDeltaRleInt32(input: Int32Array): {
-    data: Int32Array;
+    data: Uint32Array;
     runs: number;
     numValues: number;
 };
 export declare function encodeDeltaRleInt64(input: BigInt64Array): {
-    data: BigInt64Array;
+    data: BigUint64Array;
     runs: number;
     numValues: number;
 };