buninu-linux 0.7.4 → 0.7.5

package/initramfs/bin/parted

@@ -0,0 +1,178 @@
+#!/bin/bun
+// parted — GPT partitioning of a disk image, script mode only (see /lib/gpt.js).
+//
+//   parted [-s] IMAGE COMMAND...
+//
+// Commands, any number in a row as with parted -s:
+//   mklabel gpt
+//   mkpart NAME [FS-TYPE] START END    START/END with s, B, kB/MB/GB/TB,
+//                                      KiB/MiB/GiB/TiB, % or the current unit;
+//                                      a negative value counts from the end
+//   set NUMBER FLAG on|off             esp, boot, msftdata, bios_grub,
+//                                      legacy_boot, hidden, no_automount
+//   name NUMBER NAME
+//   rm NUMBER
+//   unit UNIT                          s, B, kB, MB, GB, TB, KiB, MiB, GiB, TiB, %
+//   print
+// START and END are used as given, without alignment; END is inclusive.
+
+import { closeSync, fstatSync, openSync } from "node:fs";
+import { GptError, SECTOR, TYPES, randomGuid, readGpt, usable, writeGpt } from "../lib/gpt.js";
+
+const fail = (message) => {
+  console.error(`Error: ${message}`);
+  process.exit(1);
+};
+
+const usage = () => {
+  console.error(`Usage: parted [-s] IMAGE COMMAND...
+  mklabel gpt | mkpart NAME [FS-TYPE] START END | set NUMBER FLAG on|off
+  name NUMBER NAME | rm NUMBER | unit UNIT | print`);
+  process.exit(1);
+};
+
+// -s is implied; -a takes a value and alignment is not applied anyway.
+const raw = process.argv.slice(2);
+const words = [];
+for (let index = 0; index < raw.length; index++) {
+  const argument = raw[index];
+  if (argument === "-s" || argument === "--script") continue;
+  if (argument === "-a" || argument === "--align") { index++; continue; }
+  if (argument.startsWith("--align=")) continue;
+  if (argument === "-h" || argument === "--help") usage();
+  if (argument.startsWith("-") && words.length === 0) fail(`unknown option ${argument}`);
+  words.push(argument);
+}
+if (words.length < 2) usage();
+const [image, ...commands] = words;
+
+let fd;
+try { fd = openSync(image, "r+"); } catch (error) { fail(`Could not stat device ${image} - ${error.message}.`); }
+const stat = fstatSync(fd);
+if (!stat.isFile()) fail(`${image}: only disk image files are supported`);
+const sectors = Math.floor(stat.size / SECTOR);
+if (sectors < 2 + 2 * 33 + 1) fail(`${image} is too small for a GPT`);
+
+let table = readGpt(fd, sectors);
+let dirty = false;
+let unit = "MB";
+
+const units = { s: SECTOR, B: 1, kB: 1e3, MB: 1e6, GB: 1e9, TB: 1e12, KiB: 1024, MiB: 1024 ** 2, GiB: 1024 ** 3, TiB: 1024 ** 4 };
+const unitName = (text) => Object.keys(units).find((name) => name.toLowerCase() === text.toLowerCase()) ?? (text === "%" ? "%" : null);
+
+/** A START or END position in sectors (END inclusive). */
+const position = (text, isEnd) => {
+  const match = /^(-?)(\d+(?:\.\d+)?)([a-zA-Z%]*)$/.exec(text);
+  if (!match) fail(`invalid position ${text}`);
+  const name = match[3] ? unitName(match[3]) : unit;
+  if (!name) fail(`invalid unit in ${text}`);
+  const amount = Number(match[2]);
+  if (name === "%") return Math.round((sectors - 1) * amount / 100);
+  const count = name === "s" ? amount : Math.round(amount * units[name] / SECTOR);
+  // A negative position counts back from the end of the disk: -1s is the last sector.
+  if (match[1]) return Math.floor(sectors - count);
+  return Math.floor(count - (isEnd && name !== "s" ? 1 : 0));
+};
+
+const requireTable = () => {
+  if (!table) fail(`${image}: unrecognised disk label`);
+  return table;
+};
+const partition = (text) => {
+  const number = Number(text);
+  const entry = requireTable().entries.find((candidate) => candidate.number === number);
+  if (!entry) fail(`Partition doesn't exist.`);
+  return entry;
+};
+
+const typeForFs = (fs) => {
+  if (!fs) return TYPES.linux;
+  if (/^(fat16|fat32|fat12|ntfs|exfat)$/i.test(fs)) return TYPES.msdata;
+  if (/^linux-swap/i.test(fs)) return TYPES.swap;
+  return TYPES.linux;
+};
+const knownFs = /^(fat12|fat16|fat32|ext2|ext3|ext4|btrfs|xfs|ntfs|exfat|linux-swap(\(v[01]\))?|hfs\+?|udf|zfs)$/i;
+
+const print = () => {
+  const current = requireTable();
+  const show = (sector) => unit === "s" ? `${sector}s` : unit === "%" ? `${((sector / (sectors - 1)) * 100).toFixed(1)}%` : `${+(sector * SECTOR / units[unit]).toFixed(1)}${unit}`;
+  console.log(`Model:  (file)\nDisk ${image}: ${show(sectors - 1 + (unit === "s" ? 1 : 0))}\nSector size (logical/physical): 512B/512B\nPartition Table: gpt\nDisk Flags: \n`);
+  console.log("Number  Start  End  Size  Name  Flags");
+  for (const entry of current.entries) {
+    const flags = [];
+    if (entry.type === TYPES.esp) flags.push("boot", "esp");
+    if (entry.type === TYPES.bios_grub) flags.push("bios_grub");
+    if (entry.type === TYPES.msdata) flags.push("msftdata");
+    if (entry.attributes & 4n) flags.push("legacy_boot");
+    console.log(` ${entry.number}  ${show(entry.first)}  ${show(entry.last)}  ${show(entry.last - entry.first + 1)}  ${entry.name}  ${flags.join(", ")}`);
+  }
+};
+
+try {
+  for (let index = 0; index < commands.length;) {
+    const command = commands[index++];
+    const take = (what) => {
+      if (index >= commands.length) fail(`${command}: expecting ${what}`);
+      return commands[index++];
+    };
+    if (command === "mklabel") {
+      const label = take("a disk label type");
+      if (label !== "gpt") fail(`only gpt labels are supported, not ${label}`);
+      table = { diskGuid: randomGuid(), entries: [] };
+      dirty = true;
+    } else if (command === "unit") {
+      const name = unitName(take("a unit"));
+      if (!name) fail(`invalid unit ${commands[index - 1]}`);
+      unit = name;
+    } else if (command === "mkpart") {
+      const current = requireTable();
+      const name = take("a partition name");
+      let fs = null;
+      if (knownFs.test(commands[index] ?? "")) fs = commands[index++];
+      const first = position(take("a start"), false);
+      const last = position(take("an end"), true);
+      const range = usable(sectors);
+      if (first < range.first || last > range.last || first > last) {
+        fail(`The location ${first}s-${last}s is outside of the usable range ${range.first}s-${range.last}s of the device.`);
+      }
+      if (current.entries.some((entry) => first <= entry.last && entry.first <= last)) fail("the partition overlaps another one");
+      let number = 1;
+      while (current.entries.some((entry) => entry.number === number)) number++;
+      current.entries.push({ number, type: typeForFs(fs), guid: randomGuid(), first, last, attributes: 0n, name, fs });
+      current.entries.sort((a, b) => a.number - b.number);
+      dirty = true;
+    } else if (command === "set") {
+      const entry = partition(take("a partition number"));
+      const flag = take("a flag").toLowerCase();
+      const state = take("on or off").toLowerCase();
+      if (state !== "on" && state !== "off") fail(`expecting on or off, not ${state}`);
+      const on = state === "on";
+      if (flag === "esp" || flag === "boot") entry.type = on ? TYPES.esp : typeForFs(entry.fs ?? "fat32");
+      else if (flag === "bios_grub") entry.type = on ? TYPES.bios_grub : typeForFs(entry.fs);
+      else if (flag === "msftdata") entry.type = on ? TYPES.msdata : TYPES.linux;
+      else {
+        const bits = { legacy_boot: 2n, hidden: 1n << 62n, no_automount: 1n << 63n }[flag];
+        if (bits === undefined) fail(`unsupported flag ${flag}`);
+        entry.attributes = on ? entry.attributes | bits : entry.attributes & ~bits;
+      }
+      dirty = true;
+    } else if (command === "name") {
+      const entry = partition(take("a partition number"));
+      entry.name = take("a name");
+      dirty = true;
+    } else if (command === "rm") {
+      const entry = partition(take("a partition number"));
+      table.entries = table.entries.filter((candidate) => candidate !== entry);
+      dirty = true;
+    } else if (command === "print") {
+      if (dirty) { writeGpt(fd, sectors, table); dirty = false; }
+      print();
+    } else fail(`unknown command ${command}`);
+  }
+  if (dirty) writeGpt(fd, sectors, table);
+} catch (error) {
+  if (error instanceof GptError) fail(error.message);
+  throw error;
+} finally {
+  closeSync(fd);
+}

