Varint

1import { Sink, reserve } from "./core.js";
2
3/**
4 * Write a LEB128 unsigned varint — the encode mirror of `readUVarint` (used for
5 * string/array/map lengths).
6 *
7 * Takes a JS `number`, so it is NOT bigint-friendly: the value MUST be a
8 * non-negative integer no larger than `Number.MAX_SAFE_INTEGER` (2^53 - 1). That
9 * precondition is NOT checked here — at this level the data is expected to be
10 * correct (a length the encoder itself produced), and an out-of-range value is a
11 * programming error the server will reject. If you genuinely need lengths beyond
12 * 2^53, write a bigint version with a bigint accumulator instead of widening this
13 * one.
14 *
15 * UNROLLED, mirroring `readUVarint`: branch on magnitude so the exact byte count
16 * is known up front for a single {@link reserve}, with no length-counting loop.
17 * Each byte carries 7 payload bits low-first, with the continuation bit (`+ 0x80`)
18 * set while more bits remain. `/` and `%` (never `>>>`/`&`): JS bitwise operators
19 * are 32-bit and would corrupt values past bit 31. The overwhelmingly common
20 * 1–2 byte case costs one or two compares.
21 */
22export function writeUVarint(sink: Sink, value: number): void {
23  if (value < 0x80) {
24    sink.buf[reserve(sink, 1)] = value;
25    return;
26  }
27  if (value < 0x4000) {
28    const o = reserve(sink, 2);
29    sink.buf[o] = (value % 128) + 0x80;
30    sink.buf[o + 1] = Math.floor(value / 128);
31    return;
32  }
33  if (value < 0x200000) {
34    const o = reserve(sink, 3);
35    sink.buf[o] = (value % 128) + 0x80;
36    sink.buf[o + 1] = (Math.floor(value / 128) % 128) + 0x80;
37    sink.buf[o + 2] = Math.floor(value / 16384);
38    return;
39  }
40  if (value < 0x10000000) {
41    const o = reserve(sink, 4);
42    sink.buf[o] = (value % 128) + 0x80;
43    sink.buf[o + 1] = (Math.floor(value / 128) % 128) + 0x80;
44    sink.buf[o + 2] = (Math.floor(value / 16384) % 128) + 0x80;
45    sink.buf[o + 3] = Math.floor(value / 2097152);
46    return;
47  }
48  // >= 2^28 — rare for RowBinary lengths. Fall back to a short loop writing into
49  // a single span sized by a leading magnitude count (still one reserve()).
50  let size = 5;
51  for (
52    let v = Math.floor(value / 268435456);
53    v >= 0x80;
54    v = Math.floor(v / 128)
55  )
56    size++;
57  const o = reserve(sink, size);
58  let v = value;
59  for (let i = 0; i < size - 1; i++) {
60    sink.buf[o + i] = (v % 128) + 0x80;
61    v = Math.floor(v / 128);
62  }
63  sink.buf[o + size - 1] = v;
64}