@evolu/common 8.6.2 → 8.7.0

package/dist/src/Buffer.js

@@ -1,9 +1,15 @@
 /**
  * Binary data handling and byte array utilities.
  *
+ * Buffer-based decoding functions intentionally throw errors instead of
+ * returning {@link Result}. This is a deliberate micro-optimization for Evolu
+ * Protocol's hot paths: Result is inexpensive, but returning decoded values
+ * directly avoids its success-case allocation, and using `Error` objects
+ * preserves stack traces. In the future, we will try returning `Error` objects
+ * in `Result` values to measure the real-world performance impact.
+ *
  * @module
  */
-import { NonNegativeInt, zeroNonNegativeInt } from "./Type.js";
 export { bytesToHex, bytesToUtf8, concatBytes, hexToBytes, utf8ToBytes, } from "@noble/ciphers/utils.js";
 /**
  * Custom error for {@link Buffer}-related failures like premature end of data.
@@ -18,15 +24,20 @@ export class BufferError extends Error {
 }
 /** Creates a {@link Buffer} for efficient byte operations. */
 export const createBuffer = (arrayLike) => {
+    const initialLength = arrayLike?.length ?? 0;
+    assertNonNegativeInt(initialLength, "arrayLike.length");
     let value = arrayLike
         ? new globalThis.Uint8Array(arrayLike)
         : new globalThis.Uint8Array(512);
-    let length = NonNegativeInt.orThrow(arrayLike ? arrayLike.length : 0);
+    let length = initialLength;
     const buffer = {
-        getCapacity: () => NonNegativeInt.orThrow(value.length),
+        getCapacity: () => value.length,
         getLength: () => length,
         extend: (arg) => {
-            const targetSize = length + arg.length;
+            const argLength = arg.length;
+            assertNonNegativeInt(argLength, "arg.length");
+            const targetSize = length + argLength;
+            assertNonNegativeInt(targetSize, "Buffer length");
             if (value.length < targetSize) {
                 const oldValue = value;
                 const newCapacity = Math.max(value.length * 2, targetSize);
@@ -34,24 +45,20 @@ export const createBuffer = (arrayLike) => {
                 value.set(oldValue);
             }
             value.set(arg, length);
-            length = NonNegativeInt.orThrow(length + arg.length);
+            length = targetSize;
         },
         shift: () => {
-            if (length === 0) {
-                throw new BufferError("Buffer parse ended prematurely");
-            }
+            assertBufferHasRemainingBytes(length, 1);
             const first = value[0];
             value = value.subarray(1);
             length--;
-            return NonNegativeInt.orThrow(first);
+            return first;
         },
         shiftN: (n) => {
-            if (length < n) {
-                throw new BufferError("Buffer parse ended prematurely");
-            }
+            assertBufferHasRemainingBytes(length, n);
             const subarray = value.subarray(0, n);
             value = value.subarray(n);
-            length = NonNegativeInt.orThrow(length - n);
+            length = (length - n);
             return subarray;
         },
         truncate: (newLength) => {
@@ -61,9 +68,709 @@ export const createBuffer = (arrayLike) => {
             length = newLength;
         },
         reset: () => {
-            length = zeroNonNegativeInt;
+            length = 0;
         },
-        unwrap: () => value.subarray(0, length),
+        unwrap: () => (value.length === length ? value : value.subarray(0, length)),
     };
     return buffer;
 };
+const jsonKeyCacheSize = 4096;
+const maxCachedJsonKeyByteLength = 32;
+const maxJsonNestingDepth = 1_000;
+let jsonEncoderTarget = new globalThis.Uint8Array(8192);
+let jsonEncoderTargetView = new globalThis.DataView(jsonEncoderTarget.buffer);
+let jsonEncoderPosition = 0;
+let jsonEncoderDepth = 0;
+let jsonEncoderIsActive = false;
+const emptyJsonDecoderSource = new globalThis.Uint8Array(0);
+const emptyJsonDecoderView = new globalThis.DataView(emptyJsonDecoderSource.buffer);
+let jsonDecoderSource = emptyJsonDecoderSource;
+let jsonDecoderView = emptyJsonDecoderView;
+let jsonDecoderPosition = 0;
+let jsonDecoderDepth = 0;
+const jsonStringFromCharCode = globalThis.String.fromCharCode;
+// Cache only short keys and use a fixed table to bound retained memory.
+const jsonKeyCache = globalThis.Array.from({ length: jsonKeyCacheSize }, () => undefined);
+/**
+ * Encodes a {@link JsonValue} using the MessagePack format.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   createBuffer,
+ *   encodeJsonValue,
+ *   JsonValue,
+ * } from "@evolu/common";
+ *
+ * const buffer = createBuffer();
+ * const value = JsonValue.orThrow({ name: "Ada" });
+ *
+ * encodeJsonValue(buffer, value);
+ *
+ * assertEqual(
+ *   buffer.unwrap(),
+ *   new Uint8Array([
+ *     0x81, 0xa4, 0x6e, 0x61, 0x6d, 0x65, 0xa3, 0x41, 0x64, 0x61,
+ *   ]),
+ * );
+ * ```
+ *
+ * Encoding is artificially limited to 1,000 nested arrays or objects to keep
+ * recursive encoding and decoding safe and symmetric. JSON data should not
+ * require such depth; flatten or split deeply nested data, or use a
+ * purpose-built serialization format.
+ */
+export const encodeJsonValue = (buffer, value) => {
+    if (jsonEncoderIsActive) {
+        throw new BufferError("Reentrant JSON encoding is not supported.");
+    }
+    jsonEncoderIsActive = true;
+    jsonEncoderPosition = 0;
+    try {
+        encodeJsonValueToTarget(value);
+        buffer.extend(jsonEncoderTarget.subarray(0, jsonEncoderPosition));
+    }
+    finally {
+        jsonEncoderPosition = 0;
+        jsonEncoderDepth = 0;
+        jsonEncoderIsActive = false;
+    }
+};
+/**
+ * Decodes a {@link JsonValue} using the MessagePack format.
+ *
+ * Throws a {@link BufferError} without modifying the Buffer if the encoded value
+ * is malformed, truncated, unsupported, outside the JsonValue domain, or
+ * exceeds 1,000 nested arrays or objects.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   createBuffer,
+ *   decodeJsonValue,
+ * } from "@evolu/common";
+ *
+ * const buffer = createBuffer([
+ *   0x81, 0xa4, 0x6e, 0x61, 0x6d, 0x65, 0xa3, 0x41, 0x64, 0x61,
+ * ]);
+ *
+ * assertEqual(decodeJsonValue(buffer), { name: "Ada" });
+ * assertEqual(buffer.unwrap(), new Uint8Array());
+ * ```
+ */
+export const decodeJsonValue = (buffer) => {
+    const source = buffer.unwrap();
+    jsonDecoderSource = source;
+    jsonDecoderView = new globalThis.DataView(source.buffer, source.byteOffset, source.byteLength);
+    jsonDecoderPosition = 0;
+    try {
+        const value = decodeJsonValueFromSource();
+        buffer.shiftN(jsonDecoderPosition);
+        return value;
+    }
+    catch (error) {
+        if (error instanceof BufferError)
+            throw error;
+        throw new BufferError("Invalid MessagePack data");
+    }
+    finally {
+        jsonDecoderSource = emptyJsonDecoderSource;
+        jsonDecoderView = emptyJsonDecoderView;
+        jsonDecoderPosition = 0;
+        jsonDecoderDepth = 0;
+    }
+};
+const encodeJsonValueToTarget = (value) => {
+    if (value === null) {
+        writeJsonEncoderByte(0xc0);
+        return;
+    }
+    // oxlint-disable-next-line typescript/switch-exhaustiveness-check -- JsonValue excludes the additional runtime types reported by tsgolint.
+    switch (typeof value) {
+        case "string":
+            encodeJsonStringToTarget(value);
+            return;
+        case "number": {
+            if (globalThis.Object.is(value, -0)) {
+                ensureJsonEncoderCapacity(9);
+                jsonEncoderTarget[jsonEncoderPosition++] = 0xcb;
+                jsonEncoderTargetView.setFloat64(jsonEncoderPosition, value);
+                jsonEncoderPosition += 8;
+                return;
+            }
+            if (value >>> 0 === value) {
+                if (value < 0x80) {
+                    writeJsonEncoderByte(value);
+                }
+                else if (value < 0x100) {
+                    ensureJsonEncoderCapacity(2);
+                    jsonEncoderTarget[jsonEncoderPosition++] = 0xcc;
+                    jsonEncoderTarget[jsonEncoderPosition++] = value;
+                }
+                else if (value < 0x10000) {
+                    ensureJsonEncoderCapacity(3);
+                    jsonEncoderTarget[jsonEncoderPosition++] = 0xcd;
+                    jsonEncoderTargetView.setUint16(jsonEncoderPosition, value);
+                    jsonEncoderPosition += 2;
+                }
+                else {
+                    ensureJsonEncoderCapacity(5);
+                    jsonEncoderTarget[jsonEncoderPosition++] = 0xce;
+                    jsonEncoderTargetView.setUint32(jsonEncoderPosition, value);
+                    jsonEncoderPosition += 4;
+                }
+                return;
+            }
+            if (globalThis.Number.isInteger(value) &&
+                value >= -0x80000000 &&
+                value < 0) {
+                if (value >= -0x20) {
+                    writeJsonEncoderByte(0x100 + value);
+                }
+                else if (value >= -0x80) {
+                    ensureJsonEncoderCapacity(2);
+                    jsonEncoderTarget[jsonEncoderPosition++] = 0xd0;
+                    jsonEncoderTargetView.setInt8(jsonEncoderPosition++, value);
+                }
+                else if (value >= -0x8000) {
+                    ensureJsonEncoderCapacity(3);
+                    jsonEncoderTarget[jsonEncoderPosition++] = 0xd1;
+                    jsonEncoderTargetView.setInt16(jsonEncoderPosition, value);
+                    jsonEncoderPosition += 2;
+                }
+                else {
+                    ensureJsonEncoderCapacity(5);
+                    jsonEncoderTarget[jsonEncoderPosition++] = 0xd2;
+                    jsonEncoderTargetView.setInt32(jsonEncoderPosition, value);
+                    jsonEncoderPosition += 4;
+                }
+                return;
+            }
+            ensureJsonEncoderCapacity(9);
+            jsonEncoderTarget[jsonEncoderPosition++] = 0xcb;
+            jsonEncoderTargetView.setFloat64(jsonEncoderPosition, value);
+            jsonEncoderPosition += 8;
+            return;
+        }
+        case "boolean":
+            writeJsonEncoderByte(value ? 0xc3 : 0xc2);
+            return;
+        case "object": {
+            if (jsonEncoderDepth >= maxJsonNestingDepth) {
+                throw new BufferError(`JSON nesting exceeds the maximum depth of ${maxJsonNestingDepth}.`);
+            }
+            jsonEncoderDepth++;
+            if (globalThis.Array.isArray(value)) {
+                const array = value;
+                const length = array.length;
+                writeJsonCollectionHeader(length, 0x90, 0xdc, 0xdd);
+                for (const item of array)
+                    encodeJsonValueToTarget(item);
+                jsonEncoderDepth--;
+                return;
+            }
+            const object = value;
+            const keys = globalThis.Object.keys(object);
+            writeJsonCollectionHeader(keys.length, 0x80, 0xde, 0xdf);
+            for (const key of keys) {
+                encodeJsonStringToTarget(key);
+                encodeJsonValueToTarget(object[key]);
+            }
+            jsonEncoderDepth--;
+        }
+    }
+};
+const encodeJsonStringToTarget = (value) => {
+    const valueLength = value.length;
+    const headerLength = valueLength < 0x20
+        ? 1
+        : valueLength < 0x100
+            ? 2
+            : valueLength < 0x10000
+                ? 3
+                : 5;
+    ensureJsonEncoderCapacity(5 + valueLength * 3);
+    const headerPosition = jsonEncoderPosition;
+    jsonEncoderPosition += headerLength;
+    for (let index = 0; index < valueLength; index++) {
+        let first = value.charCodeAt(index);
+        if (first < 0x80) {
+            jsonEncoderTarget[jsonEncoderPosition++] = first;
+        }
+        else if (first < 0x800) {
+            jsonEncoderTarget[jsonEncoderPosition++] = (first >> 6) | 0xc0;
+            jsonEncoderTarget[jsonEncoderPosition++] = (first & 0x3f) | 0x80;
+        }
+        else if ((first & 0xfc00) === 0xd800 &&
+            (value.charCodeAt(index + 1) & 0xfc00) === 0xdc00) {
+            const second = value.charCodeAt(++index);
+            first = 0x10000 + ((first & 0x03ff) << 10) + (second & 0x03ff);
+            jsonEncoderTarget[jsonEncoderPosition++] = (first >> 18) | 0xf0;
+            jsonEncoderTarget[jsonEncoderPosition++] = ((first >> 12) & 0x3f) | 0x80;
+            jsonEncoderTarget[jsonEncoderPosition++] = ((first >> 6) & 0x3f) | 0x80;
+            jsonEncoderTarget[jsonEncoderPosition++] = (first & 0x3f) | 0x80;
+        }
+        else {
+            jsonEncoderTarget[jsonEncoderPosition++] = (first >> 12) | 0xe0;
+            jsonEncoderTarget[jsonEncoderPosition++] = ((first >> 6) & 0x3f) | 0x80;
+            jsonEncoderTarget[jsonEncoderPosition++] = (first & 0x3f) | 0x80;
+        }
+    }
+    const byteLength = jsonEncoderPosition - headerPosition - headerLength;
+    assertMessagePackLength(byteLength, "String byte length");
+    if (byteLength < 0x20) {
+        jsonEncoderTarget[headerPosition] = 0xa0 | byteLength;
+        return;
+    }
+    if (byteLength < 0x100) {
+        if (headerLength === 1) {
+            jsonEncoderTarget.copyWithin(headerPosition + 2, headerPosition + 1, jsonEncoderPosition);
+            jsonEncoderPosition++;
+        }
+        jsonEncoderTarget[headerPosition] = 0xd9;
+        jsonEncoderTarget[headerPosition + 1] = byteLength;
+        return;
+    }
+    if (byteLength < 0x10000) {
+        if (headerLength < 3) {
+            const additionalHeaderLength = 3 - headerLength;
+            jsonEncoderTarget.copyWithin(headerPosition + 3, headerPosition + headerLength, jsonEncoderPosition);
+            jsonEncoderPosition += additionalHeaderLength;
+        }
+        jsonEncoderTarget[headerPosition] = 0xda;
+        jsonEncoderTargetView.setUint16(headerPosition + 1, byteLength);
+        return;
+    }
+    if (headerLength < 5) {
+        const additionalHeaderLength = 5 - headerLength;
+        jsonEncoderTarget.copyWithin(headerPosition + 5, headerPosition + headerLength, jsonEncoderPosition);
+        jsonEncoderPosition += additionalHeaderLength;
+    }
+    jsonEncoderTarget[headerPosition] = 0xdb;
+    jsonEncoderTargetView.setUint32(headerPosition + 1, byteLength);
+};
+const writeJsonCollectionHeader = (length, fixedMarker, marker16, marker32) => {
+    assertMessagePackLength(length, "Collection length");
+    if (length < 0x10) {
+        writeJsonEncoderByte(fixedMarker | length);
+    }
+    else if (length < 0x10000) {
+        ensureJsonEncoderCapacity(3);
+        jsonEncoderTarget[jsonEncoderPosition++] = marker16;
+        jsonEncoderTargetView.setUint16(jsonEncoderPosition, length);
+        jsonEncoderPosition += 2;
+    }
+    else {
+        ensureJsonEncoderCapacity(5);
+        jsonEncoderTarget[jsonEncoderPosition++] = marker32;
+        jsonEncoderTargetView.setUint32(jsonEncoderPosition, length);
+        jsonEncoderPosition += 4;
+    }
+};
+const writeJsonEncoderByte = (value) => {
+    ensureJsonEncoderCapacity(1);
+    jsonEncoderTarget[jsonEncoderPosition++] = value;
+};
+const ensureJsonEncoderCapacity = (additionalLength) => {
+    const requiredLength = jsonEncoderPosition + additionalLength;
+    assertNonNegativeInt(requiredLength, "Encoded JSON value length");
+    if (requiredLength <= jsonEncoderTarget.length)
+        return;
+    const newCapacity = globalThis.Math.max(jsonEncoderTarget.length * 2, requiredLength);
+    assertNonNegativeInt(newCapacity, "JSON encoder capacity");
+    const oldTarget = jsonEncoderTarget;
+    jsonEncoderTarget = new globalThis.Uint8Array(newCapacity);
+    jsonEncoderTarget.set(oldTarget.subarray(0, jsonEncoderPosition));
+    jsonEncoderTargetView = new globalThis.DataView(jsonEncoderTarget.buffer);
+};
+const assertMessagePackLength = (length, name) => {
+    if (length > 0xffffffff) {
+        throw new BufferError(`${name} exceeds the MessagePack uint32 limit.`);
+    }
+};
+const decodeJsonValueFromSource = () => {
+    const marker = readJsonDecoderByte();
+    if (marker <= 0x7f)
+        return marker;
+    if (marker <= 0x8f)
+        return decodeJsonMap(marker - 0x80);
+    if (marker <= 0x9f)
+        return decodeJsonArray(marker - 0x90);
+    if (marker <= 0xbf)
+        return decodeJsonString(marker - 0xa0);
+    if (marker >= 0xe0)
+        return (marker - 0x100);
+    switch (marker) {
+        case 0xc0:
+            return null;
+        case 0xc2:
+            return false;
+        case 0xc3:
+            return true;
+        case 0xca:
+            return decodeJsonFloat(4);
+        case 0xcb:
+            return decodeJsonFloat(8);
+        case 0xcc:
+            return readJsonDecoderByte();
+        case 0xcd:
+            return readJsonUint16();
+        case 0xce:
+            return readJsonUint32();
+        case 0xd0: {
+            assertJsonDecoderHasRemainingBytes(1);
+            return jsonDecoderView.getInt8(jsonDecoderPosition++);
+        }
+        case 0xd1: {
+            assertJsonDecoderHasRemainingBytes(2);
+            const value = jsonDecoderView.getInt16(jsonDecoderPosition);
+            jsonDecoderPosition += 2;
+            return value;
+        }
+        case 0xd2: {
+            assertJsonDecoderHasRemainingBytes(4);
+            const value = jsonDecoderView.getInt32(jsonDecoderPosition);
+            jsonDecoderPosition += 4;
+            return value;
+        }
+        case 0xd9:
+            return decodeJsonString(readJsonDecoderByte());
+        case 0xda:
+            return decodeJsonString(readJsonUint16());
+        case 0xdb:
+            return decodeJsonString(readJsonUint32());
+        case 0xdc:
+            return decodeJsonArray(readJsonUint16());
+        case 0xdd:
+            return decodeJsonArray(readJsonUint32());
+        case 0xde:
+            return decodeJsonMap(readJsonUint16());
+        case 0xdf:
+            return decodeJsonMap(readJsonUint32());
+        default:
+            throw new BufferError(`Unsupported MessagePack marker 0x${marker.toString(16).padStart(2, "0")}.`);
+    }
+};
+const decodeJsonFloat = (byteLength) => {
+    assertJsonDecoderHasRemainingBytes(byteLength);
+    const value = byteLength === 4
+        ? jsonDecoderView.getFloat32(jsonDecoderPosition)
+        : jsonDecoderView.getFloat64(jsonDecoderPosition);
+    jsonDecoderPosition += byteLength;
+    if (!globalThis.Number.isFinite(value)) {
+        throw new BufferError("A decoded JSON number must be finite.");
+    }
+    return value;
+};
+const decodeJsonString = (byteLength) => {
+    assertJsonDecoderHasRemainingBytes(byteLength);
+    shortAscii: if (byteLength < 16) {
+        if (byteLength === 0)
+            return "";
+        const start = jsonDecoderPosition;
+        const first = jsonDecoderSource[jsonDecoderPosition++];
+        if ((first & 0x80) !== 0) {
+            jsonDecoderPosition = start;
+            break shortAscii;
+        }
+        if (byteLength === 1)
+            return jsonStringFromCharCode(first);
+        const second = jsonDecoderSource[jsonDecoderPosition++];
+        if ((second & 0x80) !== 0) {
+            jsonDecoderPosition = start;
+            break shortAscii;
+        }
+        if (byteLength === 2)
+            return jsonStringFromCharCode(first, second);
+        const third = jsonDecoderSource[jsonDecoderPosition++];
+        if ((third & 0x80) !== 0) {
+            jsonDecoderPosition = start;
+            break shortAscii;
+        }
+        if (byteLength === 3)
+            return jsonStringFromCharCode(first, second, third);
+        const fourth = jsonDecoderSource[jsonDecoderPosition++];
+        if ((fourth & 0x80) !== 0) {
+            jsonDecoderPosition = start;
+            break shortAscii;
+        }
+        if (byteLength === 4) {
+            return jsonStringFromCharCode(first, second, third, fourth);
+        }
+        const fifth = jsonDecoderSource[jsonDecoderPosition++];
+        if ((fifth & 0x80) !== 0) {
+            jsonDecoderPosition = start;
+            break shortAscii;
+        }
+        if (byteLength === 5) {
+            return jsonStringFromCharCode(first, second, third, fourth, fifth);
+        }
+        const sixth = jsonDecoderSource[jsonDecoderPosition++];
+        if ((sixth & 0x80) !== 0) {
+            jsonDecoderPosition = start;
+            break shortAscii;
+        }
+        if (byteLength === 6) {
+            return jsonStringFromCharCode(first, second, third, fourth, fifth, sixth);
+        }
+        const seventh = jsonDecoderSource[jsonDecoderPosition++];
+        if ((seventh & 0x80) !== 0) {
+            jsonDecoderPosition = start;
+            break shortAscii;
+        }
+        if (byteLength === 7) {
+            return jsonStringFromCharCode(first, second, third, fourth, fifth, sixth, seventh);
+        }
+        const eighth = jsonDecoderSource[jsonDecoderPosition++];
+        if ((eighth & 0x80) !== 0) {
+            jsonDecoderPosition = start;
+            break shortAscii;
+        }
+        if (byteLength === 8) {
+            return jsonStringFromCharCode(first, second, third, fourth, fifth, sixth, seventh, eighth);
+        }
+        const ninth = jsonDecoderSource[jsonDecoderPosition++];
+        if ((ninth & 0x80) !== 0) {
+            jsonDecoderPosition = start;
+            break shortAscii;
+        }
+        if (byteLength === 9) {
+            return jsonStringFromCharCode(first, second, third, fourth, fifth, sixth, seventh, eighth, ninth);
+        }
+        const tenth = jsonDecoderSource[jsonDecoderPosition++];
+        if ((tenth & 0x80) !== 0) {
+            jsonDecoderPosition = start;
+            break shortAscii;
+        }
+        if (byteLength === 10) {
+            return jsonStringFromCharCode(first, second, third, fourth, fifth, sixth, seventh, eighth, ninth, tenth);
+        }
+        const eleventh = jsonDecoderSource[jsonDecoderPosition++];
+        if ((eleventh & 0x80) !== 0) {
+            jsonDecoderPosition = start;
+            break shortAscii;
+        }
+        if (byteLength === 11) {
+            return jsonStringFromCharCode(first, second, third, fourth, fifth, sixth, seventh, eighth, ninth, tenth, eleventh);
+        }
+        const twelfth = jsonDecoderSource[jsonDecoderPosition++];
+        if ((twelfth & 0x80) !== 0) {
+            jsonDecoderPosition = start;
+            break shortAscii;
+        }
+        if (byteLength === 12) {
+            return jsonStringFromCharCode(first, second, third, fourth, fifth, sixth, seventh, eighth, ninth, tenth, eleventh, twelfth);
+        }
+        const thirteenth = jsonDecoderSource[jsonDecoderPosition++];
+        if ((thirteenth & 0x80) !== 0) {
+            jsonDecoderPosition = start;
+            break shortAscii;
+        }
+        if (byteLength === 13) {
+            return jsonStringFromCharCode(first, second, third, fourth, fifth, sixth, seventh, eighth, ninth, tenth, eleventh, twelfth, thirteenth);
+        }
+        const fourteenth = jsonDecoderSource[jsonDecoderPosition++];
+        if ((fourteenth & 0x80) !== 0) {
+            jsonDecoderPosition = start;
+            break shortAscii;
+        }
+        if (byteLength === 14) {
+            return jsonStringFromCharCode(first, second, third, fourth, fifth, sixth, seventh, eighth, ninth, tenth, eleventh, twelfth, thirteenth, fourteenth);
+        }
+        const fifteenth = jsonDecoderSource[jsonDecoderPosition++];
+        if ((fifteenth & 0x80) !== 0) {
+            jsonDecoderPosition = start;
+            break shortAscii;
+        }
+        return jsonStringFromCharCode(first, second, third, fourth, fifth, sixth, seventh, eighth, ninth, tenth, eleventh, twelfth, thirteenth, fourteenth, fifteenth);
+    }
+    const end = jsonDecoderPosition + byteLength;
+    const units = [];
+    let result = "";
+    while (jsonDecoderPosition < end) {
+        const first = jsonDecoderSource[jsonDecoderPosition++];
+        if (first < 0x80) {
+            units.push(first);
+        }
+        else if (first >= 0xc2 && first <= 0xdf) {
+            assertJsonStringHasRemainingBytes(end, 1);
+            const second = readJsonContinuationByte();
+            units.push(((first & 0x1f) << 6) | second);
+        }
+        else if (first >= 0xe0 && first <= 0xef) {
+            assertJsonStringHasRemainingBytes(end, 2);
+            const secondByte = jsonDecoderSource[jsonDecoderPosition];
+            if (first === 0xe0 && secondByte < 0xa0) {
+                throw new BufferError("Invalid UTF-8 string encoding.");
+            }
+            const second = readJsonContinuationByte();
+            const third = readJsonContinuationByte();
+            units.push(((first & 0x0f) << 12) | (second << 6) | third);
+        }
+        else if (first >= 0xf0 && first <= 0xf4) {
+            assertJsonStringHasRemainingBytes(end, 3);
+            const secondByte = jsonDecoderSource[jsonDecoderPosition];
+            if ((first === 0xf0 && secondByte < 0x90) ||
+                (first === 0xf4 && secondByte > 0x8f)) {
+                throw new BufferError("Invalid UTF-8 string encoding.");
+            }
+            const second = readJsonContinuationByte();
+            const third = readJsonContinuationByte();
+            const fourth = readJsonContinuationByte();
+            const codePoint = ((first & 0x07) << 18) | (second << 12) | (third << 6) | fourth;
+            const pair = codePoint - 0x10000;
+            units.push(0xd800 | (pair >> 10), 0xdc00 | (pair & 0x3ff));
+        }
+        else {
+            throw new BufferError("Invalid UTF-8 string encoding.");
+        }
+        if (units.length >= 0x1000) {
+            result += jsonStringFromCharCode(...units);
+            units.length = 0;
+        }
+    }
+    if (units.length > 0) {
+        result += jsonStringFromCharCode(...units);
+    }
+    return result;
+};
+const decodeJsonArray = (length) => {
+    if (jsonDecoderDepth >= maxJsonNestingDepth) {
+        throw new BufferError(`JSON nesting exceeds the maximum depth of ${maxJsonNestingDepth}.`);
+    }
+    if (length > jsonDecoderSource.length - jsonDecoderPosition) {
+        throw new BufferError("Buffer parse ended prematurely");
+    }
+    // oxlint-disable-next-line unicorn/no-new-array -- Preallocation is intentional in this decoding hot path.
+    const value = new Array(length);
+    jsonDecoderDepth++;
+    for (let index = 0; index < length; index++) {
+        value[index] = decodeJsonValueFromSource();
+    }
+    jsonDecoderDepth--;
+    return value;
+};
+const decodeJsonMap = (length) => {
+    if (jsonDecoderDepth >= maxJsonNestingDepth) {
+        throw new BufferError(`JSON nesting exceeds the maximum depth of ${maxJsonNestingDepth}.`);
+    }
+    if (length > (jsonDecoderSource.length - jsonDecoderPosition) / 2) {
+        throw new BufferError("Buffer parse ended prematurely");
+    }
+    const value = {};
+    jsonDecoderDepth++;
+    for (let index = 0; index < length; index++) {
+        const marker = readJsonDecoderByte();
+        let key;
+        if (marker >= 0xa0 && marker <= 0xbf) {
+            key = decodeCachedJsonKey(marker - 0xa0);
+        }
+        else if (marker === 0xd9) {
+            key = decodeCachedJsonKey(readJsonDecoderByte());
+        }
+        else if (marker === 0xda) {
+            key = decodeCachedJsonKey(readJsonUint16());
+        }
+        else if (marker === 0xdb) {
+            key = decodeCachedJsonKey(readJsonUint32());
+        }
+        else {
+            jsonDecoderPosition--;
+            decodeJsonValueFromSource();
+            throw new BufferError("A decoded JSON object key must be a string.");
+        }
+        const entryValue = decodeJsonValueFromSource();
+        if (key === "__proto__") {
+            globalThis.Object.defineProperty(value, key, {
+                value: entryValue,
+                configurable: true,
+                enumerable: true,
+                writable: true,
+            });
+        }
+        else {
+            value[key] = entryValue;
+        }
+    }
+    jsonDecoderDepth--;
+    return value;
+};
+const decodeCachedJsonKey = (byteLength) => {
+    if (byteLength > maxCachedJsonKeyByteLength) {
+        return decodeJsonString(byteLength);
+    }
+    assertJsonDecoderHasRemainingBytes(byteLength);
+    const start = jsonDecoderPosition;
+    const end = start + byteLength;
+    const firstBytes = byteLength > 1
+        ? jsonDecoderView.getUint16(start)
+        : byteLength === 1
+            ? jsonDecoderSource[start]
+            : 0;
+    const cacheIndex = ((byteLength << 5) ^ firstBytes) & (jsonKeyCacheSize - 1);
+    const entry = jsonKeyCache[cacheIndex];
+    if (entry?.bytes.length === byteLength) {
+        let index = 0;
+        while (index < byteLength &&
+            entry.bytes[index] === jsonDecoderSource[start + index]) {
+            index++;
+        }
+        if (index === byteLength) {
+            jsonDecoderPosition = end;
+            return entry.value;
+        }
+    }
+    const value = decodeJsonString(byteLength);
+    jsonKeyCache[cacheIndex] = {
+        bytes: jsonDecoderSource.slice(start, end),
+        value,
+    };
+    return value;
+};
+const readJsonContinuationByte = () => {
+    const byte = jsonDecoderSource[jsonDecoderPosition++];
+    if ((byte & 0xc0) !== 0x80) {
+        throw new BufferError("Invalid UTF-8 string encoding.");
+    }
+    return byte & 0x3f;
+};
+const assertJsonStringHasRemainingBytes = (end, requiredBytes) => {
+    if (end - jsonDecoderPosition < requiredBytes) {
+        throw new BufferError("Invalid UTF-8 string encoding.");
+    }
+};
+const readJsonDecoderByte = () => {
+    assertJsonDecoderHasRemainingBytes(1);
+    return jsonDecoderSource[jsonDecoderPosition++];
+};
+const readJsonUint16 = () => {
+    assertJsonDecoderHasRemainingBytes(2);
+    const value = jsonDecoderView.getUint16(jsonDecoderPosition);
+    jsonDecoderPosition += 2;
+    return value;
+};
+const readJsonUint32 = () => {
+    assertJsonDecoderHasRemainingBytes(4);
+    const value = jsonDecoderView.getUint32(jsonDecoderPosition);
+    jsonDecoderPosition += 4;
+    return value;
+};
+const assertJsonDecoderHasRemainingBytes = (requiredBytes) => {
+    if (jsonDecoderSource.length - jsonDecoderPosition < requiredBytes) {
+        throw new BufferError("Buffer parse ended prematurely");
+    }
+};
+const assertNonNegativeInt = (value, name) => {
+    if (!globalThis.Number.isSafeInteger(value) || value < 0) {
+        throw new BufferError(`${name} must be a non-negative safe integer.`);
+    }
+};
+const assertBufferHasRemainingBytes = (remainingBytes, requiredBytes) => {
+    if (remainingBytes < requiredBytes) {
+        throw new BufferError("Buffer parse ended prematurely");
+    }
+};