@amritk/nish-x86_64-linux 0.23.1 → 0.25.0

package/std/cli.ts

@@ -12,13 +12,15 @@
  *     menu.row("--times", "<n>", "say it n times");
  *     console.log(menu.text());
  *
- * **The terminal's own colours.** A `Style` paints with the eight basic SGR
- * colours, bold and faint, never a fixed RGB or 256-palette tone. Every theme
- * redefines those eight, so the menu comes out in whatever palette the reader
- * chose, and a terminal with no theme set paints them in its built-in
- * defaults. A terminal with no colours at all (`tput colors` says fewer than
- * eight) gets the failsafe: the same structure in bold and underline, which a
- * monochrome terminal still shows. Colour that is forced is the theme's.
+ * **The terminal's own colours.** A `Style` paints with the sixteen SGR
+ * colours (the eight basic ones and their bright twins), their backgrounds
+ * and the attributes, never a fixed RGB or 256-palette tone unless the caller
+ * asks for one through `sgr`. Every theme redefines those sixteen, so the
+ * menu comes out in whatever palette the reader chose, and a terminal with no
+ * theme set paints them in its built-in defaults. A terminal with no colours
+ * at all (`tput colors` says fewer than eight) gets the failsafe: the same
+ * structure in bold and underline, which a monochrome terminal still shows,
+ * and no colour from a colour painter. Colour that is forced is the theme's.
  *
  * **Colour is for a person reading a terminal**, and nothing else may see it:
  * a script that captures `--help`, a test that compares it, a pipe into `less`
@@ -56,18 +58,92 @@ const PALETTE_THEME: i32 = 0
 /** `paletteOf`'s answer: marked up in attributes only, the failsafe. */
 const PALETTE_MONO: i32 = 2
 