package/initramfs/bin/truncate

@@ -0,0 +1,78 @@
+#!/bin/bun
+// truncate — set the size of files, creating them (sparse) when missing.
+//
+//   truncate -s [+|-|<|>|/|%]SIZE [-c] FILE...
+//
+// SIZE takes K, M, G, T (powers of 1024; KiB ... also), KB, MB, GB, TB
+// (powers of 1000) or nothing (bytes), as in coreutils.
+
+import { closeSync, fstatSync, ftruncateSync, openSync } from "node:fs";
+
+const fail = (message) => {
+  console.error(`truncate: ${message}`);
+  process.exit(1);
+};
+
+const usage = () => {
+  console.error(`Usage: truncate -s [+|-|<|>|/|%]SIZE [-c] FILE...`);
+  process.exit(1);
+};
+
+const units = { "": 1, K: 1024, M: 1024 ** 2, G: 1024 ** 3, T: 1024 ** 4, KB: 1e3, MB: 1e6, GB: 1e9, TB: 1e12 };
+const parseSize = (text) => {
+  const match = /^([+\-<>/%]?)(\d+)([KMGT]?)(B|iB)?$/i.exec(text);
+  if (!match) fail(`invalid size: '${text}'`);
+  const unit = match[3].toUpperCase() + (match[4] === "B" ? "B" : "");
+  if (!(unit in units)) fail(`invalid size: '${text}'`);
+  return { relation: match[1], bytes: Number(match[2]) * units[unit] };
+};
+
+let size = null;
+let create = true;
+const files = [];
+const argv = process.argv.slice(2);
+for (let index = 0; index < argv.length; index++) {
+  const argument = argv[index];
+  if (argument === "-h" || argument === "--help") usage();
+  else if (argument === "-s" || argument === "--size") {
+    if (index + 1 >= argv.length) fail("option requires an argument -- 's'");
+    size = parseSize(argv[++index]);
+  } else if (argument.startsWith("--size=")) size = parseSize(argument.slice(7));
+  else if (argument.startsWith("-s") && argument.length > 2) size = parseSize(argument.slice(2));
+  else if (argument === "-c" || argument === "--no-create") create = false;
+  else if (argument === "--") files.push(...argv.slice(index + 1)), index = argv.length;
+  else if (argument.startsWith("-") && argument !== "-") fail(`unknown option ${argument}`);
+  else files.push(argument);
+}
+if (size === null || files.length === 0) usage();
+
+let status = 0;
+for (const file of files) {
+  let fd;
+  try {
+    fd = openSync(file, create ? "a+" : "r+");
+  } catch (error) {
+    if (error.code === "ENOENT" && !create) continue;
+    console.error(`truncate: cannot open '${file}' for writing: ${error.message}`);
+    status = 1;
+    continue;
+  }
+  try {
+    const current = fstatSync(fd).size;
+    const { relation, bytes } = size;
+    const target = relation === "+" ? current + bytes
+      : relation === "-" ? Math.max(0, current - bytes)
+      : relation === "<" ? Math.min(current, bytes)
+      : relation === ">" ? Math.max(current, bytes)
+      : relation === "/" ? (bytes ? Math.floor(current / bytes) * bytes : fail("division by zero"))
+      : relation === "%" ? (bytes ? Math.ceil(current / bytes) * bytes : fail("division by zero"))
+      : bytes;
+    ftruncateSync(fd, target);
+  } catch (error) {
+    console.error(`truncate: failed to truncate '${file}': ${error.message}`);
+    status = 1;
+  } finally {
+    closeSync(fd);
+  }
+}
+process.exit(status);

