@rust-js/runtime 0.0.1

package/index.js

@@ -0,0 +1,3354 @@
+// @rust-js/runtime 0.0.1: the helpers the JS rust-js writes imports (ADR 0103).
+// Generated by `rust-js --runtime-module`. Do not edit.
+export function $traitImpl(cache, keys, make) {
+  // Each key is a dictionary or a drop, held weakly: a drop made for one call
+  // goes when it does. No drop, `undefined`, is keyed by this function. A
+  // const parameter's value is a number or the like, which only a Map holds.
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i] ?? $traitImpl;
+    const next = keys[i + 1] ?? $traitImpl;
+    const weak = typeof next === "object" || typeof next === "function";
+    if (!cache.has(key)) cache.set(key, weak ? new WeakMap() : new Map());
+    cache = cache.get(key);
+  }
+  const key = keys[keys.length - 1] ?? $traitImpl;
+  if (!cache.has(key)) cache.set(key, make());
+  return cache.get(key);
+}
+
+export function $index(items, index) {
+  if (index < 0 || index >= items.length) throw new Error(`index out of bounds: the len is ${items.length} but the index is ${index}`);
+  return items[index];
+}
+
+export function $at(items, index) {
+  if (index < 0 || index >= items.length) throw new Error(`index out of bounds: the len is ${items.length} but the index is ${index}`);
+  return index;
+}
+
+// Shortest round-trip decimal, using exact rational arithmetic.
+// Rust Display uses decimal notation, including for very small/large values.
+// Not JS's `String(x)`, though its digits are also the shortest: when two are
+// equally close, JS takes the even one (1888570120608320.2), and Rust the
+// larger (1888570120608320.3).
+export function $displayF64(value) {
+  if (Number.isNaN(value)) return 'NaN';
+  if (value === Infinity) return 'inf';
+  if (value === -Infinity) return '-inf';
+  const sign = value < 0 || Object.is(value, -0) ? '-' : '';
+  const x = Math.abs(value);
+  if (x === 0) return sign + '0';
+
+  const bitsView = new DataView(new ArrayBuffer(8));
+  bitsView.setFloat64(0, x);
+  const bits = bitsView.getBigUint64(0);
+  const exponentBits = Number((bits >> 52n) & 2047n);
+  const fraction = bits & ((1n << 52n) - 1n);
+  const significand = exponentBits === 0 ? fraction : fraction + (1n << 52n);
+  const binaryExponent = exponentBits === 0 ? -1074 : exponentBits - 1023 - 52;
+  const numerator = binaryExponent >= 0 ? significand << BigInt(binaryExponent) : significand;
+  const denominator = binaryExponent < 0 ? 1n << BigInt(-binaryExponent) : 1n;
+
+  // The floating-point logarithm is only an estimate; correct it exactly.
+  let exponent = Math.floor(Math.log10(x));
+  const atLeastPowerOfTen = e => e >= 0
+    ? numerator >= denominator * 10n ** BigInt(e)
+    : numerator * 10n ** BigInt(-e) >= denominator;
+  while (!atLeastPowerOfTen(exponent)) exponent--;
+  while (atLeastPowerOfTen(exponent + 1)) exponent++;
+
+  for (let precision = 1; precision <= 17; precision++) {
+    const power = exponent - precision + 1;
+    const n = power < 0 ? numerator * 10n ** BigInt(-power) : numerator;
+    const d = power > 0 ? denominator * 10n ** BigInt(power) : denominator;
+    const floor = n / d;
+    const rounded = floor + (2n * (n % d) >= d ? 1n : 0n);
+    // The rounding interval can be asymmetric at a binary power boundary.
+    let best;
+    let bestDistance;
+    for (const candidate of [rounded, rounded - 1n, rounded + 1n]) {
+      if (candidate > 0n && Number(`${candidate}e${power}`) === x) {
+        const delta = candidate * d - n;
+        const distance = delta < 0n ? -delta : delta;
+        if (best === undefined || distance < bestDistance || (distance === bestDistance && candidate > best)) {
+          best = candidate;
+          bestDistance = distance;
+        }
+      }
+    }
+    if (best !== undefined) {
+      let digits = best.toString();
+      let decimalPower = power;
+      while (digits.endsWith('0')) {
+        digits = digits.slice(0, -1);
+        decimalPower++;
+      }
+      const point = digits.length + decimalPower;
+      const body = point <= 0 ? '0.' + '0'.repeat(-point) + digits
+        : point >= digits.length ? digits + '0'.repeat(point - digits.length)
+        : digits.slice(0, point) + '.' + digits.slice(point);
+      return sign + body;
+    }
+  }
+  throw new Error('No f64 round-trip decimal found');
+}
+
+export function $f64Max(a, b) {
+  return Number.isNaN(a) ? b : Number.isNaN(b) ? a : Math.max(a, b);
+}
+
+export function $f64Min(a, b) {
+  return Number.isNaN(a) ? b : Number.isNaN(b) ? a : Math.min(a, b);
+}
+
+export function $div(a, b, min) {
+  if (b === 0) {
+    throw new Error("attempt to divide by zero");
+  }
+  if (a === min && b === -1) {
+    throw new Error("attempt to divide with overflow");
+  }
+  return a / b;
+}
+
+export function $rem(a, b, min) {
+  if (b === 0) {
+    throw new Error("attempt to calculate the remainder with a divisor of zero");
+  }
+  if (a === min && b === -1) {
+    throw new Error("attempt to calculate the remainder with overflow");
+  }
+  return a % b;
+}
+
+export function $retain(v, keep) {
+  let n = 0;
+  for (const x of v) {
+    if (keep(x)) {
+      v[n++] = x;
+    }
+  }
+  v.length = n;
+}
+
+export function $debug(v) {
+  if (typeof v === "string") {
+    return JSON.stringify(v);
+  }
+  if (Array.isArray(v)) {
+    return "[" + v.map($debug).join(", ") + "]";
+  }
+  if (v === undefined) {
+    return "()";
+  }
+  // A `HashMap` and a `HashSet` (ADR 0059), in braces as Rust shows them.
+  if (v instanceof Map) {
+    return "{" + [...v].map(([k, x]) => $debug(k) + ": " + $debug(x)).join(", ") + "}";
+  }
+  if (v instanceof Set) {
+    return "{" + [...v].map($debug).join(", ") + "}";
+  }
+  if (typeof v === "object" && v !== null) {
+    return "{ " + Object.entries(v).map(([k, x]) => k + ": " + $debug(x)).join(", ") + " }";
+  }
+  return String(v);
+}
+
+export function $eq(a, b) {
+  if (a === b || (a == null && b == null)) {
+    return true;
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return false;
+  }
+  if (Array.isArray(a)) {
+    return Array.isArray(b) && a.length === b.length && a.every((x, i) => $eq(x, b[i]));
+  }
+  const keys = Object.keys(a);
+  return keys.length === Object.keys(b).length && keys.every((k) => $eq(a[k], b[k]));
+}
+
+// `left` and `right` are their `{:?}` strings already (ADR 0060).
+export function $assertFailed(kind, left, right, message) {
+  const op = kind === "Eq" ? "==" : kind === "Ne" ? "!=" : "matches";
+  const why = message === undefined ? "" : ": " + message;
+  throw new Error("assertion `left " + op + " right` failed" + why + "\n  left: " + left + "\n right: " + right);
+}
+
+export function $unwrap(value, message = "called `Option::unwrap()` on a `None` value") {
+  if (value == null) {
+    throw new Error(message);
+  }
+  return value;
+}
+
+// `Some(x)` of a generic `T` (ADR 0051): `x`, unless it looks like `None`,
+// as `undefined`, `null` or such a box does. Then it's a box one deeper.
+export function $some(x) {
+  if (x == null) return { $someNone: 0 };
+  if (typeof x === "object" && "$someNone" in x) return { $someNone: x.$someNone + 1 };
+  return x;
+}
+
+// What's in a `$some`: the box one level shallower.
+export function $someValue(x) {
+  if (x != null && typeof x === "object" && "$someNone" in x) {
+    return x.$someNone === 0 ? undefined : { $someNone: x.$someNone - 1 };
+  }
+  return x;
+}
+
+// `Some` of the item at `index`, or `None` when there's none there.
+export function $someAt(items, index) {
+  return index >= 0 && index < items.length ? $some(items[index]) : undefined;
+}
+
+// `Vec::pop` of a generic `T`: `None` for an empty one, else `Some` of the last.
+export function $pop(items) {
+  return items.length === 0 ? undefined : $some(items.pop());
+}
+
+// A Rust iterator of the crate's own as a JS one: its `next` returns the
+// item, or `None` at the end. JS's iterator helpers are lazy, like Rust's
+// adapters, so an endless one is fine until something wants all of it. A
+// generic `next` may box its `Some` (ADR 0051): `boxed` unboxes it.
+export function $iterator(iterator, next, boxed = false) {
+  return Iterator.from({
+    next() {
+      const item = next(iterator);
+      if (item == null) {
+        return { done: true, value: undefined };
+      }
+      return { done: false, value: boxed ? $someValue(item) : item };
+    }
+  });
+}
+
+export function $insert(map, key, value) {
+  const old = map.get(key);
+  map.set(key, value);
+  return old;
+}
+
+export function $add(set, item) {
+  const added = !set.has(item);
+  set.add(item);
+  return added;
+}
+
+export function $remove(map, key) {
+  const old = map.get(key);
+  map.delete(key);
+  return old;
+}
+
+export function $repeat(item, count, clone) {
+  const result = [];
+  if (count > 0) {
+    for (let i = 1; i < count; i++) result.push(clone(item));
+    result.push(item);
+  }
+  return result;
+}
+
+export function $orInsert(map, key, value) {
+  if (!map.has(key)) {
+    map.set(key, value);
+  }
+  return map.get(key);
+}
+
+export function $orInsertWith(map, key, make) {
+  if (!map.has(key)) {
+    map.set(key, make());
+  }
+  return map.get(key);
+}
+
+export function $sortedEntries(map, cmp) {
+  return Array.from(map).sort((a, b) => cmp(a[0], b[0]));
+}
+
+export function $toDigit(c, radix) {
+  const digit = parseInt(c, 36);
+  return digit < radix ? digit : undefined;
+}
+
+export function $lines(s) {
+  const lines = s.split("\n");
+  const last = lines.pop();
+  const ended = lines.map((line) => (line.endsWith("\r") ? line.slice(0, -1) : line));
+  if (last !== "") {
+    ended.push(last);
+  }
+  return ended;
+}
+
+export function $splitBy(s, matches) {
+  const pieces = [""];
+  for (const c of s) {
+    if (matches(c)) {
+      pieces.push("");
+    } else {
+      pieces[pieces.length - 1] += c;
+    }
+  }
+  return pieces;
+}
+
+export function $pow(base, exp) {
+  let result = 1;
+  while (exp > 0) {
+    if (exp & 1) {
+      result = Math.imul(result, base);
+    }
+    base = Math.imul(base, base);
+    exp >>>= 1;
+  }
+  return result;
+}
+
+export function $checkedPow(base, exp, lo, hi) {
+  const fits = (x) => x >= lo && x <= hi;
+  const result = (x) => (typeof hi === "bigint" ? x : Number(x));
+  if (exp === 0) return result(1n);
+  let b = BigInt(base);
+  let acc = 1n;
+  while (exp > 1) {
+    if (exp & 1) {
+      acc *= b;
+      if (!fits(acc)) return undefined;
+    }
+    exp >>>= 1;
+    b *= b;
+    if (!fits(b)) return undefined;
+  }
+  acc *= b;
+  return fits(acc) ? result(acc) : undefined;
+}
+
+export function $powi(x, n) {
+  const reciprocal = n < 0;
+  let result = 1;
+  while (true) {
+    if (n & 1) {
+      result *= x;
+    }
+    n = (n / 2) | 0;
+    if (n === 0) {
+      break;
+    }
+    x *= x;
+  }
+  return reciprocal ? 1 / result : result;
+}
+
+export function $round(x) {
+  return Math.sign(x) * Math.round(Math.abs(x));
+}
+
+export function $checked(value, lo, hi) {
+  return value >= lo && value <= hi ? value + 0 : undefined;
+}
+
+export function $checkedDiv(a, b, min) {
+  return b === 0 || (a === min && b === -1) ? undefined : Math.trunc(a / b) + 0;
+}
+
+export function $remEuclid(a, b, min) {
+  const r = $rem(a, b, min) + 0;
+  return r < 0 ? (b < 0 ? r - b : r + b) : r;
+}
+
+export function $divEuclid(a, b, min) {
+  const q = Math.trunc($div(a, b, min)) + 0;
+  return a % b < 0 ? (b > 0 ? q - 1 : q + 1) : q;
+}
+
+export function $trailingZeros(x, bits) {
+  return x === 0 ? bits : 31 - Math.clz32(x & -x);
+}
+
+export function $countOnes(x) {
+  let ones = 0;
+  x >>>= 0;
+  while (x !== 0) {
+    ones += x & 1;
+    x >>>= 1;
+  }
+  return ones;
+}
+
+export function $binarySearch(items, x) {
+  let size = items.length;
+  if (size === 0) {
+    return { TAG: "Err", _0: 0 };
+  }
+  let base = 0;
+  while (size > 1) {
+    const half = size >>> 1;
+    const mid = base + half;
+    if (!(items[mid] > x)) {
+      base = mid;
+    }
+    size -= half;
+  }
+  const found = items[base];
+  return found === x ? { TAG: "Ok", _0: base } : { TAG: "Err", _0: base + (found < x ? 1 : 0) };
+}
+
+export function $removeOpt(items, index) {
+  return index < items.length ? items.splice(index, 1)[0] : undefined;
+}
+
+export function $iter(items) {
+  return {
+    items,
+    at: 0,
+    next() {
+      return this.at < this.items.length ? { value: this.items[this.at++], done: false } : { value: undefined, done: true };
+    },
+    [Symbol.iterator]() {
+      return this;
+    },
+  };
+}
+
+export function $next(it) {
+  const step = it.next();
+  return step.done ? undefined : step.value;
+}
+
+export function $nextSome(it) {
+  const step = it.next();
+  return step.done ? undefined : $some(step.value);
+}
+
+export function $scan(items, init, f) {
+  const state = { value: init };
+  const out = [];
+  for (const item of items) {
+    const next = f(state, item);
+    if (next === undefined) {
+      break;
+    }
+    out.push(next);
+  }
+  return out;
+}
+
+export class $JsonError extends Error {
+  constructor(message, line = 0, column = 0) {
+    super(message);
+    this.line = line;
+    this.column = column;
+  }
+}
+export function $jsonError(message) {
+  return new $JsonError(message);
+}
+// A float as serde_json writes one: its shortest digits, fixed from 1e-5
+// to 1e15, else `1.5e+16`.
+export function $jsonNumber(x) {
+  if (!Number.isFinite(x)) return "null";
+  if (x === 0) return Object.is(x, -0) ? "-0.0" : "0.0";
+  const [mantissa, exponent] = x.toExponential().split("e");
+  const e = Number(exponent);
+  if (e < -5 || e > 15) return `${mantissa}e${e < 0 ? "-" : "+"}${Math.abs(e)}`;
+  const fixed = String(x);
+  return fixed.includes(".") ? fixed : `${fixed}.0`;
+}
+
+export function $bigDiv(a, b, min) {
+  if (b === 0n) {
+    throw new Error("attempt to divide by zero");
+  }
+  if (a === min && b === -1n) {
+    throw new Error("attempt to divide with overflow");
+  }
+  return a / b;
+}
+
+export function $bigRem(a, b, min) {
+  if (b === 0n) {
+    throw new Error("attempt to calculate the remainder with a divisor of zero");
+  }
+  if (a === min && b === -1n) {
+    throw new Error("attempt to calculate the remainder with overflow");
+  }
+  return a % b;
+}
+
+export function $f64ToInt(x, min, max) {
+  if (Number.isNaN(x)) return 0;
+  return Math.max(min, Math.min(max, Math.trunc(x))) + 0;
+}
+
+export function $f64ToBig(x, min, max) {
+  if (Number.isNaN(x)) return 0n;
+  if (x <= Number(min)) return min;
+  if (x >= Number(max)) return max;
+  return BigInt(Math.trunc(x));
+}
+
+export function $bigAbs(x) {
+  return x < 0n ? -x : x;
+}
+
+export function $bigPow(base, exp) {
+  let result = 1n;
+  base = BigInt.asUintN(64, base);
+  for (let e = exp; e > 0; e >>>= 1) {
+    if (e & 1) result = BigInt.asUintN(64, result * base);
+    base = BigInt.asUintN(64, base * base);
+  }
+  return result;
+}
+
+export function $bigChecked(value, lo, hi) {
+  return value >= lo && value <= hi ? value : undefined;
+}
+
+export function $bigCheckedDiv(a, b, min) {
+  return b === 0n || (a === min && b === -1n) ? undefined : a / b;
+}
+
+export function $bigClamp(value, lo, hi) {
+  return value < lo ? lo : value > hi ? hi : value;
+}
+
+export function $bigRemEuclid(a, b, min) {
+  const r = $bigRem(a, b, min);
+  return r < 0n ? (b < 0n ? r - b : r + b) : r;
+}
+
+export function $bigDivEuclid(a, b, min) {
+  const q = $bigDiv(a, b, min);
+  if (a % b < 0n) return b > 0n ? q - 1n : q + 1n;
+  return q;
+}
+
+export function $bigSignum(x) {
+  return x > 0n ? 1n : x < 0n ? -1n : 0n;
+}
+
+export function $bigCountOnes(x) {
+  return BigInt.asUintN(64, x).toString(2).replaceAll("0", "").length;
+}
+export function $bigLeadingZeros(x) {
+  const bits = BigInt.asUintN(64, x);
+  return bits === 0n ? 64 : 64 - bits.toString(2).length;
+}
+export function $bigTrailingZeros(x) {
+  const bits = BigInt.asUintN(64, x).toString(2);
+  return x === 0n ? 64 : bits.length - 1 - bits.lastIndexOf("1");
+}
+
+export function $bigAbsDiff(a, b) {
+  return a > b ? a - b : b - a;
+}
+
+export function $bigMax(a, b) {
+  return b >= a ? b : a;
+}
+export function $bigMin(a, b) {
+  return b < a ? b : a;
+}
+
+export function $parseBig(s, min, max) {
+  const error = (message) => ({ TAG: "Err", _0: message });
+  if (s === "") return error("cannot parse integer from empty string");
+  if (!(min < 0n ? /^[+-]?[0-9]+$/ : /^\+?[0-9]+$/).test(s)) return error("invalid digit found in string");
+  const n = BigInt(s);
+  if (n > max) return error("number too large to fit in target type");
+  if (n < min) return error("number too small to fit in target type");
+  return { TAG: "Ok", _0: n };
+}
+
+export function $bigRange(start, end) {
+  const items = [];
+  for (let i = start; i < end; i++) items.push(i);
+  return items;
+}
+
+export function $tryFromInt(x, lo, hi) {
+  if (x < lo) return { TAG: "Err", _0: "NegOverflow" };
+  if (x > hi) return { TAG: "Err", _0: "PosOverflow" };
+  return { TAG: "Ok", _0: typeof hi === "bigint" ? BigInt(x) : Number(x) };
+}
+
+export const $printed = ["", ""];
+export function $print(text) {
+  $write(text, 0);
+}
+export function $eprint(text) {
+  $write(text, 1);
+}
+export function $write(text, error) {
+  const stream = globalThis.process?.[error ? "stderr" : "stdout"];
+  if (stream?.write) {
+    stream.write(text);
+    return;
+  }
+  const log = error ? console.error : console.log;
+  const lines = ($printed[error] + text).split("\n");
+  const rest = lines.pop();
+  for (const line of lines) log(line);
+  // What's left unended is written when this task ends, so none is lost.
+  if (rest !== "" && $printed[error] === "") {
+    queueMicrotask(() => {
+      if ($printed[error] !== "") log($printed[error]);
+      $printed[error] = "";
+    });
+  }
+  $printed[error] = rest;
+}
+
+export function $replace(s, pattern, replacement) {
+  if (pattern !== "") return s.replaceAll(pattern, replacement);
+  return Array.from(s, (c) => replacement + c).join("") + replacement;
+}
+export function $split(s, pattern) {
+  return pattern === "" ? ["", ...s, ""] : s.split(pattern);
+}
+
+export function $jsonWriter(pretty) {
+  // For each array or object open: whether nothing is in it yet.
+  const empty = [];
+  const next = (json) => {
+    const first = empty[empty.length - 1];
+    empty[empty.length - 1] = false;
+    if (pretty) json.text += (first ? "\n" : ",\n") + "  ".repeat(empty.length);
+    else if (!first) json.text += ",";
+  };
+  const open = (json, bracket) => {
+    empty.push(true);
+    json.text += bracket;
+  };
+  const close = (json, bracket) => {
+    if (!empty.pop() && pretty) json.text += "\n" + "  ".repeat(empty.length);
+    json.text += bracket;
+  };
+  return {
+    text: "",
+    null() { this.text += "null"; },
+    bool(b) { this.text += String(b); },
+    int(n) { this.text += String(n); },
+    number(x) { this.text += $jsonNumber(x); },
+    char(c) { this.text += JSON.stringify(c); },
+    string(s) { this.text += JSON.stringify(s); },
+    // An externally tagged unit variant: its name.
+    variant(name) { this.string(name); },
+    beginArray() { open(this, "["); },
+    beginTuple() { open(this, "["); },
+    beginTupleStruct() { open(this, "["); },
+    element() { next(this); },
+    endArray() { close(this, "]"); },
+    beginObject() { open(this, "{"); },
+    key(k) {
+      next(this);
+      this.text += JSON.stringify(k) + (pretty ? ": " : ":");
+    },
+    endObject() { close(this, "}"); },
+    // `#[serde(flatten)]`: `value`'s entries, among the object's own.
+    flat(value, write) { write(value, $jsonFlat(this)); },
+  };
+}
+// serde's `FlatMapSerializer`: a struct's or a map's entries go into the
+// object `into` is writing; a variant is an entry of its name; `None` and
+// `()` are nothing; and anything else can't be flattened.
+export function $jsonFlat(into) {
+  let depth = 0;
+  const top = (what) => {
+    if (depth === 0) throw $jsonError(`can only flatten structs and maps (got ${what})`);
+  };
+  const flat = {
+    null() { if (depth > 0) into.null(); },
+    bool(b) { top("a boolean"); into.bool(b); },
+    int(n) { top("an integer"); into.int(n); },
+    number(x) { top("a float"); into.number(x); },
+    char(c) { top("a char"); into.char(c); },
+    string(s) { top("a string"); into.string(s); },
+    variant(name) {
+      if (depth > 0) return into.variant(name);
+      into.key(name);
+      into.null();
+    },
+    beginArray() { top("a sequence"); depth++; into.beginArray(); },
+    beginTuple() { top("a tuple"); depth++; into.beginTuple(); },
+    beginTupleStruct() { top("a tuple struct"); depth++; into.beginTupleStruct(); },
+    element() { into.element(); },
+    endArray() { depth--; into.endArray(); },
+    beginObject() { if (depth++ > 0) into.beginObject(); },
+    key(k) { into.key(k); },
+    endObject() { if (--depth > 0) into.endObject(); },
+    flat(value, write) { write(value, $jsonFlat(this)); },
+  };
+  return flat;
+}
+export function $toJson(value, write, pretty) {
+  const json = $jsonWriter(pretty);
+  try {
+    write(value, json);
+  } catch (e) {
+    if (e instanceof $JsonError) return { TAG: "Err", _0: { message: e.message, line: e.line, column: e.column } };
+    throw e;
+  }
+  return { TAG: "Ok", _0: json.text };
+}
+
+// What serde's impls and derives read, the same whatever they read from:
+// the text (`$JsonReader`), or a value already read (`$JsonContent`), which
+// is how serde reads a tagged or an untagged enum.
+export class $JsonDecoder {
+  // An integer type, named as serde names it, from `min` to `max`: a
+  // number, or for an `i64` or `u64`, a BigInt (ADR 0086).
+  int(name, min, max) {
+    return this.deserializeNumber(name, (n) => {
+      if (n.kind === "f") throw $jsonError(`invalid type: floating point \`${$jsonNumber(n.value)}\`, expected ${name}`);
+      if (n.kind === "u" ? n.value > max : n.value < min) {
+        throw $jsonError(`invalid value: integer \`${n.value}\`, expected ${name}`);
+      }
+      return typeof max === "bigint" ? BigInt(n.value) : Number(n.value);
+    });
+  }
+
+  f64() {
+    return this.deserializeNumber("f64", (n) => Number(n.value));
+  }
+
+  string() {
+    return this.deserializeStr("a string", (s) => s);
+  }
+
+  char() {
+    return this.deserializeStr("a character", $jsonChar);
+  }
+
+  // A `&str`, which borrows from the text, so it can't have had an escape.
+  borrowedStr() {
+    return this.deserializeStr("a borrowed string", (s, borrowed) => {
+      if (borrowed) return s;
+      throw $jsonError(`invalid type: string ${$debugStr(s)}, expected a borrowed string`);
+    });
+  }
+
+  vec(read) {
+    return this.deserializeSeq("a sequence", (seq) => {
+      const items = [];
+      while (seq.next()) items.push(seq.value(read));
+      return items;
+    });
+  }
+
+  tuple(reads) {
+    const expected = `a tuple of size ${reads.length}`;
+    return this.deserializeSeq(expected, (seq) => reads.map((read, i) => seq.element(read, i, expected)));
+  }
+
+  array(length, read) {
+    const expected = length === 0 ? "an empty array" : `an array of length ${length}`;
+    return this.deserializeSeq(expected, (seq) =>
+      Array.from({ length }, (_, i) => seq.element(read, i, expected)),
+    );
+  }
+
+  map(readKey, read) {
+    return this.deserializeMap("a map", (map) => {
+      const entries = new Map();
+      while (map.next()) {
+        const key = readKey(map.key());
+        entries.set(key, map.value(read));
+      }
+      return entries;
+    });
+  }
+
+  // A struct's fields: `[name, read]`, or `[[name, ...aliases], read]`, and
+  // `missing`, the value it has when it's not there, for `#[serde(default)]`.
+  // `build` makes the struct of their values.
+  struct(expected, fields, build, options = {}) {
+    const visitMap = (map) => this.structMap(map, fields, build, options);
+    // With a flattened field, serde reads a struct as a map.
+    if (options.flatten) return this.deserializeMap(options.expecting ?? expected, visitMap);
+    return this.deserializeStruct(
+      options.expecting ?? expected,
+      fields.flatMap(([names]) => names),
+      visitMap,
+      (seq) => this.structSeq(seq, expected, fields, build, options),
+    );
+  }
+
+  // `deserialize_struct`: a map, of these `names`, or for most readers, any
+  // map at all.
+  deserializeStruct(expected, names, visitMap, visitSeq) {
+    return this.deserializeMap(expected, visitMap, visitSeq);
+  }
+
+  // An untagged struct variant, which serde reads from an object only.
+  untaggedStruct(expected, fields, build, options = {}) {
+    return this.deserializeAny(options.expecting ?? expected, {
+      map: (map) => this.structMap(map, fields, build, options),
+    });
+  }
+
+  // `flatten`: the readers of the flattened fields, which read what the
+  // struct's own fields don't, kept until they're all read.
+  structMap(map, fields, build, { deny = false, container, flatten } = {}) {
+    const values = new Array(fields.length);
+    const seen = new Array(fields.length).fill(false);
+    const kept = [];
+    while (map.next()) {
+      const keyContent = map.key().content();
+      const key = keyContent.value;
+      const i = $jsonField(key, fields, deny && !flatten);
+      if (i < 0 && flatten) {
+        kept.push([keyContent, map.value((json) => json.content())]);
+        continue;
+      }
+      if (i < 0) {
+        map.value((json) => json.ignoreValue());
+        continue;
+      }
+      if (seen[i]) throw $jsonError(`duplicate field \`${$jsonName(fields[i][0])}\``);
+      values[i] = map.value(fields[i][1]);
+      seen[i] = true;
+    }
+    const defaults = container?.();
+    fields.forEach(([names, read, missing], i) => {
+      if (!seen[i]) values[i] = missing ? missing(defaults) : read(new $JsonMissing($jsonName(names)));
+    });
+    if (!flatten) return build(values, defaults);
+    for (const read of flatten) values.push(read(new $JsonFlat(kept)));
+    const left = deny && kept.find(Boolean);
+    if (left) throw $jsonError(`unknown field \`${left[0].value}\``);
+    return build(values, defaults);
+  }
+
+  structSeq(seq, expected, fields, build, { container, expecting } = {}) {
+    const length = expecting ?? `${expected} with ${fields.length} element${fields.length === 1 ? "" : "s"}`;
+    const defaults = container?.();
+    const values = fields.map(([, read, missing], i) => seq.element(read, i, length, missing, defaults));
+    return build(values, defaults);
+  }
+
+  // A tuple struct's fields: `read`, or `[read, missing]`.
+  tupleStruct(expected, fields, build = (values) => values, { container, expecting } = {}) {
+    const length = expecting ?? `${expected} with ${fields.length} element${fields.length === 1 ? "" : "s"}`;
+    return this.deserializeSeq(expecting ?? expected, (seq) => {
+      const defaults = container?.();
+      const values = fields.map((field, i) => {
+        const [read, missing] = typeof field === "function" ? [field] : field;
+        return seq.element(read, i, length, missing, defaults);
+      });
+      return build(values, defaults);
+    });
+  }
+
+  // An internally tagged enum's unit variant, whose other fields are
+  // ignored (serde's `InternallyTaggedUnitVisitor`).
+  taggedUnit(expected) {
+    return this.deserializeAny(expected, {
+      seq: () => undefined,
+      map: (map) => {
+        while (map.next()) {
+          map.key().ignore();
+          map.value((json) => json.ignoreValue());
+        }
+        return undefined;
+      },
+    });
+  }
+
+  // An untagged unit variant: `null` (serde's `UntaggedUnitVisitor`).
+  untaggedUnit(expected) {
+    return this.deserializeAny(expected, { unit: () => undefined });
+  }
+
+  // `#[serde(tag = "type")]`: the tag, found among the other fields, which
+  // are kept for the variant to read (serde's `TaggedContentVisitor`).
+  internallyTagged(tag, expected, variants, visit, other) {
+    const [variant, rest] = this.deserializeAny(expected, {
+      seq: (seq) => {
+        if (!seq.next()) throw $jsonError(`missing field \`${tag}\``);
+        const variant = seq.value((json) => json.identifier(variants, other));
+        const items = [];
+        while (seq.next()) items.push(seq.value((json) => json.content()));
+        return [variant, { type: "seq", value: items }];
+      },
+      map: (map) => {
+        let variant;
+        const entries = [];
+        while (map.next()) {
+          const key = map.key().content();
+          if (key.value !== tag) {
+            entries.push([key, map.value((json) => json.content())]);
+            continue;
+          }
+          if (variant !== undefined) throw $jsonError(`duplicate field \`${tag}\``);
+          variant = map.value((json) => json.identifier(variants, other));
+        }
+        if (variant === undefined) throw $jsonError(`missing field \`${tag}\``);
+        return [variant, { type: "map", value: entries }];
+      },
+    });
+    return visit(variant, new $JsonContent(rest, true));
+  }
+
+  // `#[serde(tag = "t", content = "c")]`, as serde's derive reads one: the
+  // tag, then the content, or the content first, kept until the tag says
+  // how to read it.
+  adjacentlyTagged(tag, content, expected, variants, visit, { deny = false, other } = {}) {
+    const variantOf = (json) =>
+      json.enum(
+        undefined,
+        variants,
+        (name, access) => {
+          access.unit();
+          return name;
+        },
+        other,
+      );
+    // The next key that's the tag or the content, skipping any other.
+    const relevant = (map) => {
+      while (map.next()) {
+        const key = map.key().string();
+        if (key === tag) return "tag";
+        if (key === content) return "content";
+        if (deny) {
+          throw $jsonError(`invalid value: string ${$debugStr(key)}, expected ${$debugStr(tag)} or ${$debugStr(content)}`);
+        }
+        map.value((json) => json.ignoreValue());
+      }
+      return undefined;
+    };
+    const finish = (map, value) => {
+      const key = relevant(map);
+      if (key !== undefined) throw $jsonError(`duplicate field \`${key === "tag" ? tag : content}\``);
+      return value;
+    };
+    return this.deserializeStruct(
+      expected,
+      [tag, content],
+      (map) => {
+        const first = relevant(map);
+        if (first === "tag") {
+          const variant = map.value(variantOf);
+          const second = relevant(map);
+          if (second === "tag") throw $jsonError(`duplicate field \`${tag}\``);
+          if (second === "content") return finish(map, map.value((json) => visit(variant, json)));
+          return visit(variant, new $JsonMissing(content));
+        }
+        if (first === "content") {
+          const buffered = map.value((json) => json.content());
+          const second = relevant(map);
+          if (second === "tag") {
+            const variant = map.value(variantOf);
+            return finish(map, visit(variant, new $JsonContent(buffered, true)));
+          }
+          if (second === "content") throw $jsonError(`duplicate field \`${content}\``);
+        }
+        throw $jsonError(`missing field \`${tag}\``);
+      },
+      (seq) => {
+        if (!seq.next()) throw $jsonError(`invalid length 0, expected ${expected}`);
+        const variant = seq.value((json) => json.identifier(variants, other));
+        if (!seq.next()) throw $jsonError(`invalid length 1, expected ${expected}`);
+        return seq.value((json) => visit(variant, json));
+      },
+    );
+  }
+
+  // `#[serde(untagged)]`: the value, read once and kept, then each way of
+  // reading it in turn, the first that works.
+  untagged(message, attempts) {
+    const content = this.content();
+    for (const attempt of attempts) {
+      try {
+        return attempt(new $JsonContent(content, false));
+      } catch (e) {
+        if (!(e instanceof $JsonError)) throw e;
+      }
+    }
+    throw $jsonError(message);
+  }
+}
+
+// serde_json's reader (ADR 0078): its `Deserializer`, ported step for step,
+// with its methods' names. It reads the text's UTF-8 bytes, as serde_json
+// does, so a mistake is found at the same byte, with the same message, and
+// its column counts bytes.
+export class $JsonReader extends $JsonDecoder {
+  constructor(text) {
+    super();
+    this.bytes = new TextEncoder().encode(text);
+    this.index = 0;
+    this.remainingDepth = 128;
+  }
+
+  // The next byte, or -1 at the end.
+  peek() {
+    return this.index < this.bytes.length ? this.bytes[this.index] : -1;
+  }
+
+  next() {
+    return this.index < this.bytes.length ? this.bytes[this.index++] : -1;
+  }
+
+  // `position_of_index`: the line, and the bytes before `index` on it.
+  errorAt(index, message) {
+    const start = index === 0 ? 0 : this.bytes.lastIndexOf(10, index - 1) + 1;
+    let line = 1;
+    for (let i = 0; i < start; i++) if (this.bytes[i] === 10) line++;
+    return new $JsonError(message, line, index - start);
+  }
+
+  error(message) {
+    return this.errorAt(this.index, message);
+  }
+
+  peekError(message) {
+    return this.errorAt(Math.min(this.bytes.length, this.index + 1), message);
+  }
+
+  // `fix_position`: a visitor's message has no place, until it gets where
+  // the reader is.
+  fixPosition(e) {
+    return e instanceof $JsonError && e.line === 0 ? this.error(e.message) : e;
+  }
+
+  end() {
+    if (this.parseWhitespace() !== -1) throw this.peekError("trailing characters");
+  }
+
+  parseWhitespace() {
+    for (;;) {
+      const c = this.peek();
+      if (c !== 32 && c !== 10 && c !== 9 && c !== 13) return c;
+      this.index++;
+    }
+  }
+
+  parseIdent(rest) {
+    for (let i = 0; i < rest.length; i++) {
+      const c = this.next();
+      if (c === -1) throw this.error("EOF while parsing a value");
+      if (c !== rest.charCodeAt(i)) throw this.error("expected ident");
+    }
+  }
+
+  // What's there instead of `expected`, read past, in serde's words.
+  peekInvalidType(expected) {
+    const c = this.peek();
+    let unexpected;
+    if (c === 110) {
+      this.index++;
+      this.parseIdent("ull");
+      unexpected = "null";
+    } else if (c === 116) {
+      this.index++;
+      this.parseIdent("rue");
+      unexpected = "boolean `true`";
+    } else if (c === 102) {
+      this.index++;
+      this.parseIdent("alse");
+      unexpected = "boolean `false`";
+    } else if (c === 45) {
+      this.index++;
+      unexpected = $jsonUnexpectedNumber(this.parseInteger(false));
+    } else if (c >= 48 && c <= 57) {
+      unexpected = $jsonUnexpectedNumber(this.parseInteger(true));
+    } else if (c === 34) {
+      this.index++;
+      unexpected = `string ${$debugStr(this.parseStr())}`;
+    } else if (c === 91) {
+      unexpected = "sequence";
+    } else if (c === 123) {
+      unexpected = "map";
+    } else {
+      return this.peekError("expected value");
+    }
+    return this.fixPosition($jsonError(`invalid type: ${unexpected}, expected ${expected}`));
+  }
+
+  // A number: `{ kind, value }`, a `"u"`nsigned or `"i"`nteger (a BigInt
+  // past 2^53) where it's an integer that fits in 64 bits, else an `"f"`.
+  deserializeNumber(expected, visit) {
+    const peek = this.parseWhitespace();
+    if (peek === -1) throw this.peekError("EOF while parsing a value");
+    try {
+      if (peek === 45) {
+        this.index++;
+        return visit(this.parseInteger(false));
+      }
+      if (peek >= 48 && peek <= 57) return visit(this.parseInteger(true));
+      throw this.peekInvalidType(expected);
+    } catch (e) {
+      throw this.fixPosition(e);
+    }
+  }
+
+  parseInteger(positive) {
+    const c = this.next();
+    if (c === -1) throw this.error("EOF while parsing a value");
+    if (c === 48) {
+      const p = this.peek();
+      if (p >= 48 && p <= 57) throw this.peekError("invalid number");
+      return this.parseNumber(positive, 0);
+    }
+    if (c < 49 || c > 57) throw this.error("invalid number");
+    let significand = c - 48;
+    for (;;) {
+      const p = this.peek();
+      if (p < 48 || p > 57) return this.parseNumber(positive, significand);
+      const grown = $jsonGrow(significand, p - 48);
+      if (grown > 18446744073709551615n) {
+        return { kind: "f", value: this.parseLongInteger(positive, significand) };
+      }
+      this.index++;
+      significand = grown;
+    }
+  }
+
+  parseNumber(positive, significand) {
+    const p = this.peek();
+    if (p === 46) return { kind: "f", value: this.parseDecimal(positive, significand, 0) };
+    if (p === 101 || p === 69) return { kind: "f", value: this.parseExponent(positive, significand, 0) };
+    if (positive) return { kind: "u", value: significand };
+    // `-0`, and below `i64::MIN`, are floats.
+    if (significand === 0 || significand > 9223372036854775808n) {
+      return { kind: "f", value: -Number(significand) };
+    }
+    return { kind: "i", value: -significand };
+  }
+
+  parseDecimal(positive, significand, exponentBeforeDecimalPoint) {
+    this.index++;
+    let exponentAfterDecimalPoint = 0;
+    for (let p = this.peek(); p >= 48 && p <= 57; p = this.peek()) {
+      const grown = $jsonGrow(significand, p - 48);
+      if (grown > 18446744073709551615n) {
+        const exponent = exponentBeforeDecimalPoint + exponentAfterDecimalPoint;
+        return this.parseDecimalOverflow(positive, significand, exponent);
+      }
+      this.index++;
+      significand = grown;
+      exponentAfterDecimalPoint--;
+    }
+    if (exponentAfterDecimalPoint === 0) {
+      throw this.peekError(this.peek() === -1 ? "EOF while parsing a value" : "invalid number");
+    }
+    const exponent = exponentBeforeDecimalPoint + exponentAfterDecimalPoint;
+    const p = this.peek();
+    return p === 101 || p === 69
+      ? this.parseExponent(positive, significand, exponent)
+      : this.f64FromParts(positive, significand, exponent);
+  }
+
+  parseExponent(positive, significand, startingExp) {
+    this.index++;
+    let positiveExp = true;
+    const sign = this.peek();
+    if (sign === 43) {
+      this.index++;
+    } else if (sign === 45) {
+      this.index++;
+      positiveExp = false;
+    }
+    const c = this.next();
+    if (c === -1) throw this.error("EOF while parsing a value");
+    if (c < 48 || c > 57) throw this.error("invalid number");
+    let exp = c - 48;
+    for (let p = this.peek(); p >= 48 && p <= 57; p = this.peek()) {
+      this.index++;
+      if (exp * 10 + (p - 48) > 2147483647) {
+        return this.parseExponentOverflow(positive, significand == 0, positiveExp);
+      }
+      exp = exp * 10 + (p - 48);
+    }
+    // i32's saturating add and subtract.
+    const finalExp = Math.max(-2147483648, Math.min(2147483647, positiveExp ? startingExp + exp : startingExp - exp));
+    return this.f64FromParts(positive, significand, finalExp);
+  }
+
+  // Not correctly rounded, as serde_json's isn't without its
+  // `float_roundtrip` feature: the significand times or over a power of ten.
+  f64FromParts(positive, significand, exponent) {
+    let f = Number(significand);
+    for (;;) {
+      const pow = $JSON_POW10[Math.abs(exponent)];
+      if (pow !== undefined) {
+        if (exponent >= 0) {
+          f *= pow;
+          if (!Number.isFinite(f)) throw this.error("number out of range");
+        } else {
+          f /= pow;
+        }
+        break;
+      }
+      if (f === 0) break;
+      if (exponent >= 0) throw this.error("number out of range");
+      f /= 1e308;
+      exponent += 308;
+    }
+    return positive ? f : -f;
+  }
+
+  parseLongInteger(positive, significand) {
+    let exponent = 0;
+    for (;;) {
+      const p = this.peek();
+      if (p >= 48 && p <= 57) {
+        this.index++;
+        exponent++;
+      } else if (p === 46) {
+        return this.parseDecimal(positive, significand, exponent);
+      } else if (p === 101 || p === 69) {
+        return this.parseExponent(positive, significand, exponent);
+      } else {
+        return this.f64FromParts(positive, significand, exponent);
+      }
+    }
+  }
+
+  parseDecimalOverflow(positive, significand, exponent) {
+    for (let p = this.peek(); p >= 48 && p <= 57; p = this.peek()) this.index++;
+    const p = this.peek();
+    return p === 101 || p === 69
+      ? this.parseExponent(positive, significand, exponent)
+      : this.f64FromParts(positive, significand, exponent);
+  }
+
+  parseExponentOverflow(positive, zeroSignificand, positiveExp) {
+    if (!zeroSignificand && positiveExp) throw this.error("number out of range");
+    for (let p = this.peek(); p >= 48 && p <= 57; p = this.peek()) this.index++;
+    return positive ? 0 : -0;
+  }
+
+  // A string, after its opening quote. `escaped` says whether it had an
+  // escape, which a borrowed `&str` can't (serde_json's `Reference::Copied`).
+  parseStr() {
+    const bytes = this.bytes;
+    let text = "";
+    let start = this.index;
+    this.escaped = false;
+    for (;;) {
+      while (this.index < bytes.length) {
+        const c = bytes[this.index];
+        if (c === 34 || c === 92 || c < 32) break;
+        this.index++;
+      }
+      if (this.index === bytes.length) throw this.error("EOF while parsing a string");
+      const c = bytes[this.index];
+      if (c === 34) {
+        text += $JSON_UTF8.decode(bytes.subarray(start, this.index));
+        this.index++;
+        return text;
+      }
+      if (c !== 92) {
+        this.index++;
+        throw this.error("control character (\\u0000-\\u001F) found while parsing a string");
+      }
+      text += $JSON_UTF8.decode(bytes.subarray(start, this.index));
+      this.index++;
+      text += this.parseEscape();
+      this.escaped = true;
+      start = this.index;
+    }
+  }
+
+  parseEscape() {
+    const c = this.next();
+    if (c === -1) throw this.error("EOF while parsing a string");
+    switch (c) {
+      case 34:
+        return '"';
+      case 92:
+        return "\\";
+      case 47:
+        return "/";
+      case 98:
+        return "\b";
+      case 102:
+        return "\f";
+      case 110:
+        return "\n";
+      case 114:
+        return "\r";
+      case 116:
+        return "\t";
+      case 117:
+        return this.parseUnicodeEscape();
+    }
+    throw this.error("invalid escape");
+  }
+
+  parseUnicodeEscape() {
+    const n = this.decodeHexEscape();
+    // A trailing surrogate, which serde_json calls a leading one.
+    if (n >= 0xdc00 && n <= 0xdfff) throw this.error("lone leading surrogate in hex escape");
+    if (n < 0xd800 || n > 0xdbff) return String.fromCharCode(n);
+    for (const expected of [92, 117]) {
+      if (this.peek() === -1) throw this.error("EOF while parsing a string");
+      const c = this.bytes[this.index++];
+      if (c !== expected) throw this.error("unexpected end of hex escape");
+    }
+    const n2 = this.decodeHexEscape();
+    if (n2 < 0xdc00 || n2 > 0xdfff) throw this.error("lone leading surrogate in hex escape");
+    return String.fromCharCode(n, n2);
+  }
+
+  decodeHexEscape() {
+    if (this.index + 4 > this.bytes.length) {
+      this.index = this.bytes.length;
+      throw this.error("EOF while parsing a string");
+    }
+    let n = 0;
+    let valid = true;
+    for (let i = 0; i < 4; i++) {
+      const digit = $jsonHexDigit(this.bytes[this.index + i]);
+      valid &&= digit >= 0;
+      n = n * 16 + digit;
+    }
+    this.index += 4;
+    if (!valid) throw this.error("invalid escape");
+    return n;
+  }
+
+  ignoreStr() {
+    const bytes = this.bytes;
+    for (;;) {
+      while (this.index < bytes.length) {
+        const c = bytes[this.index];
+        if (c === 34 || c === 92 || c < 32) break;
+        this.index++;
+      }
+      if (this.index === bytes.length) throw this.error("EOF while parsing a string");
+      const c = bytes[this.index];
+      if (c === 34) {
+        this.index++;
+        return;
+      }
+      if (c !== 92) throw this.error("control character (\\u0000-\\u001F) found while parsing a string");
+      this.index++;
+      const escape = this.next();
+      if (escape === -1) throw this.error("EOF while parsing a string");
+      if (escape === 117) this.decodeHexEscape();
+      else if (!'"\\/bfnrt'.includes(String.fromCharCode(escape))) throw this.error("invalid escape");
+    }
+  }
+
+  parseObjectColon() {
+    const c = this.parseWhitespace();
+    if (c === 58) {
+      this.index++;
+      return;
+    }
+    throw this.peekError(c === -1 ? "EOF while parsing an object" : "expected `:`");
+  }
+
+  endSeq() {
+    const c = this.parseWhitespace();
+    if (c === 93) {
+      this.index++;
+      return;
+    }
+    if (c === 44) {
+      this.index++;
+      throw this.peekError(this.parseWhitespace() === 93 ? "trailing comma" : "trailing characters");
+    }
+    throw this.peekError(c === -1 ? "EOF while parsing a list" : "trailing characters");
+  }
+
+  endMap() {
+    const c = this.parseWhitespace();
+    if (c === 125) {
+      this.index++;
+      return;
+    }
+    throw this.peekError(c === 44 ? "trailing comma" : c === -1 ? "EOF while parsing an object" : "trailing characters");
+  }
+
+  ignoreValue() {
+    const frames = [];
+    let enclosing;
+    for (;;) {
+      const peek = this.parseWhitespace();
+      if (peek === -1) throw this.peekError("EOF while parsing a value");
+      let frame;
+      if (peek === 110) {
+        this.index++;
+        this.parseIdent("ull");
+      } else if (peek === 116) {
+        this.index++;
+        this.parseIdent("rue");
+      } else if (peek === 102) {
+        this.index++;
+        this.parseIdent("alse");
+      } else if (peek === 45) {
+        this.index++;
+        this.ignoreInteger();
+      } else if (peek >= 48 && peek <= 57) {
+        this.ignoreInteger();
+      } else if (peek === 34) {
+        this.index++;
+        this.ignoreStr();
+      } else if (peek === 91 || peek === 123) {
+        if (enclosing !== undefined) frames.push(enclosing);
+        enclosing = undefined;
+        this.index++;
+        frame = peek;
+      } else {
+        throw this.peekError("expected value");
+      }
+      let acceptComma = true;
+      if (frame !== undefined) {
+        acceptComma = false;
+      } else if (enclosing !== undefined) {
+        frame = enclosing;
+        enclosing = undefined;
+      } else if (frames.length > 0) {
+        frame = frames.pop();
+      } else {
+        return;
+      }
+      for (;;) {
+        const c = this.parseWhitespace();
+        if (c === 44 && acceptComma) {
+          this.index++;
+          break;
+        }
+        if (c === -1) throw this.peekError(frame === 91 ? "EOF while parsing a list" : "EOF while parsing an object");
+        if (!((c === 93 && frame === 91) || (c === 125 && frame === 123))) {
+          if (acceptComma) throw this.peekError(frame === 91 ? "expected `,` or `]`" : "expected `,` or `}`");
+          break;
+        }
+        this.index++;
+        if (frames.length === 0) return;
+        frame = frames.pop();
+        acceptComma = true;
+      }
+      if (frame === 123) {
+        const quote = this.parseWhitespace();
+        if (quote !== 34) throw this.peekError(quote === -1 ? "EOF while parsing an object" : "key must be a string");
+        this.index++;
+        this.ignoreStr();
+        const colon = this.parseWhitespace();
+        if (colon !== 58) throw this.peekError(colon === -1 ? "EOF while parsing an object" : "expected `:`");
+        this.index++;
+      }
+      enclosing = frame;
+    }
+  }
+
+  ignoreInteger() {
+    const c = this.next();
+    if (c === 48) {
+      const p = this.peek();
+      if (p >= 48 && p <= 57) throw this.peekError("invalid number");
+    } else if (c >= 49 && c <= 57) {
+      for (let p = this.peek(); p >= 48 && p <= 57; p = this.peek()) this.index++;
+    } else {
+      throw this.error("invalid number");
+    }
+    const p = this.peek();
+    if (p === 46) this.ignoreDecimal();
+    else if (p === 101 || p === 69) this.ignoreExponent();
+  }
+
+  ignoreDecimal() {
+    this.index++;
+    let atLeastOneDigit = false;
+    for (let p = this.peek(); p >= 48 && p <= 57; p = this.peek()) {
+      this.index++;
+      atLeastOneDigit = true;
+    }
+    if (!atLeastOneDigit) throw this.peekError("invalid number");
+    const p = this.peek();
+    if (p === 101 || p === 69) this.ignoreExponent();
+  }
+
+  ignoreExponent() {
+    this.index++;
+    const sign = this.peek();
+    if (sign === 43 || sign === 45) this.index++;
+    const c = this.next();
+    if (c < 48 || c > 57) throw this.error("invalid number");
+    for (let p = this.peek(); p >= 48 && p <= 57; p = this.peek()) this.index++;
+  }
+
+  // An array or an object: `visit` reads what's inside, and the closing
+  // bracket is looked for even when it fails, as serde_json does.
+  nested(visit, end) {
+    if (--this.remainingDepth === 0) throw this.peekError("recursion limit exceeded");
+    this.index++;
+    let value;
+    let failure;
+    try {
+      value = visit();
+    } catch (e) {
+      if (!(e instanceof $JsonError)) throw e;
+      failure = e;
+    }
+    this.remainingDepth++;
+    try {
+      end();
+    } catch (e) {
+      if (!(e instanceof $JsonError)) throw e;
+      failure ??= e;
+    }
+    if (failure) throw failure;
+    return value;
+  }
+
+  // `deserialize_seq`: `[ .. ]`, which `visit` reads with a `$JsonSeq`.
+  deserializeSeq(expected, visit) {
+    const peek = this.parseWhitespace();
+    if (peek === -1) throw this.peekError("EOF while parsing a value");
+    try {
+      if (peek !== 91) throw this.peekInvalidType(expected);
+      return this.nested(() => visit(new $JsonSeq(this)), () => this.endSeq());
+    } catch (e) {
+      throw this.fixPosition(e);
+    }
+  }
+
+  // `deserialize_map` and `deserialize_struct`: `{ .. }`, or for a struct,
+  // `[ .. ]` too.
+  deserializeMap(expected, visitMap, visitSeq) {
+    const peek = this.parseWhitespace();
+    if (peek === -1) throw this.peekError("EOF while parsing a value");
+    try {
+      if (peek === 91 && visitSeq) return this.nested(() => visitSeq(new $JsonSeq(this)), () => this.endSeq());
+      if (peek !== 123) throw this.peekInvalidType(expected);
+      return this.nested(() => visitMap(new $JsonMap(this)), () => this.endMap());
+    } catch (e) {
+      throw this.fixPosition(e);
+    }
+  }
+
+  deserializeStr(expected, visit) {
+    const peek = this.parseWhitespace();
+    if (peek === -1) throw this.peekError("EOF while parsing a value");
+    try {
+      if (peek !== 34) throw this.peekInvalidType(expected);
+      this.index++;
+      const s = this.parseStr();
+      return visit(s, !this.escaped);
+    } catch (e) {
+      throw this.fixPosition(e);
+    }
+  }
+
+  // What serde's own impls read, from the text.
+
+  bool() {
+    const peek = this.parseWhitespace();
+    if (peek === -1) throw this.peekError("EOF while parsing a value");
+    try {
+      if (peek === 116) {
+        this.index++;
+        this.parseIdent("rue");
+        return true;
+      }
+      if (peek === 102) {
+        this.index++;
+        this.parseIdent("alse");
+        return false;
+      }
+      throw this.peekInvalidType("a boolean");
+    } catch (e) {
+      throw this.fixPosition(e);
+    }
+  }
+
+  unit(expected = "unit") {
+    const peek = this.parseWhitespace();
+    if (peek === -1) throw this.peekError("EOF while parsing a value");
+    try {
+      if (peek !== 110) throw this.peekInvalidType(expected);
+      this.index++;
+      this.parseIdent("ull");
+      return undefined;
+    } catch (e) {
+      throw this.fixPosition(e);
+    }
+  }
+
+  unitStruct(expected) {
+    return this.unit(expected);
+  }
+
+  option(read) {
+    if (this.parseWhitespace() !== 110) return read(this);
+    this.index++;
+    this.parseIdent("ull");
+    return undefined;
+  }
+
+  // `deserialize_any`: whatever's there, for the `visitor` method of its
+  // kind (`unit`, `bool`, `number`, `string`, `seq` or `map`), which is
+  // `expected` if the visitor has none.
+  deserializeAny(expected, visitor) {
+    const peek = this.parseWhitespace();
+    if (peek === -1) throw this.peekError("EOF while parsing a value");
+    const invalid = (unexpected) => $jsonError(`invalid type: ${unexpected}, expected ${expected}`);
+    try {
+      if (peek === 110) {
+        this.index++;
+        this.parseIdent("ull");
+        if (visitor.unit) return visitor.unit();
+        throw invalid("null");
+      }
+      if (peek === 116 || peek === 102) {
+        this.index++;
+        this.parseIdent(peek === 116 ? "rue" : "alse");
+        if (visitor.bool) return visitor.bool(peek === 116);
+        throw invalid(`boolean \`${peek === 116}\``);
+      }
+      if (peek === 45 || (peek >= 48 && peek <= 57)) {
+        if (peek === 45) this.index++;
+        const n = this.parseInteger(peek !== 45);
+        if (visitor.number) return visitor.number(n);
+        throw invalid($jsonUnexpectedNumber(n));
+      }
+      if (peek === 34) {
+        this.index++;
+        const s = this.parseStr();
+        if (visitor.string) return visitor.string(s, !this.escaped);
+        throw invalid(`string ${$debugStr(s)}`);
+      }
+      if (peek === 91) {
+        return this.nested(() => {
+          if (!visitor.seq) throw invalid("sequence");
+          return visitor.seq(new $JsonSeq(this));
+        }, () => this.endSeq());
+      }
+      if (peek === 123) {
+        return this.nested(() => {
+          if (!visitor.map) throw invalid("map");
+          return visitor.map(new $JsonMap(this));
+        }, () => this.endMap());
+      }
+      throw this.peekError("expected value");
+    } catch (e) {
+      throw this.fixPosition(e);
+    }
+  }
+
+  // serde's `ContentVisitor`: the value, read into a `{ type, value }`.
+  content() {
+    return this.deserializeAny("any value", {
+      unit: () => ({ type: "unit" }),
+      bool: (value) => ({ type: "bool", value }),
+      number: (value) => ({ type: "num", value }),
+      string: (value, borrowed) => ({ type: "str", value, borrowed }),
+      seq: (seq) => {
+        const items = [];
+        while (seq.next()) items.push(seq.value((json) => json.content()));
+        return { type: "seq", value: items };
+      },
+      map: (map) => {
+        const entries = [];
+        while (map.next()) {
+          const key = map.key().content();
+          entries.push([key, map.value((json) => json.content())]);
+        }
+        return { type: "map", value: entries };
+      },
+    });
+  }
+
+  // `deserialize_enum`: `"Name"`, or `{"Name": ..}`. `visit` gets the
+  // variant's name and a `$JsonVariant` to read what it holds. `enumName` is
+  // the enum's, for a flattened one.
+  enum(enumName, variants, visit, other) {
+    const peek = this.parseWhitespace();
+    if (peek === 34) return visit(this.identifier(variants, other), new $JsonVariant(this, true));
+    if (peek !== 123) throw this.peekError(peek === -1 ? "EOF while parsing a value" : "expected value");
+    if (--this.remainingDepth === 0) throw this.peekError("recursion limit exceeded");
+    this.index++;
+    let value;
+    try {
+      const c = this.parseWhitespace();
+      if (c !== 34) {
+        throw this.peekError(
+          c === 125 ? "expected value" : c === -1 ? "EOF while parsing an object" : "key must be a string",
+        );
+      }
+      const name = this.identifier(variants, other);
+      this.parseObjectColon();
+      value = visit(name, new $JsonVariant(this, false));
+    } finally {
+      this.remainingDepth++;
+    }
+    const c = this.parseWhitespace();
+    if (c === 125) {
+      this.index++;
+      return value;
+    }
+    throw this.error(c === -1 ? "EOF while parsing an object" : "expected value");
+  }
+
+  // A variant's name, from a string.
+  identifier(variants, other) {
+    return this.deserializeStr("variant identifier", (name) => $jsonVariantNamed(name, variants, other));
+  }
+}
+
+// A value already read (serde's `ContentDeserializer`, or when not `owned`,
+// its `ContentRefDeserializer`): `{ type, value }`, where `type` is `unit`,
+// `bool`, `num`, `str`, `seq` or `map`.
+export class $JsonContent extends $JsonDecoder {
+  constructor(content, owned) {
+    super();
+    this.data = content;
+    this.owned = owned;
+  }
+
+  invalid(expected) {
+    return $jsonError(`invalid type: ${$jsonUnexpectedContent(this.data)}, expected ${expected}`);
+  }
+
+  deserializeNumber(expected, visit) {
+    if (this.data.type === "num") return visit(this.data.value);
+    throw this.invalid(expected);
+  }
+
+  deserializeStr(expected, visit) {
+    if (this.data.type === "str") return visit(this.data.value, this.data.borrowed);
+    throw this.invalid(expected);
+  }
+
+  visitSeq(visit) {
+    const seq = new $JsonContentSeq(this.data.value, this.owned);
+    const value = visit(seq);
+    seq.end();
+    return value;
+  }
+
+  visitMap(visit) {
+    const map = new $JsonContentMap(this.data.value, this.owned);
+    const value = visit(map);
+    map.end();
+    return value;
+  }
+
+  deserializeSeq(expected, visit) {
+    if (this.data.type === "seq") return this.visitSeq(visit);
+    throw this.invalid(expected);
+  }
+
+  deserializeMap(expected, visitMap, visitSeq) {
+    if (this.data.type === "seq" && visitSeq) return this.visitSeq(visitSeq);
+    if (this.data.type === "map") return this.visitMap(visitMap);
+    throw this.invalid(expected);
+  }
+
+  deserializeAny(expected, visitor) {
+    const { type, value } = this.data;
+    if (type === "seq" && visitor.seq) return this.visitSeq(visitor.seq);
+    if (type === "map" && visitor.map) return this.visitMap(visitor.map);
+    const visit = { unit: visitor.unit, bool: visitor.bool, num: visitor.number, str: visitor.string }[type];
+    if (visit) return visit(value);
+    throw this.invalid(expected);
+  }
+
+  bool() {
+    if (this.data.type === "bool") return this.data.value;
+    throw this.invalid("a boolean");
+  }
+
+  unit(expected = "unit") {
+    const { type, value } = this.data;
+    // An owned one takes `{}` for a unit, as a newtype variant of `()`.
+    if (type === "unit" || (this.owned && type === "map" && value.length === 0)) return undefined;
+    throw this.invalid(expected);
+  }
+
+  unitStruct(expected) {
+    const { type, value } = this.data;
+    if (type === "unit" || (this.owned && (type === "map" || type === "seq") && value.length === 0)) return undefined;
+    throw this.invalid(expected);
+  }
+
+  option(read) {
+    return this.data.type === "unit" ? undefined : read(this);
+  }
+
+  ignoreValue() {}
+
+  content() {
+    return this.data;
+  }
+
+  enum(enumName, variants, visit, other) {
+    const { type, value } = this.data;
+    let variant;
+    let held;
+    if (type === "map") {
+      if (value.length !== 1) throw $jsonError("invalid value: map, expected map with a single key");
+      [[variant, held]] = value;
+    } else if (type === "str") {
+      variant = this.data;
+    } else {
+      throw this.invalid("string or map");
+    }
+    const name = new $JsonContent(variant, this.owned).identifier(variants, other);
+    return visit(name, new $JsonContentVariant(held, this.owned));
+  }
+
+  // A variant's name, or its index among the variants.
+  identifier(variants, other) {
+    const { type, value } = this.data;
+    if (type === "str") return $jsonVariantNamed(value, variants, other);
+    if (type !== "num" || value.kind !== "u") throw this.invalid("variant identifier");
+    if (value.value < variants.length) return $jsonName(variants[Number(value.value)]);
+    if (other !== undefined) return other;
+    throw $jsonError(`invalid value: integer \`${value.value}\`, expected variant index 0 <= i < ${variants.length}`);
+  }
+}
+
+// `SeqAccess`.
+export class $JsonSeq {
+  constructor(reader) {
+    this.reader = reader;
+    this.first = true;
+  }
+
+  // `has_next_element`.
+  next() {
+    const reader = this.reader;
+    const peek = reader.parseWhitespace();
+    if (peek === -1) throw reader.peekError("EOF while parsing a list");
+    if (peek === 93) return false;
+    if (this.first) {
+      this.first = false;
+      return true;
+    }
+    if (peek !== 44) throw reader.peekError("expected `,` or `]`");
+    reader.index++;
+    const c = reader.parseWhitespace();
+    if (c === 93) throw reader.peekError("trailing comma");
+    if (c === -1) throw reader.peekError("EOF while parsing a value");
+    return true;
+  }
+
+  value(read) {
+    return read(this.reader);
+  }
+
+  // The `i`th of `expected`'s items.
+  element(read, i, expected, missing, defaults) {
+    if (this.next()) return this.value(read);
+    if (missing) return missing(defaults);
+    throw $jsonError(`invalid length ${i}, expected ${expected}`);
+  }
+}
+
+// The items of a value already read.
+export class $JsonContentSeq {
+  constructor(items, owned) {
+    this.items = items;
+    this.owned = owned;
+    this.count = 0;
+  }
+
+  next() {
+    return this.count < this.items.length && ++this.count > 0;
+  }
+
+  value(read) {
+    return read(new $JsonContent(this.items[this.count - 1], this.owned));
+  }
+
+  element(read, i, expected, missing, defaults) {
+    return $JsonSeq.prototype.element.call(this, read, i, expected, missing, defaults);
+  }
+
+  // Items left over: the length is wrong.
+  end() {
+    const length = this.items.length;
+    if (this.count < length) {
+      const count = this.count;
+      throw $jsonError(`invalid length ${length}, expected ${count} element${count === 1 ? "" : "s"} in sequence`);
+    }
+  }
+}
+
+// `MapAccess`.
+export class $JsonMap {
+  constructor(reader) {
+    this.reader = reader;
+    this.first = true;
+  }
+
+  // `has_next_key`.
+  next() {
+    const reader = this.reader;
+    const peek = reader.parseWhitespace();
+    if (peek === -1) throw reader.peekError("EOF while parsing an object");
+    if (peek === 125) return false;
+    if (this.first) {
+      this.first = false;
+      if (peek === 34) return true;
+      throw reader.peekError("key must be a string");
+    }
+    if (peek !== 44) throw reader.peekError("expected `,` or `}`");
+    reader.index++;
+    const c = reader.parseWhitespace();
+    if (c === 34) return true;
+    throw reader.peekError(
+      c === 125 ? "trailing comma" : c === -1 ? "EOF while parsing a value" : "key must be a string",
+    );
+  }
+
+  key() {
+    return new $JsonKey(this.reader);
+  }
+
+  value(read) {
+    this.reader.parseObjectColon();
+    return read(this.reader);
+  }
+}
+
+// The entries of a value already read.
+export class $JsonContentMap {
+  constructor(entries, owned) {
+    this.entries = entries;
+    this.owned = owned;
+    this.count = 0;
+  }
+
+  next() {
+    return this.count < this.entries.length && ++this.count > 0;
+  }
+
+  key() {
+    return new $JsonContentKey(this.entries[this.count - 1][0], this.owned);
+  }
+
+  value(read) {
+    return read(new $JsonContent(this.entries[this.count - 1][1], this.owned));
+  }
+
+  end() {
+    const length = this.entries.length;
+    if (this.count < length) {
+      const count = this.count;
+      throw $jsonError(`invalid length ${length}, expected ${count} element${count === 1 ? "" : "s"} in map`);
+    }
+  }
+}
+
+// `MapKey`: an object's key, from its opening quote. A number or a `bool`
+// is read from inside the quotes.
+export class $JsonKey {
+  constructor(reader) {
+    this.reader = reader;
+  }
+
+  string() {
+    this.reader.index++;
+    return this.reader.parseStr();
+  }
+
+  char() {
+    return $jsonChar(this.string());
+  }
+
+  ignore() {
+    this.string();
+  }
+
+  content() {
+    const value = this.string();
+    return { type: "str", value, borrowed: !this.reader.escaped };
+  }
+
+  number(read) {
+    const reader = this.reader;
+    reader.index++;
+    const c = reader.peek();
+    if (!(c === 45 || (c >= 48 && c <= 57))) throw reader.error("invalid value: expected key to be a number in quotes");
+    const value = read(reader);
+    if (reader.peek() !== 34) throw reader.peekError('expected `"`');
+    reader.index++;
+    return value;
+  }
+
+  bool() {
+    const reader = this.reader;
+    reader.index++;
+    try {
+      const c = reader.next();
+      if (c === -1) throw reader.peekError("EOF while parsing a value");
+      if (c === 116) {
+        reader.parseIdent('rue"');
+        return true;
+      }
+      if (c === 102) {
+        reader.parseIdent('alse"');
+        return false;
+      }
+      throw $jsonError(`invalid type: string ${$debugStr(reader.parseStr())}, expected a boolean`);
+    } catch (e) {
+      throw reader.fixPosition(e);
+    }
+  }
+}
+
+// A key already read: it's read as any other value is, so a number in
+// quotes isn't a number, as in serde.
+export class $JsonContentKey {
+  constructor(key, owned) {
+    this.key = new $JsonContent(key, owned);
+  }
+
+  string() {
+    return this.key.string();
+  }
+
+  char() {
+    return this.key.char();
+  }
+
+  bool() {
+    return this.key.bool();
+  }
+
+  ignore() {}
+
+  content() {
+    return this.key.content();
+  }
+
+  number(read) {
+    return read(this.key);
+  }
+}
+
+// `VariantAccess` of `{"Name": ..}`, or of `"Name"` (`unit`), which holds
+// nothing.
+export class $JsonVariant {
+  constructor(reader, unit) {
+    this.reader = reader;
+    this.isUnit = unit;
+  }
+
+  unit() {
+    if (!this.isUnit) this.reader.unit();
+  }
+
+  newtype(read) {
+    if (this.isUnit) throw $jsonError("invalid type: unit variant, expected newtype variant");
+    return read(this.reader);
+  }
+
+  tuple(expected, fields, build, options) {
+    if (this.isUnit) throw $jsonError("invalid type: unit variant, expected tuple variant");
+    return this.reader.tupleStruct(expected, fields, build, options);
+  }
+
+  // With a flattened field, serde reads it as a newtype variant of a map.
+  struct(expected, fields, build, options) {
+    if (this.isUnit) {
+      throw $jsonError(`invalid type: unit variant, expected ${options?.flatten ? "newtype" : "struct"} variant`);
+    }
+    return this.reader.struct(expected, fields, build, options);
+  }
+}
+
+// The same, of a value already read: what a variant holds, if anything.
+export class $JsonContentVariant {
+  constructor(held, owned) {
+    this.held = held;
+    this.owned = owned;
+  }
+
+  reader(kind, types) {
+    if (this.held === undefined) throw $jsonError(`invalid type: unit variant, expected ${kind}`);
+    if (types && !types.includes(this.held.type)) {
+      throw $jsonError(`invalid type: ${$jsonUnexpectedContent(this.held)}, expected ${kind}`);
+    }
+    return new $JsonContent(this.held, this.owned);
+  }
+
+  unit() {
+    if (this.held !== undefined) new $JsonContent(this.held, this.owned).unit();
+  }
+
+  newtype(read) {
+    return read(this.reader("newtype variant"));
+  }
+
+  tuple(expected, fields, build, options) {
+    return this.reader("tuple variant", ["seq"]).tupleStruct(expected, fields, build, options);
+  }
+
+  struct(expected, fields, build, options) {
+    const reader = options?.flatten ? this.reader("newtype variant") : this.reader("struct variant", ["map", "seq"]);
+    return reader.struct(expected, fields, build, options);
+  }
+}
+
+// A flattened field (serde's `FlatMapDeserializer`): what's left of its
+// struct's object. A struct takes the entries it has fields for, a map or an
+// untagged or internally tagged enum sees every one left, and an enum takes
+// the first that names a variant. Anything else can't be flattened.
+export class $JsonFlat extends $JsonDecoder {
+  constructor(entries) {
+    super();
+    this.entries = entries;
+  }
+
+  other() {
+    return $jsonError("can only flatten structs and maps");
+  }
+
+  deserializeNumber() {
+    throw this.other();
+  }
+
+  deserializeStr() {
+    throw this.other();
+  }
+
+  deserializeSeq() {
+    throw this.other();
+  }
+
+  bool() {
+    throw this.other();
+  }
+
+  identifier() {
+    throw this.other();
+  }
+
+  deserializeMap(expected, visitMap) {
+    return visitMap(new $JsonFlatMap(this.entries));
+  }
+
+  deserializeStruct(expected, names, visitMap) {
+    return visitMap(new $JsonFlatStruct(this.entries, names));
+  }
+
+  deserializeAny(expected, visitor) {
+    return this.deserializeMap(expected, (map) => {
+      if (!visitor.map) throw $jsonError(`invalid type: map, expected ${expected}`);
+      return visitor.map(map);
+    });
+  }
+
+  unit() {
+    return undefined;
+  }
+
+  unitStruct() {
+    return undefined;
+  }
+
+  ignoreValue() {}
+
+  // An `Option`: `None` when what it holds can't be read from what's left.
+  option(read) {
+    try {
+      return read(this);
+    } catch (e) {
+      if (!(e instanceof $JsonError)) throw e;
+      return undefined;
+    }
+  }
+
+  content() {
+    return { type: "map", value: this.entries.filter(Boolean) };
+  }
+
+  enum(enumName, variants, visit, other) {
+    const names = variants.flatMap((names) => names);
+    const i = this.entries.findIndex((entry) => entry && entry[0].type === "str" && names.includes(entry[0].value));
+    if (i < 0) throw $jsonError(`no variant of enum ${enumName} found in flattened data`);
+    const entry = this.entries[i];
+    this.entries[i] = null;
+    return new $JsonContent({ type: "map", value: [entry] }, true).enum(enumName, variants, visit, other);
+  }
+}
+
+// `FlatStructAccess`: the entries a struct has fields for, taken.
+export class $JsonFlatStruct {
+  constructor(entries, names) {
+    this.entries = entries;
+    this.names = names;
+    this.index = 0;
+  }
+
+  next() {
+    while (this.index < this.entries.length) {
+      const i = this.index++;
+      const entry = this.entries[i];
+      if (entry && entry[0].type === "str" && this.names.includes(entry[0].value)) {
+        this.entries[i] = null;
+        this.entry = entry;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  key() {
+    return new $JsonContentKey(this.entry[0], true);
+  }
+
+  value(read) {
+    return read(new $JsonContent(this.entry[1], true));
+  }
+}
+
+// `FlatMapAccess`: every entry left, seen but left for the fields after.
+export class $JsonFlatMap {
+  constructor(entries) {
+    this.entries = entries;
+    this.index = 0;
+  }
+
+  next() {
+    while (this.index < this.entries.length) {
+      const entry = this.entries[this.index++];
+      if (entry) {
+        this.entry = entry;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  key() {
+    return new $JsonContentKey(this.entry[0], false);
+  }
+
+  value(read) {
+    return read(new $JsonContent(this.entry[1], false));
+  }
+}
+
+// A `serde_json::Value` read as a deserializer (ADR 0083), for
+// `serde_json::from_value`: its `impl Deserializer for Value`.
+export class $JsonValueReader extends $JsonDecoder {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+
+  // serde_json's `Value::unexpected`.
+  unexpected() {
+    const value = this.value;
+    if (value === "Null") return "null";
+    const { TAG: tag, _0: inner } = value;
+    if (tag === "Bool") return `boolean \`${inner}\``;
+    if (tag === "Number") return $jsonUnexpectedNumber(inner);
+    if (tag === "String") return `string ${$debugStr(inner)}`;
+    return tag === "Array" ? "sequence" : "map";
+  }
+
+  invalid(expected) {
+    return $jsonError(`invalid type: ${this.unexpected()}, expected ${expected}`);
+  }
+
+  deserializeNumber(expected, visit) {
+    if (this.value.TAG === "Number") return visit(this.value._0);
+    throw this.invalid(expected);
+  }
+
+  // A string of a `Value` is its own, so a `&str` can't borrow it.
+  deserializeStr(expected, visit) {
+    if (this.value.TAG === "String") return visit(this.value._0, false);
+    throw this.invalid(expected);
+  }
+
+  visitArray(visit) {
+    const items = this.value._0;
+    const seq = new $JsonValueSeq(items);
+    const value = visit(seq);
+    if (seq.count < items.length) throw $jsonError(`invalid length ${items.length}, expected fewer elements in array`);
+    return value;
+  }
+
+  visitObject(visit) {
+    const entries = $sortedEntries(this.value._0, $cmp);
+    const map = new $JsonValueMap(entries);
+    const value = visit(map);
+    if (map.count < entries.length) throw $jsonError(`invalid length ${entries.length}, expected fewer elements in map`);
+    return value;
+  }
+
+  deserializeSeq(expected, visit) {
+    if (this.value.TAG === "Array") return this.visitArray(visit);
+    throw this.invalid(expected);
+  }
+
+  deserializeMap(expected, visitMap, visitSeq) {
+    if (this.value.TAG === "Array" && visitSeq) return this.visitArray(visitSeq);
+    if (this.value.TAG === "Object") return this.visitObject(visitMap);
+    throw this.invalid(expected);
+  }
+
+  deserializeAny(expected, visitor) {
+    const value = this.value;
+    if (value === "Null") {
+      if (visitor.unit) return visitor.unit();
+      throw this.invalid(expected);
+    }
+    const { TAG: tag, _0: inner } = value;
+    if (tag === "Array") {
+      return this.visitArray((seq) => {
+        if (!visitor.seq) throw this.invalid(expected);
+        return visitor.seq(seq);
+      });
+    }
+    if (tag === "Object") {
+      return this.visitObject((map) => {
+        if (!visitor.map) throw this.invalid(expected);
+        return visitor.map(map);
+      });
+    }
+    const visit = { Bool: visitor.bool, Number: visitor.number, String: visitor.string }[tag];
+    if (visit) return visit(inner, false);
+    throw this.invalid(expected);
+  }
+
+  bool() {
+    if (this.value.TAG === "Bool") return this.value._0;
+    throw this.invalid("a boolean");
+  }
+
+  unit(expected = "unit") {
+    if (this.value === "Null") return undefined;
+    throw this.invalid(expected);
+  }
+
+  unitStruct(expected) {
+    return this.unit(expected);
+  }
+
+  option(read) {
+    return this.value === "Null" ? undefined : read(this);
+  }
+
+  ignoreValue() {}
+
+  // serde's `ContentVisitor` of it: a string is an owned one.
+  content() {
+    return $jsonValueContent(this.value);
+  }
+
+  enum(enumName, variants, visit, other) {
+    const value = this.value;
+    let name;
+    let held;
+    if (value.TAG === "Object") {
+      if (value._0.size !== 1) throw $jsonError("invalid value: map, expected map with a single key");
+      [[name, held]] = value._0;
+    } else if (value.TAG === "String") {
+      name = value._0;
+    } else {
+      throw this.invalid("string or map");
+    }
+    return visit($jsonVariantNamed(name, variants, other), new $JsonValueVariant(held));
+  }
+
+  identifier(variants, other) {
+    return this.deserializeStr("variant identifier", (name) => $jsonVariantNamed(name, variants, other));
+  }
+}
+
+export function $jsonValueContent(value) {
+  if (value === "Null") return { type: "unit" };
+  const { TAG: tag, _0: inner } = value;
+  if (tag === "Bool") return { type: "bool", value: inner };
+  if (tag === "Number") return { type: "num", value: inner };
+  if (tag === "String") return { type: "str", value: inner, borrowed: false };
+  if (tag === "Array") return { type: "seq", value: inner.map($jsonValueContent) };
+  const entries = $sortedEntries(inner, $cmp).map(([key, item]) => [
+    { type: "str", value: key, borrowed: false },
+    $jsonValueContent(item),
+  ]);
+  return { type: "map", value: entries };
+}
+
+export class $JsonValueSeq {
+  constructor(items) {
+    this.items = items;
+    this.count = 0;
+  }
+
+  next() {
+    return this.count < this.items.length && ++this.count > 0;
+  }
+
+  value(read) {
+    return read(new $JsonValueReader(this.items[this.count - 1]));
+  }
+
+  element(read, i, expected, missing, defaults) {
+    return $JsonSeq.prototype.element.call(this, read, i, expected, missing, defaults);
+  }
+}
+
+export class $JsonValueMap {
+  constructor(entries) {
+    this.entries = entries;
+    this.count = 0;
+  }
+
+  next() {
+    return this.count < this.entries.length && ++this.count > 0;
+  }
+
+  key() {
+    return new $JsonValueKey(this.entries[this.count - 1][0]);
+  }
+
+  value(read) {
+    return read(new $JsonValueReader(this.entries[this.count - 1][1]));
+  }
+}
+
+// serde_json's `MapKeyDeserializer`: an object's key, a number read from it
+// as JSON text would be.
+export class $JsonValueKey {
+  constructor(key) {
+    this.key = key;
+  }
+
+  string() {
+    return this.key;
+  }
+
+  char() {
+    return $jsonChar(this.key);
+  }
+
+  ignore() {}
+
+  content() {
+    return { type: "str", value: this.key, borrowed: false };
+  }
+
+  number(read) {
+    const json = new $JsonReader(this.key);
+    const c = json.peek();
+    if (!(c === 45 || (c >= 48 && c <= 57))) throw $jsonError("invalid value: expected key to be a number in quotes");
+    const value = read(json);
+    if (json.peek() !== -1) throw $jsonError("invalid value: expected key to be a number in quotes");
+    return value;
+  }
+
+  bool() {
+    if (this.key === "true" || this.key === "false") return this.key === "true";
+    throw $jsonError(`invalid type: string ${$debugStr(this.key)}, expected a boolean`);
+  }
+}
+
+// `VariantAccess` of a `Value`'s variant: what it holds, if anything.
+export class $JsonValueVariant {
+  constructor(held) {
+    this.held = held;
+  }
+
+  reader(kind, tag) {
+    if (this.held === undefined) throw $jsonError(`invalid type: unit variant, expected ${kind}`);
+    const reader = new $JsonValueReader(this.held);
+    if (tag && this.held.TAG !== tag) throw reader.invalid(kind);
+    return reader;
+  }
+
+  unit() {
+    if (this.held !== undefined) new $JsonValueReader(this.held).unit();
+  }
+
+  newtype(read) {
+    return read(this.reader("newtype variant"));
+  }
+
+  tuple(expected, fields, build, options) {
+    const reader = this.reader("tuple variant", "Array");
+    // An empty array is a unit, which a tuple variant isn't.
+    if (this.held._0.length === 0) throw $jsonError(`invalid type: null, expected ${options?.expecting ?? expected}`);
+    return reader.tupleStruct(expected, fields, build, options);
+  }
+
+  struct(expected, fields, build, options) {
+    if (options?.flatten) return this.reader("newtype variant").struct(expected, fields, build, options);
+    return this.reader("struct variant", "Object").struct(expected, fields, build, options);
+  }
+}
+
+// `serde_json::from_value`: a `Result` of what `read` reads of `value`.
+export function $fromJsonValue(value, read) {
+  try {
+    return { TAG: "Ok", _0: read(new $JsonValueReader(value)) };
+  } catch (e) {
+    if (e instanceof $JsonError) return { TAG: "Err", _0: { message: e.message, line: e.line, column: e.column } };
+    throw e;
+  }
+}
+
+// serde's `missing_field`: what a field that isn't there reads as, which is
+// `None` for an `Option`, and otherwise an error. An adjacently tagged
+// enum's content that isn't there is read so too, and is nothing for a
+// unit variant.
+export class $JsonMissing {
+  constructor(name) {
+    this.name = name;
+  }
+
+  option() {
+    return undefined;
+  }
+
+  untaggedUnit() {
+    return undefined;
+  }
+}
+for (const method of [
+  "bool", "int", "f64", "string", "char", "borrowedStr", "unit", "unitStruct", "vec", "tuple", "array", "map",
+  "struct", "untaggedStruct", "tupleStruct", "enum", "taggedUnit", "internallyTagged",
+  "adjacentlyTagged", "untagged",
+]) {
+  $JsonMissing.prototype[method] = function () {
+    throw $jsonError(`missing field \`${this.name}\``);
+  };
+}
+
+export const $JSON_UTF8 = new TextDecoder();
+export const $JSON_POW10 = Array.from({ length: 309 }, (_, i) => Number(`1e${i}`));
+
+// `significand * 10 + digit`, a BigInt once it's past 2^53.
+export function $jsonGrow(significand, digit) {
+  if (typeof significand === "number") {
+    const grown = significand * 10 + digit;
+    if (grown <= Number.MAX_SAFE_INTEGER) return grown;
+  }
+  return BigInt(significand) * 10n + BigInt(digit);
+}
+
+export function $jsonHexDigit(c) {
+  if (c >= 48 && c <= 57) return c - 48;
+  if (c >= 65 && c <= 70) return c - 55;
+  if (c >= 97 && c <= 102) return c - 87;
+  return -1;
+}
+
+// serde's `Unexpected` of a number, a float as serde_json writes one.
+export function $jsonUnexpectedNumber(n) {
+  return n.kind === "f" ? `floating point \`${$jsonNumber(n.value)}\`` : `integer \`${n.value}\``;
+}
+
+export function $jsonChar(s) {
+  if ([...s].length === 1) return s;
+  throw $jsonError(`invalid value: string ${$debugStr(s)}, expected a character`);
+}
+
+// serde's `Unexpected` of a value already read.
+export function $jsonUnexpectedContent({ type, value }) {
+  if (type === "unit") return "null";
+  if (type === "bool") return `boolean \`${value}\``;
+  if (type === "num") return $jsonUnexpectedNumber(value);
+  if (type === "str") return `string ${$debugStr(value)}`;
+  return type === "seq" ? "sequence" : "map";
+}
+
+// The variant a name names, or `other`'s, as a derive's variant visitor finds it.
+export function $jsonVariantNamed(name, variants, other) {
+  for (const names of variants) {
+    if (typeof names === "string" ? names === name : names.includes(name)) return $jsonName(names);
+  }
+  if (other !== undefined) return other;
+  throw variants.length === 0
+    ? $jsonError(`unknown variant \`${name}\`, there are no variants`)
+    : $jsonError(`unknown variant \`${name}\`, expected ${$jsonOneOf(variants)}`);
+}
+
+export function $jsonName(names) {
+  return typeof names === "string" ? names : names[0];
+}
+
+// The field a key names, or -1 to skip its value.
+export function $jsonField(key, fields, deny) {
+  const i = fields.findIndex(([names]) => (typeof names === "string" ? names === key : names.includes(key)));
+  if (i >= 0 || !deny) return i;
+  throw fields.length === 0
+    ? $jsonError(`unknown field \`${key}\`, there are no fields`)
+    : $jsonError(`unknown field \`${key}\`, expected ${$jsonOneOf(fields.map(([names]) => names))}`);
+}
+
+// serde's `OneOf`, of each name and its aliases, which serde keeps sorted.
+export function $jsonOneOf(entries) {
+  const byCodePoint = (a, b) => {
+    const [x, y] = [[...a], [...b]];
+    for (let i = 0; i < Math.min(x.length, y.length); i++) {
+      const d = x[i].codePointAt(0) - y[i].codePointAt(0);
+      if (d !== 0) return d;
+    }
+    return x.length - y.length;
+  };
+  const names = entries.flatMap((names) => (typeof names === "string" ? [names] : [...names].sort(byCodePoint)));
+  const quoted = names.map((name) => `\`${name}\``);
+  if (quoted.length === 1) return quoted[0];
+  if (quoted.length === 2) return `${quoted[0]} or ${quoted[1]}`;
+  return `one of ${quoted.join(", ")}`;
+}
+
+// What the crate reads with: `$json.u32`, `$json.option($json.string)`.
+export const $json = {
+  bool: (json) => json.bool(),
+  u8: (json) => json.int("u8", 0, 255),
+  u16: (json) => json.int("u16", 0, 65535),
+  u32: (json) => json.int("u32", 0, 4294967295),
+  usize: (json) => json.int("usize", 0, 4294967295),
+  i8: (json) => json.int("i8", -128, 127),
+  i16: (json) => json.int("i16", -32768, 32767),
+  i32: (json) => json.int("i32", -2147483648, 2147483647),
+  isize: (json) => json.int("isize", -2147483648, 2147483647),
+  u64: (json) => json.int("u64", 0n, 18446744073709551615n),
+  i64: (json) => json.int("i64", -9223372036854775808n, 9223372036854775807n),
+  f64: (json) => json.f64(),
+  string: (json) => json.string(),
+  str: (json) => json.borrowedStr(),
+  // serde_json's `Value` (ADR 0083), from whatever's there, and its `Number`.
+  value: (json) => json.deserializeAny("any valid JSON value", $JSON_VALUE),
+  number: (json) =>
+    json.deserializeAny("a JSON number", {
+      number: (n) => {
+        if (n.kind === "f" && !Number.isFinite(n.value)) throw $jsonError("not a JSON number");
+        return n;
+      },
+    }),
+  char: (json) => json.char(),
+  unit: (json) => json.unit(),
+  option: (read) => (json) => json.option(read),
+  // A generic `T` in an `Option`, boxed when it looks like `None` (ADR 0051).
+  some: (read) => (json) => $some(read(json)),
+  // A generic type's reader, given its type arguments' readers (ADR 0080).
+  with:
+    (deserialize, ...readers) =>
+    (json) =>
+      deserialize(json, ...readers),
+  vec: (read) => (json) => json.vec(read),
+  set: (read) => (json) => new Set(json.vec(read)),
+  map: (readKey, read) => (json) => json.map(readKey, read),
+  tuple: (...reads) => (json) => json.tuple(reads),
+  // `#[serde(try_from = "T")]`: the value of a `TryFrom`'s `Ok`, and of an
+  // `Err`, serde's `Error::custom` of its `display`.
+  tried: (result, display) => {
+    if (result.TAG === "Err") throw $jsonError(display(result._0));
+    return result._0;
+  },
+  // serde's impl for `Result`: `{"Ok": ..}` or `{"Err": ..}`.
+  result: (ok, err) => (json) =>
+    json.enum("Result", ["Ok", "Err"], (variant, content) => ({
+      TAG: variant,
+      _0: content.newtype(variant === "Ok" ? ok : err),
+    })),
+  array: (length, read) => (json) => json.array(length, read),
+  // An object's keys.
+  key: {
+    string: (key) => key.string(),
+    char: (key) => key.char(),
+    bool: (key) => key.bool(),
+    number: (read) => (key) => key.number(read),
+  },
+};
+
+// serde_json's `ValueVisitor`: a `Value` of each kind.
+export const $JSON_VALUE = {
+  unit: () => "Null",
+  bool: (b) => ({ TAG: "Bool", _0: b }),
+  number: (n) => ({ TAG: "Number", _0: n }),
+  string: (s) => ({ TAG: "String", _0: s }),
+  seq: (seq) => {
+    const items = [];
+    while (seq.next()) items.push(seq.value($json.value));
+    return { TAG: "Array", _0: items };
+  },
+  map: (map) => {
+    const entries = new Map();
+    while (map.next()) {
+      const key = map.key().string();
+      entries.set(key, map.value($json.value));
+    }
+    return { TAG: "Object", _0: entries };
+  },
+};
+
+// `serde_json::from_str`: a `Result` of what `read` reads, which must be
+// all there is.
+export function $fromJson(text, read) {
+  const json = new $JsonReader(text);
+  try {
+    const value = read(json);
+    json.end();
+    return { TAG: "Ok", _0: value };
+  } catch (e) {
+    if (e instanceof $JsonError) return { TAG: "Err", _0: { message: e.message, line: e.line, column: e.column } };
+    throw e;
+  }
+}
+
+// serde_json's `Value` (ADR 0083): `"Null"`, or `{ TAG, _0 }` of `Bool`,
+// `Number`, `String`, `Array` or `Object`, whose `Map` is a JS `Map`. A
+// `Number` is `{ kind, value }`: `"u"` and `"i"` are integers (a BigInt past
+// 2^53), `"f"` a finite float.
+
+// `Number::from` of an integer, and `Value::from` of an `f64`, which is
+// `Null` unless it's finite.
+export function $jsonInt(n) {
+  return { kind: n < 0 ? "i" : "u", value: n };
+}
+export function $jsonFloat(x) {
+  return Number.isFinite(x) ? { TAG: "Number", _0: { kind: "f", value: x } } : "Null";
+}
+// `Number::from_f64`: `None` unless it's finite.
+export function $jsonNumberOfF64(x) {
+  return Number.isFinite(x) ? { kind: "f", value: x } : undefined;
+}
+// `Value::from` of an `Option`: `Null`, or what it holds, converted.
+export function $jsonOption(o, convert) {
+  return o == null ? "Null" : convert(o);
+}
+
+export function $jsonNumberWrite(n, json) {
+  if (n.kind === "f") json.number(n.value);
+  else json.int(n.value);
+}
+
+// serde_json's `Serialize` for `Value`: an object's keys in the order its
+// `BTreeMap` keeps them.
+export function $jsonValueWrite(value, json) {
+  if (value === "Null") return json.null();
+  const { TAG: tag, _0: inner } = value;
+  if (tag === "Bool") return json.bool(inner);
+  if (tag === "Number") return $jsonNumberWrite(inner, json);
+  if (tag === "String") return json.string(inner);
+  if (tag === "Array") {
+    json.beginArray();
+    for (const item of inner) {
+      json.element();
+      $jsonValueWrite(item, json);
+    }
+    return json.endArray();
+  }
+  json.beginObject();
+  for (const [key, item] of $sortedEntries(inner, $cmp)) {
+    json.key(key);
+    $jsonValueWrite(item, json);
+  }
+  json.endObject();
+}
+
+// `clone()`: a copy of each array and map, which change in place; a
+// string or a number can't.
+export function $jsonValueClone(value) {
+  if (value.TAG === "Array") return { TAG: "Array", _0: value._0.map($jsonValueClone) };
+  if (value.TAG === "Object") return { TAG: "Object", _0: $jsonMapClone(value._0) };
+  return value;
+}
+export function $jsonMapClone(map) {
+  return new Map(Array.from(map, ([key, item]) => [key, $jsonValueClone(item)]));
+}
+
+// `{}` of a `Value`, its JSON, and with `{:#}`, its pretty JSON.
+export function $jsonValueText(value, pretty) {
+  return $toJson(value, $jsonValueWrite, pretty)._0;
+}
+export function $jsonNumberText(n) {
+  return n.kind === "f" ? $jsonNumber(n.value) : String(n.value);
+}
+
+// serde_json's `Debug`: `Null`, `Bool(true)`, `Number(1)`, `String("a")`,
+// `Array [..]` and `Object {..}`.
+export function $debugJsonValue(value) {
+  if (value === "Null") return "Null";
+  const { TAG: tag, _0: inner } = value;
+  if (tag === "Bool") return `Bool(${inner})`;
+  if (tag === "Number") return $debugJsonNumber(inner);
+  if (tag === "String") return `String(${$debugStr(inner)})`;
+  if (tag === "Array") return `Array [${inner.map($debugJsonValue).join(", ")}]`;
+  const entries = $sortedEntries(inner, $cmp).map(([key, item]) => `${$debugStr(key)}: ${$debugJsonValue(item)}`);
+  return `Object {${entries.join(", ")}}`;
+}
+export function $debugJsonNumber(n) {
+  return `Number(${$jsonNumberText(n)})`;
+}
+
+// `as_bool`, `as_str`, `as_array`, `as_object`: what the variant `tag`
+// holds, if it's that one.
+export function $jsonValueAs(value, tag) {
+  return value.TAG === tag ? value._0 : undefined;
+}
+export function $jsonValueF64(value) {
+  return value.TAG === "Number" ? $jsonNumberF64(value._0) : undefined;
+}
+export function $jsonNumberF64(n) {
+  return Number(n.value);
+}
+// `as_u64()` and `as_i64()`: the integer, a BigInt, if it's of that kind
+// and fits.
+export function $jsonNumberInt(n, kind) {
+  const fits = kind === "u64" ? n.kind === "u" : $jsonNumberIsI64(n);
+  return fits ? BigInt(n.value) : undefined;
+}
+export function $jsonValueInt(value, kind) {
+  return value.TAG === "Number" ? $jsonNumberInt(value._0, kind) : undefined;
+}
+export function $jsonNumberIsI64(n) {
+  return n.kind === "i" || (n.kind === "u" && n.value <= 9223372036854775807n);
+}
+// `is_f64`, `is_u64` and `is_i64` of a `Value`.
+export function $jsonValueIs(value, kind) {
+  if (value.TAG !== "Number") return false;
+  if (kind === "i64") return $jsonNumberIsI64(value._0);
+  return value._0.kind === kind[0];
+}
+
+// `get(key)` of an object, or `get(i)` of an array, and `value[key]`, which is
+// `Null` for what isn't there.
+export function $jsonGet(value, key) {
+  if (typeof key === "string") return value.TAG === "Object" ? value._0.get(key) : undefined;
+  return value.TAG === "Array" ? value._0[key] : undefined;
+}
+export function $jsonIndex(value, key) {
+  return $jsonGet(value, key) ?? "Null";
+}
+
+// serde_json's `PartialEq` of a `Value` and a `String`, a `bool` or a
+// number: `as_str()`, `as_bool()`, `as_f64()`, `as_i64()` or `as_u64()`
+// is it.
+export function $jsonValueEq(value, other, kind) {
+  if (kind === "String" || kind === "Bool") return value.TAG === kind && value._0 === other;
+  if (value.TAG !== "Number") return false;
+  const n = value._0;
+  if (kind === "f64") return Number(n.value) === other;
+  if (kind === "i64") return $jsonNumberIsI64(n) && n.value == other;
+  return n.kind === "u" && n.value == other;
+}
+
+// `serde_json::to_value`: a `Value` of what `write` writes, serde_json's
+// value serializer. A `NaN` is `Null`, and a map's keys are strings.
+export function $toJsonValue(value, write) {
+  const stack = [];
+  let root;
+  const put = (v) => {
+    const top = stack[stack.length - 1];
+    if (!top) root = v;
+    else if (top.items) top.items.push(v);
+    else top.entries.set(top.key, v);
+  };
+  const string = (s) => put({ TAG: "String", _0: s });
+  const open = () => stack.push({ items: [] });
+  const builder = {
+    null: () => put("Null"),
+    bool: (b) => put({ TAG: "Bool", _0: b }),
+    int: (n) => put({ TAG: "Number", _0: $jsonInt(n) }),
+    number: (x) => put($jsonFloat(x)),
+    char: string,
+    string,
+    variant: string,
+    beginArray: open,
+    beginTuple: open,
+    beginTupleStruct: open,
+    element() {},
+    endArray: () => put({ TAG: "Array", _0: stack.pop().items }),
+    beginObject: () => stack.push({ entries: new Map() }),
+    key(k) {
+      stack[stack.length - 1].key = k;
+    },
+    endObject: () => put({ TAG: "Object", _0: stack.pop().entries }),
+    flat(v, writeFlat) {
+      writeFlat(v, $jsonFlat(builder));
+    },
+  };
+  try {
+    write(value, builder);
+  } catch (e) {
+    if (e instanceof $JsonError) return { TAG: "Err", _0: { message: e.message, line: e.line, column: e.column } };
+    throw e;
+  }
+  return { TAG: "Ok", _0: root };
+}
+
+export function $displayJsonError(e) {
+  return e.line === 0 ? e.message : `${e.message} at line ${e.line} column ${e.column}`;
+}
+export function $debugJsonError(e) {
+  return `Error(${$debugStr(e.message)}, line: ${e.line}, column: ${e.column})`;
+}
+
+export function $lowerExp(x) {
+  if (Number.isNaN(x)) return "NaN";
+  if (!Number.isFinite(x)) return x > 0 ? "inf" : "-inf";
+  return x.toExponential().replace("e+", "e");
+}
+
+export function $fromDigit(num, radix) {
+  if (radix > 36) throw new Error("from_digit: radix is too high (maximum 36)");
+  return num < radix ? String.fromCharCode(num < 10 ? 48 + num : 87 + num) : undefined;
+}
+
+export function $fromU32(n) {
+  return n > 0x10ffff || (n >= 0xd800 && n <= 0xdfff) ? undefined : String.fromCodePoint(n);
+}
+
+export function $totalCmp(a, b) {
+  const view = new DataView(new ArrayBuffer(16));
+  view.setFloat64(0, a);
+  view.setFloat64(8, b);
+  const ordered = (bits) => bits ^ BigInt.asIntN(64, BigInt.asUintN(64, bits >> 63n) >> 1n);
+  const x = ordered(view.getBigInt64(0));
+  const y = ordered(view.getBigInt64(8));
+  return x < y ? -1 : x > y ? 1 : 0;
+}
+
+export function $drain(items, start, end = items.length) {
+  if (start > end) throw new Error(`slice index starts at ${start} but ends at ${end}`);
+  if (end > items.length) throw new Error(`range end index ${end} out of range for slice of length ${items.length}`);
+  return items.splice(start, end - start);
+}
+
+export function $splitOff(items, at) {
+  if (at > items.length) throw new Error(`\`at\` split index (is ${at}) should be <= len (is ${items.length})`);
+  return items.splice(at);
+}
+
+export function $peek(it) {
+  return it.items[it.at];
+}
+
+export function $nextIf(it, f) {
+  return it.at < it.items.length && f(it.items[it.at]) ? it.items[it.at++] : undefined;
+}
+
+export function $rest(it) {
+  const rest = it.items.slice(it.at);
+  it.at = it.items.length;
+  return rest;
+}
+
+export function $restStr(it) {
+  return it.items.slice(it.at).join("");
+}
+
+export function $unwrapErr(result, message = "called `Result::unwrap_err()` on an `Ok` value") {
+  if (result.TAG === "Ok") {
+    throw new Error(message + ": " + $debug(result._0));
+  }
+  return result._0;
+}
+
+export function $debugParseError(message, name) {
+  const kinds = {
+    "cannot parse integer from empty string": "Empty",
+    "invalid digit found in string": "InvalidDigit",
+    "number too large to fit in target type": "PosOverflow",
+    "number too small to fit in target type": "NegOverflow",
+    "number would be zero for non-zero type": "Zero",
+    "cannot parse float from empty string": "Empty",
+    "invalid float literal": "Invalid",
+    "cannot parse char from empty string": "EmptyString",
+    "too many characters in string": "TooManyChars",
+  };
+  if (name === "TryFromIntError") return `TryFromIntError(${message})`;
+  return name === "ParseBoolError" ? name : `${name} { kind: ${kinds[message]} }`;
+}
+
+export function $siftUp(heap, start, pos, cmp) {
+  const item = heap[pos];
+  while (pos > start) {
+    const parent = (pos - 1) >>> 1;
+    if (cmp(item, heap[parent]) <= 0) {
+      break;
+    }
+    heap[pos] = heap[parent];
+    pos = parent;
+  }
+  heap[pos] = item;
+  return pos;
+}
+
+export function $siftDown(heap, pos, end, cmp) {
+  const item = heap[pos];
+  let child = 2 * pos + 1;
+  while (child <= end - 2) {
+    if (cmp(heap[child], heap[child + 1]) <= 0) {
+      child += 1;
+    }
+    if (cmp(item, heap[child]) >= 0) {
+      heap[pos] = item;
+      return pos;
+    }
+    heap[pos] = heap[child];
+    pos = child;
+    child = 2 * pos + 1;
+  }
+  if (child === end - 1 && cmp(item, heap[child]) < 0) {
+    heap[pos] = heap[child];
+    pos = child;
+  }
+  heap[pos] = item;
+  return pos;
+}
+
+export function $heapPush(heap, item, cmp) {
+  heap.push(item);
+  $siftUp(heap, 0, heap.length - 1, cmp);
+}
+
+export function $heapPop(heap, cmp) {
+  if (heap.length === 0) {
+    return undefined;
+  }
+  let top = heap.pop();
+  if (heap.length > 0) {
+    [top, heap[0]] = [heap[0], top];
+    const end = heap.length;
+    const item = heap[0];
+    let pos = 0;
+    let child = 1;
+    while (child <= end - 2) {
+      if (cmp(heap[child], heap[child + 1]) <= 0) {
+        child += 1;
+      }
+      heap[pos] = heap[child];
+      pos = child;
+      child = 2 * pos + 1;
+    }
+    if (child === end - 1) {
+      heap[pos] = heap[child];
+      pos = child;
+    }
+    heap[pos] = item;
+    $siftUp(heap, 0, pos, cmp);
+  }
+  return top;
+}
+
+export function $heapSorted(items, cmp) {
+  const heap = items.slice();
+  let end = heap.length;
+  while (end > 1) {
+    end -= 1;
+    [heap[0], heap[end]] = [heap[end], heap[0]];
+    $siftDown(heap, 0, end, cmp);
+  }
+  return heap;
+}
+
+export function $heapFrom(items, cmp) {
+  const heap = items.slice();
+  let n = heap.length >>> 1;
+  while (n > 0) {
+    n -= 1;
+    $siftDown(heap, n, heap.length, cmp);
+  }
+  return heap;
+}
+
+export function $parseInt(s, min, max) {
+  const error = (message) => ({ TAG: "Err", _0: message });
+  if (s === "") return error("cannot parse integer from empty string");
+  if (!(min < 0 ? /^[+-]?[0-9]+$/ : /^\+?[0-9]+$/).test(s)) return error("invalid digit found in string");
+  const n = Number(s);
+  if (n > max) return error("number too large to fit in target type");
+  if (n < min) return error("number too small to fit in target type");
+  return { TAG: "Ok", _0: n };
+}
+
+export function $parseF64(s) {
+  if (s === "") return { TAG: "Err", _0: "cannot parse float from empty string" };
+  const lower = s.toLowerCase();
+  const sign = lower.startsWith("-") ? -1 : 1;
+  const rest = lower.replace(/^[+-]/, "");
+  if (rest === "inf" || rest === "infinity") return { TAG: "Ok", _0: sign * Infinity };
+  if (rest === "nan") return { TAG: "Ok", _0: NaN };
+  if (!/^([0-9]+\.?[0-9]*|\.[0-9]+)(e[+-]?[0-9]+)?$/.test(rest)) return { TAG: "Err", _0: "invalid float literal" };
+  return { TAG: "Ok", _0: sign * Number(rest) };
+}
+
+export function $parseBool(s) {
+  return s === "true" || s === "false"
+    ? { TAG: "Ok", _0: s === "true" }
+    : { TAG: "Err", _0: "provided string was not `true` or `false`" };
+}
+
+export function $parseChar(s) {
+  const chars = [...s];
+  if (chars.length === 1) return { TAG: "Ok", _0: s };
+  return { TAG: "Err", _0: chars.length === 0 ? "cannot parse char from empty string" : "too many characters in string" };
+}
+
+export function $slice(items, start, end = items.length) {
+  if (start > end) throw new Error(`slice index starts at ${start} but ends at ${end}`);
+  if (end > items.length) throw new Error(`range end index ${end} out of range for slice of length ${items.length}`);
+  return items.slice(start, end);
+}
+
+export function $sliceEnd(items, start, end = items.length) {
+  if (start > end) throw new Error(`slice index starts at ${start} but ends at ${end}`);
+  if (end > items.length) throw new Error(`range end index ${end} out of range for slice of length ${items.length}`);
+  return end;
+}
+
+export function $extend(v, items) {
+  for (const item of items) {
+    v.push(item);
+  }
+}
+
+export function $insertAt(v, index, item) {
+  if (index > v.length) {
+    throw new Error(`insertion index (is ${index}) should be <= len (is ${v.length})`);
+  }
+  v.splice(index, 0, item);
+}
+
+export function $removeAt(v, index) {
+  if (index >= v.length) {
+    throw new Error(`removal index (is ${index}) should be < len (is ${v.length})`);
+  }
+  return v.splice(index, 1)[0];
+}
+
+export function $swap(v, a, b) {
+  if (a >= v.length || b >= v.length) {
+    throw new Error(`index out of bounds: the len is ${v.length} but the index is ${Math.max(a, b)}`);
+  }
+  [v[a], v[b]] = [v[b], v[a]];
+}
+
+export function $truncate(v, length) {
+  if (length < v.length) {
+    v.length = length;
+  }
+}
+
+export function $dedup(v) {
+  let n = 0;
+  for (const item of v) {
+    if (n === 0 || v[n - 1] !== item) {
+      v[n++] = item;
+    }
+  }
+  v.length = n;
+}
+
+export function $windows(v, size) {
+  if (size === 0) {
+    throw new Error("window size must be non-zero");
+  }
+  return Array.from({ length: Math.max(0, v.length - size + 1) }, (_, i) => v.slice(i, i + size));
+}
+
+export function $chunks(v, size) {
+  if (size === 0) {
+    throw new Error("chunk size must be non-zero");
+  }
+  return Array.from({ length: Math.ceil(v.length / size) }, (_, i) => v.slice(i * size, i * size + size));
+}
+
+export function $zip(a, b) {
+  return Array.from({ length: Math.min(a.length, b.length) }, (_, i) => [a[i], b[i]]);
+}
+
+export function $takeWhile(items, keep) {
+  const end = items.findIndex((item) => !keep(item));
+  return end < 0 ? items.slice() : items.slice(0, end);
+}
+
+export function $skipWhile(items, skip) {
+  const start = items.findIndex((item) => !skip(item));
+  return start < 0 ? [] : items.slice(start);
+}
+
+export function $partition(items, keep) {
+  const yes = [];
+  const no = [];
+  for (const item of items) {
+    (keep(item) ? yes : no).push(item);
+  }
+  return [yes, no];
+}
+
+export function $sortedKeys(set, cmp) {
+  return Array.from(set).sort(cmp);
+}
+
+export function $stripPrefix(s, prefix) {
+  return s.startsWith(prefix) ? s.slice(prefix.length) : undefined;
+}
+
+export function $stripSuffix(s, suffix) {
+  return s.endsWith(suffix) ? s.slice(0, s.length - suffix.length) : undefined;
+}
+
+export function $splitOnce(s, separator) {
+  const i = s.indexOf(separator);
+  return i < 0 ? undefined : [s.slice(0, i), s.slice(i + separator.length)];
+}
+
+export function $rsplitOnce(s, separator) {
+  const i = s.lastIndexOf(separator);
+  return i < 0 ? undefined : [s.slice(0, i), s.slice(i + separator.length)];
+}
+
+export function $try(f) {
+  try {
+    return { TAG: "Ok", _0: f() };
+  } catch (e) {
+    return { TAG: "Err", _0: e };
+  }
+}
+
+export function $settle(promise) {
+  return promise.then((value) => ({ TAG: "Ok", _0: value }), (e) => ({ TAG: "Err", _0: e }));
+}
+
+export function $unwrapOk(result, message = "called `Result::unwrap()` on an `Err` value", debug = $debug) {
+  if (result.TAG === "Err") {
+    throw new Error(message + ": " + debug(result._0));
+  }
+  return result._0;
+}
+
+export function $range(start, end) {
+  return Array.from({ length: Math.max(0, end - start) }, (_, i) => start + i);
+}
+
+export function $cmp(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+export function $partialCmp(a, b) {
+  return a < b ? -1 : a > b ? 1 : a === b ? 0 : undefined;
+}
+
+export function $toFixed(value, digits) {
+  if (Number.isNaN(value)) return "NaN";
+  if (value === Infinity) return "inf";
+  if (value === -Infinity) return "-inf";
+  const sign = value < 0 || Object.is(value, -0) ? "-" : "";
+  const view = new DataView(new ArrayBuffer(8));
+  view.setFloat64(0, Math.abs(value));
+  const bits = view.getBigUint64(0);
+  const exponent = Number((bits >> 52n) & 2047n);
+  const fraction = bits & ((1n << 52n) - 1n);
+  const significand = exponent === 0 ? fraction : fraction | (1n << 52n);
+  const shift = exponent === 0 ? -1074 : exponent - 1075;
+  // |value| * 10^digits, as a fraction.
+  let numerator = significand * 10n ** BigInt(digits);
+  let denominator = 1n;
+  if (shift >= 0) numerator <<= BigInt(shift);
+  else denominator <<= BigInt(-shift);
+  let rounded = numerator / denominator;
+  const twice = 2n * (numerator % denominator);
+  if (twice > denominator || (twice === denominator && rounded % 2n === 1n)) rounded += 1n;
+  const text = rounded.toString().padStart(digits + 1, "0");
+  return sign + (digits === 0 ? text : text.slice(0, -digits) + "." + text.slice(-digits));
+}
+
+export function $debugF64(value) {
+  const size = Math.abs(value);
+  if (Number.isFinite(value) && size !== 0 && (size < 1e-4 || size >= 1e16)) {
+    return value.toExponential().replace("e+", "e");
+  }
+  const text = $displayF64(value);
+  return Number.isFinite(value) && !text.includes(".") ? text + ".0" : text;
+}
+
+export function $debugStr(s, quote = '"') {
+  let out = quote;
+  for (const c of s) {
+    if (c === quote || c === "\\") out += "\\" + c;
+    else if (c === "\n") out += "\\n";
+    else if (c === "\r") out += "\\r";
+    else if (c === "\t") out += "\\t";
+    else if (c === "\0") out += "\\0";
+    else if (/[\p{Cc}\p{Cf}\p{Cs}\p{Co}\p{Cn}\p{Zl}\p{Zp}\p{Grapheme_Extend}]/u.test(c) || (c !== " " && /\p{Zs}/u.test(c)))
+      out += "\\u{" + c.codePointAt(0).toString(16) + "}";
+    else out += c;
+  }
+  return out + quote;
+}
+
+export function $debugFields(name, fields, values) {
+  return name + " { " + fields.map((field, i) => field + ": " + values[i]).join(", ") + " }";
+}
+
+export function $plus(text) {
+  return text.startsWith("-") || text === "NaN" ? text : "+" + text;
+}
+
+export function $zeroPad(text, width) {
+  const head = /^[+-]?(0[xbo])?/.exec(text)[0];
+  return head + text.slice(head.length).padStart(width - head.length, "0");
+}
+
+export function $pad(text, width, align, fill = " ") {
+  const room = width - [...text].length;
+  if (room <= 0) return text;
+  const before = align === ">" ? room : align === "^" ? Math.floor(room / 2) : 0;
+  return fill.repeat(before) + text + fill.repeat(room - before);
+}
+
+export function $cmpIn(names, a, b) {
+  return $cmp(names.indexOf(a), names.indexOf(b));
+}
+
+export function $cmpItems(a, b, cmp) {
+  for (let i = 0; i < a.length && i < b.length; i++) {
+    const order = cmp(a[i], b[i]);
+    if (order !== 0) {
+      return order;
+    }
+  }
+  return $cmp(a.length, b.length);
+}
+
+export function $thenCmp(...orders) {
+  for (const order of orders) {
+    if (order !== 0) {
+      return order;
+    }
+  }
+  return 0;
+}
+
+export function $maxBy(items, cmp, boxed = false) {
+  if (items.length === 0) {
+    return undefined;
+  }
+  const max = items.reduce((max, x) => (cmp(x, max) >= 0 ? x : max));
+  return boxed ? $some(max) : max;
+}
+
+export function $minBy(items, cmp, boxed = false) {
+  if (items.length === 0) {
+    return undefined;
+  }
+  const min = items.reduce((min, x) => (cmp(x, min) < 0 ? x : min));
+  return boxed ? $some(min) : min;
+}
+
+export function $max(items) {
+  return items.length === 0 ? undefined : items.reduce((max, x) => (x >= max ? x : max));
+}
+
+export function $min(items) {
+  return items.length === 0 ? undefined : items.reduce((min, x) => (x < min ? x : min));
+}
+
+export function $position(items, found) {
+  const i = items.findIndex(found);
+  return i < 0 ? undefined : i;
+}