+/*
+ * The SGR parameters `Style`'s painters use, exported so a caller composes a
+ * list for `sgr` (`${SGR_BOLD};${SGR_RED}`) or a role (`flagThemed`) without
+ * spelling the numbers. The first sixteen are the colours a theme redefines:
+ * the eight basic ones and their bright twins.
+ */
+export const SGR_BLACK: string = "30"
+export const SGR_RED: string = "31"
+export const SGR_GREEN: string = "32"
+export const SGR_YELLOW: string = "33"
+export const SGR_BLUE: string = "34"
+export const SGR_MAGENTA: string = "35"
+export const SGR_CYAN: string = "36"
+export const SGR_WHITE: string = "37"
+export const SGR_BRIGHT_BLACK: string = "90"
+export const SGR_BRIGHT_RED: string = "91"
+export const SGR_BRIGHT_GREEN: string = "92"
+export const SGR_BRIGHT_YELLOW: string = "93"
+export const SGR_BRIGHT_BLUE: string = "94"
+export const SGR_BRIGHT_MAGENTA: string = "95"
+export const SGR_BRIGHT_CYAN: string = "96"
+export const SGR_BRIGHT_WHITE: string = "97"
+export const SGR_BG_BLACK: string = "40"
+export const SGR_BG_RED: string = "41"
+export const SGR_BG_GREEN: string = "42"
+export const SGR_BG_YELLOW: string = "43"
+export const SGR_BG_BLUE: string = "44"
+export const SGR_BG_MAGENTA: string = "45"
+export const SGR_BG_CYAN: string = "46"
+export const SGR_BG_WHITE: string = "47"
+export const SGR_BG_BRIGHT_BLACK: string = "100"
+export const SGR_BG_BRIGHT_RED: string = "101"
+export const SGR_BG_BRIGHT_GREEN: string = "102"
+export const SGR_BG_BRIGHT_YELLOW: string = "103"
+export const SGR_BG_BRIGHT_BLUE: string = "104"
+export const SGR_BG_BRIGHT_MAGENTA: string = "105"
+export const SGR_BG_BRIGHT_CYAN: string = "106"
+export const SGR_BG_BRIGHT_WHITE: string = "107"
+export const SGR_BOLD: string = "1"
+export const SGR_FAINT: string = "2"
+export const SGR_ITALIC: string = "3"
+export const SGR_UNDERLINE: string = "4"
+export const SGR_INVERSE: string = "7"
+export const SGR_STRIKETHROUGH: string = "9"
+
 /**
  * How one output stream is painted. `on` says whether to mark the text up at
  * all, and `colour` whether the terminal has colours to mark it up with;
  * without them each mark falls back to bold, underline or nothing.
+ *
+ * Each help role (`heading`, `name`, `flag`, `meta`, `dim`) keeps a pair of
+ * SGR lists, the theme's and the failsafe's, so a program recolours its menu
+ * by setting a pair (`flagThemed`, `flagMono`) and `styleFor` still decides
+ * whether, and which of the two, it paints. An empty list leaves the role
+ * plain.
  */
 export class Style {
   on: boolean
   colour: boolean
+  headingThemed: string
+  headingMono: string
+  nameThemed: string
+  nameMono: string
+  flagThemed: string
+  flagMono: string
+  metaThemed: string
+  metaMono: string
+  dimThemed: string
+  dimMono: string
 
   constructor(on: boolean, colour: boolean) {
     this.on = on
     this.colour = colour
+    // Bold magenta, spelled out: a template here would allocate per Style.
+    this.headingThemed = "1;35"
+    this.headingMono = SGR_BOLD
+    this.nameThemed = "1;35"
+    this.nameMono = SGR_BOLD
+    this.flagThemed = SGR_CYAN
+    this.flagMono = SGR_BOLD
+    this.metaThemed = SGR_YELLOW
+    this.metaMono = SGR_UNDERLINE
+    // Faint rather than bright black, which Solarized makes the background;
+    // plain without colour, where the bold flags already stand apart from it.
+    this.dimThemed = SGR_FAINT
+    this.dimMono = ""
   }
 
   /**
@@ -84,33 +160,246 @@ export class Style {
     return `${CSI}${code}m${text}${CSI}0m`
   }
 
-  /** A section heading: bold, in the theme's magenta. */
+  /** A section heading, in `headingThemed` or `headingMono`. */
   heading(text: string): string {
-    return this.paint(text, "1;35", "1")
+    return this.paint(text, this.headingThemed, this.headingMono)
   }
 
-  /** The tool's own name where it opens a line. */
+  /**
+   * The tool's own name where it opens a line, in `nameThemed` or
+   * `nameMono`.
+   */
   name(text: string): string {
-    return this.paint(text, "1;35", "1")
+    return this.paint(text, this.nameThemed, this.nameMono)
   }
 
-  /** A flag, or a command a person would type. */
+  /**
+   * A flag, or a command a person would type, in `flagThemed` or
+   * `flagMono`.
+   */
   flag(text: string): string {
-    return this.paint(text, "36", "1")
+    return this.paint(text, this.flagThemed, this.flagMono)
   }
 
-  /** A placeholder the person fills in: `<file.ts>`, `speed|size`. */
+  /**
+   * A placeholder the person fills in, such as `<file.ts>` or `speed|size`, in
+   * `metaThemed` or `metaMono`.
+   */
   meta(text: string): string {
-    return this.paint(text, "33", "4")
+    return this.paint(text, this.metaThemed, this.metaMono)
   }
 
   /**
-   * Text that explains rather than names: descriptions, notes. Faint rather
-   * than bright black, which Solarized makes the background; plain without
-   * colour, where the bold flags already stand apart from it.
+   * Text that explains rather than names, such as descriptions and notes, in
+   * `dimThemed` or `dimMono`.
    */
   dim(text: string): string {
-    return this.paint(text, "2", "")
+    return this.paint(text, this.dimThemed, this.dimMono)
+  }
+
+  /**
+   * `text` painted with any SGR parameter list (`"1;31"`, `"38;5;208"`,
+   * `"38;2;255;128;0"`) when colour is on, and unchanged otherwise: the way to
+   * 256-colour and truecolor, which ignore the reader's theme, so they stay
+   * the caller's explicit choice. The failsafe paints nothing, since the list
+   * may name a colour a monochrome terminal cannot show.
+   */
+  sgr(text: string, codes: string): string {
+    return this.paint(text, codes, "")
+  }
+
+  // The colour painters go through `sgr`, so the failsafe, which has no
+  // colours to show, paints none of them; the attribute painters paint under
+  // both.
+
+  /** `text` in the theme's black. */
+  black(text: string): string {
+    return this.sgr(text, SGR_BLACK)
+  }
+
+  /** `text` in the theme's red. */
+  red(text: string): string {
+    return this.sgr(text, SGR_RED)
+  }
+
+  /** `text` in the theme's green. */
+  green(text: string): string {
+    return this.sgr(text, SGR_GREEN)
+  }
+
+  /** `text` in the theme's yellow. */
+  yellow(text: string): string {
+    return this.sgr(text, SGR_YELLOW)
+  }
+
+  /** `text` in the theme's blue. */
+  blue(text: string): string {
+    return this.sgr(text, SGR_BLUE)
+  }
+
+  /** `text` in the theme's magenta. */
+  magenta(text: string): string {
+    return this.sgr(text, SGR_MAGENTA)
+  }
+
+  /** `text` in the theme's cyan. */
+  cyan(text: string): string {
+    return this.sgr(text, SGR_CYAN)
+  }
+
+  /** `text` in the theme's white. */
+  white(text: string): string {
+    return this.sgr(text, SGR_WHITE)
+  }
+
+  /** `text` in the theme's bright black (gray). */
+  brightBlack(text: string): string {
+    return this.sgr(text, SGR_BRIGHT_BLACK)
+  }
+
+  /** `text` in the theme's bright red. */
+  brightRed(text: string): string {
+    return this.sgr(text, SGR_BRIGHT_RED)
+  }
+
+  /** `text` in the theme's bright green. */
+  brightGreen(text: string): string {
+    return this.sgr(text, SGR_BRIGHT_GREEN)
+  }
+
+  /** `text` in the theme's bright yellow. */
+  brightYellow(text: string): string {
+    return this.sgr(text, SGR_BRIGHT_YELLOW)
+  }
+
+  /** `text` in the theme's bright blue. */
+  brightBlue(text: string): string {
+    return this.sgr(text, SGR_BRIGHT_BLUE)
+  }
+
+  /** `text` in the theme's bright magenta. */
+  brightMagenta(text: string): string {
+    return this.sgr(text, SGR_BRIGHT_MAGENTA)
+  }
+
+  /** `text` in the theme's bright cyan. */
+  brightCyan(text: string): string {
+    return this.sgr(text, SGR_BRIGHT_CYAN)
+  }
+
+  /** `text` in the theme's bright white. */
+  brightWhite(text: string): string {
+    return this.sgr(text, SGR_BRIGHT_WHITE)
+  }
+
+  /** `text` on the theme's black. */
+  bgBlack(text: string): string {
+    return this.sgr(text, SGR_BG_BLACK)
+  }
+
+  /** `text` on the theme's red. */
+  bgRed(text: string): string {
+    return this.sgr(text, SGR_BG_RED)
+  }
+
+  /** `text` on the theme's green. */
+  bgGreen(text: string): string {
+    return this.sgr(text, SGR_BG_GREEN)
+  }
+
+  /** `text` on the theme's yellow. */
+  bgYellow(text: string): string {
+    return this.sgr(text, SGR_BG_YELLOW)
+  }
+
+  /** `text` on the theme's blue. */
+  bgBlue(text: string): string {
+    return this.sgr(text, SGR_BG_BLUE)
+  }
+
+  /** `text` on the theme's magenta. */
+  bgMagenta(text: string): string {
+    return this.sgr(text, SGR_BG_MAGENTA)
+  }
+
+  /** `text` on the theme's cyan. */
+  bgCyan(text: string): string {
+    return this.sgr(text, SGR_BG_CYAN)
+  }
+
+  /** `text` on the theme's white. */
+  bgWhite(text: string): string {
+    return this.sgr(text, SGR_BG_WHITE)
+  }
+
+  /** `text` on the theme's bright black. */
+  bgBrightBlack(text: string): string {
+    return this.sgr(text, SGR_BG_BRIGHT_BLACK)
+  }
+
+  /** `text` on the theme's bright red. */
+  bgBrightRed(text: string): string {
+    return this.sgr(text, SGR_BG_BRIGHT_RED)
+  }
+
+  /** `text` on the theme's bright green. */
+  bgBrightGreen(text: string): string {
+    return this.sgr(text, SGR_BG_BRIGHT_GREEN)
+  }
+
+  /** `text` on the theme's bright yellow. */
+  bgBrightYellow(text: string): string {
+    return this.sgr(text, SGR_BG_BRIGHT_YELLOW)
+  }
+
+  /** `text` on the theme's bright blue. */
+  bgBrightBlue(text: string): string {
+    return this.sgr(text, SGR_BG_BRIGHT_BLUE)
+  }
+
+  /** `text` on the theme's bright magenta. */
+  bgBrightMagenta(text: string): string {
+    return this.sgr(text, SGR_BG_BRIGHT_MAGENTA)
+  }
+
+  /** `text` on the theme's bright cyan. */
+  bgBrightCyan(text: string): string {
+    return this.sgr(text, SGR_BG_BRIGHT_CYAN)
+  }
+
+  /** `text` on the theme's bright white. */
+  bgBrightWhite(text: string): string {
+    return this.sgr(text, SGR_BG_BRIGHT_WHITE)
+  }
+
+  /** `text` bold. */
+  bold(text: string): string {
+    return this.paint(text, SGR_BOLD, SGR_BOLD)
+  }
+
+  /** `text` faint. */
+  faint(text: string): string {
+    return this.paint(text, SGR_FAINT, SGR_FAINT)
+  }
+
+  /** `text` italic, where the terminal has it. */
+  italic(text: string): string {
+    return this.paint(text, SGR_ITALIC, SGR_ITALIC)
+  }
+
+  /** `text` underlined. */
+  underline(text: string): string {
+    return this.paint(text, SGR_UNDERLINE, SGR_UNDERLINE)
+  }
+
+  /** `text` with foreground and background swapped. */
+  inverse(text: string): string {
+    return this.paint(text, SGR_INVERSE, SGR_INVERSE)
+  }
+
+  /** `text` struck through. */
+  strikethrough(text: string): string {
+    return this.paint(text, SGR_STRIKETHROUGH, SGR_STRIKETHROUGH)
   }
 }
 