package/initramfs/bin/unzip

@@ -0,0 +1,248 @@
+#!/bin/bun
+// unzip — list, test and extract zip archives (stored and deflated members,
+// zip64 included) over node:zlib.
+//
+// Supported: -p (members to standard output), -l (list), -t (test),
+// -d DIR, -o (overwrite), -n (never overwrite), -j (junk paths), -q/-qq;
+// MEMBER operands may be wildcards. Unix modes and symlinks are restored.
+// Runs under node as well as bun.
+
+import { chmodSync, closeSync, fstatSync, lstatSync, mkdirSync, openSync, readSync, rmSync, symlinkSync, writeFileSync, writeSync } from "node:fs";
+import { basename, dirname, join, normalize, resolve } from "node:path";
+import { inflateRawSync } from "node:zlib";
+import { crc32 } from "../lib/crc32.js";
+
+const fail = (message, status = 1) => {
+  console.error(`unzip: ${message}`);
+  process.exit(status);
+};
+
+const usage = () => {
+  console.error(`Usage:
+  unzip [-o|-n] [-j] [-q] ZIP [MEMBER...] [-d DIR]
+  unzip -p ZIP [MEMBER...]
+  unzip -l ZIP [MEMBER...]
+  unzip -t ZIP`);
+  process.exit(10);
+};
+
+let mode = "extract";
+let overwrite = null; // null: refuse, true: -o, false: -n
+let junkPaths = false;
+let quiet = 0;
+let directory = ".";
+const operands = [];
+const argv = process.argv.slice(2);
+for (let index = 0; index < argv.length; index++) {
+  const argument = argv[index];
+  if (argument === "-h" || argument === "--help") usage();
+  if (argument === "-d") {
+    if (index + 1 >= argv.length) fail("-d requires a directory", 10);
+    directory = argv[++index];
+    continue;
+  }
+  if (argument.startsWith("-d") && argument.length > 2) { directory = argument.slice(2); continue; }
+  if (argument.startsWith("-") && argument.length > 1) {
+    for (const letter of argument.slice(1)) {
+      if (letter === "p") mode = "pipe";
+      else if (letter === "l") mode = "list";
+      else if (letter === "t") mode = "test";
+      else if (letter === "o") overwrite = true;
+      else if (letter === "n") overwrite = false;
+      else if (letter === "j") junkPaths = true;
+      else if (letter === "q") quiet++;
+      else fail(`unknown option -${letter}`, 10);
+    }
+    continue;
+  }
+  operands.push(argument);
+}
+if (operands.length === 0) usage();
+const [archive, ...patterns] = operands;
+
+const fd = (() => {
+  try { return openSync(archive, "r"); } catch (error) { return fail(`cannot open ${archive}: ${error.message}`, 9); }
+})();
+const size = fstatSync(fd).size;
+const read = (position, length) => {
+  const buffer = Buffer.alloc(length);
+  let done = 0;
+  while (done < length) {
+    const count = readSync(fd, buffer, done, length - done, position + done);
+    if (count === 0) fail(`${archive}: unexpected end of file`, 3);
+    done += count;
+  }
+  return buffer;
+};
+
+// End of central directory: in the last 64 KiB + 22 bytes, searched backwards.
+const tailLength = Math.min(size, 65557);
+const tail = read(size - tailLength, tailLength);
+let eocd = -1;
+for (let offset = tailLength - 22; offset >= 0; offset--) {
+  if (tail.readUInt32LE(offset) === 0x06054b50) { eocd = offset; break; }
+}
+if (eocd < 0) fail(`${archive}: not a zip archive (no end of central directory)`, 9);
+let entryCount = tail.readUInt16LE(eocd + 10);
+let directorySize = tail.readUInt32LE(eocd + 12);
+let directoryOffset = tail.readUInt32LE(eocd + 16);
+// zip64: the locator sits just before the end of central directory record.
+if (eocd >= 20 && tail.readUInt32LE(eocd - 20) === 0x07064b50) {
+  const record = read(Number(tail.readBigUInt64LE(eocd - 20 + 8)), 56);
+  if (record.readUInt32LE(0) !== 0x06064b50) fail(`${archive}: bad zip64 end of central directory`, 3);
+  entryCount = Number(record.readBigUInt64LE(32));
+  directorySize = Number(record.readBigUInt64LE(40));
+  directoryOffset = Number(record.readBigUInt64LE(48));
+}
+
+const entries = [];
+const central = read(directoryOffset, directorySize);
+for (let offset = 0, index = 0; index < entryCount; index++) {
+  if (central.readUInt32LE(offset) !== 0x02014b50) fail(`${archive}: bad central directory entry ${index}`, 3);
+  const nameLength = central.readUInt16LE(offset + 28);
+  const extraLength = central.readUInt16LE(offset + 30);
+  const commentLength = central.readUInt16LE(offset + 32);
+  const flags = central.readUInt16LE(offset + 8);
+  const entry = {
+    madeBy: central.readUInt16LE(offset + 4) >> 8,
+    flags,
+    method: central.readUInt16LE(offset + 10),
+    time: central.readUInt16LE(offset + 12),
+    date: central.readUInt16LE(offset + 14),
+    crc: central.readUInt32LE(offset + 16),
+    compressedSize: central.readUInt32LE(offset + 20),
+    size: central.readUInt32LE(offset + 24),
+    external: central.readUInt32LE(offset + 38),
+    localOffset: central.readUInt32LE(offset + 42),
+    name: central.toString(flags & 0x800 ? "utf8" : "latin1", offset + 46, offset + 46 + nameLength),
+  };
+  // zip64 extra field: the 0xFFFFFFFF fields follow, in this order.
+  const extra = central.subarray(offset + 46 + nameLength, offset + 46 + nameLength + extraLength);
+  for (let position = 0; position + 4 <= extra.length;) {
+    const id = extra.readUInt16LE(position);
+    const length = extra.readUInt16LE(position + 2);
+    if (id === 0x0001) {
+      let field = position + 4;
+      for (const key of ["size", "compressedSize", "localOffset"]) {
+        if (entry[key] === 0xffffffff) { entry[key] = Number(extra.readBigUInt64LE(field)); field += 8; }
+      }
+    }
+    position += 4 + length;
+  }
+  entries.push(entry);
+  offset += 46 + nameLength + extraLength + commentLength;
+}
+
+// Bun.Glob when running under Bun; elsewhere the wildcards become a RegExp:
+// * and ? match across "/" as in Info-ZIP, [...] is a set.
+const globToRegExp = (pattern) => new RegExp(`^${pattern.replace(/\[[^\]]*\]|[*?]|[.+^${}()|\\]/g, (token) =>
+  token === "*" ? ".*" : token === "?" ? "." : token.startsWith("[") ? token.replace(/^\[!/, "[^") : `\\${token}`)}$`, "s");
+const toMatcher = (pattern) => {
+  if (typeof Bun !== "undefined") {
+    const glob = new Bun.Glob(pattern);
+    return { test: (name) => glob.match(name) };
+  }
+  return globToRegExp(pattern);
+};
+const globs = patterns.map(toMatcher);
+const selected = globs.length ? entries.filter((entry) => globs.some((glob) => glob.test(entry.name))) : entries;
+for (const [index, pattern] of patterns.entries()) {
+  if (!entries.some((entry) => globs[index].test(entry.name))) {
+    console.error(`caution: filename not matched:  ${pattern}`);
+  }
+}
+
+const dosDate = (entry) => {
+  const year = (entry.date >> 9) + 1980;
+  const month = (entry.date >> 5) & 15;
+  const day = entry.date & 31;
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${year}-${pad(month)}-${pad(day)} ${pad(entry.time >> 11)}:${pad((entry.time >> 5) & 63)}`;
+};
+
+const data = (entry) => {
+  if (entry.flags & 1) throw new Error("encrypted members are not supported");
+  const local = read(entry.localOffset, 30);
+  if (local.readUInt32LE(0) !== 0x04034b50) throw new Error("bad local header");
+  const start = entry.localOffset + 30 + local.readUInt16LE(26) + local.readUInt16LE(28);
+  const raw = read(start, entry.compressedSize);
+  let bytes;
+  if (entry.method === 0) bytes = raw;
+  else if (entry.method === 8) bytes = inflateRawSync(raw);
+  else throw new Error(`compression method ${entry.method} is not supported`);
+  if (bytes.length !== entry.size) throw new Error(`size mismatch (${bytes.length} != ${entry.size})`);
+  if (crc32(bytes) !== entry.crc) throw new Error("CRC error");
+  return bytes;
+};
+
+const writeAll = (target, bytes) => {
+  for (let offset = 0; offset < bytes.length;) offset += writeSync(target, bytes, offset, bytes.length - offset);
+};
+
+let status = 0;
+if (mode === "list") {
+  let total = 0;
+  console.log("  Length      Date    Time    Name\n---------  ---------- -----   ----");
+  for (const entry of selected) {
+    total += entry.size;
+    console.log(`${String(entry.size).padStart(9)}  ${dosDate(entry)}   ${entry.name}`);
+  }
+  console.log(`---------                     -------\n${String(total).padStart(9)}                     ${selected.length} file${selected.length === 1 ? "" : "s"}`);
+} else if (mode === "pipe") {
+  for (const entry of selected) {
+    if (entry.name.endsWith("/")) continue;
+    try { writeAll(1, data(entry)); } catch (error) { console.error(`unzip: ${entry.name}: ${error.message}`); status = 2; }
+  }
+} else if (mode === "test") {
+  for (const entry of selected) {
+    if (entry.name.endsWith("/")) continue;
+    try { data(entry); if (!quiet) console.log(`    testing: ${entry.name.padEnd(24)} OK`); }
+    catch (error) { console.log(`    testing: ${entry.name.padEnd(24)} ${error.message}`); status = 2; }
+  }
+  if (status === 0 && quiet < 2) console.log(`No errors detected in compressed data of ${archive}.`);
+} else {
+  if (!quiet) console.log(`Archive:  ${archive}`);
+  const root = resolve(directory);
+  mkdirSync(root, { recursive: true });
+  for (const entry of selected) {
+    const name = junkPaths ? basename(entry.name) : entry.name;
+    if (!name || (junkPaths && entry.name.endsWith("/"))) continue;
+    // No absolute paths or "..": a member never lands outside DIR.
+    const relative = normalize(name.replace(/^\/+/, ""));
+    if (relative.startsWith("..") || relative.split("/").includes("..")) {
+      console.error(`unzip: skipping ${entry.name}: path outside the destination`);
+      status = 1;
+      continue;
+    }
+    const target = join(root, relative);
+    const unixMode = entry.madeBy === 3 ? entry.external >>> 16 : 0;
+    try {
+      if (entry.name.endsWith("/")) {
+        mkdirSync(target, { recursive: true });
+        if (!quiet) console.log(`   creating: ${join(directory, relative)}/`);
+        if (unixMode & 0o7777) chmodSync(target, unixMode & 0o7777);
+        continue;
+      }
+      const exists = (() => { try { lstatSync(target); return true; } catch { return false; } })();
+      if (exists) {
+        if (overwrite === false) continue;
+        if (overwrite === null) { console.error(`unzip: ${join(directory, relative)} exists; use -o to overwrite or -n to skip`); status = 1; continue; }
+        rmSync(target, { force: true });
+      }
+      mkdirSync(dirname(target), { recursive: true });
+      const bytes = data(entry);
+      if ((unixMode & 0o170000) === 0o120000) {
+        symlinkSync(bytes.toString(), target);
+      } else {
+        writeFileSync(target, bytes);
+        if (unixMode & 0o7777) chmodSync(target, unixMode & 0o7777);
+      }
+      if (!quiet) console.log(`  inflating: ${join(directory, relative)}`);
+    } catch (error) {
+      console.error(`unzip: ${entry.name}: ${error.message}`);
+      status = 2;
+    }
+  }
+}
+closeSync(fd);
+process.exit(status);

package/initramfs/bin/zcat

@@ -0,0 +1,6 @@
+#!/bin/bun
+// zcat — see /lib/gzip.js.
+
+import { run } from "../lib/gzip.js";
+
+process.exit(run("zcat", process.argv.slice(2), { decompress: true, stdout: true }));

package/initramfs/lib/crc32.js

@@ -0,0 +1,16 @@
+// /lib/crc32.js — the CRC-32 of zip, gzip and GPT (IEEE 802.3, reflected,
+// polynomial 0xEDB88320).
+
+const table = new Uint32Array(256);
+for (let index = 0; index < 256; index++) {
+  let value = index;
+  for (let bit = 0; bit < 8; bit++) value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+  table[index] = value >>> 0;
+}
+
+/** CRC-32 of `bytes`, continuing from `previous` (the CRC of what came before). */
+export const crc32 = (bytes, previous = 0) => {
+  let crc = ~previous >>> 0;
+  for (let index = 0; index < bytes.length; index++) crc = table[(crc ^ bytes[index]) & 0xff] ^ (crc >>> 8);
+  return ~crc >>> 0;
+};