@graphty/graph-samples 0.0.1 → 0.1.2

package/dist/generators.js

@@ -0,0 +1,4496 @@
+import { MAX_COUNT } from "@graphty/graph-format";
+const LN2_HI$1 = 0.6931471803691238;
+const LN2_LO$1 = 19082149292705877e-26;
+const TWO54 = 18014398509481984;
+const LG1 = 0.6666666666666735;
+const LG2 = 0.3999999999940942;
+const LG3 = 0.2857142874366239;
+const LG4 = 0.22222198432149784;
+const LG5 = 0.1818357216161805;
+const LG6 = 0.15313837699209373;
+const LG7 = 0.14798198605116586;
+const view$1 = new DataView(new ArrayBuffer(8));
+function detLog(input) {
+  let x = input;
+  view$1.setFloat64(0, x, true);
+  let hx = view$1.getInt32(4, true);
+  const lx = view$1.getUint32(0, true);
+  let k = 0;
+  if (hx < 1048576) {
+    if ((hx & 2147483647 | lx) === 0) {
+      return -Infinity;
+    }
+    if (hx < 0) {
+      return NaN;
+    }
+    k -= 54;
+    x *= TWO54;
+    view$1.setFloat64(0, x, true);
+    hx = view$1.getInt32(4, true);
+  }
+  if (hx >= 2146435072) {
+    return x + x;
+  }
+  k += (hx >> 20) - 1023;
+  hx &= 1048575;
+  const i0 = hx + 614244 & 1048576;
+  view$1.setInt32(4, hx | i0 ^ 1072693248, true);
+  x = view$1.getFloat64(0, true);
+  k += i0 >> 20;
+  const f = x - 1;
+  if ((1048575 & 2 + hx) < 3) {
+    if (f === 0) {
+      return k === 0 ? 0 : k * LN2_HI$1 + k * LN2_LO$1;
+    }
+    const r = f * f * (0.5 - 0.3333333333333333 * f);
+    return k === 0 ? f - r : k * LN2_HI$1 - (r - k * LN2_LO$1 - f);
+  }
+  const s = f / (2 + f);
+  const dk = k;
+  const z = s * s;
+  let i = hx - 398458;
+  const w = z * z;
+  const j = 440401 - hx;
+  const t1 = w * (LG2 + w * (LG4 + w * LG6));
+  const t2 = z * (LG1 + w * (LG3 + w * (LG5 + w * LG7)));
+  i |= j;
+  const R = t2 + t1;
+  if (i > 0) {
+    const hfsq = 0.5 * f * f;
+    return k === 0 ? f - (hfsq - s * (hfsq + R)) : dk * LN2_HI$1 - (hfsq - (s * (hfsq + R) + dk * LN2_LO$1) - f);
+  }
+  return k === 0 ? f - s * (f - R) : dk * LN2_HI$1 - (s * (f - R) - dk * LN2_LO$1 - f);
+}
+const ROTATIONS = [13, 15, 26, 6, 17, 29, 16, 24];
+const KS_PARITY = 466688986;
+function threefry2x32(k0, k1, c0, c1, out) {
+  const ks0 = k0 >>> 0;
+  const ks1 = k1 >>> 0;
+  const ks2 = (KS_PARITY ^ ks0 ^ ks1) >>> 0;
+  const ks = [ks0, ks1, ks2];
+  let x0 = c0 + ks0 | 0;
+  let x1 = c1 + ks1 | 0;
+  for (let round = 0; round < 20; round++) {
+    x0 = x0 + x1 | 0;
+    const r = ROTATIONS[round & 7];
+    x1 = x1 << r | x1 >>> 32 - r;
+    x1 ^= x0;
+    if ((round & 3) === 3) {
+      const s = round + 1 >>> 2;
+      x0 = x0 + ks[s % 3] | 0;
+      x1 = x1 + ks[(s + 1) % 3] + s | 0;
+    }
+  }
+  out[0] = x0;
+  out[1] = x1;
+}
+const TWO_32 = 4294967296;
+const TWO_53 = 9007199254740992;
+function domainId(name) {
+  let h = 2166136261;
+  for (let i = 0; i < name.length; i++) {
+    h ^= name.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+const DEFAULT_SEED = 0;
+function resolveSeed(seed) {
+  const resolved = seed ?? DEFAULT_SEED;
+  checkSeed(resolved);
+  return resolved;
+}
+function checkSeed(seed) {
+  if (!Number.isSafeInteger(seed) || seed < 0) {
+    throw new RangeError(`seed must be an integer in [0, 2^53), got ${String(seed)}`);
+  }
+}
+class RandomStream {
+  /**
+   * The stream of one block.
+   * @param seed - the caller's seed, an integer in [0, 2^53)
+   * @param domain - the generator's fixed domain name
+   * @param block - the first block, an integer in [0, 2^32)
+   */
+  constructor(seed, domain, block) {
+    this.key = new Uint32Array(2);
+    this.out = new Uint32Array(2);
+    this.counter = 0;
+    this.spare = -1;
+    checkSeed(seed);
+    this.seedLo = seed >>> 0;
+    this.seedHi = Math.floor(seed / TWO_32);
+    this.domain = domainId(domain);
+    this.reset(block);
+  }
+  /**
+   * Restart the stream at the first word of another block of the same seed and domain.
+   * @param block - the block, an integer in [0, 2^32)
+   */
+  reset(block) {
+    threefry2x32(this.seedLo, this.seedHi, this.domain, block >>> 0, this.key);
+    this.counter = 0;
+    this.spare = -1;
+  }
+  /**
+   * The next word.
+   * @returns an unsigned 32-bit integer
+   */
+  nextU32() {
+    if (this.spare >= 0) {
+      const word = this.spare;
+      this.spare = -1;
+      return word;
+    }
+    const c = this.counter++;
+    threefry2x32(this.key[0], this.key[1], c >>> 0, Math.floor(c / TWO_32), this.out);
+    this.spare = this.out[1];
+    return this.out[0];
+  }
+  /**
+   * A uniform double in [0, 1) with 53 random bits: (a >>> 5) * 2^26 + (b >>> 6), over 2^53,
+   * for the next two words a and b. Exact: every step is an integer below 2^53.
+   * @returns the double
+   */
+  nextFloat() {
+    const a = this.nextU32() >>> 5;
+    const b = this.nextU32() >>> 6;
+    return (a * 67108864 + b) / TWO_53;
+  }
+  /**
+   * A uniform integer in [0, n) by masked rejection: draw a word, keep its low
+   * ceil(log2 n) bits, retry while the result is >= n. Exact and unbiased; fewer than two
+   * words per call on average. For n above 2^32 the high bits come from one extra word drawn
+   * first.
+   * @param n - the bound, an integer in [1, 2^53]
+   * @returns the integer
+   */
+  nextBelow(n) {
+    if (n <= TWO_32) {
+      const mask = n === 1 ? 0 : 4294967295 >>> Math.clz32(n - 1);
+      for (; ; ) {
+        const x = (this.nextU32() & mask) >>> 0;
+        if (x < n) {
+          return x;
+        }
+      }
+    }
+    const hiBound = Math.ceil(n / TWO_32);
+    const hiMask = 4294967295 >>> Math.clz32(hiBound - 1);
+    for (; ; ) {
+      const hi = (this.nextU32() & hiMask) >>> 0;
+      const x = hi * TWO_32 + this.nextU32();
+      if (x < n) {
+        return x;
+      }
+    }
+  }
+  /**
+   * The number of failures before the next success of a Bernoulli(p) sequence, given
+   * `logQ = detLog(1 - p)` for 0 < p < 1: floor(detLog(1 - u) / logQ) for u = nextFloat().
+   * The caller handles p = 0 and p = 1 without drawing.
+   * @param logQ - detLog(1 - p), negative and finite
+   * @returns a non-negative integer (possibly above 2^53 for tiny p)
+   */
+  nextSkip(logQ) {
+    return Math.floor(detLog(1 - this.nextFloat()) / logQ);
+  }
+}
+function checkInt(name, value, min, max = MAX_COUNT) {
+  if (!Number.isInteger(value) || value < min || value > max) {
+    throw new RangeError(`${name} must be an integer in [${min}, ${max}], got ${String(value)}`);
+  }
+}
+function checkProbability(name, value) {
+  if (!(value >= 0 && value <= 1)) {
+    throw new RangeError(`${name} must be a probability in [0, 1], got ${String(value)}`);
+  }
+}
+function checkEdgeCount(count) {
+  if (count > MAX_COUNT) {
+    throw new RangeError(`the graph would have ${count} edges, above the limit of ${MAX_COUNT}`);
+  }
+}
+class EdgeBuffer {
+  /**
+   * An empty buffer.
+   * @param capacity - the initial capacity in edges
+   */
+  constructor(capacity) {
+    this.length = 0;
+    const size = Math.max(16, Math.min(capacity, MAX_COUNT));
+    this.src = new Uint32Array(size);
+    this.dst = new Uint32Array(size);
+  }
+  /**
+   * Append one edge.
+   * @param u - the source index
+   * @param v - the target index
+   */
+  push(u, v) {
+    if (this.length === this.src.length) {
+      this.grow();
+    }
+    this.src[this.length] = u;
+    this.dst[this.length] = v;
+    this.length++;
+  }
+  /**
+   * The edges pushed so far as exactly sized arrays (copies when the buffer has slack).
+   * @returns the endpoint arrays
+   */
+  finish() {
+    if (this.length === this.src.length) {
+      return { src: this.src, dst: this.dst };
+    }
+    return { src: this.src.slice(0, this.length), dst: this.dst.slice(0, this.length) };
+  }
+  grow() {
+    checkEdgeCount(this.length + 1);
+    const size = Math.min(this.src.length * 2, MAX_COUNT);
+    const src = new Uint32Array(size);
+    const dst = new Uint32Array(size);
+    src.set(this.src);
+    dst.set(this.dst);
+    this.src = src;
+    this.dst = dst;
+  }
+}
+function binomialBuffer(pairs, p) {
+  const mean = pairs * p;
+  checkEdgeCount(mean);
+  return new EdgeBuffer(Math.ceil(mean + 6 * Math.sqrt(mean * (1 - p)) + 16));
+}
+function bernoulliSegment(stream, p, logQ, row, lo, hi, out) {
+  if (p === 0 || lo >= hi) {
+    return;
+  }
+  if (p === 1) {
+    for (let c2 = lo; c2 < hi; c2++) {
+      out.push(row, c2);
+    }
+    return;
+  }
+  let c = lo + stream.nextSkip(logQ);
+  while (c < hi) {
+    out.push(row, c);
+    c += 1 + stream.nextSkip(logQ);
+  }
+}
+function toGraph(nodeCount, edges, directed, nodeColumns) {
+  const { src, dst } = edges.finish();
+  return nodeColumns === void 0 ? { directed, nodeCount, src, dst } : { directed, nodeCount, src, dst, nodeColumns };
+}
+function numericColumn(graph, name) {
+  const column = graph.nodeColumns?.[name];
+  if (column === void 0 || !ArrayBuffer.isView(column)) {
+    throw new RangeError(`weights: the graph has no numeric node column "${name}"`);
+  }
+  return column;
+}
+function drawWeights(graph, spec, seed) {
+  const m = graph.src.length;
+  const out = new Float32Array(m);
+  const { src, dst } = graph;
+  const stream = new RandomStream(seed, "weights", 0);
+  switch (spec.kind) {
+    case "uniform": {
+      const min = spec.min ?? 0;
+      const max = spec.max ?? 1;
+      if (!(Number.isFinite(min) && Number.isFinite(max) && min <= max)) {
+        throw new RangeError(`weights: uniform needs finite min <= max, got ${min} and ${max}`);
+      }
+      for (let e = 0; e < m; e++) {
+        out[e] = min + (max - min) * stream.nextFloat();
+      }
+      break;
+    }
+    case "integer": {
+      const { min, max } = spec;
+      if (!(Number.isSafeInteger(min) && Number.isSafeInteger(max) && min <= max)) {
+        throw new RangeError(`weights: integer needs integers min <= max, got ${min} and ${max}`);
+      }
+      for (let e = 0; e < m; e++) {
+        out[e] = min + stream.nextBelow(max - min + 1);
+      }
+      break;
+    }
+    case "exponential": {
+      const mean = spec.mean ?? 1;
+      if (!(mean > 0 && Number.isFinite(mean))) {
+        throw new RangeError(`weights: exponential needs a positive mean, got ${mean}`);
+      }
+      for (let e = 0; e < m; e++) {
+        out[e] = -mean * detLog(1 - stream.nextFloat());
+      }
+      break;
+    }
+    case "euclidean": {
+      const x = numericColumn(graph, "x");
+      const y = numericColumn(graph, "y");
+      const z = graph.nodeColumns?.z === void 0 ? null : numericColumn(graph, "z");
+      for (let e = 0; e < m; e++) {
+        const dx = x[src[e]] - x[dst[e]];
+        const dy = y[src[e]] - y[dst[e]];
+        const dz = z === null ? 0 : z[src[e]] - z[dst[e]];
+        out[e] = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      }
+      break;
+    }
+    default: {
+      const values = numericColumn(graph, spec.column);
+      const combine = spec.combine ?? "sum";
+      for (let e = 0; e < m; e++) {
+        const a = values[src[e]];
+        const b = values[dst[e]];
+        out[e] = combineValues(combine, a, b);
+      }
+    }
+  }
+  return out;
+}
+function combineValues(combine, a, b) {
+  switch (combine) {
+    case "source":
+      return a;
+    case "target":
+      return b;
+    case "sum":
+      return a + b;
+    case "mean":
+      return (a + b) / 2;
+    case "product":
+      return a * b;
+    case "min":
+      return Math.min(a, b);
+    case "max":
+      return Math.max(a, b);
+    default:
+      return Math.abs(a - b);
+  }
+}
+function withWeights(graph, spec, seed) {
+  return { ...graph, weights: drawWeights(graph, spec, resolveSeed(seed)) };
+}
+function applyWeights(graph, options) {
+  return options.weights === void 0 ? graph : withWeights(graph, options.weights, options.seed);
+}
+function plantedMatching(n, seed) {
+  const stream = new RandomStream(seed, "bipartite-matching", 0);
+  const match = new Uint32Array(n);
+  for (let i = 0; i < n; i++) {
+    match[i] = i;
+  }
+  for (let i = n - 1; i > 0; i--) {
+    const j = stream.nextBelow(i + 1);
+    const t = match[i];
+    match[i] = match[j];
+    match[j] = t;
+  }
+  return match;
+}
+function bipartiteRows(options, match, start, end, out) {
+  const { n1, n2, p } = options;
+  const seed = resolveSeed(options.seed);
+  const logQ = detLog(1 - p);
+  const stream = new RandomStream(seed, "bipartite", 0);
+  for (let u = start; u < end; u++) {
+    stream.reset(u);
+    let pending = match === null ? -1 : match[u];
+    const emit = (j) => {
+      if (pending >= 0 && pending < j) {
+        out.push(u, n1 + pending);
+      }
+      if (pending >= 0 && pending <= j) {
+        pending = -1;
+      }
+      out.push(u, n1 + j);
+    };
+    if (p === 1) {
+      for (let j = 0; j < n2; j++) {
+        emit(j);
+      }
+    } else if (p > 0) {
+      let j = stream.nextSkip(logQ);
+      while (j < n2) {
+        emit(j);
+        j += 1 + stream.nextSkip(logQ);
+      }
+    }
+    if (pending >= 0) {
+      out.push(u, n1 + pending);
+    }
+  }
+}
+function randomBipartiteGraph(options) {
+  const { n1, n2, p } = options;
+  checkInt("n1", n1, 0);
+  checkInt("n2", n2, 0);
+  checkInt("n1 + n2", n1 + n2, 0);
+  checkProbability("p", p);
+  const seed = resolveSeed(options.seed);
+  let match = null;
+  if (options.perfectMatching === true) {
+    if (n1 !== n2) {
+      throw new RangeError(`perfectMatching needs n1 === n2, got ${n1} and ${n2}`);
+    }
+    match = plantedMatching(n1, seed);
+  }
+  const out = binomialBuffer(n1 * n2, p);
+  bipartiteRows(options, match, 0, n1, out);
+  const side = new Uint8Array(n1 + n2).fill(1, n1);
+  return applyWeights(toGraph(n1 + n2, out, false, { side }), options);
+}
+function planBlocks(options) {
+  const { sizes, probabilities } = options;
+  const seed = resolveSeed(options.seed);
+  const count = sizes.length;
+  checkInt("sizes.length", count, 1);
+  if (probabilities.length !== count) {
+    throw new RangeError(`probabilities must be ${count} x ${count}`);
+  }
+  const starts = [0];
+  for (let b = 0; b < count; b++) {
+    checkInt(`sizes[${b}]`, sizes[b], 0);
+    starts.push(starts[b] + sizes[b]);
+    if (probabilities[b].length !== count) {
+      throw new RangeError(`probabilities must be ${count} x ${count}`);
+    }
+    for (let c = 0; c < count; c++) {
+      checkProbability(`probabilities[${b}][${c}]`, probabilities[b][c]);
+      if (probabilities[b][c] !== probabilities[c][b]) {
+        throw new RangeError(`probabilities must be symmetric: [${b}][${c}] differs from [${c}][${b}]`);
+      }
+    }
+  }
+  const n = starts[count];
+  checkInt("the total size", n, 0);
+  const block = new Uint32Array(n);
+  for (let b = 0; b < count; b++) {
+    block.fill(b, starts[b], starts[b + 1]);
+  }
+  return {
+    n,
+    seed,
+    starts,
+    block,
+    p: probabilities,
+    logQ: probabilities.map((row) => row.map((p) => detLog(1 - p)))
+  };
+}
+function blockModelRows(plan, start, end, out) {
+  const { starts, block, p, logQ } = plan;
+  const stream = new RandomStream(plan.seed, "sbm", 0);
+  const count = starts.length - 1;
+  for (let u = start; u < end; u++) {
+    stream.reset(u);
+    const b = block[u];
+    for (let c = b; c < count; c++) {
+      bernoulliSegment(stream, p[b][c], logQ[b][c], u, c === b ? u + 1 : starts[c], starts[c + 1], out);
+    }
+  }
+}
+function stochasticBlockModelGraph(options) {
+  const plan = planBlocks(options);
+  let expected = 0;
+  let pairs = 0;
+  for (let b = 0; b < plan.starts.length - 1; b++) {
+    for (let c = b; c < plan.starts.length - 1; c++) {
+      const sb = plan.starts[b + 1] - plan.starts[b];
+      const sc = plan.starts[c + 1] - plan.starts[c];
+      const blockPairs = b === c ? sb * (sb - 1) / 2 : sb * sc;
+      expected += blockPairs * plan.p[b][c];
+      pairs += blockPairs;
+    }
+  }
+  const out = binomialBuffer(pairs, pairs === 0 ? 0 : expected / pairs);
+  blockModelRows(plan, 0, plan.n, out);
+  return applyWeights(toGraph(plan.n, out, false, { community: plan.block }), options);
+}
+function plantedPartitionGraph(options) {
+  const { groups, groupSize, pIn, pOut, seed } = options;
+  checkInt("groups", groups, 1);
+  checkInt("groupSize", groupSize, 1);
+  return stochasticBlockModelGraph({
+    sizes: new Array(groups).fill(groupSize),
+    probabilities: Array.from(
+      { length: groups },
+      (_, b) => Array.from({ length: groups }, (_2, c) => b === c ? pIn : pOut)
+    ),
+    seed,
+    weights: options.weights
+  });
+}
+function pushClique(out, lo, size) {
+  for (let i = lo; i < lo + size; i++) {
+    for (let j = i + 1; j < lo + size; j++) {
+      out.push(i, j);
+    }
+  }
+}
+function pathGraph(options) {
+  const { n } = options;
+  checkInt("n", n, 0);
+  const out = new EdgeBuffer(n);
+  for (let i = 0; i + 1 < n; i++) {
+    out.push(i, i + 1);
+  }
+  return applyWeights(toGraph(n, out, false), options);
+}
+function cycleGraph(options) {
+  const { n } = options;
+  checkInt("n", n, 3);
+  const out = new EdgeBuffer(n);
+  for (let i = 0; i + 1 < n; i++) {
+    out.push(i, i + 1);
+  }
+  out.push(n - 1, 0);
+  return applyWeights(toGraph(n, out, false), options);
+}
+function starGraph(options) {
+  const { n } = options;
+  checkInt("n", n, 1);
+  const out = new EdgeBuffer(n);
+  for (let i = 1; i < n; i++) {
+    out.push(0, i);
+  }
+  return applyWeights(toGraph(n, out, false), options);
+}
+function wheelGraph(options) {
+  const { n } = options;
+  checkInt("n", n, 4);
+  const out = new EdgeBuffer(2 * n);
+  for (let i = 1; i < n; i++) {
+    out.push(0, i);
+  }
+  for (let i = 1; i + 1 < n; i++) {
+    out.push(i, i + 1);
+  }
+  out.push(n - 1, 1);
+  return applyWeights(toGraph(n, out, false), options);
+}
+function completeGraph(options) {
+  const { n } = options;
+  checkInt("n", n, 0);
+  const m = n * (n - 1) / 2;
+  checkEdgeCount(m);
+  const out = new EdgeBuffer(m);
+  pushClique(out, 0, n);
+  return applyWeights(toGraph(n, out, false), options);
+}
+function completeBipartiteGraph(options) {
+  const { a, b } = options;
+  checkInt("a", a, 0);
+  checkInt("b", b, 0);
+  checkInt("a + b", a + b, 0);
+  checkEdgeCount(a * b);
+  const out = new EdgeBuffer(a * b);
+  for (let i = 0; i < a; i++) {
+    for (let j = 0; j < b; j++) {
+      out.push(i, a + j);
+    }
+  }
+  const side = new Uint8Array(a + b).fill(1, a);
+  return applyWeights(toGraph(a + b, out, false, { side }), options);
+}
+function hypercubeGraph(options) {
+  const { dimension } = options;
+  checkInt("dimension", dimension, 0, 26);
+  const n = 2 ** dimension;
+  const out = new EdgeBuffer(dimension * n / 2);
+  for (let i = 0; i < n; i++) {
+    for (let b = 0; b < dimension; b++) {
+      const j = i | 1 << b;
+      if (j !== i) {
+        out.push(i, j);
+      }
+    }
+  }
+  return applyWeights(toGraph(n, out, false), options);
+}
+function ladderGraph(options) {
+  const { n } = options;
+  checkInt("n", n, 1);
+  checkInt("2n", 2 * n, 2);
+  return applyWeights(toGraph(2 * n, ladderEdges(n), false), options);
+}
+function barbellGraph(options) {
+  const { cliqueSize: m1, pathLength: m2 } = options;
+  checkInt("cliqueSize", m1, 2);
+  checkInt("pathLength", m2, 0);
+  const n = 2 * m1 + m2;
+  checkInt("2 * cliqueSize + pathLength", n, 4);
+  checkEdgeCount(m1 * (m1 - 1) + m2 + 1);
+  const out = new EdgeBuffer(m1 * (m1 - 1) + m2 + 1);
+  pushClique(out, 0, m1);
+  for (let i = m1 - 1; i < m1 + m2; i++) {
+    out.push(i, i + 1);
+  }
+  pushClique(out, m1 + m2, m1);
+  return applyWeights(toGraph(n, out, false), options);
+}
+function lollipopGraph(options) {
+  const { cliqueSize: m, pathLength } = options;
+  checkInt("cliqueSize", m, 2);
+  checkInt("pathLength", pathLength, 0);
+  checkInt("cliqueSize + pathLength", m + pathLength, 2);
+  checkEdgeCount(m * (m - 1) / 2 + pathLength);
+  const out = new EdgeBuffer(m * (m - 1) / 2 + pathLength);
+  pushClique(out, 0, m);
+  for (let i = m - 1; i + 1 < m + pathLength; i++) {
+    out.push(i, i + 1);
+  }
+  return applyWeights(toGraph(m + pathLength, out, false), options);
+}
+function groupLabels(cliques, size) {
+  const community = new Uint32Array(cliques * size);
+  for (let g = 0; g < cliques; g++) {
+    community.fill(g, g * size, (g + 1) * size);
+  }
+  return community;
+}
+function cavemanGraph(options) {
+  const { cliques, size } = options;
+  checkInt("cliques", cliques, 1);
+  checkInt("size", size, 1);
+  const n = cliques * size;
+  checkInt("cliques * size", n, 1);
+  checkEdgeCount(n * (size - 1) / 2);
+  const out = new EdgeBuffer(n * (size - 1) / 2);
+  for (let g = 0; g < cliques; g++) {
+    pushClique(out, g * size, size);
+  }
+  return applyWeights(toGraph(n, out, false, { community: groupLabels(cliques, size) }), options);
+}
+function connectedCavemanGraph(options) {
+  const { cliques, size } = options;
+  checkInt("cliques", cliques, 2);
+  checkInt("size", size, 2);
+  const n = cliques * size;
+  checkInt("cliques * size", n, 4);
+  checkEdgeCount(n * (size - 1) / 2);
+  const out = new EdgeBuffer(n * (size - 1) / 2);
+  for (let g = 0; g < cliques; g++) {
+    const s = g * size;
+    for (let i = s; i < s + size; i++) {
+      for (let j = i + 1; j < s + size; j++) {
+        if (i === s && j === s + 1) {
+          out.push(s, (s - 1 + n) % n);
+        } else {
+          out.push(i, j);
+        }
+      }
+    }
+  }
+  return applyWeights(toGraph(n, out, false, { community: groupLabels(cliques, size) }), options);
+}
+function balancedTreeGraph(options) {
+  const { branching: r, height: h } = options;
+  checkInt("branching", r, 1);
+  checkInt("height", h, 0);
+  let n = 0;
+  let level = 1;
+  for (let d = 0; d <= h; d++) {
+    n += level;
+    level *= r;
+    checkInt("node count", n, 1);
+  }
+  const out = new EdgeBuffer(n);
+  for (let c = 1; c < n; c++) {
+    out.push(Math.floor((c - 1) / r), c);
+  }
+  return applyWeights(toGraph(n, out, false), options);
+}
+function petersenGraph(options = {}) {
+  const out = new EdgeBuffer(15);
+  for (let i = 0; i < 5; i++) {
+    out.push(i, (i + 1) % 5);
+  }
+  for (let i = 0; i < 5; i++) {
+    out.push(i, i + 5);
+  }
+  for (let i = 0; i < 5; i++) {
+    out.push(5 + i, 5 + (i + 2) % 5);
+  }
+  return applyWeights(toGraph(10, out, false), options);
+}
+function emptyGraph(options) {
+  checkInt("n", options.n, 0);
+  return applyWeights(toGraph(options.n, new EdgeBuffer(0), false), options);
+}
+function completeMultipartiteGraph(options) {
+  const { sizes } = options;
+  const starts = [0];
+  for (let p = 0; p < sizes.length; p++) {
+    checkInt(`sizes[${p}]`, sizes[p], 0);
+    starts.push(starts[p] + sizes[p]);
+  }
+  const n = starts[sizes.length];
+  checkInt("the total size", n, 0);
+  let m = n * (n - 1) / 2;
+  for (const size of sizes) {
+    m -= size * (size - 1) / 2;
+  }
+  checkEdgeCount(m);
+  const part = new Uint32Array(n);
+  for (let p = 0; p < sizes.length; p++) {
+    part.fill(p, starts[p], starts[p + 1]);
+  }
+  const out = new EdgeBuffer(m);
+  for (let u = 0; u < n; u++) {
+    for (let v = starts[part[u] + 1]; v < n; v++) {
+      out.push(u, v);
+    }
+  }
+  return applyWeights(toGraph(n, out, false, { part }), options);
+}
+function circularLadderGraph(options) {
+  const { n } = options;
+  checkInt("n", n, 3);
+  checkEdgeCount(3 * n);
+  const out = ladderEdges(n);
+  out.push(n - 1, 0);
+  out.push(2 * n - 1, n);
+  return applyWeights(toGraph(2 * n, out, false), options);
+}
+function mobiusLadderGraph(options) {
+  const { n } = options;
+  checkInt("n", n, 3);
+  checkEdgeCount(3 * n);
+  const out = new EdgeBuffer(3 * n);
+  for (let i = 0; i + 1 < 2 * n; i++) {
+    out.push(i, i + 1);
+  }
+  out.push(2 * n - 1, 0);
+  for (let i = 0; i < n; i++) {
+    out.push(i, i + n);
+  }
+  return applyWeights(toGraph(2 * n, out, false), options);
+}
+function ladderEdges(n) {
+  const out = new EdgeBuffer(3 * n);
+  for (let side = 0; side < 2; side++) {
+    for (let i = 0; i + 1 < n; i++) {
+      out.push(side * n + i, side * n + i + 1);
+    }
+  }
+  for (let i = 0; i < n; i++) {
+    out.push(i, n + i);
+  }
+  return out;
+}
+function ringOfCliquesGraph(options) {
+  const { cliques, size } = options;
+  checkInt("cliques", cliques, 2);
+  checkInt("size", size, 2);
+  const n = cliques * size;
+  checkInt("cliques * size", n, 4);
+  const m = n * (size - 1) / 2 + cliques;
+  checkEdgeCount(m);
+  const out = new EdgeBuffer(m);
+  for (let g = 0; g < cliques; g++) {
+    pushClique(out, g * size, size);
+    out.push(g * size + 1, (g + 1) * size % n);
+  }
+  return applyWeights(toGraph(n, out, false, { community: groupLabels(cliques, size) }), options);
+}
+const O_THRESHOLD = 709.782712893384;
+const U_THRESHOLD = -745.1332191019411;
+const LN2_HI = 0.6931471803691238;
+const LN2_LO = 19082149292705877e-26;
+const INV_LN2 = 1.4426950408889634;
+const TWOM1000 = 9332636185032189e-317;
+const P1 = 0.16666666666666602;
+const P2 = -0.0027777777777015593;
+const P3 = 6613756321437934e-20;
+const P4 = -16533902205465252e-22;
+const P5 = 41381367970572385e-24;
+const view = new DataView(new ArrayBuffer(8));
+function scale(y, k) {
+  view.setFloat64(0, y, true);
+  view.setInt32(4, view.getInt32(4, true) + (k << 20), true);
+  return view.getFloat64(0, true);
+}
+function detExp(x) {
+  view.setFloat64(0, x, true);
+  const high = view.getInt32(4, true);
+  const negative = high < 0 ? 1 : 0;
+  const hx = high & 2147483647;
+  if (hx >= 1082535490) {
+    if (hx >= 2146435072) {
+      return negative === 0 || Number.isNaN(x) ? x + x : 0;
+    }
+    if (x > O_THRESHOLD) {
+      return Infinity;
+    }
+    if (x < U_THRESHOLD) {
+      return 0;
+    }
+  }
+  let hi = 0;
+  let lo = 0;
+  let k = 0;
+  let r = x;
+  if (hx > 1071001154) {
+    if (hx < 1072734898) {
+      hi = negative === 0 ? x - LN2_HI : x + LN2_HI;
+      lo = negative === 0 ? LN2_LO : -LN2_LO;
+      k = 1 - negative - negative;
+    } else {
+      k = Math.trunc(INV_LN2 * x + (negative === 0 ? 0.5 : -0.5));
+      hi = x - k * LN2_HI;
+      lo = k * LN2_LO;
+    }
+    r = hi - lo;
+  } else if (hx < 1043333120) {
+    return 1 + x;
+  }
+  const t = r * r;
+  const c = r - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));
+  if (k === 0) {
+    return 1 - (r * c / (c - 2) - r);
+  }
+  const y = 1 - (lo - r * c / (2 - c) - hi);
+  return k >= -1021 ? scale(y, k) : scale(y, k + 1e3) * TWOM1000;
+}
+function detPow(x, y) {
+  if (x === 0) {
+    if (y === 0) {
+      return 1;
+    }
+    return y > 0 ? 0 : Infinity;
+  }
+  return detExp(y * detLog(x));
+}
+const MAX_POWER_LAW_SUPPORT = 2 ** 24;
+function checkExponent(name, exponent) {
+  if (!(Number.isFinite(exponent) && exponent >= 0)) {
+    throw new RangeError(`${name} must be a finite number >= 0, got ${String(exponent)}`);
+  }
+}
+function powerLawSampler(names, exponent, min, max) {
+  checkExponent(names[0], exponent);
+  checkInt(names[1], min, 1);
+  checkInt(names[2], max, min, Math.min(MAX_COUNT, min + MAX_POWER_LAW_SUPPORT - 1));
+  const count = max - min + 1;
+  const cdf = new Float64Array(count);
+  let total = 0;
+  for (let k = 0; k < count; k++) {
+    total += detPow(min + k, -exponent);
+    cdf[k] = total;
+  }
+  return (stream) => {
+    const u = stream.nextFloat() * total;
+    let lo = 0;
+    let hi = count - 1;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (cdf[mid] > u) {
+        hi = mid;
+      } else {
+        lo = mid + 1;
+      }
+    }
+    return min + lo;
+  };
+}
+function makeSumEven(seq, min, max) {
+  let total = 0;
+  for (const d of seq) {
+    total += d;
+  }
+  if (total % 2 === 0) {
+    return;
+  }
+  const last = seq.length - 1;
+  if (seq[last] < max) {
+    seq[last]++;
+  } else if (seq[last] > min) {
+    seq[last]--;
+  } else {
+    throw new RangeError(`cannot make the degree sum even: every degree is ${min} and n is odd`);
+  }
+}
+function powerLawDegreeSequence(options) {
+  const { n, exponent, minDegree, maxDegree } = options;
+  const seed = resolveSeed(options.seed);
+  checkInt("n", n, 0);
+  const sample = powerLawSampler(["exponent", "minDegree", "maxDegree"], exponent, minDegree, maxDegree);
+  const stream = new RandomStream(seed, "power-law", 0);
+  const seq = new Uint32Array(n);
+  for (let i = 0; i < n; i++) {
+    seq[i] = sample(stream);
+  }
+  if ((options.evenSum ?? true) && n > 0) {
+    makeSumEven(seq, minDegree, maxDegree);
+  }
+  return seq;
+}
+function degreeSum(name, degrees) {
+  checkInt(`${name}.length`, degrees.length, 0);
+  let total = 0;
+  for (let i = 0; i < degrees.length; i++) {
+    const d = degrees[i];
+    if (!(Number.isInteger(d) && d >= 0 && d <= MAX_COUNT)) {
+      checkInt(`${name}[${i}]`, d, 0);
+    }
+    total += d;
+  }
+  checkEdgeCount(total / 2);
+  return total;
+}
+function keeps(name, value) {
+  if (value !== void 0 && value !== "keep" && value !== "erase") {
+    throw new RangeError(`${name} must be "keep" or "erase", got ${String(value)}`);
+  }
+  return value === "keep";
+}
+function stubList(degrees, total, offset = 0) {
+  const stubs = new Uint32Array(total);
+  let k = 0;
+  for (let i = 0; i < degrees.length; i++) {
+    stubs.fill(i + offset, k, k + degrees[i]);
+    k += degrees[i];
+  }
+  return stubs;
+}
+function shuffle(a, stream) {
+  for (let i = a.length - 1; i > 0; i--) {
+    const j = stream.nextBelow(i + 1);
+    const t = a[i];
+    a[i] = a[j];
+    a[j] = t;
+  }
+}
+function eraseEdges(n, src, dst, directed, keepLoops, keepMulti, out, group) {
+  const m = src.length;
+  const keep = new Uint8Array(m).fill(1);
+  for (let e = 0; e < m; e++) {
+    const u = src[e];
+    const v = dst[e];
+    if (!keepLoops && u === v || group !== void 0 && group[u] === group[v]) {
+      keep[e] = 0;
+    }
+  }
+  if (!keepMulti) {
+    const lo = (e) => directed ? src[e] : Math.min(src[e], dst[e]);
+    const start = new Uint32Array(n + 1);
+    for (let e = 0; e < m; e++) {
+      start[lo(e) + 1]++;
+    }
+    for (let i = 0; i < n; i++) {
+      start[i + 1] += start[i];
+    }
+    const fill = start.slice(0, n);
+    const order = new Uint32Array(m);
+    for (let e = 0; e < m; e++) {
+      order[fill[lo(e)]++] = e;
+    }
+    const mark = new Uint32Array(n);
+    for (let k = 0; k < m; k++) {
+      const e = order[k];
+      if (keep[e] === 0) {
+        continue;
+      }
+      const u = lo(e);
+      const v = directed ? dst[e] : Math.max(src[e], dst[e]);
+      if (mark[v] === u + 1) {
+        keep[e] = 0;
+      } else {
+        mark[v] = u + 1;
+      }
+    }
+  }
+  for (let e = 0; e < m; e++) {
+    if (keep[e] === 1) {
+      out.push(src[e], dst[e]);
+    }
+  }
+}
+function pairStubs(n, stubs, keepLoops, keepMulti, out, group) {
+  const m = stubs.length / 2;
+  const src = new Uint32Array(m);
+  const dst = new Uint32Array(m);
+  for (let k = 0; k < m; k++) {
+    src[k] = stubs[2 * k];
+    dst[k] = stubs[2 * k + 1];
+  }
+  eraseEdges(n, src, dst, false, keepLoops, keepMulti, out, group);
+}
+function configurationModelGraph(options) {
+  const { degrees } = options;
+  const seed = resolveSeed(options.seed);
+  const keepLoops = keeps("selfLoops", options.selfLoops);
+  const keepMulti = keeps("multiEdges", options.multiEdges);
+  const total = degreeSum("degrees", degrees);
+  if (total % 2 !== 0) {
+    throw new RangeError(`the degree sum must be even, got ${total}`);
+  }
+  const n = degrees.length;
+  const stubs = stubList(degrees, total);
+  shuffle(stubs, new RandomStream(seed, "configuration", 0));
+  const out = new EdgeBuffer(total / 2);
+  pairStubs(n, stubs, keepLoops, keepMulti, out);
+  return applyWeights(toGraph(n, out, false), options);
+}
+function directedConfigurationModelGraph(options) {
+  const { outDegrees, inDegrees } = options;
+  const seed = resolveSeed(options.seed);
+  const keepLoops = keeps("selfLoops", options.selfLoops);
+  const keepMulti = keeps("multiEdges", options.multiEdges);
+  const outTotal = degreeSum("outDegrees", outDegrees);
+  const inTotal = degreeSum("inDegrees", inDegrees);
+  if (outDegrees.length !== inDegrees.length) {
+    throw new RangeError(`outDegrees and inDegrees must have the same length`);
+  }
+  if (outTotal !== inTotal) {
+    throw new RangeError(`the out-degree sum (${outTotal}) must equal the in-degree sum (${inTotal})`);
+  }
+  const n = outDegrees.length;
+  const dst = stubList(inDegrees, inTotal);
+  shuffle(dst, new RandomStream(seed, "configuration-directed", 0));
+  const out = new EdgeBuffer(outTotal);
+  eraseEdges(n, stubList(outDegrees, outTotal), dst, true, keepLoops, keepMulti, out);
+  return applyWeights(toGraph(n, out, true), options);
+}
+function bipartiteConfigurationModelGraph(options) {
+  const { leftDegrees, rightDegrees } = options;
+  const seed = resolveSeed(options.seed);
+  const keepMulti = keeps("multiEdges", options.multiEdges);
+  const leftTotal = degreeSum("leftDegrees", leftDegrees);
+  const rightTotal = degreeSum("rightDegrees", rightDegrees);
+  if (leftTotal !== rightTotal) {
+    throw new RangeError(`the left degree sum (${leftTotal}) must equal the right degree sum (${rightTotal})`);
+  }
+  const left = leftDegrees.length;
+  const n = left + rightDegrees.length;
+  checkInt("the node count", n, 0);
+  const dst = stubList(rightDegrees, rightTotal, left);
+  shuffle(dst, new RandomStream(seed, "bipartite-configuration", 0));
+  const out = new EdgeBuffer(leftTotal);
+  eraseEdges(n, stubList(leftDegrees, leftTotal), dst, false, true, keepMulti, out);
+  const side = new Uint8Array(n).fill(1, left);
+  return applyWeights(toGraph(n, out, false, { side }), options);
+}
+function weightSum(weights) {
+  checkInt("expectedDegrees.length", weights.length, 0);
+  let total = 0;
+  for (let i = 0; i < weights.length; i++) {
+    if (!(Number.isFinite(weights[i]) && weights[i] >= 0)) {
+      throw new RangeError(`expectedDegrees[${i}] must be a finite number >= 0, got ${String(weights[i])}`);
+    }
+    total += weights[i];
+  }
+  return total;
+}
+function planRows(weights, nodeStarts, factor, seed, domain, total) {
+  const n = weights.length;
+  const order = new Uint32Array(n);
+  const rowBlock = new Uint32Array(n);
+  for (let i = 0; i < n; i++) {
+    order[i] = i;
+  }
+  for (let b = 0; b + 1 < nodeStarts.length; b++) {
+    order.subarray(nodeStarts[b], nodeStarts[b + 1]).sort((x, y) => weights[y] - weights[x] || x - y);
+    rowBlock.fill(b, nodeStarts[b], nodeStarts[b + 1]);
+  }
+  const weight = Float64Array.from(order, (i) => weights[i]);
+  return { n, seed, domain, order, weight, rowBlock, starts: nodeStarts, factor, total };
+}
+function planChungLu(options) {
+  const seed = resolveSeed(options.seed);
+  const total = weightSum(options.expectedDegrees);
+  const n = options.expectedDegrees.length;
+  return planRows(options.expectedDegrees, [0, n], [[total > 0 ? 1 / total : 0]], seed, "chung-lu", total);
+}
+function chungLuRows(plan, start, end, out) {
+  const { order, weight, rowBlock, starts, factor } = plan;
+  const stream = new RandomStream(plan.seed, plan.domain, 0);
+  const count = starts.length - 1;
+  for (let row = start; row < end; row++) {
+    stream.reset(row);
+    const r = rowBlock[row];
+    for (let s = r; s < count; s++) {
+      const cu = factor[r][s] * weight[row];
+      let v = s === r ? row + 1 : starts[s];
+      const hi = starts[s + 1];
+      if (cu === 0 || v >= hi) {
+        continue;
+      }
+      let p = Math.min(1, cu * weight[v]);
+      while (v < hi && p > 0) {
+        if (p !== 1) {
+          const logQ = detLog(1 - p);
+          if (logQ === 0) {
+            break;
+          }
+          v += stream.nextSkip(logQ);
+          if (v >= hi) {
+            break;
+          }
+        }
+        const q = Math.min(1, cu * weight[v]);
+        if (stream.nextFloat() < q / p) {
+          out.push(order[row], order[v]);
+        }
+        p = q;
+        v++;
+      }
+    }
+  }
+}
+function runPlan(plan, nodeColumns, options) {
+  const mean = plan.total / 2;
+  checkEdgeCount(mean);
+  const out = new EdgeBuffer(Math.ceil(mean + 6 * Math.sqrt(mean) + 16));
+  chungLuRows(plan, 0, plan.n, out);
+  return applyWeights(toGraph(plan.n, out, false, nodeColumns), options);
+}
+function chungLuGraph(options) {
+  return runPlan(planChungLu(options), void 0, options);
+}
+function planDegreeCorrectedSbm(options) {
+  const { sizes, expectedDegrees, mixing } = options;
+  const seed = resolveSeed(options.seed);
+  checkInt("sizes.length", sizes.length, 1);
+  checkProbability("mixing", mixing);
+  const total = weightSum(expectedDegrees);
+  const starts = [0];
+  for (let b = 0; b < sizes.length; b++) {
+    checkInt(`sizes[${b}]`, sizes[b], 0);
+    starts.push(starts[b] + sizes[b]);
+  }
+  if (starts[sizes.length] !== expectedDegrees.length) {
+    throw new RangeError(
+      `the sizes sum to ${starts[sizes.length]}, but expectedDegrees has ${expectedDegrees.length} entries`
+    );
+  }
+  const kappa = sizes.map((_, b) => {
+    let k = 0;
+    for (let i = starts[b]; i < starts[b + 1]; i++) {
+      k += expectedDegrees[i];
+    }
+    return k;
+  });
+  const between = total > 0 ? mixing / total : 0;
+  const inside = kappa.map((kr) => kr > 0 ? (1 - mixing) / kr : 0);
+  const factor = kappa.map((_, r) => kappa.map((_2, s) => r === s ? inside[r] : between));
+  return planRows(expectedDegrees, starts, factor, seed, "dcsbm", total);
+}
+function degreeCorrectedSbmGraph(options) {
+  const plan = planDegreeCorrectedSbm(options);
+  const community = new Uint32Array(plan.n);
+  for (let b = 0; b + 1 < plan.starts.length; b++) {
+    community.fill(b, plan.starts[b], plan.starts[b + 1]);
+  }
+  return runPlan(plan, { community }, options);
+}
+const REGULAR_ATTEMPTS = 100;
+const REGULAR_ROUNDS = 1e3;
+function regularAttempt(n, d, stream, adj, deg) {
+  deg.fill(0);
+  const has = (u, v) => {
+    const base = u * d;
+    for (let k = base; k < base + deg[u]; k++) {
+      if (adj[k] === v) {
+        return true;
+      }
+    }
+    return false;
+  };
+  const potential = new Uint32Array(n);
+  let stubs = stubList(new Uint32Array(n).fill(d), n * d);
+  for (let round = 0; round < REGULAR_ROUNDS && stubs.length > 0; round++) {
+    shuffle(stubs, stream);
+    const touched = [];
+    for (let k2 = 0; k2 < stubs.length; k2 += 2) {
+      const u = Math.min(stubs[k2], stubs[k2 + 1]);
+      const v = Math.max(stubs[k2], stubs[k2 + 1]);
+      if (u !== v && !has(u, v)) {
+        adj[u * d + deg[u]++] = v;
+        adj[v * d + deg[v]++] = u;
+      } else {
+        for (const x of [u, v]) {
+          if (potential[x]++ === 0) {
+            touched.push(x);
+          }
+        }
+      }
+    }
+    touched.sort((a, b) => a - b);
+    let suitable = touched.length === 0;
+    for (let i = 0; i < touched.length && !suitable; i++) {
+      for (let j = i + 1; j < touched.length && !suitable; j++) {
+        suitable = !has(touched[i], touched[j]);
+      }
+    }
+    if (!suitable) {
+      return false;
+    }
+    let total = 0;
+    for (const x of touched) {
+      total += potential[x];
+    }
+    const next = new Uint32Array(total);
+    let k = 0;
+    for (const x of touched) {
+      next.fill(x, k, k + potential[x]);
+      k += potential[x];
+      potential[x] = 0;
+    }
+    stubs = next;
+  }
+  return stubs.length === 0;
+}
+function randomRegularGraph(options) {
+  const { n, d } = options;
+  const seed = resolveSeed(options.seed);
+  checkInt("n", n, 0);
+  checkInt("d", d, 0, Math.max(0, n - 1));
+  if (n * d % 2 !== 0) {
+    throw new RangeError(`n * d must be even, got ${n} * ${d}`);
+  }
+  checkEdgeCount(n * d / 2);
+  const out = new EdgeBuffer(n * d / 2);
+  if (d > 0) {
+    const adj = new Uint32Array(n * d);
+    const deg = new Uint32Array(n);
+    const stream = new RandomStream(seed, "random-regular", 0);
+    let attempt = 0;
+    for (; attempt < REGULAR_ATTEMPTS; attempt++) {
+      stream.reset(attempt);
+      if (regularAttempt(n, d, stream, adj, deg)) {
+        break;
+      }
+    }
+    if (attempt === REGULAR_ATTEMPTS) {
+      throw new RangeError(`randomRegularGraph found no ${d}-regular graph on ${n} nodes in ${REGULAR_ATTEMPTS} attempts`);
+    }
+    for (let u = 0; u < n; u++) {
+      const row = adj.subarray(u * d, u * d + d).sort();
+      for (const v of row) {
+        if (v > u) {
+          out.push(u, v);
+        }
+      }
+    }
+  }
+  return applyWeights(toGraph(n, out, false), options);
+}
+function checkPolicy(name, value) {
+  if (value !== void 0 && value !== "keep" && value !== "erase") {
+    throw new RangeError(`${name} must be "keep" or "erase", got ${String(value)}`);
+  }
+}
+function finishRecursive(n, src, dst, options, seed, permuteDomain) {
+  const directed = options.directed ?? true;
+  const m = src.length;
+  if (options.permute === true) {
+    const perm = new Uint32Array(n);
+    for (let i = 0; i < n; i++) {
+      perm[i] = i;
+    }
+    const stream = new RandomStream(seed, permuteDomain, 0);
+    for (let i = n - 1; i > 0; i--) {
+      const j = stream.nextBelow(i + 1);
+      const t = perm[i];
+      perm[i] = perm[j];
+      perm[j] = t;
+    }
+    for (let e = 0; e < m; e++) {
+      src[e] = perm[src[e]];
+      dst[e] = perm[dst[e]];
+    }
+  }
+  const keep = new Uint8Array(m).fill(1);
+  if (options.selfLoops === "erase") {
+    for (let e = 0; e < m; e++) {
+      if (src[e] === dst[e]) {
+        keep[e] = 0;
+      }
+    }
+  }
+  if (options.multiEdges === "erase") {
+    const lo = directed ? src : src.map((u, e) => Math.min(u, dst[e]));
+    const hi = directed ? dst : src.map((u, e) => Math.max(u, dst[e]));
+    const order = new Uint32Array(m);
+    for (let e = 0; e < m; e++) {
+      order[e] = e;
+    }
+    order.sort((a, b) => lo[a] - lo[b] || hi[a] - hi[b] || a - b);
+    for (let i = 1; i < m; i++) {
+      const a = order[i - 1];
+      const b = order[i];
+      if (lo[a] === lo[b] && hi[a] === hi[b]) {
+        keep[b] = 0;
+      }
+    }
+  }
+  const out = new EdgeBuffer(m);
+  for (let e = 0; e < m; e++) {
+    if (keep[e] === 1) {
+      out.push(src[e], dst[e]);
+    }
+  }
+  return toGraph(n, out, directed);
+}
+function checkRecursive(options) {
+  checkPolicy("selfLoops", options.selfLoops);
+  checkPolicy("multiEdges", options.multiEdges);
+  return resolveSeed(options.seed);
+}
+function kroneckerGraph(options) {
+  const { initiator, power } = options;
+  const k = initiator.length;
+  checkInt("initiator.length", k, 1);
+  let sum = 0;
+  for (let r = 0; r < k; r++) {
+    checkInt(`initiator[${r}].length`, initiator[r].length, k, k);
+    for (const value of initiator[r]) {
+      checkProbability(`initiator[${r}] entries`, value);
+      sum += value;
+    }
+  }
+  checkInt("power", power, 1, 64);
+  let n = 1;
+  let mean = 1;
+  for (let i = 0; i < power; i++) {
+    n *= k;
+    mean *= sum;
+  }
+  checkInt("k^power (the node count)", n, 1);
+  const m = options.edges ?? Math.round(mean);
+  checkEdgeCount(m);
+  checkInt("edges", m, 0);
+  if (m > 0 && sum === 0) {
+    throw new RangeError("edges must be 0 when the initiator is all zeros");
+  }
+  const seed = checkRecursive(options);
+  const cells = k * k;
+  const cumulative = new Float64Array(cells);
+  let partial = 0;
+  let lastPositive = 0;
+  for (let i = 0; i < cells; i++) {
+    const value = initiator[Math.floor(i / k)][i % k];
+    partial += value;
+    cumulative[i] = partial / sum;
+    if (value > 0) {
+      lastPositive = i;
+    }
+  }
+  cumulative.fill(1, lastPositive);
+  const src = new Uint32Array(m);
+  const dst = new Uint32Array(m);
+  const stream = new RandomStream(seed, "kronecker", 0);
+  for (let e = 0; e < m; e++) {
+    stream.reset(e);
+    let u = 0;
+    let v = 0;
+    for (let level = 0; level < power; level++) {
+      const x = stream.nextFloat();
+      let cell = 0;
+      while (x >= cumulative[cell]) {
+        cell++;
+      }
+      u = u * k + Math.floor(cell / k);
+      v = v * k + cell % k;
+    }
+    src[e] = u;
+    dst[e] = v;
+  }
+  return applyWeights(finishRecursive(n, src, dst, options, seed, "kronecker-permute"), options);
+}
+function rmatGraph(options) {
+  const { scale: scale2 } = options;
+  const edgeFactor = options.edgeFactor ?? 16;
+  const a = options.a ?? 0.57;
+  const b = options.b ?? 0.19;
+  const c = options.c ?? 0.19;
+  const d = options.d ?? 0.05;
+  checkInt("scale", scale2, 0, 31);
+  checkInt("edgeFactor", edgeFactor, 0);
+  checkProbability("a", a);
+  checkProbability("b", b);
+  checkProbability("c", c);
+  checkProbability("d", d);
+  if (Math.abs(a + b + c + d - 1) > 1e-9) {
+    throw new RangeError(`a + b + c + d must be 1, got ${a + b + c + d}`);
+  }
+  const n = 2 ** scale2;
+  const m = edgeFactor * n;
+  checkEdgeCount(m);
+  const seed = checkRecursive(options);
+  const ab = a + b;
+  const abc = a + b + c;
+  const src = new Uint32Array(m);
+  const dst = new Uint32Array(m);
+  const stream = new RandomStream(seed, "rmat", 0);
+  for (let e = 0; e < m; e++) {
+    stream.reset(e);
+    let u = 0;
+    let v = 0;
+    for (let level = 0; level < scale2; level++) {
+      const x = stream.nextFloat();
+      u *= 2;
+      v *= 2;
+      if (x < a) ;
+      else if (x < ab) {
+        v += 1;
+      } else if (x < abc) {
+        u += 1;
+      } else {
+        u += 1;
+        v += 1;
+      }
+    }
+    src[e] = u;
+    dst[e] = v;
+  }
+  return applyWeights(finishRecursive(n, src, dst, options, seed, "rmat-permute"), options);
+}
+function priceGraph(options) {
+  const { n, citations: m } = options;
+  const attractiveness = options.attractiveness ?? 1;
+  checkInt("n", n, 1);
+  checkInt("citations", m, 1);
+  if (!(attractiveness > 0 && Number.isFinite(attractiveness))) {
+    throw new RangeError(`attractiveness must be a positive number, got ${String(attractiveness)}`);
+  }
+  const seed = resolveSeed(options.seed);
+  const full = Math.min(m, n);
+  const edgeCount = full * (full - 1) / 2 + (n - full) * m;
+  checkEdgeCount(edgeCount);
+  const stream = new RandomStream(seed, "price", 0);
+  const out = new EdgeBuffer(edgeCount);
+  const citedBy = new Int32Array(n).fill(-1);
+  for (let t = 1; t < n; t++) {
+    const arcs = out.length;
+    if (t <= m) {
+      for (let v = 0; v < t; v++) {
+        out.push(t, v);
+      }
+      continue;
+    }
+    const total = arcs + attractiveness * t;
+    for (let found = 0; found < m; ) {
+      const x = stream.nextFloat() * total;
+      const v = x < arcs ? out.dst[stream.nextBelow(arcs)] : stream.nextBelow(t);
+      if (citedBy[v] !== t) {
+        citedBy[v] = t;
+        out.push(t, v);
+        found++;
+      }
+    }
+  }
+  return applyWeights(toGraph(n, out, true), options);
+}
+function orderDagRows(options, start, end, out) {
+  const { n, p } = options;
+  const logQ = detLog(1 - p);
+  const stream = new RandomStream(resolveSeed(options.seed), "order-dag", 0);
+  for (let u = start; u < end; u++) {
+    stream.reset(u);
+    bernoulliSegment(stream, p, logQ, u, u + 1, n, out);
+  }
+}
+function randomOrderDagGraph(options) {
+  const { n, p } = options;
+  checkInt("n", n, 0);
+  checkProbability("p", p);
+  resolveSeed(options.seed);
+  const out = binomialBuffer(n * (n - 1) / 2, p);
+  orderDagRows(options, 0, n, out);
+  return applyWeights(toGraph(n, out, true), options);
+}
+function erdosRenyiRows(options, start, end, out) {
+  const { n, p } = options;
+  const logQ = detLog(1 - p);
+  if (options.directed === true) {
+    directedRows(n, p, logQ, resolveSeed(options.seed), start, end, out);
+    return;
+  }
+  const stream = new RandomStream(resolveSeed(options.seed), "gnp", 0);
+  for (let u = start; u < end; u++) {
+    stream.reset(u);
+    bernoulliSegment(stream, p, logQ, u, u + 1, n, out);
+  }
+}
+function directedRows(n, p, logQ, seed, start, end, out) {
+  if (p === 0) {
+    return;
+  }
+  const stream = new RandomStream(seed, "gnp-directed", 0);
+  for (let u = start; u < end; u++) {
+    stream.reset(u);
+    let j = p === 1 ? 0 : stream.nextSkip(logQ);
+    while (j < n - 1) {
+      out.push(u, j < u ? j : j + 1);
+      j += p === 1 ? 1 : 1 + stream.nextSkip(logQ);
+    }
+  }
+}
+function erdosRenyiGraph(options) {
+  const { n, p } = options;
+  checkInt("n", n, 0);
+  checkProbability("p", p);
+  resolveSeed(options.seed);
+  const directed = options.directed === true;
+  const pairs = n * (n - 1) / (directed ? 1 : 2);
+  const out = binomialBuffer(pairs, p);
+  erdosRenyiRows(options, 0, n, out);
+  return applyWeights(toGraph(n, out, directed), options);
+}
+class NumberSet {
+  /**
+   * An empty set.
+   * @param capacity - the maximum number of entries
+   */
+  constructor(capacity) {
+    let size = 16;
+    while (size < capacity * 2) {
+      size *= 2;
+    }
+    this.slots = new Float64Array(size).fill(-1);
+    this.mask = size - 1;
+  }
+  /**
+   * Insert `x`.
+   * @param x - the value
+   * @returns false when it was already present
+   */
+  add(x) {
+    let i = Math.imul(x >>> 0 ^ Math.floor(x / 4294967296), 2654435761) & this.mask;
+    for (; ; ) {
+      const slot = this.slots[i];
+      if (slot === -1) {
+        this.slots[i] = x;
+        return true;
+      }
+      if (slot === x) {
+        return false;
+      }
+      i = i + 1 & this.mask;
+    }
+  }
+}
+function erdosRenyiGnmGraph(options) {
+  const { n, m } = options;
+  const seed = resolveSeed(options.seed);
+  checkInt("n", n, 0, 2 ** 27);
+  const total = n * (n - 1) / 2;
+  checkInt("m", m, 0, Math.min(total, 2 ** 32 - 2));
+  const stream = new RandomStream(seed, "gnm", 0);
+  const chosen = new Float64Array(m);
+  const set = new NumberSet(m);
+  for (let k = 0, j = total - m; j < total; j++, k++) {
+    const t = stream.nextBelow(j + 1);
+    if (set.add(t)) {
+      chosen[k] = t;
+    } else {
+      set.add(j);
+      chosen[k] = j;
+    }
+  }
+  chosen.sort();
+  const out = new EdgeBuffer(m);
+  let u = 0;
+  let rowStart = 0;
+  for (let k = 0; k < m; k++) {
+    const index = chosen[k];
+    while (index >= rowStart + (n - u - 1)) {
+      rowStart += n - u - 1;
+      u++;
+    }
+    out.push(u, u + 1 + (index - rowStart));
+  }
+  return applyWeights(toGraph(n, out, false), options);
+}
+const MAX_CAPACITY = 2 ** 24;
+function capacityRange(options, terminalFactor) {
+  const min = options.minCapacity ?? 1;
+  const max = options.maxCapacity ?? 10;
+  checkInt("minCapacity", min, 0, MAX_CAPACITY);
+  checkInt("maxCapacity", max, min, Math.floor(MAX_CAPACITY / terminalFactor));
+  return { min, max };
+}
+function toNetwork(n, out, capacities, source, sink, columns) {
+  const { src, dst } = out.finish();
+  const role = new Uint8Array(n);
+  role[source] = 1;
+  role[sink] = 2;
+  return {
+    directed: true,
+    nodeCount: n,
+    src,
+    dst,
+    weights: Float32Array.from(capacities),
+    nodeColumns: { ...columns, role },
+    source,
+    sink
+  };
+}
+function gridArcs(out, base, rows, cols, r, c) {
+  const u = base + r * cols + c;
+  const before = out.length;
+  if (c + 1 < cols) {
+    out.push(u, u + 1);
+  }
+  if (r + 1 < rows) {
+    out.push(u, u + cols);
+  }
+  if (c > 0) {
+    out.push(u, u - 1);
+  }
+  if (r > 0) {
+    out.push(u, u - cols);
+  }
+  return out.length - before;
+}
+function gridFlowNetwork(options) {
+  const { rows, cols } = options;
+  checkInt("rows", rows, 1);
+  checkInt("cols", cols, 2);
+  const cells = rows * cols;
+  checkInt("rows * cols + 2 (the node count)", cells + 2, 0);
+  const { min, max } = capacityRange(options, 4);
+  const seed = resolveSeed(options.seed);
+  const arcs = 2 * (rows * (cols - 1) + cols * (rows - 1)) + 2 * rows;
+  checkEdgeCount(arcs);
+  const out = new EdgeBuffer(arcs);
+  const capacities = [];
+  const stream = new RandomStream(seed, "grid-flow", 0);
+  const x = new Float64Array(cells + 2);
+  const y = new Float64Array(cells + 2);
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const u = r * cols + c;
+      x[u] = c;
+      y[u] = r;
+      stream.reset(u);
+      const count = gridArcs(out, 0, rows, cols, r, c);
+      for (let i = 0; i < count; i++) {
+        capacities.push(min + stream.nextBelow(max - min + 1));
+      }
+    }
+  }
+  const source = cells;
+  const sink = cells + 1;
+  x[source] = -1;
+  x[sink] = cols;
+  y[source] = (rows - 1) / 2;
+  y[sink] = (rows - 1) / 2;
+  for (let r = 0; r < rows; r++) {
+    out.push(source, r * cols);
+    capacities.push(4 * max);
+  }
+  for (let r = 0; r < rows; r++) {
+    out.push(r * cols + cols - 1, sink);
+    capacities.push(4 * max);
+  }
+  return toNetwork(cells + 2, out, capacities, source, sink, { x, y });
+}
+function planLayeredFlow(options) {
+  const { layers, p } = options;
+  checkInt("layers.length", layers.length, 1);
+  checkProbability("p", p);
+  const starts = [0];
+  let widest = 0;
+  for (let i = 0; i < layers.length; i++) {
+    checkInt(`layers[${i}]`, layers[i], 1);
+    starts.push(starts[i] + layers[i]);
+    widest = Math.max(widest, layers[i]);
+  }
+  const inner = starts[layers.length];
+  checkInt("the total size + 2 (the node count)", inner + 2, 0);
+  const { min, max } = capacityRange(options, widest);
+  const layerOf = new Uint32Array(inner);
+  for (let i = 0; i < layers.length; i++) {
+    layerOf.fill(i, starts[i], starts[i + 1]);
+  }
+  return { starts, layerOf, p, min, max, terminal: max * widest, seed: resolveSeed(options.seed) };
+}
+function layeredFlowRows(plan, start, end, out, capacities) {
+  const { starts, layerOf, p, min, max } = plan;
+  const logQ = detLog(1 - p);
+  const stream = new RandomStream(plan.seed, "layered-flow", 0);
+  const last = starts.length - 2;
+  for (let u = start; u < end; u++) {
+    const layer = layerOf[u];
+    if (layer < last) {
+      stream.reset(u);
+      const before = out.length;
+      bernoulliSegment(stream, p, logQ, u, starts[layer + 1], starts[layer + 2], out);
+      for (let i = before; i < out.length; i++) {
+        capacities.push(min + stream.nextBelow(max - min + 1));
+      }
+    }
+  }
+}
+function layeredFlowNetwork(options) {
+  const plan = planLayeredFlow(options);
+  const { starts } = plan;
+  const L = starts.length - 1;
+  const inner = starts[L];
+  const out = new EdgeBuffer(inner);
+  const capacities = [];
+  layeredFlowRows(plan, 0, inner, out, capacities);
+  const source = inner;
+  const sink = inner + 1;
+  const { terminal } = plan;
+  for (let u = starts[0]; u < starts[1]; u++) {
+    out.push(source, u);
+    capacities.push(terminal);
+  }
+  for (let u = starts[L - 1]; u < starts[L]; u++) {
+    out.push(u, sink);
+    capacities.push(terminal);
+  }
+  const layer = new Uint32Array(inner + 2);
+  for (let u = 0; u < inner; u++) {
+    layer[u] = plan.layerOf[u] + 1;
+  }
+  layer[sink] = L + 1;
+  return toNetwork(inner + 2, out, capacities, source, sink, { layer });
+}
+function genrmfGraph(options) {
+  const { a, b, c1, c2 } = options;
+  checkInt("a", a, 1);
+  checkInt("b", b, 1);
+  const side = a * a;
+  checkInt("a * a * b (the node count)", side * b, 2);
+  checkInt("c1", c1, 0, MAX_CAPACITY);
+  checkInt("c2", c2, c1, MAX_CAPACITY);
+  if (c2 * side > MAX_CAPACITY) {
+    throw new RangeError(`c2 * a * a must be at most 2^24 to stay exact, got ${c2 * side}`);
+  }
+  const seed = resolveSeed(options.seed);
+  const n = side * b;
+  const arcs = b * 4 * a * (a - 1) + (b - 1) * side;
+  checkEdgeCount(arcs);
+  const out = new EdgeBuffer(arcs);
+  const capacities = [];
+  const frame = new Uint32Array(n);
+  const perm = new Uint32Array(side);
+  const stream = new RandomStream(seed, "genrmf", 0);
+  for (let f = 0; f < b; f++) {
+    const base = f * side;
+    frame.fill(f, base, base + side);
+    for (let r = 0; r < a; r++) {
+      for (let c = 0; c < a; c++) {
+        const count = gridArcs(out, base, a, a, r, c);
+        for (let i = 0; i < count; i++) {
+          capacities.push(c2 * side);
+        }
+      }
+    }
+    if (f === b - 1) {
+      break;
+    }
+    stream.reset(f);
+    for (let i = 0; i < side; i++) {
+      perm[i] = i;
+    }
+    for (let i = side - 1; i > 0; i--) {
+      const j = stream.nextBelow(i + 1);
+      const t = perm[i];
+      perm[i] = perm[j];
+      perm[j] = t;
+    }
+    for (let j = 0; j < side; j++) {
+      out.push(base + j, base + side + perm[j]);
+      capacities.push(c1 + stream.nextBelow(c2 - c1 + 1));
+    }
+  }
+  return toNetwork(n, out, capacities, 0, n - 1, { frame });
+}
+const AK_BIG = 1e6;
+function akGraph(options) {
+  const { k } = options;
+  checkInt("k", k, 1, 499998);
+  const n = 4 * k + 6;
+  const out = new EdgeBuffer(6 * k + 7);
+  const capacities = [];
+  const arc = (u, v, capacity) => {
+    out.push(u, v);
+    capacities.push(capacity);
+  };
+  const hub = k + 3;
+  const chainEnd = 2 * k + 3;
+  const b0 = 2 * k + 4;
+  for (let i = 0; i < k; i++) {
+    arc(2 + i, 3 + i, k + 1 - i);
+    arc(2 + i, hub, 1);
+  }
+  arc(2 + k, chainEnd, 1);
+  arc(2 + k, hub, 1);
+  for (let j = hub; j < chainEnd; j++) {
+    arc(j, j + 1, k + 1);
+  }
+  for (let i = 0; i <= 2 * k; i++) {
+    arc(b0 + i, b0 + i + 1, k);
+  }
+  for (let i = 0; i < k; i++) {
+    arc(b0 + i, b0 + 2 * k + 1 - i, 1);
+  }
+  arc(0, 2, AK_BIG);
+  arc(0, b0, AK_BIG);
+  arc(chainEnd, 1, AK_BIG);
+  arc(b0 + 2 * k + 1, 1, AK_BIG);
+  return toNetwork(n, out, capacities, 0, 1, {});
+}
+const WAXMAN_L = Math.SQRT2;
+const WAXMAN_MAX_DRAWS = 5e8;
+function checkDimension(dimension) {
+  const d = dimension ?? 2;
+  if (d !== 2 && d !== 3) {
+    throw new RangeError(`dimension must be 2 or 3, got ${String(d)}`);
+  }
+  return d;
+}
+function checkNonNegative(name, value, positive = false) {
+  if (!(Number.isFinite(value) && (positive ? value > 0 : value >= 0))) {
+    throw new RangeError(`${name} must be a finite number ${positive ? ">" : ">="} 0, got ${String(value)}`);
+  }
+}
+function uniformPoints(seed, domain, n, dimension) {
+  const axes = Array.from({ length: dimension }, () => new Float64Array(n));
+  const stream = new RandomStream(seed, domain, 0);
+  for (let i = 0; i < n; i++) {
+    stream.reset(i);
+    for (const axis of axes) {
+      axis[i] = stream.nextFloat();
+    }
+  }
+  return axes;
+}
+function positionColumns(axes) {
+  const names = ["x", "y", "z"];
+  return Object.fromEntries(axes.map((axis, a) => [names[a], axis]));
+}
+function cellsPerAxis(target, dimension) {
+  let g = 1;
+  while ((g + 1) ** dimension <= target) {
+    g++;
+  }
+  return g;
+}
+function buildGrid(axes, g, lo, hi) {
+  const n = axes[0].length;
+  const side = lo.map((l, a) => (hi[a] - l) / g || 1);
+  const cell = axes.map(() => new Uint32Array(n));
+  const flat = new Uint32Array(n);
+  const start = new Uint32Array(g ** axes.length + 1);
+  for (let i = 0; i < n; i++) {
+    let c = 0;
+    for (let a = 0; a < axes.length; a++) {
+      const k = Math.min(g - 1, Math.floor((axes[a][i] - lo[a]) / side[a]));
+      cell[a][i] = k;
+      c = c * g + k;
+    }
+    flat[i] = c;
+    start[c + 1]++;
+  }
+  for (let c = 0; c + 1 < start.length; c++) {
+    start[c + 1] += start[c];
+  }
+  const fill = start.slice(0, -1);
+  const items = new Uint32Array(n);
+  for (let i = 0; i < n; i++) {
+    items[fill[flat[i]]++] = i;
+  }
+  return { g, lo, side, start, items, cell };
+}
+function randomGeometricGraph(options) {
+  const { n, radius } = options;
+  checkInt("n", n, 0);
+  checkNonNegative("radius", radius);
+  const dimension = checkDimension(options.dimension);
+  const periodic = options.periodic ?? false;
+  const seed = resolveSeed(options.seed);
+  const axes = uniformPoints(seed, "rgg-points", n, dimension);
+  const r2 = radius * radius;
+  const g = Math.max(1, Math.min(Math.floor((1 - 1e-9) / radius), cellsPerAxis(Math.max(1, n), dimension)));
+  const grid = buildGrid(axes, g, new Array(dimension).fill(0), new Array(dimension).fill(1));
+  const volume = dimension === 2 ? Math.PI * r2 : 4 / 3 * Math.PI * r2 * radius;
+  const pairs = n * (n - 1) / 2;
+  const out = new EdgeBuffer(Math.ceil(Math.min(pairs, pairs * volume * 1.1, 1 << 24) + 16));
+  const around = Array.from({ length: g }, (_, k) => {
+    const list = periodic ? [(k + g - 1) % g, k, (k + 1) % g] : [k - 1, k, k + 1].filter((c) => c >= 0 && c < g);
+    return [...new Set(list)];
+  });
+  let found = new Uint32Array(16);
+  for (let u = 0; u < n; u++) {
+    let count = 0;
+    const zCells = dimension === 3 ? around[grid.cell[2][u]] : [0];
+    for (const cx of around[grid.cell[0][u]]) {
+      for (const cy of around[grid.cell[1][u]]) {
+        for (const cz of zCells) {
+          const c = dimension === 3 ? (cx * g + cy) * g + cz : cx * g + cy;
+          for (let t = grid.start[c]; t < grid.start[c + 1]; t++) {
+            const v = grid.items[t];
+            if (v <= u) {
+              continue;
+            }
+            let d2 = 0;
+            for (const axis of axes) {
+              let d = Math.abs(axis[u] - axis[v]);
+              if (periodic && d > 0.5) {
+                d = 1 - d;
+              }
+              d2 += d * d;
+            }
+            if (d2 <= r2) {
+              if (count === found.length) {
+                const grown = new Uint32Array(count * 2);
+                grown.set(found);
+                found = grown;
+              }
+              found[count++] = v;
+            }
+          }
+        }
+      }
+    }
+    const row = found.subarray(0, count).sort();
+    for (const v of row) {
+      out.push(u, v);
+    }
+  }
+  return applyWeights(toGraph(n, out, false, positionColumns(axes)), options);
+}
+function planWaxman(options) {
+  const { n, alpha, beta } = options;
+  checkInt("n", n, 0);
+  checkNonNegative("alpha", alpha, true);
+  checkProbability("beta", beta);
+  const seed = resolveSeed(options.seed);
+  if (beta * n * n / 2 > WAXMAN_MAX_DRAWS) {
+    throw new RangeError(
+      `waxmanGraph: beta n^2 / 2 = ${beta * n * n / 2} candidate pairs, above the limit of ${WAXMAN_MAX_DRAWS}`
+    );
+  }
+  const [x, y] = uniformPoints(seed, "waxman-points", n, 2);
+  return { n, seed, beta, logQ: detLog(1 - beta), scale: alpha * WAXMAN_L, x, y };
+}
+function waxmanRows(plan, start, end, out) {
+  const { n, beta, logQ, scale: scale2, x, y } = plan;
+  if (beta === 0) {
+    return;
+  }
+  const stream = new RandomStream(plan.seed, "waxman", 0);
+  const skip = () => beta === 1 ? 0 : stream.nextSkip(logQ);
+  for (let u = start; u < end; u++) {
+    stream.reset(u);
+    for (let v = u + 1 + skip(); v < n; v += 1 + skip()) {
+      const dx = x[u] - x[v];
+      const dy = y[u] - y[v];
+      const bound = scale2 * detLog(stream.nextFloat());
+      if (dx * dx + dy * dy < bound * bound) {
+        out.push(u, v);
+      }
+    }
+  }
+}
+function waxmanGraph(options) {
+  const plan = planWaxman(options);
+  const out = new EdgeBuffer(Math.min(Math.ceil(plan.beta * plan.n * plan.n / 8), 1 << 24) + 16);
+  waxmanRows(plan, 0, plan.n, out);
+  return applyWeights(toGraph(plan.n, out, false, positionColumns([plan.x, plan.y])), options);
+}
+function mixturePoints(seed, n, dimension, clusters, spread) {
+  const centres = uniformPoints(seed, "knn-centres", clusters, dimension);
+  const axes = Array.from({ length: dimension }, () => new Float64Array(n));
+  const community = new Uint32Array(n);
+  const stream = new RandomStream(seed, "knn-points", 0);
+  const normals = new Float64Array(4);
+  for (let i = 0; i < n; i++) {
+    stream.reset(i);
+    const c = stream.nextBelow(clusters);
+    community[i] = c;
+    for (let j = 0; j < dimension; j += 2) {
+      let u;
+      let v;
+      let s;
+      do {
+        u = 2 * stream.nextFloat() - 1;
+        v = 2 * stream.nextFloat() - 1;
+        s = u * u + v * v;
+      } while (s >= 1 || s === 0);
+      const m = Math.sqrt(-2 * detLog(s) / s);
+      normals[j] = u * m;
+      normals[j + 1] = v * m;
+    }
+    for (let a = 0; a < dimension; a++) {
+      axes[a][i] = centres[a][c] + spread * normals[a];
+    }
+  }
+  return { axes, community };
+}
+function nearestNeighbours(axes, k) {
+  const n = axes[0].length;
+  const dimension = axes.length;
+  const result = new Uint32Array(n * k);
+  if (k === 0) {
+    return result;
+  }
+  const lo = axes.map((axis) => axis.reduce((a, b) => Math.min(a, b), Infinity));
+  const hi = axes.map((axis) => axis.reduce((a, b) => Math.max(a, b), -Infinity));
+  const g = cellsPerAxis(Math.max(1, n / k), dimension);
+  const grid = buildGrid(axes, g, lo, hi);
+  const bestD = new Float64Array(k);
+  const bestI = new Uint32Array(k);
+  const slack = 1e-12 * Math.max(1, ...lo.map(Math.abs), ...hi.map(Math.abs));
+  const cell = new Array(dimension).fill(0);
+  const offset = new Array(dimension).fill(0);
+  for (let u = 0; u < n; u++) {
+    let count = 0;
+    const consider = (v) => {
+      let d2 = 0;
+      for (const axis of axes) {
+        const d = Math.abs(axis[u] - axis[v]);
+        d2 += d * d;
+      }
+      if (count === k && (d2 > bestD[k - 1] || d2 === bestD[k - 1] && v > bestI[k - 1])) {
+        return;
+      }
+      let j = count < k ? count++ : k - 1;
+      while (j > 0 && (bestD[j - 1] > d2 || bestD[j - 1] === d2 && bestI[j - 1] > v)) {
+        bestD[j] = bestD[j - 1];
+        bestI[j] = bestI[j - 1];
+        j--;
+      }
+      bestD[j] = d2;
+      bestI[j] = v;
+    };
+    for (let a = 0; a < dimension; a++) {
+      cell[a] = grid.cell[a][u];
+    }
+    for (let r = 0; ; r++) {
+      let covered = true;
+      for (let a = 0; a < dimension; a++) {
+        offset[a] = -r;
+        if (cell[a] - r > 0 || cell[a] + r < g - 1) {
+          covered = false;
+        }
+      }
+      for (; ; ) {
+        let chebyshev = 0;
+        let inside = true;
+        let c = 0;
+        for (let a2 = 0; a2 < dimension; a2++) {
+          const k2 = cell[a2] + offset[a2];
+          if (k2 < 0 || k2 >= g) {
+            inside = false;
+          }
+          chebyshev = Math.max(chebyshev, Math.abs(offset[a2]));
+          c = c * g + k2;
+        }
+        if (inside && chebyshev === r) {
+          for (let t = grid.start[c]; t < grid.start[c + 1]; t++) {
+            const v = grid.items[t];
+            if (v !== u) {
+              consider(v);
+            }
+          }
+        }
+        let a = dimension - 1;
+        while (a >= 0 && offset[a] === r) {
+          offset[a] = -r;
+          a--;
+        }
+        if (a < 0) {
+          break;
+        }
+        offset[a]++;
+      }
+      if (covered) {
+        break;
+      }
+      if (count === k) {
+        let gap = Infinity;
+        for (let a = 0; a < dimension; a++) {
+          const p = axes[a][u] - grid.lo[a];
+          gap = Math.min(gap, p - (cell[a] - r) * grid.side[a], (cell[a] + r + 1) * grid.side[a] - p);
+        }
+        gap -= slack;
+        if (gap > 0 && bestD[k - 1] < gap * gap * (1 - 1e-9)) {
+          break;
+        }
+      }
+    }
+    const row = result.subarray(u * k, (u + 1) * k);
+    row.set(bestI);
+    row.sort();
+  }
+  return result;
+}
+function knnGraph(options) {
+  const { n, k, clusters, spread } = options;
+  checkInt("n", n, 0);
+  checkInt("k", k, 0, Math.max(0, n - 1));
+  const dimension = checkDimension(options.dimension);
+  const directed = options.directed ?? true;
+  if (clusters === void 0 && spread !== void 0) {
+    throw new RangeError("spread needs clusters");
+  }
+  const seed = resolveSeed(options.seed);
+  let axes;
+  const columns = {};
+  if (clusters === void 0) {
+    axes = uniformPoints(seed, "knn-points", n, dimension);
+  } else {
+    checkInt("clusters", clusters, 1);
+    const sd = spread ?? 0.05;
+    checkNonNegative("spread", sd);
+    let community;
+    ({ axes, community } = mixturePoints(seed, n, dimension, clusters, sd));
+    columns.community = community;
+  }
+  Object.assign(columns, positionColumns(axes));
+  const neighbours = nearestNeighbours(axes, k);
+  checkEdgeCount(n * k);
+  let out;
+  if (directed) {
+    out = new EdgeBuffer(n * k);
+    for (let u = 0; u < n; u++) {
+      for (let j = u * k; j < (u + 1) * k; j++) {
+        out.push(u, neighbours[j]);
+      }
+    }
+  } else {
+    const start = new Uint32Array(n + 1);
+    for (let u = 0; u < n; u++) {
+      for (let j = u * k; j < (u + 1) * k; j++) {
+        start[Math.min(u, neighbours[j]) + 1]++;
+      }
+    }
+    for (let u = 0; u < n; u++) {
+      start[u + 1] += start[u];
+    }
+    const fill = start.slice(0, -1);
+    const other = new Uint32Array(n * k);
+    for (let u = 0; u < n; u++) {
+      for (let j = u * k; j < (u + 1) * k; j++) {
+        const v = neighbours[j];
+        other[fill[Math.min(u, v)]++] = Math.max(u, v);
+      }
+    }
+    out = new EdgeBuffer(n * k);
+    for (let u = 0; u < n; u++) {
+      const row = other.subarray(start[u], start[u + 1]).sort();
+      for (let j = 0; j < row.length; j++) {
+        if (j === 0 || row[j] !== row[j - 1]) {
+          out.push(u, row[j]);
+        }
+      }
+    }
+  }
+  return applyWeights(toGraph(n, out, directed, columns), options);
+}
+function randomRecursiveTreeGraph(options) {
+  const { n } = options;
+  checkInt("n", n, 1);
+  const stream = new RandomStream(resolveSeed(options.seed), "recursive-tree", 0);
+  const src = new Uint32Array(n - 1);
+  const dst = new Uint32Array(n - 1);
+  for (let t = 1; t < n; t++) {
+    src[t - 1] = stream.nextBelow(t);
+    dst[t - 1] = t;
+  }
+  return applyWeights({ directed: false, nodeCount: n, src, dst }, options);
+}
+function pickPrefix(stream, candidates, count) {
+  for (let i = 0; i < count; i++) {
+    const j = i + stream.nextBelow(candidates.length - i);
+    const t = candidates[i];
+    candidates[i] = candidates[j];
+    candidates[j] = t;
+  }
+}
+function forestFireGraph(options) {
+  const { n, forward: p, backward: r } = options;
+  const maxBurn = options.maxBurn ?? 1e3;
+  checkInt("n", n, 1);
+  if (!(p >= 0 && p < 1)) {
+    throw new RangeError(`forward must be a probability in [0, 1), got ${String(p)}`);
+  }
+  if (!(r >= 0 && r * p < 1)) {
+    throw new RangeError(`backward must be >= 0 with backward * forward < 1, got ${String(r)}`);
+  }
+  checkInt("maxBurn", maxBurn, 1);
+  const stream = new RandomStream(resolveSeed(options.seed), "forest-fire", 0);
+  const pb = r * p;
+  const logForward = detLog(p);
+  const logBackward = detLog(pb);
+  const out = Array.from({ length: n }, () => []);
+  const inn = Array.from({ length: n }, () => []);
+  const stamp = new Uint32Array(n);
+  const edges = new EdgeBuffer(4 * n);
+  const burned = [];
+  const burn = (v, list, count) => {
+    const candidates = list.filter((t) => stamp[t] !== v);
+    const take = Math.min(count, candidates.length, maxBurn - burned.length);
+    pickPrefix(stream, candidates, take);
+    for (let i = 0; i < take; i++) {
+      stamp[candidates[i]] = v;
+      burned.push(candidates[i]);
+    }
+  };
+  for (let v = 1; v < n; v++) {
+    burned.length = 0;
+    const w = stream.nextBelow(v);
+    stamp[w] = v;
+    burned.push(w);
+    for (let head = 0; head < burned.length && burned.length < maxBurn; head++) {
+      const x = burned[head];
+      const xOut = p === 0 ? 0 : stream.nextSkip(logForward);
+      const xIn = pb === 0 ? 0 : stream.nextSkip(logBackward);
+      burn(v, out[x], xOut);
+      burn(v, inn[x], xIn);
+    }
+    for (const t of burned) {
+      edges.push(v, t);
+      out[v].push(t);
+      inn[t].push(v);
+    }
+  }
+  return applyWeights(toGraph(n, edges, true), options);
+}
+function duplicationDivergenceGraph(options) {
+  const { n, retention } = options;
+  checkInt("n", n, 2);
+  if (!(retention > 0 && retention <= 1)) {
+    throw new RangeError(`retention must be a probability in (0, 1], got ${String(retention)}`);
+  }
+  const stream = new RandomStream(resolveSeed(options.seed), "duplication-divergence", 0);
+  const adj = Array.from({ length: n }, () => []);
+  const edges = new EdgeBuffer(4 * n);
+  edges.push(0, 1);
+  adj[0].push(1);
+  adj[1].push(0);
+  const maxAttempts = 1e3 * n;
+  let attempts = 0;
+  for (let i = 2; i < n; ) {
+    if (++attempts > maxAttempts) {
+      throw new RangeError(
+        `duplicationDivergenceGraph gave up after ${maxAttempts} attempts at ${i} of ${n} nodes: retention ${retention} is too small`
+      );
+    }
+    const copied = adj[stream.nextBelow(i)];
+    for (const t of copied) {
+      if (stream.nextFloat() < retention) {
+        edges.push(i, t);
+        adj[i].push(t);
+      }
+    }
+    for (const t of adj[i]) {
+      adj[t].push(i);
+    }
+    if (adj[i].length > 0) {
+      i++;
+    }
+  }
+  return applyWeights(toGraph(n, edges, false), options);
+}
+function newmanWattsGraph(options) {
+  const { n, k, p } = options;
+  checkInt("k", k, 2);
+  if (k % 2 !== 0) {
+    throw new RangeError(`k must be even, got ${k}`);
+  }
+  checkInt("n", n, k + 1);
+  checkProbability("p", p);
+  const half = k / 2;
+  const ring = n * half;
+  checkEdgeCount(2 * ring);
+  const edges = new EdgeBuffer(ring + Math.ceil(ring * p + 6 * Math.sqrt(ring) + 16));
+  const degree = new Uint32Array(n).fill(k);
+  const present = /* @__PURE__ */ new Set();
+  const key = (a, b) => a < b ? a * n + b : b * n + a;
+  for (let u = 0; u < n; u++) {
+    for (let j = 1; j <= half; j++) {
+      const v = (u + j) % n;
+      edges.push(u, v);
+      present.add(key(u, v));
+    }
+  }
+  const stream = new RandomStream(resolveSeed(options.seed), "newman-watts", 0);
+  for (let slot = 0; slot < ring; slot++) {
+    const u = edges.src[slot];
+    if (stream.nextFloat() >= p || degree[u] >= n - 1) {
+      continue;
+    }
+    let w = stream.nextBelow(n);
+    while (w === u || present.has(key(u, w))) {
+      w = stream.nextBelow(n);
+    }
+    edges.push(u, w);
+    present.add(key(u, w));
+    degree[u]++;
+    degree[w]++;
+  }
+  return applyWeights(toGraph(n, edges, false), options);
+}
+function bianconiBarabasiGraph(options) {
+  const { n, m } = options;
+  checkInt("m", m, 1);
+  checkInt("n", n, m + 1);
+  const seed = resolveSeed(options.seed);
+  checkEdgeCount(m * (m + 1) / 2 + (n - m - 1) * m);
+  const fitness = new Float64Array(n);
+  if (options.fitness === void 0) {
+    const draw = new RandomStream(seed, "fitness", 0);
+    for (let i = 0; i < n; i++) {
+      draw.reset(i);
+      fitness[i] = 1 - draw.nextFloat();
+    }
+  } else {
+    if (options.fitness.length !== n) {
+      throw new RangeError(`fitness must have n = ${n} values, got ${options.fitness.length}`);
+    }
+    for (let i = 0; i < n; i++) {
+      const f = options.fitness[i];
+      if (!(f > 0 && Number.isFinite(f))) {
+        throw new RangeError(`fitness[${i}] must be finite and positive, got ${String(f)}`);
+      }
+      fitness[i] = f;
+    }
+  }
+  const edges = new EdgeBuffer(m * (m + 1) / 2 + (n - m - 1) * m);
+  const degree = new Uint32Array(n);
+  for (let a = 0; a <= m; a++) {
+    for (let b = a + 1; b <= m; b++) {
+      edges.push(a, b);
+    }
+    degree[a] = m;
+  }
+  const weight = new Float64Array(n);
+  const tree = new Float64Array(n + 1);
+  const add = (i, delta) => {
+    weight[i] += delta;
+    for (let j = i + 1; j <= n; j += j & -j) {
+      tree[j] += delta;
+    }
+  };
+  let top = 1;
+  while (top * 2 <= n) {
+    top *= 2;
+  }
+  const find = (x, limit) => {
+    let pos = 0;
+    let rest = x;
+    for (let step = top; step >= 1; step = Math.floor(step / 2)) {
+      if (pos + step <= n && tree[pos + step] <= rest) {
+        pos += step;
+        rest -= tree[pos];
+      }
+    }
+    pos = Math.min(pos, limit - 1);
+    while (weight[pos] === 0) {
+      pos--;
+    }
+    return pos;
+  };
+  let total = 0;
+  for (let i = 0; i <= m; i++) {
+    add(i, fitness[i] * m);
+    total += fitness[i] * m;
+  }
+  const stream = new RandomStream(seed, "bianconi-barabasi", 0);
+  const picked = new Uint32Array(m);
+  for (let s = m + 1; s < n; s++) {
+    let remaining = total;
+    for (let i = 0; i < m; i++) {
+      const t = find(stream.nextFloat() * remaining, s);
+      picked[i] = t;
+      remaining -= weight[t];
+      add(t, -weight[t]);
+    }
+    for (let i = 0; i < m; i++) {
+      const t = picked[i];
+      edges.push(s, t);
+      degree[t]++;
+      add(t, fitness[t] * degree[t]);
+    }
+    degree[s] = m;
+    add(s, fitness[s] * m);
+    total = 0;
+    for (let j = n; j > 0; j -= j & -j) {
+      total += tree[j];
+    }
+  }
+  return applyWeights(toGraph(n, edges, false, { fitness }), options);
+}
+function randomApollonianGraph(options) {
+  const { n } = options;
+  checkInt("n", n, 3);
+  const m = 3 * n - 6;
+  checkEdgeCount(m);
+  const stream = new RandomStream(resolveSeed(options.seed), "apollonian", 0);
+  const faces = 2 * n - 5;
+  const fa = new Uint32Array(faces);
+  const fb = new Uint32Array(faces);
+  const fc = new Uint32Array(faces);
+  fa[0] = 0;
+  fb[0] = 1;
+  fc[0] = 2;
+  let faceCount = 1;
+  const src = new Uint32Array(m);
+  const dst = new Uint32Array(m);
+  src.set([0, 0, 1]);
+  dst.set([1, 2, 2]);
+  let e = 3;
+  for (let v = 3; v < n; v++) {
+    const f = stream.nextBelow(faceCount);
+    const a = fa[f];
+    const b = fb[f];
+    const c = fc[f];
+    src.fill(v, e, e + 3);
+    dst[e++] = a;
+    dst[e++] = b;
+    dst[e++] = c;
+    fc[f] = v;
+    fa[faceCount] = b;
+    fb[faceCount] = c;
+    fc[faceCount++] = v;
+    fa[faceCount] = a;
+    fb[faceCount] = c;
+    fc[faceCount++] = v;
+  }
+  return applyWeights({ directed: false, nodeCount: n, src, dst }, options);
+}
+function wilsonMazeGraph(options) {
+  const { rows, cols } = options;
+  checkInt("rows", rows, 1);
+  checkInt("cols", cols, 1);
+  const n = rows * cols;
+  checkInt("rows * cols", n, 1);
+  const stream = new RandomStream(resolveSeed(options.seed), "wilson", 0);
+  const inTree = new Uint8Array(n);
+  const next = new Uint32Array(n);
+  const src = new Uint32Array(n - 1);
+  const dst = new Uint32Array(n - 1);
+  const options4 = new Uint32Array(4);
+  inTree[0] = 1;
+  let e = 0;
+  for (let start = 1; start < n; start++) {
+    let u = start;
+    while (inTree[u] === 0) {
+      const r = Math.floor(u / cols);
+      const c = u - r * cols;
+      let count = 0;
+      if (c > 0) {
+        options4[count++] = u - 1;
+      }
+      if (c + 1 < cols) {
+        options4[count++] = u + 1;
+      }
+      if (r > 0) {
+        options4[count++] = u - cols;
+      }
+      if (r + 1 < rows) {
+        options4[count++] = u + cols;
+      }
+      next[u] = options4[stream.nextBelow(count)];
+      u = next[u];
+    }
+    for (u = start; inTree[u] === 0; u = next[u]) {
+      inTree[u] = 1;
+      src[e] = u;
+      dst[e++] = next[u];
+    }
+  }
+  const x = new Float64Array(n);
+  const y = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    y[i] = Math.floor(i / cols);
+    x[i] = i - y[i] * cols;
+  }
+  return applyWeights({ directed: false, nodeCount: n, src, dst, nodeColumns: { x, y } }, options);
+}
+const PIO4 = 0.7853981633974483;
+const S1 = -0.16666666666666632;
+const S2 = 0.00833333333332249;
+const S3 = -1984126982985795e-19;
+const S4 = 27557313707070068e-22;
+const S5 = -25050760253406863e-24;
+const S6 = 158969099521155e-24;
+const C1 = 0.0416666666666666;
+const C2 = -0.001388888888887411;
+const C3 = 2480158728947673e-20;
+const C4 = -27557314351390663e-23;
+const C5 = 2087572321298175e-24;
+const C6 = -11359647557788195e-27;
+function kernelSin(x) {
+  const z = x * x;
+  const r = S2 + z * (S3 + z * (S4 + z * (S5 + z * S6)));
+  return x + z * x * (S1 + z * r);
+}
+function kernelCos(x) {
+  const z = x * x;
+  const w = z * z;
+  const r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));
+  const hz = 0.5 * z;
+  const v = 1 - hz;
+  return v + (1 - v - hz + z * r);
+}
+function detCosSinTurn(u, out) {
+  const t = u * 8;
+  const octant = Math.floor(t);
+  const x = (t - octant) * PIO4;
+  const odd = (octant & 1) === 1;
+  const z = odd ? PIO4 - x : x;
+  const c = odd ? kernelSin(z) : kernelCos(z);
+  const s = odd ? kernelCos(z) : kernelSin(z);
+  switch (octant >> 1 & 3) {
+    case 0:
+      out[0] = c;
+      out[1] = s;
+      break;
+    case 1:
+      out[0] = -s;
+      out[1] = c;
+      break;
+    case 2:
+      out[0] = -c;
+      out[1] = -s;
+      break;
+    default:
+      out[0] = s;
+      out[1] = -c;
+  }
+}
+const MAX_NODES = 2e4;
+function cosh(x) {
+  return (detExp(x) + detExp(-x)) / 2;
+}
+function acosh(y) {
+  return detLog(y + Math.sqrt((y - 1) * (y + 1)));
+}
+function planHyperbolic(options) {
+  const { n, averageDegree, exponent } = options;
+  const temperature = options.temperature ?? 0;
+  checkInt("n", n, 0, MAX_NODES);
+  if (!(Number.isFinite(averageDegree) && averageDegree > 0)) {
+    throw new RangeError(`averageDegree must be a finite number > 0, got ${String(averageDegree)}`);
+  }
+  if (!(Number.isFinite(exponent) && exponent > 2)) {
+    throw new RangeError(`exponent must be a finite number > 2, got ${String(exponent)}`);
+  }
+  if (!(temperature >= 0 && temperature < 1)) {
+    throw new RangeError(`temperature must be in [0, 1), got ${String(temperature)}`);
+  }
+  const seed = resolveSeed(options.seed);
+  const alpha = (exponent - 1) / 2;
+  const xi = alpha / (alpha - 0.5);
+  let correction = 1;
+  if (temperature > 0) {
+    const cs2 = new Float64Array(2);
+    detCosSinTurn(temperature / 2, cs2);
+    correction = Math.PI * temperature / cs2[1];
+  }
+  const scale2 = 2 * xi * xi * n / (Math.PI * averageDegree) * correction;
+  if (n >= 2 && !(scale2 > 1)) {
+    throw new RangeError(`averageDegree ${averageDegree} is too large for n = ${n}: the disk radius would be <= 0`);
+  }
+  const R = n >= 2 ? 2 * detLog(scale2) : 0;
+  const coshAlphaR = cosh(alpha * R);
+  if (!Number.isFinite(coshAlphaR)) {
+    throw new RangeError(`exponent ${exponent} is too large: cosh(alpha R) overflows`);
+  }
+  const cosT = new Float64Array(n);
+  const sinT = new Float64Array(n);
+  const coshr = new Float64Array(n);
+  const sinhr = new Float64Array(n);
+  const x = new Float64Array(n);
+  const y = new Float64Array(n);
+  const radius = new Float64Array(n);
+  const cs = new Float64Array(2);
+  const stream = new RandomStream(seed, "hyperbolic-points", 0);
+  for (let i = 0; i < n; i++) {
+    stream.reset(i);
+    detCosSinTurn(stream.nextFloat(), cs);
+    const r = acosh(1 + (coshAlphaR - 1) * stream.nextFloat()) / alpha;
+    const er = detExp(r);
+    cosT[i] = cs[0];
+    sinT[i] = cs[1];
+    coshr[i] = (er + 1 / er) / 2;
+    sinhr[i] = (er - 1 / er) / 2;
+    radius[i] = r;
+    x[i] = r * cs[0];
+    y[i] = r * cs[1];
+  }
+  return { n, seed, temperature, R, coshR: cosh(R), cosT, sinT, coshr, sinhr, x, y, radius };
+}
+function hyperbolicRows(plan, start, end, out) {
+  const { n, R, coshR, temperature, cosT, sinT, coshr, sinhr } = plan;
+  const stream = new RandomStream(plan.seed, "hyperbolic", 0);
+  for (let u = start; u < end; u++) {
+    stream.reset(u);
+    for (let v = u + 1; v < n; v++) {
+      const coshD = coshr[u] * coshr[v] - sinhr[u] * sinhr[v] * (cosT[u] * cosT[v] + sinT[u] * sinT[v]);
+      if (temperature === 0) {
+        if (coshD < coshR) {
+          out.push(u, v);
+        }
+        continue;
+      }
+      const t = stream.nextFloat();
+      if (acosh(Math.max(1, coshD)) < R + 2 * temperature * detLog((1 - t) / t)) {
+        out.push(u, v);
+      }
+    }
+  }
+}
+function hyperbolicGraph(options) {
+  const plan = planHyperbolic(options);
+  const out = new EdgeBuffer(Math.ceil(plan.n * options.averageDegree * 0.75) + 16);
+  hyperbolicRows(plan, 0, plan.n, out);
+  return applyWeights(toGraph(plan.n, out, false, { x: plan.x, y: plan.y, radius: plan.radius }), options);
+}
+function forwardOffsets(diagonals) {
+  const offsets = [
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]
+  ];
+  if (diagonals) {
+    for (let dl = 0; dl <= 1; dl++) {
+      for (let dr = -1; dr <= 1; dr++) {
+        for (let dc = -1; dc <= 1; dc++) {
+          const positive = dl > 0 || dl === 0 && (dr > 0 || dr === 0 && dc > 0);
+          const axis = Math.abs(dc) + Math.abs(dr) + Math.abs(dl) === 1;
+          if (positive && !axis) {
+            offsets.push([dc, dr, dl]);
+          }
+        }
+      }
+    }
+  }
+  return offsets;
+}
+function grid3dGraph(options) {
+  const { rows, cols, layers } = options;
+  checkInt("rows", rows, 1);
+  checkInt("cols", cols, 1);
+  checkInt("layers", layers, 1);
+  const n = rows * cols * layers;
+  checkInt("rows * cols * layers", n, 1);
+  const periodic = options.periodic === true;
+  const directed = options.directed === true;
+  if (periodic && directed) {
+    throw new RangeError("directed grids cannot be periodic: the wrap-around arcs would close cycles");
+  }
+  const offsets = forwardOffsets(options.diagonals === true);
+  checkEdgeCount(n * offsets.length);
+  let blocked = null;
+  if (options.obstacles !== void 0) {
+    const p = options.obstacles;
+    checkProbability("obstacles", p);
+    if (p >= 1) {
+      throw new RangeError("obstacles must be below 1");
+    }
+    blocked = new Uint8Array(n);
+    const stream = new RandomStream(resolveSeed(options.seed), "grid-obstacles", 0);
+    for (let i = 0; i < n; i++) {
+      stream.reset(i);
+      blocked[i] = stream.nextFloat() < p ? 1 : 0;
+    }
+  }
+  const sizes = [cols, rows, layers];
+  const wraps = sizes.map((size) => periodic && size >= 3);
+  const plane = rows * cols;
+  const out = new EdgeBuffer(n * Math.min(offsets.length, 3));
+  const at = [0, 0, 0];
+  for (let l = 0; l < layers; l++) {
+    for (let r = 0; r < rows; r++) {
+      for (let c = 0; c < cols; c++) {
+        const i = l * plane + r * cols + c;
+        if (blocked?.[i] === 1) {
+          continue;
+        }
+        const here = [c, r, l];
+        for (const offset of offsets) {
+          let inside = true;
+          for (let axis = 0; axis < 3; axis++) {
+            let x = here[axis] + offset[axis];
+            if (x < 0 || x >= sizes[axis]) {
+              if (!wraps[axis]) {
+                inside = false;
+                break;
+              }
+              x = (x + sizes[axis]) % sizes[axis];
+            }
+            at[axis] = x;
+          }
+          if (!inside) {
+            continue;
+          }
+          const j = at[2] * plane + at[1] * cols + at[0];
+          if (blocked?.[j] === 1) {
+            continue;
+          }
+          out.push(directed && j < i ? j : i, directed && j < i ? i : j);
+        }
+      }
+    }
+  }
+  const columns = {};
+  if (blocked !== null) {
+    columns.blocked = blocked;
+  }
+  if (options.positions === true) {
+    const x = new Float64Array(n);
+    const y = new Float64Array(n);
+    const z = layers > 1 ? new Float64Array(n) : null;
+    for (let i = 0; i < n; i++) {
+      x[i] = i % cols;
+      y[i] = Math.floor(i / cols) % rows;
+      if (z !== null) {
+        z[i] = Math.floor(i / plane);
+      }
+    }
+    columns.x = x;
+    columns.y = y;
+    if (z !== null) {
+      columns.z = z;
+    }
+  }
+  const graph = toGraph(n, out, directed, Object.keys(columns).length > 0 ? columns : void 0);
+  return applyWeights(graph, options);
+}
+function gridGraph(options) {
+  return grid3dGraph({ ...options, layers: 1 });
+}
+const HALF_SQRT3 = 0.8660254037844386;
+function planarSize(options) {
+  checkInt("rows", options.rows, 1);
+  checkInt("cols", options.cols, 1);
+  const n = options.rows * options.cols;
+  checkInt("rows * cols", n, 1);
+  checkEdgeCount(3 * n);
+  return n;
+}
+function triangularLatticeGraph(options) {
+  const n = planarSize(options);
+  const { rows, cols } = options;
+  const out = new EdgeBuffer(3 * n);
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const i = r * cols + c;
+      if (c + 1 < cols) {
+        out.push(i, i + 1);
+      }
+      if (r + 1 < rows) {
+        out.push(i, i + cols);
+        if (c > 0) {
+          out.push(i, i + cols - 1);
+        }
+      }
+    }
+  }
+  let columns;
+  if (options.positions === true) {
+    const x = new Float64Array(n);
+    const y = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+      const r = Math.floor(i / cols);
+      x[i] = i % cols + r / 2;
+      y[i] = r * HALF_SQRT3;
+    }
+    columns = { x, y };
+  }
+  return applyWeights(toGraph(n, out, false, columns), options);
+}
+function hexagonalLatticeGraph(options) {
+  const n = planarSize(options);
+  const { rows, cols } = options;
+  const out = new EdgeBuffer(2 * n);
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const i = r * cols + c;
+      if (c + 1 < cols) {
+        out.push(i, i + 1);
+      }
+      if (r + 1 < rows && (r + c) % 2 === 0) {
+        out.push(i, i + cols);
+      }
+    }
+  }
+  let columns;
+  if (options.positions === true) {
+    const x = new Float64Array(n);
+    const y = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+      const r = Math.floor(i / cols);
+      const c = i % cols;
+      x[i] = c * HALF_SQRT3;
+      y[i] = 1.5 * r + ((r + c) % 2 === 0 ? 0.5 : 0);
+    }
+    columns = { x, y };
+  }
+  return applyWeights(toGraph(n, out, false, columns), options);
+}
+const MAX_LFR_NODES = 1e6;
+function communitySizes(n, min, max, sample, seed) {
+  if (Math.ceil(n / max) * min > n) {
+    throw new RangeError(`there is no partition of ${n} nodes into communities of ${min} to ${max} nodes`);
+  }
+  const stream = new RandomStream(seed, "lfr-sizes", 0);
+  const sizes = [];
+  let excess = -n;
+  while (excess < 0) {
+    const s = sample(stream);
+    sizes.push(s);
+    excess += s;
+  }
+  if (sizes.length * min > n) {
+    excess -= sizes[sizes.length - 1];
+    sizes.pop();
+  }
+  for (let i = sizes.length - 1; i >= 0 && excess !== 0; i--) {
+    const change = excess > 0 ? -Math.min(excess, sizes[i] - min) : Math.min(-excess, max - sizes[i]);
+    sizes[i] += change;
+    excess += change;
+  }
+  return sizes;
+}
+function assignCommunities(internal, sizes, seed) {
+  const n = internal.length;
+  const nodes = Uint32Array.from({ length: n }, (_, i) => i).sort((a, b) => internal[b] - internal[a] || a - b);
+  const bySize = Uint32Array.from(sizes, (_, i) => i).sort((a, b) => sizes[b] - sizes[a] || a - b);
+  const room = sizes.slice();
+  const open = [];
+  const community = new Uint32Array(n);
+  const stream = new RandomStream(seed, "lfr-assign", 0);
+  let next = 0;
+  for (const node of nodes) {
+    while (next < bySize.length && sizes[bySize[next]] > internal[node]) {
+      open.push(bySize[next++]);
+    }
+    if (open.length === 0) {
+      throw new RangeError(
+        `could not assign communities: node ${node} needs a community of more than ${internal[node]} nodes; raise maxCommunity or mixing, or lower maxDegree`
+      );
+    }
+    const j = stream.nextBelow(open.length);
+    const c = open[j];
+    community[node] = c;
+    if (--room[c] === 0) {
+      open[j] = open[open.length - 1];
+      open.pop();
+    }
+  }
+  return community;
+}
+function lfrGraph(options) {
+  const { n, minDegree, maxDegree, minCommunity, maxCommunity, mixing } = options;
+  const seed = resolveSeed(options.seed);
+  checkInt("n", n, 1, MAX_LFR_NODES);
+  checkInt("maxDegree", maxDegree, 1, n - 1);
+  checkProbability("mixing", mixing);
+  checkInt("maxCommunity", maxCommunity, 1, n);
+  const degreeOf = powerLawSampler(
+    ["degreeExponent", "minDegree", "maxDegree"],
+    options.degreeExponent,
+    minDegree,
+    maxDegree
+  );
+  const sizeOf = powerLawSampler(
+    ["communityExponent", "minCommunity", "maxCommunity"],
+    options.communityExponent,
+    minCommunity,
+    maxCommunity
+  );
+  const degree = new Uint32Array(n);
+  const degreeStream = new RandomStream(seed, "lfr-degrees", 0);
+  for (let i = 0; i < n; i++) {
+    degree[i] = degreeOf(degreeStream);
+  }
+  makeSumEven(degree, minDegree, maxDegree);
+  const sizes = communitySizes(n, minCommunity, maxCommunity, sizeOf, seed);
+  const internal = Uint32Array.from(degree, (d) => Math.round((1 - mixing) * d));
+  const community = assignCommunities(internal, sizes, seed);
+  const start = new Uint32Array(sizes.length + 1);
+  for (let c = 0; c < sizes.length; c++) {
+    start[c + 1] = start[c] + sizes[c];
+  }
+  const fill = start.slice(0, sizes.length);
+  const members = new Uint32Array(n);
+  for (let i = 0; i < n; i++) {
+    members[fill[community[i]]++] = i;
+  }
+  let total = 0;
+  for (const d of degree) {
+    total += d;
+  }
+  const out = new EdgeBuffer(total / 2);
+  const stream = new RandomStream(seed, "lfr-internal", 0);
+  for (let c = 0; c < sizes.length; c++) {
+    const group = members.subarray(start[c], start[c + 1]);
+    const k = Uint32Array.from(group, (i) => internal[i]);
+    let sum = 0;
+    let largest = 0;
+    for (let j = 0; j < k.length; j++) {
+      sum += k[j];
+      if (k[j] > k[largest]) {
+        largest = j;
+      }
+    }
+    if (sum % 2 === 1) {
+      k[largest]--;
+      internal[group[largest]]--;
+      sum--;
+    }
+    const stubs2 = stubList(k, sum);
+    for (let j = 0; j < stubs2.length; j++) {
+      stubs2[j] = group[stubs2[j]];
+    }
+    stream.reset(c);
+    shuffle(stubs2, stream);
+    pairStubs(n, stubs2, false, false, out);
+  }
+  const external = Uint32Array.from(degree, (d, i) => d - internal[i]);
+  let externalTotal = 0;
+  for (const d of external) {
+    externalTotal += d;
+  }
+  const stubs = stubList(external, externalTotal);
+  shuffle(stubs, new RandomStream(seed, "lfr-external", 0));
+  pairStubs(n, stubs, false, false, out, community);
+  return applyWeights(toGraph(n, out, false, { community }), options);
+}
+const NAMED_GRAPH_NAMES = [
+  "bull",
+  "chvatal",
+  "cubical",
+  "desargues",
+  "diamond",
+  "dodecahedral",
+  "frucht",
+  "heawood",
+  "hoffman-singleton",
+  "house",
+  "house-x",
+  "icosahedral",
+  "krackhardt-kite",
+  "moebius-kantor",
+  "octahedral",
+  "pappus",
+  "sedgewick-maze",
+  "tetrahedral",
+  "truncated-cube",
+  "truncated-tetrahedron",
+  "tutte"
+];
+const GRAPHS = {
+  // a triangle with two pendant horns; 5 nodes, 5 edges
+  bull: [5, [0, 1, 0, 2, 1, 2, 1, 3, 2, 4]],
+  // the smallest triangle-free 4-regular 4-chromatic graph; 12 nodes, 24 edges
+  chvatal: [
+    12,
+    [
+      0,
+      1,
+      0,
+      4,
+      0,
+      6,
+      0,
+      9,
+      1,
+      2,
+      1,
+      5,
+      1,
+      7,
+      2,
+      3,
+      2,
+      6,
+      2,
+      8,
+      3,
+      4,
+      3,
+      7,
+      3,
+      9,
+      4,
+      5,
+      4,
+      8,
+      5,
+      10,
+      5,
+      11,
+      6,
+      10,
+      6,
+      11,
+      7,
+      8,
+      7,
+      11,
+      8,
+      10,
+      9,
+      10,
+      9,
+      11
+    ]
+  ],
+  // the cube's skeleton (Q_3); 8 nodes, 12 edges, planar
+  cubical: [8, [0, 1, 0, 3, 0, 4, 1, 2, 1, 7, 2, 3, 2, 6, 3, 5, 4, 5, 4, 7, 5, 6, 6, 7]],
+  // the Desargues graph, 3-regular, distance-transitive; 20 nodes, 30 edges
+  desargues: [
+    20,
+    [
+      0,
+      1,
+      0,
+      19,
+      0,
+      5,
+      1,
+      2,
+      1,
+      16,
+      2,
+      3,
+      2,
+      11,
+      3,
+      4,
+      3,
+      14,
+      4,
+      5,
+      4,
+      9,
+      5,
+      6,
+      6,
+      7,
+      6,
+      15,
+      7,
+      8,
+      7,
+      18,
+      8,
+      9,
+      8,
+      13,
+      9,
+      10,
+      10,
+      11,
+      10,
+      19,
+      11,
+      12,
+      12,
+      13,
+      12,
+      17,
+      13,
+      14,
+      14,
+      15,
+      15,
+      16,
+      16,
+      17,
+      17,
+      18,
+      18,
+      19
+    ]
+  ],
+  // K_4 minus one edge; 4 nodes, 5 edges
+  diamond: [4, [0, 1, 0, 2, 1, 2, 1, 3, 2, 3]],
+  // the dodecahedron's skeleton; 20 nodes, 30 edges, planar, 3-regular
+  dodecahedral: [
+    20,
+    [
+      0,
+      1,
+      0,
+      19,
+      0,
+      10,
+      1,
+      2,
+      1,
+      8,
+      2,
+      3,
+      2,
+      6,
+      3,
+      4,
+      3,
+      19,
+      4,
+      5,
+      4,
+      17,
+      5,
+      6,
+      5,
+      15,
+      6,
+      7,
+      7,
+      8,
+      7,
+      14,
+      8,
+      9,
+      9,
+      10,
+      9,
+      13,
+      10,
+      11,
+      11,
+      12,
+      11,
+      18,
+      12,
+      13,
+      12,
+      16,
+      13,
+      14,
+      14,
+      15,
+      15,
+      16,
+      16,
+      17,
+      17,
+      18,
+      18,
+      19
+    ]
+  ],
+  // 3-regular with no non-trivial automorphism; 12 nodes, 18 edges
+  frucht: [
+    12,
+    [
+      0,
+      1,
+      0,
+      6,
+      0,
+      7,
+      1,
+      2,
+      1,
+      7,
+      2,
+      3,
+      2,
+      8,
+      3,
+      4,
+      3,
+      9,
+      4,
+      5,
+      4,
+      9,
+      5,
+      6,
+      5,
+      10,
+      6,
+      10,
+      7,
+      11,
+      8,
+      11,
+      8,
+      9,
+      10,
+      11
+    ]
+  ],
+  // the (3,6)-cage, the Fano plane's incidence graph; 14 nodes, 21 edges
+  heawood: [
+    14,
+    [
+      0,
+      1,
+      0,
+      13,
+      0,
+      5,
+      1,
+      2,
+      1,
+      10,
+      2,
+      3,
+      2,
+      7,
+      3,
+      4,
+      3,
+      12,
+      4,
+      5,
+      4,
+      9,
+      5,
+      6,
+      6,
+      7,
+      6,
+      11,
+      7,
+      8,
+      8,
+      9,
+      8,
+      13,
+      9,
+      10,
+      10,
+      11,
+      11,
+      12,
+      12,
+      13
+    ]
+  ],
+  // the (7,5)-cage, a Moore graph; 50 nodes, 175 edges
+  "hoffman-singleton": [
+    50,
+    [
+      0,
+      1,
+      0,
+      2,
+      0,
+      3,
+      0,
+      6,
+      0,
+      7,
+      0,
+      8,
+      0,
+      9,
+      1,
+      17,
+      1,
+      12,
+      1,
+      26,
+      1,
+      27,
+      1,
+      28,
+      1,
+      29,
+      2,
+      10,
+      2,
+      11,
+      2,
+      13,
+      2,
+      14,
+      2,
+      15,
+      2,
+      16,
+      3,
+      4,
+      3,
+      5,
+      3,
+      30,
+      3,
+      35,
+      3,
+      40,
+      3,
+      45,
+      4,
+      11,
+      4,
+      17,
+      4,
+      34,
+      4,
+      39,
+      4,
+      44,
+      4,
+      49,
+      5,
+      12,
+      5,
+      10,
+      5,
+      33,
+      5,
+      38,
+      5,
+      43,
+      5,
+      48,
+      6,
+      22,
+      6,
+      18,
+      6,
+      31,
+      6,
+      39,
+      6,
+      43,
+      6,
+      47,
+      7,
+      34,
+      7,
+      23,
+      7,
+      19,
+      7,
+      37,
+      7,
+      41,
+      7,
+      48,
+      8,
+      33,
+      8,
+      36,
+      8,
+      24,
+      8,
+      20,
+      8,
+      42,
+      8,
+      49,
+      9,
+      32,
+      9,
+      38,
+      9,
+      44,
+      9,
+      25,
+      9,
+      21,
+      9,
+      46,
+      10,
+      17,
+      10,
+      18,
+      10,
+      19,
+      10,
+      20,
+      10,
+      21,
+      11,
+      12,
+      11,
+      32,
+      11,
+      37,
+      11,
+      42,
+      11,
+      47,
+      12,
+      31,
+      12,
+      36,
+      12,
+      41,
+      12,
+      46,
+      13,
+      30,
+      13,
+      26,
+      13,
+      22,
+      13,
+      36,
+      13,
+      44,
+      13,
+      48,
+      14,
+      31,
+      14,
+      27,
+      14,
+      23,
+      14,
+      38,
+      14,
+      40,
+      14,
+      49,
+      15,
+      34,
+      15,
+      35,
+      15,
+      28,
+      15,
+      24,
+      15,
+      43,
+      15,
+      46,
+      16,
+      33,
+      16,
+      39,
+      16,
+      41,
+      16,
+      45,
+      16,
+      29,
+      16,
+      25,
+      17,
+      22,
+      17,
+      23,
+      17,
+      24,
+      17,
+      25,
+      18,
+      32,
+      18,
+      26,
+      18,
+      35,
+      18,
+      41,
+      18,
+      49,
+      19,
+      30,
+      19,
+      27,
+      19,
+      39,
+      19,
+      42,
+      19,
+      46,
+      20,
+      31,
+      20,
+      37,
+      20,
+      28,
+      20,
+      44,
+      20,
+      45,
+      21,
+      34,
+      21,
+      36,
+      21,
+      40,
+      21,
+      47,
+      21,
+      29,
+      22,
+      33,
+      22,
+      37,
+      22,
+      40,
+      22,
+      46,
+      23,
+      32,
+      23,
+      36,
+      23,
+      43,
+      23,
+      45,
+      24,
+      30,
+      24,
+      38,
+      24,
+      41,
+      24,
+      47,
+      25,
+      31,
+      25,
+      35,
+      25,
+      42,
+      25,
+      48,
+      26,
+      34,
+      26,
+      38,
+      26,
+      42,
+      26,
+      45,
+      27,
+      33,
+      27,
+      35,
+      27,
+      44,
+      27,
+      47,
+      28,
+      32,
+      28,
+      39,
+      28,
+      40,
+      28,
+      48,
+      29,
+      30,
+      29,
+      37,
+      29,
+      43,
+      29,
+      49,
+      30,
+      31,
+      30,
+      32,
+      31,
+      34,
+      32,
+      33,
+      33,
+      34,
+      35,
+      36,
+      35,
+      37,
+      36,
+      39,
+      37,
+      38,
+      38,
+      39,
+      40,
+      41,
+      40,
+      42,
+      41,
+      44,
+      42,
+      43,
+      43,
+      44,
+      45,
+      46,
+      45,
+      47,
+      46,
+      49,
+      47,
+      48,
+      48,
+      49
+    ]
+  ],
+  // a square with a triangular roof; 5 nodes, 6 edges
+  house: [5, [0, 1, 0, 2, 1, 3, 2, 3, 2, 4, 3, 4]],
+  // the house with both diagonals of the square; 5 nodes, 8 edges
+  "house-x": [5, [0, 1, 0, 2, 0, 3, 1, 3, 1, 2, 2, 3, 2, 4, 3, 4]],
+  // the icosahedron's skeleton; 12 nodes, 30 edges, planar, 5-regular
+  icosahedral: [
+    12,
+    [
+      0,
+      1,
+      0,
+      5,
+      0,
+      7,
+      0,
+      8,
+      0,
+      11,
+      1,
+      2,
+      1,
+      5,
+      1,
+      6,
+      1,
+      8,
+      2,
+      3,
+      2,
+      6,
+      2,
+      8,
+      2,
+      9,
+      3,
+      4,
+      3,
+      6,
+      3,
+      9,
+      3,
+      10,
+      4,
+      5,
+      4,
+      6,
+      4,
+      10,
+      4,
+      11,
+      5,
+      6,
+      5,
+      11,
+      7,
+      8,
+      7,
+      9,
+      7,
+      10,
+      7,
+      11,
+      8,
+      9,
+      9,
+      10,
+      10,
+      11
+    ]
+  ],
+  // Krackhardt's kite: degree, betweenness and closeness each crown a different node; 10 nodes, 18 edges
+  "krackhardt-kite": [
+    10,
+    [0, 1, 0, 2, 0, 3, 0, 5, 1, 3, 1, 4, 1, 6, 2, 3, 2, 5, 3, 4, 3, 5, 3, 6, 4, 6, 5, 6, 5, 7, 6, 7, 7, 8, 8, 9]
+  ],
+  // the Moebius-Kantor graph, the generalized Petersen graph GP(8, 3); 16 nodes, 24 edges
+  "moebius-kantor": [
+    16,
+    [
+      0,
+      1,
+      0,
+      15,
+      0,
+      5,
+      1,
+      2,
+      1,
+      12,
+      2,
+      3,
+      2,
+      7,
+      3,
+      4,
+      3,
+      14,
+      4,
+      5,
+      4,
+      9,
+      5,
+      6,
+      6,
+      7,
+      6,
+      11,
+      7,
+      8,
+      8,
+      9,
+      8,
+      13,
+      9,
+      10,
+      10,
+      11,
+      10,
+      15,
+      11,
+      12,
+      12,
+      13,
+      13,
+      14,
+      14,
+      15
+    ]
+  ],
+  // the octahedron's skeleton, K_{2,2,2}; 6 nodes, 12 edges
+  octahedral: [6, [0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 5, 2, 4, 2, 5, 3, 4, 3, 5, 4, 5]],
+  // the Pappus graph, 3-regular, bipartite, distance-regular; 18 nodes, 27 edges
+  pappus: [
+    18,
+    [
+      0,
+      1,
+      0,
+      17,
+      0,
+      5,
+      1,
+      2,
+      1,
+      8,
+      2,
+      3,
+      2,
+      13,
+      3,
+      4,
+      3,
+      10,
+      4,
+      5,
+      4,
+      15,
+      5,
+      6,
+      6,
+      7,
+      6,
+      11,
+      7,
+      8,
+      7,
+      14,
+      8,
+      9,
+      9,
+      10,
+      9,
+      16,
+      10,
+      11,
+      11,
+      12,
+      12,
+      13,
+      12,
+      17,
+      13,
+      14,
+      14,
+      15,
+      15,
+      16,
+      16,
+      17
+    ]
+  ],
+  // the small maze of Sedgewick's Algorithms in C (DFS teaching); 8 nodes, 10 edges
+  "sedgewick-maze": [8, [0, 2, 0, 7, 0, 5, 1, 7, 2, 6, 3, 4, 3, 5, 4, 5, 4, 7, 4, 6]],
+  // the tetrahedron's skeleton, K_4; 4 nodes, 6 edges
+  tetrahedral: [4, [0, 1, 0, 2, 0, 3, 1, 2, 1, 3, 2, 3]],
+  // the truncated cube's skeleton; 24 nodes, 36 edges, planar
+  "truncated-cube": [
+    24,
+    [
+      0,
+      1,
+      0,
+      2,
+      0,
+      4,
+      1,
+      11,
+      1,
+      14,
+      2,
+      3,
+      2,
+      4,
+      3,
+      6,
+      3,
+      8,
+      4,
+      5,
+      5,
+      16,
+      5,
+      18,
+      6,
+      7,
+      6,
+      8,
+      7,
+      10,
+      7,
+      12,
+      8,
+      9,
+      9,
+      17,
+      9,
+      20,
+      10,
+      11,
+      10,
+      12,
+      11,
+      14,
+      12,
+      13,
+      13,
+      21,
+      13,
+      22,
+      14,
+      15,
+      15,
+      19,
+      15,
+      23,
+      16,
+      17,
+      16,
+      18,
+      17,
+      20,
+      18,
+      19,
+      19,
+      23,
+      20,
+      21,
+      21,
+      22,
+      22,
+      23
+    ]
+  ],
+  // the truncated tetrahedron's skeleton; 12 nodes, 18 edges, planar
+  "truncated-tetrahedron": [
+    12,
+    [
+      0,
+      1,
+      0,
+      2,
+      0,
+      9,
+      1,
+      2,
+      1,
+      6,
+      2,
+      3,
+      3,
+      4,
+      3,
+      11,
+      4,
+      5,
+      4,
+      11,
+      5,
+      6,
+      5,
+      7,
+      6,
+      7,
+      7,
+      8,
+      8,
+      9,
+      8,
+      10,
+      9,
+      10,
+      10,
+      11
+    ]
+  ],
+  // Tutte's graph: 3-regular, 3-connected, planar and not Hamiltonian; 46 nodes, 69 edges
+  tutte: [
+    46,
+    [
+      0,
+      1,
+      0,
+      2,
+      0,
+      3,
+      1,
+      4,
+      1,
+      26,
+      2,
+      10,
+      2,
+      11,
+      3,
+      18,
+      3,
+      19,
+      4,
+      5,
+      4,
+      33,
+      5,
+      6,
+      5,
+      29,
+      6,
+      7,
+      6,
+      27,
+      7,
+      8,
+      7,
+      14,
+      8,
+      9,
+      8,
+      38,
+      9,
+      10,
+      9,
+      37,
+      10,
+      39,
+      11,
+      12,
+      11,
+      39,
+      12,
+      13,
+      12,
+      35,
+      13,
+      14,
+      13,
+      15,
+      14,
+      34,
+      15,
+      16,
+      15,
+      22,
+      16,
+      17,
+      16,
+      44,
+      17,
+      18,
+      17,
+      43,
+      18,
+      45,
+      19,
+      20,
+      19,
+      45,
+      20,
+      21,
+      20,
+      41,
+      21,
+      22,
+      21,
+      23,
+      22,
+      40,
+      23,
+      24,
+      23,
+      27,
+      24,
+      25,
+      24,
+      32,
+      25,
+      26,
+      25,
+      31,
+      26,
+      33,
+      27,
+      28,
+      28,
+      29,
+      28,
+      32,
+      29,
+      30,
+      30,
+      31,
+      30,
+      33,
+      31,
+      32,
+      34,
+      35,
+      34,
+      38,
+      35,
+      36,
+      36,
+      37,
+      36,
+      39,
+      37,
+      38,
+      40,
+      41,
+      40,
+      44,
+      41,
+      42,
+      42,
+      43,
+      42,
+      45,
+      43,
+      44
+    ]
+  ]
+};
+function namedGraph(name, options = {}) {
+  const entry = Object.prototype.hasOwnProperty.call(GRAPHS, name) ? GRAPHS[name] : void 0;
+  if (entry === void 0) {
+    throw new RangeError(`unknown named graph "${name}"; see NAMED_GRAPH_NAMES`);
+  }
+  const [nodeCount, flat] = entry;
+  const m = flat.length / 2;
+  const src = new Uint32Array(m);
+  const dst = new Uint32Array(m);
+  for (let e = 0; e < m; e++) {
+    src[e] = flat[2 * e];
+    dst[e] = flat[2 * e + 1];
+  }
+  return applyWeights({ directed: false, nodeCount, src, dst }, options);
+}
+function barabasiAlbertGraph(options) {
+  const { n, m } = options;
+  const triad = options.triadProbability ?? 0;
+  checkInt("m", m, 1);
+  checkInt("n", n, m + 1);
+  checkProbability("triadProbability", triad);
+  const seed = resolveSeed(options.seed);
+  const edgeCount = (n - m) * m;
+  checkEdgeCount(edgeCount);
+  const stream = new RandomStream(seed, "barabasi-albert", 0);
+  const out = new EdgeBuffer(edgeCount);
+  const repeated = new Uint32Array(m + 2 * edgeCount);
+  let length = 0;
+  for (let i = 0; i < m; i++) {
+    repeated[length++] = i;
+  }
+  const adjacency = triad > 0 ? Array.from({ length: n }, () => []) : null;
+  const targets = new Array(m);
+  const link = (s, t) => {
+    out.push(s, t);
+    repeated[length++] = t;
+    if (adjacency !== null) {
+      adjacency[s].push(t);
+      adjacency[t].push(s);
+    }
+  };
+  for (let s = m; s < n; s++) {
+    let found = 0;
+    while (found < m) {
+      const t = repeated[stream.nextBelow(length)];
+      let fresh = true;
+      for (let i = 0; i < found; i++) {
+        fresh &&= targets[i] !== t;
+      }
+      if (fresh) {
+        targets[found++] = t;
+      }
+    }
+    let next = 0;
+    let target = targets[next++];
+    link(s, target);
+    for (let count = 1; count < m; count++) {
+      if (adjacency !== null && stream.nextFloat() < triad) {
+        const mine = adjacency[s];
+        const candidates = adjacency[target].filter((x) => x !== s && !mine.includes(x));
+        if (candidates.length > 0) {
+          link(s, candidates[stream.nextBelow(candidates.length)]);
+          continue;
+        }
+      }
+      do {
+        target = targets[next++];
+      } while (adjacency !== null && adjacency[s].includes(target) && next < m);
+      if (adjacency !== null && adjacency[s].includes(target)) {
+        do {
+          target = repeated[stream.nextBelow(length)];
+        } while (target === s || adjacency[s].includes(target));
+      }
+      link(s, target);
+    }
+    for (let i = 0; i < m; i++) {
+      repeated[length++] = s;
+    }
+  }
+  return applyWeights(toGraph(n, out, false), options);
+}
+function wattsStrogatzGraph(options) {
+  const { n, k, beta } = options;
+  checkInt("k", k, 2);
+  if (k % 2 !== 0) {
+    throw new RangeError(`k must be even, got ${k}`);
+  }
+  checkInt("n", n, k + 1);
+  checkProbability("beta", beta);
+  const seed = resolveSeed(options.seed);
+  const half = k / 2;
+  const m = n * half;
+  checkEdgeCount(m);
+  const src = new Uint32Array(m);
+  const dst = new Uint32Array(m);
+  const degree = new Uint32Array(n).fill(k);
+  const edges = /* @__PURE__ */ new Set();
+  const key = (a, b) => a < b ? a * n + b : b * n + a;
+  for (let u = 0; u < n; u++) {
+    for (let j = 1; j <= half; j++) {
+      const v = (u + j) % n;
+      src[u * half + j - 1] = u;
+      dst[u * half + j - 1] = v;
+      edges.add(key(u, v));
+    }
+  }
+  const stream = new RandomStream(seed, "watts-strogatz", 0);
+  for (let j = 1; j <= half; j++) {
+    for (let u = 0; u < n; u++) {
+      if (stream.nextFloat() >= beta || degree[u] >= n - 1) {
+        continue;
+      }
+      let w = stream.nextBelow(n);
+      while (w === u || edges.has(key(u, w))) {
+        w = stream.nextBelow(n);
+      }
+      const slot = u * half + j - 1;
+      const v = dst[slot];
+      edges.delete(key(u, v));
+      edges.add(key(u, w));
+      degree[v]--;
+      degree[w]++;
+      dst[slot] = w;
+    }
+  }
+  return applyWeights({ directed: false, nodeCount: n, src, dst }, options);
+}
+function randomTreeGraph(options) {
+  const { n } = options;
+  checkInt("n", n, 1);
+  const seed = resolveSeed(options.seed);
+  const out = new EdgeBuffer(n);
+  if (n === 1) {
+    return applyWeights(toGraph(1, out, false), options);
+  }
+  const stream = new RandomStream(seed, "prufer", 0);
+  const code = new Uint32Array(n - 2);
+  const degree = new Uint32Array(n).fill(1);
+  for (let i = 0; i < n - 2; i++) {
+    code[i] = stream.nextBelow(n);
+    degree[code[i]]++;
+  }
+  let ptr = 0;
+  while (degree[ptr] !== 1) {
+    ptr++;
+  }
+  let leaf = ptr;
+  for (let i = 0; i < n - 2; i++) {
+    const v = code[i];
+    out.push(leaf, v);
+    degree[v]--;
+    if (degree[v] === 1 && v < ptr) {
+      leaf = v;
+    } else {
+      ptr++;
+      while (degree[ptr] !== 1) {
+        ptr++;
+      }
+      leaf = ptr;
+    }
+  }
+  out.push(leaf, n - 1);
+  return applyWeights(toGraph(n, out, false), options);
+}
+function dagRows(starts, layerOf, p, seed, start, end, out) {
+  const logQ = detLog(1 - p);
+  const stream = new RandomStream(seed, "layered-dag", 0);
+  const last = starts.length - 2;
+  for (let u = start; u < end; u++) {
+    const layer = layerOf[u];
+    if (layer < last) {
+      stream.reset(u);
+      bernoulliSegment(stream, p, logQ, u, starts[layer + 1], starts[layer + 2], out);
+    }
+  }
+}
+function randomDagGraph(options) {
+  const { layers, p } = options;
+  checkInt("layers.length", layers.length, 1);
+  checkProbability("p", p);
+  const seed = resolveSeed(options.seed);
+  const starts = [0];
+  let pairs = 0;
+  for (let i = 0; i < layers.length; i++) {
+    checkInt(`layers[${i}]`, layers[i], 0);
+    starts.push(starts[i] + layers[i]);
+    if (i > 0) {
+      pairs += layers[i - 1] * layers[i];
+    }
+  }
+  const n = starts[layers.length];
+  checkInt("the total size", n, 0);
+  const layerOf = new Uint32Array(n);
+  for (let i = 0; i < layers.length; i++) {
+    layerOf.fill(i, starts[i], starts[i + 1]);
+  }
+  const out = binomialBuffer(pairs, p);
+  dagRows(starts, layerOf, p, seed, 0, n, out);
+  return applyWeights(toGraph(n, out, true, { layer: layerOf }), options);
+}
+function randomMultigraph(options) {
+  const { n, m } = options;
+  const loops = options.selfLoops ?? true;
+  checkInt("n", n, 1);
+  checkInt("m", m, 0);
+  if (!loops && n < 2) {
+    throw new RangeError(`selfLoops: false needs n >= 2, got ${n}`);
+  }
+  const stream = new RandomStream(resolveSeed(options.seed), "multigraph", 0);
+  const src = new Uint32Array(m);
+  const dst = new Uint32Array(m);
+  for (let e = 0; e < m; e++) {
+    const u = stream.nextBelow(n);
+    let v;
+    if (loops) {
+      v = stream.nextBelow(n);
+    } else {
+      v = stream.nextBelow(n - 1);
+      if (v >= u) {
+        v++;
+      }
+    }
+    src[e] = u;
+    dst[e] = v;
+  }
+  return applyWeights({ directed: options.directed ?? false, nodeCount: n, src, dst }, options);
+}
+function addPathologicalEdges(graph, options) {
+  const loops = options.selfLoops ?? 0;
+  const parallel = options.parallelEdges ?? 0;
+  const anti = options.antiParallelEdges ?? 0;
+  checkInt("selfLoops", loops, 0);
+  checkInt("parallelEdges", parallel, 0);
+  checkInt("antiParallelEdges", anti, 0);
+  if (anti > 0 && !graph.directed) {
+    throw new RangeError("antiParallelEdges needs a directed graph");
+  }
+  const m = graph.src.length;
+  if (loops > 0 && graph.nodeCount === 0) {
+    throw new RangeError("selfLoops needs a graph with at least one node");
+  }
+  if (parallel + anti > 0 && m === 0) {
+    throw new RangeError("parallelEdges and antiParallelEdges need a graph with at least one edge");
+  }
+  const total = m + loops + parallel + anti;
+  checkEdgeCount(total);
+  const stream = new RandomStream(resolveSeed(options.seed), "pathological", 0);
+  const src = new Uint32Array(total);
+  const dst = new Uint32Array(total);
+  src.set(graph.src);
+  dst.set(graph.dst);
+  const weights = graph.weights === void 0 ? void 0 : new Float32Array(total);
+  weights?.set(graph.weights ?? []);
+  let e = m;
+  for (let i = 0; i < loops; i++, e++) {
+    const v = stream.nextBelow(graph.nodeCount);
+    src[e] = v;
+    dst[e] = v;
+    if (weights !== void 0) {
+      weights[e] = 1;
+    }
+  }
+  for (let i = 0; i < parallel + anti; i++, e++) {
+    const f = stream.nextBelow(m);
+    const reversed = i >= parallel;
+    src[e] = reversed ? graph.dst[f] : graph.src[f];
+    dst[e] = reversed ? graph.src[f] : graph.dst[f];
+    if (weights !== void 0) {
+      weights[e] = weights[f];
+    }
+  }
+  return { ...graph, src, dst, weights };
+}
+const EDGE_CASE_NAMES = [
+  "empty",
+  "single-node",
+  "single-self-loop",
+  "isolated-nodes",
+  "disconnected",
+  "pathological-undirected",
+  "pathological-directed",
+  "zero-weights",
+  "negative-weights",
+  "negative-cycle",
+  "duplicate-heavy",
+  "max-node-index",
+  "star-100k",
+  "path-100k"
+];
+function build(directed, nodeCount, edges, weighted = false) {
+  const stride = weighted ? 3 : 2;
+  const m = edges.length / stride;
+  const src = new Uint32Array(m);
+  const dst = new Uint32Array(m);
+  const weights = new Float32Array(weighted ? m : 0);
+  for (let e = 0; e < m; e++) {
+    src[e] = edges[e * stride];
+    dst[e] = edges[e * stride + 1];
+    weights[e] = weighted ? edges[e * stride + 2] : 0;
+  }
+  return weighted ? { directed, nodeCount, src, dst, weights } : { directed, nodeCount, src, dst };
+}
+function generated(nodeCount, m, end) {
+  const src = new Uint32Array(m);
+  const dst = new Uint32Array(m);
+  for (let e = 0; e < m; e++) {
+    [src[e], dst[e]] = end(e);
+  }
+  return { directed: false, nodeCount, src, dst };
+}
+const CASES = {
+  empty: () => build(false, 0, []),
+  "single-node": () => build(false, 1, []),
+  "single-self-loop": () => build(false, 1, [0, 0]),
+  "isolated-nodes": () => build(false, 10, []),
+  // triangle 0-1-2, path 3-4-5, edge 6-7, isolated 8 and 9
+  disconnected: () => build(false, 10, [0, 1, 1, 2, 2, 0, 3, 4, 4, 5, 6, 7]),
+  // self-loop at 0; (1, 2) three times, once written (2, 1); weights 0, negative and fractional
+  "pathological-undirected": () => build(false, 4, [0, 0, 1, 1, 2, 0, 1, 2, -2, 2, 1, 0.5, 2, 3, 2.5, 3, 0, -1], true),
+  // self-loop at 0; parallel arcs 0 -> 1; the 2-cycle 1 <-> 2 (an anti-parallel pair, one arc
+  // of weight 0); the negative cycle 2 -> 3 -> 4 -> 2 of total weight -2, reachable from 0
+  "pathological-directed": () => build(true, 5, [0, 0, 1, 0, 1, 2, 0, 1, 3, 1, 2, 1, 2, 1, 0, 2, 3, -1, 3, 4, -2, 4, 2, 1, 1, 3, 0.5], true),
+  // a 4-cycle with the chord 0-2, every weight 0: ties everywhere for Dijkstra and MST
+  "zero-weights": () => build(false, 4, [0, 1, 0, 1, 2, 0, 2, 3, 0, 3, 0, 0, 0, 2, 0], true),
+  // a DAG with negative arcs and no negative cycle; distances from 0 are [0, 4, 1, 4, 3]
+  "negative-weights": () => build(true, 5, [0, 1, 4, 0, 2, 2, 1, 2, -3, 1, 3, 2, 2, 3, 3, 3, 4, -1, 2, 4, 5], true),
+  // 0 -> 1, then the cycle 1 -> 2 -> 3 -> 1 of total weight -1
+  "negative-cycle": () => build(true, 4, [0, 1, 1, 1, 2, -1, 2, 3, -1, 3, 1, 1], true),
+  // 1,000 copies of the edge (0, 1)
+  "duplicate-heavy": () => generated(2, 1e3, () => [0, 1]),
+  // 2^20 nodes, edges only at the ends: sparse index handling and large-id output
+  "max-node-index": () => build(false, 2 ** 20, [0, 1, 2 ** 20 - 2, 2 ** 20 - 1, 0, 2 ** 20 - 1]),
+  // hub 0 with 100,000 leaves
+  "star-100k": () => generated(100001, 1e5, (e) => [0, e + 1]),
+  // the path 0 - 1 - ... - 99,999
+  "path-100k": () => generated(1e5, 99999, (e) => [e, e + 1])
+};
+function edgeCaseGraph(name) {
+  if (!EDGE_CASE_NAMES.includes(name)) {
+    throw new RangeError(`unknown edge case "${name}"; expected one of ${EDGE_CASE_NAMES.join(", ")}`);
+  }
+  return CASES[name]();
+}
+export {
+  EDGE_CASE_NAMES,
+  NAMED_GRAPH_NAMES,
+  addPathologicalEdges,
+  akGraph,
+  balancedTreeGraph,
+  barabasiAlbertGraph,
+  barbellGraph,
+  bianconiBarabasiGraph,
+  bipartiteConfigurationModelGraph,
+  cavemanGraph,
+  chungLuGraph,
+  circularLadderGraph,
+  completeBipartiteGraph,
+  completeGraph,
+  completeMultipartiteGraph,
+  configurationModelGraph,
+  connectedCavemanGraph,
+  cycleGraph,
+  degreeCorrectedSbmGraph,
+  directedConfigurationModelGraph,
+  duplicationDivergenceGraph,
+  edgeCaseGraph,
+  emptyGraph,
+  erdosRenyiGnmGraph,
+  erdosRenyiGraph,
+  forestFireGraph,
+  genrmfGraph,
+  grid3dGraph,
+  gridFlowNetwork,
+  gridGraph,
+  hexagonalLatticeGraph,
+  hyperbolicGraph,
+  hypercubeGraph,
+  knnGraph,
+  kroneckerGraph,
+  ladderGraph,
+  layeredFlowNetwork,
+  lfrGraph,
+  lollipopGraph,
+  mobiusLadderGraph,
+  namedGraph,
+  newmanWattsGraph,
+  pathGraph,
+  petersenGraph,
+  plantedPartitionGraph,
+  powerLawDegreeSequence,
+  priceGraph,
+  randomApollonianGraph,
+  randomBipartiteGraph,
+  randomDagGraph,
+  randomGeometricGraph,
+  randomMultigraph,
+  randomOrderDagGraph,
+  randomRecursiveTreeGraph,
+  randomRegularGraph,
+  randomTreeGraph,
+  ringOfCliquesGraph,
+  rmatGraph,
+  starGraph,
+  stochasticBlockModelGraph,
+  triangularLatticeGraph,
+  wattsStrogatzGraph,
+  waxmanGraph,
+  wheelGraph,
+  wilsonMazeGraph,
+  withWeights
+};
+//# sourceMappingURL=generators.js.map