package/std/compress/checksum.ts

@@ -0,0 +1,290 @@
+/**
+ * `nish/compress/checksum` — the two checksums the compressed formats carry:
+ * CRC-32 (ISO 3309, the polynomial gzip's trailer uses, RFC 1952 §8) and
+ * Adler-32 (zlib's trailer, RFC 1950 §9).
+ *
+ *     import { Crc32 } from "nish/compress/checksum";
+ *
+ *     const crc = new Crc32(); // the tables, once
+ *     let c: u32 = crc.update(toU32(0), body, 0, 100);
+ *     c = crc.update(c, body, 100, toI32(body.length) - 100); // the same as one call
+ *
+ * A module has no global state, so CRC-32's tables live in a `Crc32` object:
+ * build one and keep it, because building it is 4,096 table entries (about
+ * ten microseconds) and an update of a 5 KB body is under one. `crc32`
+ * is the one-off convenience that builds a table for one call.
+ *
+ * CRC-32 is slicing-by-8: eight 256-entry tables, eight bytes per step with
+ * one table read per byte and no dependency between the reads of a step
+ * (Kounavis and Berry, "A Systematic Approach to Building High Performance
+ * Software-based CRC Generators", 2005). From 80 bytes on it is also braided
+ * five ways (Kadatch and Jenkins, 2010), so five steps are in flight at once;
+ * the braids have a second set of eight tables. Adler-32 defers its two modulo
+ * reductions to once every 5,552 bytes, the most that cannot overflow 32 bits
+ * (RFC 1950 §9 and zlib's `NMAX`).
+ *
+ * Neither is a cryptographic hash: both detect accidental corruption only.
+ * Written from the specifications, not ported from another implementation.
+ *
+ * The table reads in `update` are `nish:unsafe`'s `uncheckedGet`: every index
+ * is a byte plus a multiple of 256 below 2,048, and both tables are built here
+ * at exactly that length and never replaced, which is the whole proof. The input
+ * window is checked once, before the loop.
+ */
+import { uncheckedGet, uncheckedSet } from "nish:unsafe"
+
+/** The reflected CRC-32 polynomial, x^32 + x^26 + ... + 1 (RFC 1952 §8). */
+const CRC32_POLY: i64 = 0xedb88320
+
+/** The entries of the eight slicing tables, 256 each. */
+const CRC32_TABLE_SIZE: i32 = 2048
+
+/**
+ * The braids `Crc32.update` runs at once over a long input, each over every
+ * fifth 8-byte word, and the bytes a block of one word per braid spans.
+ */
+const CRC32_BRAIDS: i32 = 5
+const CRC32_BLOCK: i32 = 40
+
+/** The shortest input `Crc32.update` braids: two blocks, one braided and the last joined. */
+const CRC32_BRAID_MIN: i32 = 80
+
+/** zlib's `NMAX`: the most bytes Adler-32's sums take before they must be reduced. */
+const ADLER32_NMAX: i32 = 5552
+
+/** The Adler-32 modulus, the largest prime below 2^16 (RFC 1950 §9). */
+const ADLER32_BASE: i32 = 65521
+
+/**
+ * The little-endian 64-bit word at `buf[p .. p + 8)`, which the caller has
+ * checked. `p`'s range makes each `p + k` an `add nsw`, which lets LLVM load
+ * the word at once.
+ */
+const checksumLoad64 = (buf: u8[], p: integer<0, 2147483639>): u64 =>
+  toU64(uncheckedGet(buf, p)) |
+  (toU64(uncheckedGet(buf, p + 1)) << toU64(8)) |
+  (toU64(uncheckedGet(buf, p + 2)) << toU64(16)) |
+  (toU64(uncheckedGet(buf, p + 3)) << toU64(24)) |
+  (toU64(uncheckedGet(buf, p + 4)) << toU64(32)) |
+  (toU64(uncheckedGet(buf, p + 5)) << toU64(40)) |
+  (toU64(uncheckedGet(buf, p + 6)) << toU64(48)) |
+  (toU64(uncheckedGet(buf, p + 7)) << toU64(56))
+
+/**
+ * One slicing-by-8 step: the register `c` advanced over the eight bytes of
+ * `w`. `t` is the 2,048-entry table, which every caller has checked.
+ */
+const crc32Step = (t: u32[], c: u32, w: u64): u32 => {
+  const lo: u32 = c ^ toU32(w)
+  const hi: u32 = toU32(w >> toU64(32))
+  return (
+    uncheckedGet(t, 1792 + toI32(lo & 255)) ^
+    uncheckedGet(t, 1536 + toI32((lo >>> 8) & 255)) ^
+    uncheckedGet(t, 1280 + toI32((lo >>> 16) & 255)) ^
+    uncheckedGet(t, 1024 + toI32(lo >>> 24)) ^
+    uncheckedGet(t, 768 + toI32(hi & 255)) ^
+    uncheckedGet(t, 512 + toI32((hi >>> 8) & 255)) ^
+    uncheckedGet(t, 256 + toI32((hi >>> 16) & 255)) ^
+    uncheckedGet(t, toI32(hi >>> 24))
+  )
+}
+
+/** Panics unless `buf[off .. off + len)` lies inside `buf`. */
+const checksumWindow = (what: string, buf: u8[], off: i32, len: i32): void => {
+  if (off < 0 || len < 0 || off > toI32(buf.length) - len) {
+    panic(`${what}: the window lies outside its array`)
+  }
+}
+
+/**
+ * CRC-32's lookup tables, built once and read by every `update`. The object
+ * holds nothing else, so one may be shared by every compressor and reader in
+ * a thread, and by threads that only read it.
+ */
+export class Crc32 {
+  /** `table[k * 256 + b]`: the CRC of byte `b` followed by `k` zero bytes. */
+  readonly table: u32[]
+  /**
+   * `braid[k * 256 + b]`: the same, followed by the 32 bytes of the other
+   * four braids' words as well, which a braid steps over.
+   */
+  readonly braid: u32[]
+
+  /** Builds the eight tables and their braided form. */
+  constructor() {
+    const t: u32[] = new Array<u32>(CRC32_TABLE_SIZE)
+    for (let i: i32 = 0; i < 256; i += 1) {
+      let c: u32 = toU32(i)
+      for (let k: i32 = 0; k < 8; k += 1) {
+        c = (c & 1) !== 0 ? toU32(CRC32_POLY) ^ (c >>> 1) : c >>> 1
+      }
+      uncheckedSet(t, i, c)
+    }
+    for (let i: i32 = 256; i < CRC32_TABLE_SIZE; i += 1) {
+      const prev: u32 = uncheckedGet(t, i - 256)
+      uncheckedSet(t, i, (prev >>> 8) ^ uncheckedGet(t, toI32(prev & 255)))
+    }
+    this.table = t
+    // A register is linear in its bytes, so each braided table is its eight
+    // one-bit entries, stepped over the 32 bytes, and XORs of them.
+    const braid: u32[] = new Array<u32>(CRC32_TABLE_SIZE)
+    const bits: u32[] = new Array<u32>(8)
+    for (let k: i32 = 0; k < 8; k += 1) {
+      for (let i: i32 = 0; i < 8; i += 1) {
+        let c: u32 = uncheckedGet(t, k * 256 + (toI32(1) << i))
+        for (let z: i32 = 0; z < (CRC32_BRAIDS - 1) * 8; z += 1) {
+          c = (c >>> 8) ^ uncheckedGet(t, toI32(c & 255))
+        }
+        bits[i] = c
+      }
+      uncheckedSet(braid, k * 256, toU32(0))
+      for (let b: i32 = 1; b < 256; b += 1) {
+        const low: i32 = 31 - toI32(Math.clz32(toU32(b & -b)))
+        if (low >= 0 && low < 8) {
+          uncheckedSet(braid, k * 256 + b, uncheckedGet(braid, k * 256 + (b & (b - 1))) ^ bits[low])
+        }
+      }
+    }
+    this.braid = braid
+  }
+
+  /**
+   * The CRC-32 of the bytes `crc` was the CRC of, followed by
+   * `buf[off .. off + len)`. Start a new checksum from 0. A window outside
+   * `buf` panics.
+   */
+  update(crc: u32, buf: u8[], off: i32, len: i32): u32 {
+    checksumWindow("Crc32.update", buf, off, len)
+    const t: u32[] = this.table
+    const bt: u32[] = this.braid
+    if (toI32(t.length) !== CRC32_TABLE_SIZE || toI32(bt.length) !== CRC32_TABLE_SIZE) {
+      panic("Crc32.update: the table is not its size")
+    }
+    let c: u32 = ~crc
+    let p: i32 = off
+    const end: i32 = off + len
+    if (len >= CRC32_BRAID_MIN) {
+      // Braided (Kadatch and Jenkins, "Everything we know about CRC but
+      // afraid to forget", 2010): five chains, each over every fifth 8-byte
+      // word, so a step's table reads overlap the other four's instead of
+      // waiting on its own last. A braid's table also steps it over the
+      // other braids' 32 bytes, so before each block every register sits at
+      // its own word's place. The last block is taken one word at a time
+      // with the plain table, each braid's register joining as its word
+      // comes, which adds them into one.
+      const blocks: i32 = len / CRC32_BLOCK
+      const lastBlock: i32 = off + (blocks - 1) * CRC32_BLOCK
+      let c1: u32 = 0
+      let c2: u32 = 0
+      let c3: u32 = 0
+      let c4: u32 = 0
+      // Each word's position is a local the loop condition bounds, which
+      // is what lets it enter the loader's range without a check.
+      let p1: i32 = p + 8
+      let p2: i32 = p + 16
+      let p3: i32 = p + 24
+      let p4: i32 = p + 32
+      while (
+        p < lastBlock &&
+        p >= 0 &&
+        p1 >= 0 &&
+        p2 >= 0 &&
+        p3 >= 0 &&
+        p4 >= 0 &&
+        p4 <= 2147483639 &&
+        p3 <= 2147483639 &&
+        p2 <= 2147483639 &&
+        p1 <= 2147483639 &&
+        p <= 2147483639
+      ) {
+        c = crc32Step(bt, c, checksumLoad64(buf, p))
+        c1 = crc32Step(bt, c1, checksumLoad64(buf, p1))
+        c2 = crc32Step(bt, c2, checksumLoad64(buf, p2))
+        c3 = crc32Step(bt, c3, checksumLoad64(buf, p3))
+        c4 = crc32Step(bt, c4, checksumLoad64(buf, p4))
+        p += CRC32_BLOCK
+        p1 += CRC32_BLOCK
+        p2 += CRC32_BLOCK
+        p3 += CRC32_BLOCK
+        p4 += CRC32_BLOCK
+      }
+      if (
+        p >= 0 &&
+        p1 >= 0 &&
+        p2 >= 0 &&
+        p3 >= 0 &&
+        p4 >= 0 &&
+        p4 <= 2147483639 &&
+        p3 <= 2147483639 &&
+        p2 <= 2147483639 &&
+        p1 <= 2147483639 &&
+        p <= 2147483639
+      ) {
+        c = crc32Step(t, c, checksumLoad64(buf, p))
+        c = crc32Step(t, c ^ c1, checksumLoad64(buf, p1))
+        c = crc32Step(t, c ^ c2, checksumLoad64(buf, p2))
+        c = crc32Step(t, c ^ c3, checksumLoad64(buf, p3))
+        c = crc32Step(t, c ^ c4, checksumLoad64(buf, p4))
+        p += CRC32_BLOCK
+      }
+    }
+    const whole: i32 = end - (len & 7)
+    while (p < whole && p >= 0 && p <= 2147483639) {
+      c = crc32Step(t, c, checksumLoad64(buf, p))
+      p += 8
+    }
+    while (p < end) {
+      c = uncheckedGet(t, toI32((c ^ toU32(uncheckedGet(buf, p))) & 255)) ^ (c >>> 8)
+      p += 1
+    }
+    return ~c
+  }
+}
+
+/**
+ * The CRC-32 of `buf[off .. off + len)`. It builds a `Crc32` for the one
+ * call, which costs about as much as checksumming 5 KB: keep a `Crc32` for
+ * anything repeated. A window outside `buf` panics.
+ */
+export const crc32 = (buf: u8[], off: i32, len: i32): u32 => new Crc32().update(toU32(0), buf, off, len)
+
+/**
+ * The Adler-32 of the bytes `adler` was the Adler-32 of, followed by
+ * `buf[off .. off + len)` (RFC 1950 §9). Start a new checksum from 1. A
+ * window outside `buf` panics.
+ */
+export const adler32Update = (adler: u32, buf: u8[], off: i32, len: i32): u32 => {
+  checksumWindow("adler32Update", buf, off, len)
+  let s1: u32 = adler & 0xffff
+  let s2: u32 = adler >>> 16
+  let p: i32 = off
+  const end: i32 = off + len
+  while (p < end) {
+    let stop: i32 = p + ADLER32_NMAX
+    if (stop > end) {
+      stop = end
+    }
+    while (p + 4 <= stop) {
+      s1 += toU32(uncheckedGet(buf, p))
+      s2 += s1
+      s1 += toU32(uncheckedGet(buf, p + 1))
+      s2 += s1
+      s1 += toU32(uncheckedGet(buf, p + 2))
+      s2 += s1
+      s1 += toU32(uncheckedGet(buf, p + 3))
+      s2 += s1
+      p += 4
+    }
+    while (p < stop) {
+      s1 += toU32(uncheckedGet(buf, p))
+      s2 += s1
+      p += 1
+    }
+    s1 = s1 % toU32(ADLER32_BASE)
+    s2 = s2 % toU32(ADLER32_BASE)
+  }
+  return (s2 << 16) | s1
+}
+
+/** The Adler-32 of `buf[off .. off + len)`. A window outside `buf` panics. */
+export const adler32 = (buf: u8[], off: i32, len: i32): u32 => adler32Update(toU32(1), buf, off, len)