@cloudbitmaps/roaring 0.24.0 → 0.26.0

package/dist/index.js

@@ -119,14 +119,99 @@ function refuseReservedNamespace(namespace) {
   }
 }
 
-// src/roaring-codec.ts
-import { ValidationError as ValidationError3, decodeSerialized } from "@cloudbitmaps/core";
-
 // src/ts-roaring/bitmap.ts
-import { IntegrityError as IntegrityError3, ValidationError as ValidationError2 } from "@cloudbitmaps/core";
+import { IntegrityError as IntegrityError3, ValidationError as ValidationError2, refusalOfId } from "@cloudbitmaps/core";
 
 // src/portable/layout.ts
 import { IntegrityError } from "@cloudbitmaps/core";
+
+// src/portable/popcount.ts
+var BITSET_WORDS = 2048;
+function popcount32(word) {
+  let w = word - (word >>> 1 & 1431655765);
+  w = (w & 858993459) + (w >>> 2 & 858993459);
+  return Math.imul(w + (w >>> 4) & 252645135, 16843009) >>> 24;
+}
+function popcountWords(d) {
+  let total = 0;
+  let ones = 0;
+  let twos = 0;
+  let fours = 0;
+  let eights = 0;
+  for (let i = 0; i < BITSET_WORDS; i += 16) {
+    let u;
+    let twosA;
+    let twosB;
+    let foursA;
+    let foursB;
+    let x = d[i];
+    let y = d[i + 1];
+    u = ones ^ x;
+    twosA = ones & x | u & y;
+    ones = u ^ y;
+    x = d[i + 2];
+    y = d[i + 3];
+    u = ones ^ x;
+    twosB = ones & x | u & y;
+    ones = u ^ y;
+    u = twos ^ twosA;
+    foursA = twos & twosA | u & twosB;
+    twos = u ^ twosB;
+    x = d[i + 4];
+    y = d[i + 5];
+    u = ones ^ x;
+    twosA = ones & x | u & y;
+    ones = u ^ y;
+    x = d[i + 6];
+    y = d[i + 7];
+    u = ones ^ x;
+    twosB = ones & x | u & y;
+    ones = u ^ y;
+    u = twos ^ twosA;
+    foursB = twos & twosA | u & twosB;
+    twos = u ^ twosB;
+    u = fours ^ foursA;
+    const eightsA = fours & foursA | u & foursB;
+    fours = u ^ foursB;
+    x = d[i + 8];
+    y = d[i + 9];
+    u = ones ^ x;
+    twosA = ones & x | u & y;
+    ones = u ^ y;
+    x = d[i + 10];
+    y = d[i + 11];
+    u = ones ^ x;
+    twosB = ones & x | u & y;
+    ones = u ^ y;
+    u = twos ^ twosA;
+    foursA = twos & twosA | u & twosB;
+    twos = u ^ twosB;
+    x = d[i + 12];
+    y = d[i + 13];
+    u = ones ^ x;
+    twosA = ones & x | u & y;
+    ones = u ^ y;
+    x = d[i + 14];
+    y = d[i + 15];
+    u = ones ^ x;
+    twosB = ones & x | u & y;
+    ones = u ^ y;
+    u = twos ^ twosA;
+    foursB = twos & twosA | u & twosB;
+    twos = u ^ twosB;
+    u = fours ^ foursA;
+    const eightsB = fours & foursA | u & foursB;
+    fours = u ^ foursB;
+    u = eights ^ eightsA;
+    const sixteens = eights & eightsA | u & eightsB;
+    eights = u ^ eightsB;
+    total += popcount32(sixteens);
+  }
+  return 16 * total + 8 * popcount32(eights) + 4 * popcount32(fours) + 2 * popcount32(twos) + popcount32(ones);
+}
+
+// src/portable/layout.ts
+var LITTLE_ENDIAN = new Uint8Array(Uint16Array.of(1).buffer)[0] === 1;
 var SERIAL_COOKIE_NO_RUNCONTAINER = 12346;
 var SERIAL_COOKIE = 12347;
 var NO_OFFSET_THRESHOLD = 4;
@@ -191,7 +276,7 @@ function walk(bytes, out) {
     const key = view.getUint16(descriptiveAt + i * 4, true);
     if (key <= previousKey) {
       throw new IntegrityError(
-        `portable roaring: container keys are not strictly ascending (${previousKey} then ${key} at index ${i})`
+        `portable roaring: container keys are not strictly ascending at index ${i}`
       );
     }
     previousKey = key;
@@ -224,7 +309,7 @@ function checkContainer(bytes, view, pos, kind, cardinality, i) {
     if (pos + BITMAP_CONTAINER_BYTES > length) {
       throw overrun(bytes, pos, BITMAP_CONTAINER_BYTES, `container ${i} (bitmap)`);
     }
-    const bits = popcount(view, pos);
+    const bits = bitsetBits(bytes, pos);
     if (bits !== cardinality) {
       throw new IntegrityError(
         `portable roaring: container ${i} (bitmap) holds ${bits} values, but its header says ${cardinality}`
@@ -284,25 +369,22 @@ function checkRuns(view, at, runs, index) {
   }
   return covered;
 }
-function popcount(view, at) {
-  let bits = 0;
-  for (let p = at, end = at + BITMAP_CONTAINER_BYTES; p < end; p += 4) {
-    let w = view.getUint32(p, true);
-    w -= w >>> 1 & 1431655765;
-    w = (w & 858993459) + (w >>> 2 & 858993459);
-    bits += Math.imul(w + (w >>> 4) & 252645135, 16843009) >>> 24;
-  }
-  return bits;
+function bitsetBits(bytes, at) {
+  const offset = bytes.byteOffset + at;
+  if ((offset & 3) === 0) return popcountWords(new Uint32Array(bytes.buffer, offset, BITSET_WORDS));
+  scratchBytes.set(bytes.subarray(at, at + BITMAP_CONTAINER_BYTES));
+  return popcountWords(scratchWords);
 }
+var scratchWords = new Uint32Array(BITSET_WORDS);
+var scratchBytes = new Uint8Array(scratchWords.buffer);
 
 // src/ts-roaring/containers.ts
 var ARRAY2 = 0;
 var BITSET = 1;
 var RUN2 = 2;
-var WORDS = 2048;
+var WORDS = BITSET_WORDS;
 var BITSET_BYTES = 8192;
 var GALLOP_SKEW = 16;
-var LITTLE_ENDIAN = new Uint8Array(Uint16Array.of(1).buffer)[0] === 1;
 var Container = class {
   constructor(kind, data, off, len, card, shared) {
     this.kind = kind;
@@ -352,12 +434,7 @@ function pairs16(n) {
 function arrayOfScratch(scratch, n) {
   return n === 0 ? null : arrayContainer(scratch.slice(0, n), n);
 }
-function popcount32(word) {
-  let w = word - (word >>> 1 & 1431655765);
-  w = (w & 858993459) + (w >>> 2 & 858993459);
-  return Math.imul(w + (w >>> 4) & 252645135, 16843009) >>> 24;
-}
-function popcountWords(d) {
+function popcountAnd(d, e) {
   let total = 0;
   let ones = 0;
   let twos = 0;
@@ -369,26 +446,26 @@ function popcountWords(d) {
     let twosB;
     let foursA;
     let foursB;
-    let x = d[i];
-    let y = d[i + 1];
+    let x = d[i] & e[i];
+    let y = d[i + 1] & e[i + 1];
     u = ones ^ x;
     twosA = ones & x | u & y;
     ones = u ^ y;
-    x = d[i + 2];
-    y = d[i + 3];
+    x = d[i + 2] & e[i + 2];
+    y = d[i + 3] & e[i + 3];
     u = ones ^ x;
     twosB = ones & x | u & y;
     ones = u ^ y;
     u = twos ^ twosA;
     foursA = twos & twosA | u & twosB;
     twos = u ^ twosB;
-    x = d[i + 4];
-    y = d[i + 5];
+    x = d[i + 4] & e[i + 4];
+    y = d[i + 5] & e[i + 5];
     u = ones ^ x;
     twosA = ones & x | u & y;
     ones = u ^ y;
-    x = d[i + 6];
-    y = d[i + 7];
+    x = d[i + 6] & e[i + 6];
+    y = d[i + 7] & e[i + 7];
     u = ones ^ x;
     twosB = ones & x | u & y;
     ones = u ^ y;
@@ -398,26 +475,26 @@ function popcountWords(d) {
     u = fours ^ foursA;
     const eightsA = fours & foursA | u & foursB;
     fours = u ^ foursB;
-    x = d[i + 8];
-    y = d[i + 9];
+    x = d[i + 8] & e[i + 8];
+    y = d[i + 9] & e[i + 9];
     u = ones ^ x;
     twosA = ones & x | u & y;
     ones = u ^ y;
-    x = d[i + 10];
-    y = d[i + 11];
+    x = d[i + 10] & e[i + 10];
+    y = d[i + 11] & e[i + 11];
     u = ones ^ x;
     twosB = ones & x | u & y;
     ones = u ^ y;
     u = twos ^ twosA;
     foursA = twos & twosA | u & twosB;
     twos = u ^ twosB;
-    x = d[i + 12];
-    y = d[i + 13];
+    x = d[i + 12] & e[i + 12];
+    y = d[i + 13] & e[i + 13];
     u = ones ^ x;
     twosA = ones & x | u & y;
     ones = u ^ y;
-    x = d[i + 14];
-    y = d[i + 15];
+    x = d[i + 14] & e[i + 14];
+    y = d[i + 15] & e[i + 15];
     u = ones ^ x;
     twosB = ones & x | u & y;
     ones = u ^ y;
@@ -460,6 +537,19 @@ function clearRange(words, start, end) {
   for (let i = first + 1; i < last; i++) words[i] = 0;
   words[last] = words[last] & ~tail;
 }
+function flipRange(words, start, end) {
+  const first = start >>> 5;
+  const last = end >>> 5;
+  const head = 4294967295 << (start & 31) >>> 0;
+  const tail = 4294967295 >>> 31 - (end & 31);
+  if (first === last) {
+    words[first] = words[first] ^ head & tail;
+    return;
+  }
+  words[first] = words[first] ^ head;
+  for (let i = first + 1; i < last; i++) words[i] = ~words[i];
+  words[last] = words[last] ^ tail;
+}
 function fromSortedIds(ids, from, to) {
   const n = to - from;
   if (n <= ARRAY_MAX_CARDINALITY) {
@@ -515,11 +605,12 @@ function writeLows(c, out) {
     }
   }
 }
+var SMALL_IDS = 32;
 function appendIds(c, out, at, base) {
   if (c.kind === ARRAY2) {
     const u162 = lows16(c);
     const end = c.off + c.len;
-    if (base === 0) {
+    if (base === 0 && c.len >= SMALL_IDS) {
       out.set(u162.subarray(c.off, end), at);
       return at + c.len;
     }
@@ -542,14 +633,15 @@ function appendIds(c, out, at, base) {
   const u16 = lows16(c);
   for (let r = 0; r < c.len; r++) {
     const start = u16[c.off + 2 * r];
-    const last = start + u16[c.off + 2 * r + 1];
-    if (last - start < LONG_RUN) {
-      for (let v = base + start; v <= base + last; v++) out[at++] = v;
+    const length = u16[c.off + 2 * r + 1];
+    if (length < LONG_RUN) {
+      const last = base + start + length;
+      for (let v = base + start; v <= last; v++) out[at++] = v;
       continue;
     }
     const from = at;
-    out.set(iota().subarray(start, last + 1), at);
-    at += last - start + 1;
+    out.set(iota().subarray(start, start + length + 1), at);
+    at += length + 1;
     if (base !== 0) for (let i = from; i < at; i++) out[i] = out[i] + base;
   }
   return at;
@@ -635,31 +727,130 @@ function containerHas(c, low) {
   const r = c.off + 2 * (after - 1);
   return low <= u16[r] + u16[r + 1];
 }
+function runsAfter(data, off, from, len, value) {
+  let step = 1;
+  let lo = from;
+  let hi = from;
+  while (hi < len && data[off + 2 * hi] <= value) {
+    lo = hi + 1;
+    hi += step;
+    step *= 2;
+  }
+  if (hi > len) hi = len;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (data[off + 2 * mid] <= value) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function runsOrPlain(pairs, runs, card, copy) {
+  const plain = card <= ARRAY_MAX_CARDINALITY ? 2 * card : BITSET_BYTES;
+  if (2 + 4 * runs < plain) {
+    return runContainer(copy ? pairs.slice(0, 2 * runs) : pairs, runs, card);
+  }
+  return fromRunPairs(pairs, runs, card);
+}
+function addToRuns(c, low) {
+  const u16 = lows16(c);
+  const next = runsAfter(u16, c.off, 0, c.len, low);
+  const prev = next - 1;
+  const joinPrev = prev >= 0 && u16[c.off + 2 * prev] + u16[c.off + 2 * prev + 1] + 1 === low;
+  const joinNext = next < c.len && u16[c.off + 2 * next] === low + 1;
+  const runs = c.len + 1 - (joinPrev ? 1 : 0) - (joinNext ? 1 : 0);
+  const out = new Uint16Array(2 * runs);
+  const head = joinPrev ? prev : next;
+  out.set(u16.subarray(c.off, c.off + 2 * head));
+  let at = 2 * head;
+  if (joinPrev && joinNext) {
+    out[at++] = u16[c.off + 2 * prev];
+    out[at++] = u16[c.off + 2 * next] + u16[c.off + 2 * next + 1] - u16[c.off + 2 * prev];
+  } else if (joinPrev) {
+    out[at++] = u16[c.off + 2 * prev];
+    out[at++] = u16[c.off + 2 * prev + 1] + 1;
+  } else if (joinNext) {
+    out[at++] = low;
+    out[at++] = u16[c.off + 2 * next + 1] + 1;
+  } else {
+    out[at++] = low;
+    out[at++] = 0;
+  }
+  const rest = joinNext ? next + 1 : next;
+  out.set(u16.subarray(c.off + 2 * rest, c.off + 2 * c.len), at);
+  return runsOrPlain(out, runs, c.card + 1, false);
+}
 function containerAdd(c, low) {
   if (containerHas(c, low)) return c;
-  const plain = demote(c);
-  if (plain.kind === BITSET) {
-    const words = writableWords(plain);
+  if (c.kind === RUN2) return addToRuns(c, low);
+  if (c.kind === BITSET) {
+    const words = writableWords(c);
     words[low >>> 5] = words[low >>> 5] | 1 << (low & 31);
-    return bitsetContainer(words, plain.card + 1);
+    return bitsetContainer(words, c.card + 1);
   }
-  if (plain.card === ARRAY_MAX_CARDINALITY) {
-    const words = toWords(plain);
+  if (c.card === ARRAY_MAX_CARDINALITY) {
+    const words = toWords(c);
     words[low >>> 5] = words[low >>> 5] | 1 << (low & 31);
-    return bitsetContainer(words, plain.card + 1);
+    return bitsetContainer(words, c.card + 1);
   }
-  const old = lows16(plain);
-  const at = lowerBound(old, plain.off, plain.len, low, 1);
+  const old = lows16(c);
+  const at = lowerBound(old, c.off, c.len, low, 1);
   let u16 = old;
-  if (!plain.shared && plain.off === 0 && old.length > plain.len) {
-    u16.copyWithin(at + 1, at, plain.len);
+  if (!c.shared && c.off === 0 && old.length > c.len) {
+    u16.copyWithin(at + 1, at, c.len);
   } else {
-    u16 = new Uint16Array(Math.min(ARRAY_MAX_CARDINALITY, Math.max(8, plain.len * 2)));
-    u16.set(old.subarray(plain.off, plain.off + at));
-    u16.set(old.subarray(plain.off + at, plain.off + plain.len), at + 1);
+    u16 = new Uint16Array(Math.min(ARRAY_MAX_CARDINALITY, Math.max(8, c.len * 2)));
+    u16.set(old.subarray(c.off, c.off + at));
+    u16.set(old.subarray(c.off + at, c.off + c.len), at + 1);
   }
   u16[at] = low;
-  return arrayContainer(u16, plain.card + 1);
+  return arrayContainer(u16, c.card + 1);
+}
+function addFewToRuns(c, ids, from, to) {
+  const x = lows16(c);
+  let data = x;
+  let base = c.off;
+  let out = null;
+  let n = c.len;
+  let added = 0;
+  for (let k = from; k < to; k++) {
+    const low = ids[k] & 65535;
+    const next = runsAfter(data, base, 0, n, low);
+    const prev = next - 1;
+    const prevEnd = prev >= 0 ? data[base + 2 * prev] + data[base + 2 * prev + 1] : -2;
+    if (prevEnd >= low) continue;
+    if (out === null) {
+      out = new Uint16Array(2 * (c.len + to - from));
+      out.set(x.subarray(c.off, c.off + 2 * c.len));
+      data = out;
+      base = 0;
+    }
+    const joinPrev = prevEnd + 1 === low;
+    const joinNext = next < n && out[2 * next] === low + 1;
+    if (joinPrev && joinNext) {
+      out[2 * prev + 1] = out[2 * next] + out[2 * next + 1] - out[2 * prev];
+      out.copyWithin(2 * next, 2 * next + 2, 2 * n);
+      n--;
+    } else if (joinPrev) {
+      out[2 * prev + 1] = out[2 * prev + 1] + 1;
+    } else if (joinNext) {
+      out[2 * next] = low;
+      out[2 * next + 1] = out[2 * next + 1] + 1;
+    } else {
+      out.copyWithin(2 * next + 2, 2 * next, 2 * n);
+      out[2 * next] = low;
+      out[2 * next + 1] = 0;
+      n++;
+    }
+    added++;
+  }
+  if (out === null) return c;
+  return runsOrPlain(out, n, c.card + added, true);
+}
+function containerAddSorted(c, ids, from, to) {
+  if (c.kind === RUN2) return addFewToRuns(c, ids, from, to);
+  let cur = c;
+  for (let k = from; k < to; k++) cur = containerAdd(cur, ids[k] & 65535);
+  return cur;
 }
 function containerRemove(c, low) {
   if (!containerHas(c, low)) return c;
@@ -681,6 +872,15 @@ function containerRemove(c, low) {
   u16.set(old.subarray(plain.off + at + 1, plain.off + plain.len), at);
   return arrayContainer(u16, plain.card - 1);
 }
+function containerMin(c) {
+  if (c.kind === ARRAY2 || c.kind === RUN2) return c.data[c.off];
+  const words = words32(c);
+  for (let i = 0; i < WORDS; i++) {
+    const w = words[i];
+    if (w !== 0) return i * 32 + 31 - Math.clz32(w & -w);
+  }
+  throw new RangeError("a bitset container holds no bits");
+}
 function containerMax(c) {
   if (c.kind === ARRAY2) return c.data[c.off + c.len - 1];
   if (c.kind === RUN2) {
@@ -775,6 +975,7 @@ function skewed(shorter, longer) {
   return longer >= GALLOP_SKEW * shorter;
 }
 var PROBE_MIN = 32;
+var MERGE_FIRST = 64;
 var probeWords = new Uint32Array(WORDS);
 function andArrays(a, b) {
   const small = a.len <= b.len ? a : b;
@@ -949,6 +1150,70 @@ function orArrays(a, b) {
   while (j < je) out[n++] = y[j++];
   return arrayOfScratch(out, n);
 }
+function andWords(out, x, y) {
+  for (let i = 0; i < WORDS; i += 4) {
+    const X0 = x[i];
+    const Y0 = y[i];
+    const X1 = x[i + 1];
+    const Y1 = y[i + 1];
+    const X2 = x[i + 2];
+    const Y2 = y[i + 2];
+    const X3 = x[i + 3];
+    const Y3 = y[i + 3];
+    out[i] = X0 & Y0;
+    out[i + 1] = X1 & Y1;
+    out[i + 2] = X2 & Y2;
+    out[i + 3] = X3 & Y3;
+  }
+}
+function orWords(out, x, y) {
+  for (let i = 0; i < WORDS; i += 4) {
+    const X0 = x[i];
+    const Y0 = y[i];
+    const X1 = x[i + 1];
+    const Y1 = y[i + 1];
+    const X2 = x[i + 2];
+    const Y2 = y[i + 2];
+    const X3 = x[i + 3];
+    const Y3 = y[i + 3];
+    out[i] = X0 | Y0;
+    out[i + 1] = X1 | Y1;
+    out[i + 2] = X2 | Y2;
+    out[i + 3] = X3 | Y3;
+  }
+}
+function xorWords(out, x, y) {
+  for (let i = 0; i < WORDS; i += 4) {
+    const X0 = x[i];
+    const Y0 = y[i];
+    const X1 = x[i + 1];
+    const Y1 = y[i + 1];
+    const X2 = x[i + 2];
+    const Y2 = y[i + 2];
+    const X3 = x[i + 3];
+    const Y3 = y[i + 3];
+    out[i] = X0 ^ Y0;
+    out[i + 1] = X1 ^ Y1;
+    out[i + 2] = X2 ^ Y2;
+    out[i + 3] = X3 ^ Y3;
+  }
+}
+function andNotWords(out, x, y) {
+  for (let i = 0; i < WORDS; i += 4) {
+    const X0 = x[i];
+    const Y0 = y[i];
+    const X1 = x[i + 1];
+    const Y1 = y[i + 1];
+    const X2 = x[i + 2];
+    const Y2 = y[i + 2];
+    const X3 = x[i + 3];
+    const Y3 = y[i + 3];
+    out[i] = X0 & ~Y0;
+    out[i + 1] = X1 & ~Y1;
+    out[i + 2] = X2 & ~Y2;
+    out[i + 3] = X3 & ~Y3;
+  }
+}
 function orIntoBitset(dest, other, inPlace) {
   const words = inPlace ? words32(dest) : words32(dest).slice();
   if (other.kind === ARRAY2) {
@@ -966,8 +1231,7 @@ function orIntoBitset(dest, other, inPlace) {
     return bitsetContainer(words, card);
   }
   if (other.kind === BITSET) {
-    const o = words32(other);
-    for (let i = 0; i < WORDS; i++) words[i] = words[i] | o[i];
+    orWords(words, words, words32(other));
   } else {
     const pairs = lows16(other);
     for (let r = 0; r < other.len; r++) {
@@ -977,6 +1241,81 @@ function orIntoBitset(dest, other, inPlace) {
   }
   return bitsetContainer(words, popcountWords(words));
 }
+function orBitsetWords(list) {
+  const bits = [];
+  for (const c of list) if (c.kind === BITSET) bits.push(words32(c));
+  const n = bits.length;
+  if (n === 0) return new Uint32Array(WORDS);
+  let k;
+  let words;
+  if (n >= 4) {
+    const a = bits[0];
+    const b = bits[1];
+    const c = bits[2];
+    const d = bits[3];
+    words = new Uint32Array(WORDS);
+    for (let i = 0; i < WORDS; i++)
+      words[i] = a[i] | b[i] | c[i] | d[i];
+    k = 4;
+  } else {
+    words = bits[0].slice();
+    k = 1;
+  }
+  for (; k + 4 <= n; k += 4) {
+    const a = bits[k];
+    const b = bits[k + 1];
+    const c = bits[k + 2];
+    const d = bits[k + 3];
+    for (let i = 0; i < WORDS; i++) {
+      words[i] = words[i] | a[i] | b[i] | c[i] | d[i];
+    }
+  }
+  for (; k < n; k++) {
+    const o = bits[k];
+    for (let i = 0; i < WORDS; i++) words[i] = words[i] | o[i];
+  }
+  return words;
+}
+function orManyContainers(list) {
+  let total = 0;
+  let allArrays = true;
+  for (const c of list) {
+    total += c.card;
+    if (c.kind !== ARRAY2) allArrays = false;
+  }
+  if (allArrays && total <= ARRAY_MAX_CARDINALITY) {
+    const out = values16(total);
+    let n = 0;
+    for (const c of list) {
+      out.set(lows16(c).subarray(c.off, c.off + c.len), n);
+      n += c.len;
+    }
+    const sorted = out.subarray(0, n).sort();
+    let distinct = 0;
+    for (let i = 0; i < n; i++) {
+      const v = sorted[i];
+      if (i === 0 || v !== sorted[distinct - 1]) sorted[distinct++] = v;
+    }
+    return arrayContainer(sorted.slice(0, distinct), distinct);
+  }
+  const words = orBitsetWords(list);
+  for (const c of list) {
+    if (c.kind === ARRAY2) {
+      const u16 = lows16(c);
+      for (let i = c.off; i < c.off + c.len; i++) {
+        const v = u16[i];
+        words[v >>> 5] = words[v >>> 5] | 1 << (v & 31);
+      }
+    } else if (c.kind === RUN2) {
+      const pairs = lows16(c);
+      for (let r = 0; r < c.len; r++) {
+        const start = pairs[c.off + 2 * r];
+        setRange(words, start, start + pairs[c.off + 2 * r + 1]);
+      }
+    }
+  }
+  return fromWordsCard(words, popcountWords(words));
+}
 function fromRunPairs(pairs, runs, card) {
   if (card === 0) return null;
   if (card <= ARRAY_MAX_CARDINALITY) {
@@ -1020,7 +1359,7 @@ function andRuns(a, b) {
     if (ae < be) i++;
     else j++;
   }
-  return fromRunPairs(out, runs, card);
+  return card === 0 ? null : runsOrPlain(out, runs, card, true);
 }
 function orRuns(a, b) {
   const x = lows16(a);
@@ -1060,7 +1399,7 @@ function orRuns(a, b) {
     }
   }
   flush();
-  return fromRunPairs(out, runs, card);
+  return runsOrPlain(out, runs, card, true);
 }
 function andNotRuns(a, b) {
   const x = lows16(a);
@@ -1094,7 +1433,7 @@ function andNotRuns(a, b) {
       k++;
     }
   }
-  return fromRunPairs(out, runs, card);
+  return card === 0 ? null : runsOrPlain(out, runs, card, true);
 }
 function bitsetInRuns(a, b) {
   const words = words32(a);
@@ -1146,7 +1485,7 @@ function containerAnd(a, b, inPlace = false) {
     const x = words32(a);
     const y = words32(b);
     const out = inPlace ? x : new Uint32Array(WORDS);
-    for (let i = 0; i < WORDS; i++) out[i] = x[i] & y[i];
+    andWords(out, x, y);
     return fromWordsCard(out, popcountWords(out));
   }
   if (a.kind > b.kind) return containerAnd(b, a);
@@ -1161,16 +1500,162 @@ function containerOr(a, b, inPlace = false) {
   if (b.kind === BITSET) return orIntoBitset(b, a, false);
   if (a.kind === ARRAY2 && b.kind === ARRAY2) return orArrays(a, b);
   if (a.kind === RUN2 && b.kind === RUN2) return orRuns(a, b);
-  const words = toWords(a.kind === RUN2 ? a : b);
-  return orIntoBitsetWords(words, a.kind === RUN2 ? b : a);
+  return a.kind === RUN2 ? orRunArray(a, b, inPlace) : orRunArray(b, a, false);
 }
-function orIntoBitsetWords(words, array) {
-  const u16 = lows16(array);
+var EXPAND_MIN_STEPS = 1024;
+function expandsRunArray(runs, array) {
+  return expandsRunSteps(runs, array.len);
+}
+function expandsRunSteps(runs, values) {
+  const steps = runs.len + values;
+  if (steps < EXPAND_MIN_STEPS) return false;
+  const cardMax = runs.card + values;
+  const plainMax = cardMax <= ARRAY_MAX_CARDINALITY ? 2 * cardMax : BITSET_BYTES;
+  return 2 + 4 * steps >= plainMax;
+}
+function walksRunIds(runs, count) {
+  return runs.kind === RUN2 && !expandsRunSteps(runs, count);
+}
+function orRunArrayExpand(runs, array, keep) {
+  const words = toWords(runs);
+  const v = lows16(array);
+  let added = 0;
   for (let i = array.off; i < array.off + array.len; i++) {
-    const v = u16[i];
-    words[v >>> 5] = words[v >>> 5] | 1 << (v & 31);
+    const value = v[i];
+    const word = words[value >>> 5];
+    const bit = 1 << (value & 31);
+    if ((word & bit) === 0) {
+      words[value >>> 5] = word | bit;
+      added++;
+    }
   }
-  return fromWordsCard(words, popcountWords(words));
+  if (added === 0 && keep) return runs;
+  return optimize(fromWordsCard(words, runs.card + added));
+}
+function orRunArray(runs, array, keep) {
+  return expandsRunArray(runs, array) ? orRunArrayExpand(runs, array, keep) : orRunArrayWalk(runs, array, keep);
+}
+function orRunArrayWalk(runs, array, keep) {
+  const x = lows16(runs);
+  const v = lows16(array);
+  const out = pairs16(2 * (runs.len + array.len));
+  const runEnd = runs.off + 2 * runs.len;
+  const valueEnd = array.off + array.len;
+  let r = runs.off;
+  let vi = array.off;
+  let at = 0;
+  let from = 0;
+  let to = -2;
+  let added = 0;
+  while (vi < valueEnd) {
+    const value = v[vi++];
+    while (r < runEnd && x[r] <= value) {
+      const start = x[r];
+      const end = start + x[r + 1];
+      r += 2;
+      if (start <= to + 1) {
+        if (end > to) to = end;
+      } else {
+        if (to >= 0) {
+          out[at++] = from;
+          out[at++] = to - from;
+        }
+        from = start;
+        to = end;
+      }
+    }
+    if (value <= to) continue;
+    added++;
+    if (value === to + 1) {
+      to = value;
+    } else {
+      if (to >= 0) {
+        out[at++] = from;
+        out[at++] = to - from;
+      }
+      from = value;
+      to = value;
+    }
+  }
+  while (r < runEnd) {
+    const start = x[r];
+    const end = start + x[r + 1];
+    r += 2;
+    if (start <= to + 1) {
+      if (end > to) to = end;
+    } else {
+      if (to >= 0) {
+        out[at++] = from;
+        out[at++] = to - from;
+      }
+      from = start;
+      to = end;
+    }
+  }
+  out[at++] = from;
+  out[at++] = to - from;
+  if (added === 0 && keep) return runs;
+  return runsOrPlain(out, at >>> 1, runs.card + added, true);
+}
+function orRunIdsWalk(runs, ids, from, to) {
+  const x = lows16(runs);
+  const out = pairs16(2 * (runs.len + to - from));
+  const runEnd = runs.off + 2 * runs.len;
+  let r = runs.off;
+  let vi = from;
+  let at = 0;
+  let start = 0;
+  let last = -2;
+  let added = 0;
+  while (vi < to) {
+    const value = ids[vi++] & 65535;
+    while (r < runEnd && x[r] <= value) {
+      const s = x[r];
+      const end = s + x[r + 1];
+      r += 2;
+      if (s <= last + 1) {
+        if (end > last) last = end;
+      } else {
+        if (last >= 0) {
+          out[at++] = start;
+          out[at++] = last - start;
+        }
+        start = s;
+        last = end;
+      }
+    }
+    if (value <= last) continue;
+    added++;
+    if (value === last + 1) {
+      last = value;
+    } else {
+      if (last >= 0) {
+        out[at++] = start;
+        out[at++] = last - start;
+      }
+      start = value;
+      last = value;
+    }
+  }
+  while (r < runEnd) {
+    const s = x[r];
+    const end = s + x[r + 1];
+    r += 2;
+    if (s <= last + 1) {
+      if (end > last) last = end;
+    } else {
+      if (last >= 0) {
+        out[at++] = start;
+        out[at++] = last - start;
+      }
+      start = s;
+      last = end;
+    }
+  }
+  out[at++] = start;
+  out[at++] = last - start;
+  if (added === 0) return runs;
+  return runsOrPlain(out, at >>> 1, runs.card + added, true);
 }
 function containerAndNot(a, b, inPlace = false) {
   if (a.kind === ARRAY2) {
@@ -1186,8 +1671,7 @@ function containerAndNot(a, b, inPlace = false) {
       words[v >>> 5] = words[v >>> 5] & ~(1 << (v & 31));
     }
   } else if (b.kind === BITSET) {
-    const y = words32(b);
-    for (let i = 0; i < WORDS; i++) words[i] = words[i] & ~y[i];
+    andNotWords(words, words, words32(b));
   } else {
     const pairs = lows16(b);
     for (let r = 0; r < b.len; r++) {
@@ -1197,38 +1681,583 @@ function containerAndNot(a, b, inPlace = false) {
   }
   return fromWordsCard(words, popcountWords(words));
 }
-
-// src/ts-roaring/iterator.ts
-var DONE = { done: true, value: void 0 };
-var BitmapIterator = class {
-  #keys;
-  #conts;
-  /** The container being walked, as an index into `#conts`, and its kind, storage and offset. */
-  #at = -1;
-  #kind = ARRAY2;
-  #u16 = new Uint16Array(0);
-  #words = new Uint32Array(0);
-  #off = 0;
-  /** Added to every remainder: the container's key times 65,536. */
-  #base = 0;
-  /** An array: the next index and one past the last. A run container: the next run's index and the run count. A bitset: the word index. */
-  #pos = 0;
-  #end = 0;
-  /** A run container: the next value and the last of the current run. A bitset: what is left of the current word. */
-  #next = 0;
-  #last = -1;
-  constructor(keys, conts) {
-    this.#keys = keys;
-    this.#conts = conts;
-  }
-  [Symbol.iterator]() {
-    return this;
-  }
-  next() {
-    for (; ; ) {
-      if (this.#kind === ARRAY2) {
-        if (this.#pos < this.#end) {
-          return { done: false, value: this.#base + this.#u16[this.#pos++] };
+function xorArrays(a, b) {
+  const x = lows16(a);
+  const y = lows16(b);
+  const ie = a.off + a.len;
+  const je = b.off + b.len;
+  const out = values16(a.len + b.len);
+  let n = 0;
+  let i = a.off;
+  let j = b.off;
+  while (i < ie && j < je) {
+    const p = x[i];
+    const q = y[j];
+    out[n] = p < q ? p : q;
+    n += p === q ? 0 : 1;
+    i += p <= q ? 1 : 0;
+    j += p >= q ? 1 : 0;
+  }
+  while (i < ie) out[n++] = x[i++];
+  while (j < je) out[n++] = y[j++];
+  if (n <= ARRAY_MAX_CARDINALITY) return arrayOfScratch(out, n);
+  const words = new Uint32Array(WORDS);
+  for (let k = 0; k < n; k++) {
+    const v = out[k];
+    words[v >>> 5] = words[v >>> 5] | 1 << (v & 31);
+  }
+  return bitsetContainer(words, n);
+}
+function xorRuns(a, b) {
+  const x = lows16(a);
+  const y = lows16(b);
+  const na = 2 * a.len;
+  const nb = 2 * b.len;
+  const out = pairs16(2 * (a.len + b.len));
+  const NONE = 2147483647;
+  let i = 0;
+  let j = 0;
+  let pa = na > 0 ? boundary(x, a.off, 0) : NONE;
+  let pb = nb > 0 ? boundary(y, b.off, 0) : NONE;
+  let open = -1;
+  let runs = 0;
+  let card = 0;
+  while (i < na || j < nb) {
+    let p;
+    if (pa === pb) {
+      i++;
+      j++;
+      pa = i < na ? boundary(x, a.off, i) : NONE;
+      pb = j < nb ? boundary(y, b.off, j) : NONE;
+      continue;
+    }
+    if (pa < pb) {
+      p = pa;
+      i++;
+      pa = i < na ? boundary(x, a.off, i) : NONE;
+    } else {
+      p = pb;
+      j++;
+      pb = j < nb ? boundary(y, b.off, j) : NONE;
+    }
+    if (open < 0) {
+      open = p;
+    } else {
+      out[2 * runs] = open;
+      out[2 * runs + 1] = p - 1 - open;
+      runs++;
+      card += p - open;
+      open = -1;
+    }
+  }
+  return card === 0 ? null : runsOrPlain(out, runs, card, true);
+}
+function boundary(u16, off, k) {
+  const at = off + (k & ~1);
+  return u16[at] + ((k & 1) === 0 ? 0 : u16[at + 1] + 1);
+}
+function containerXor(a, b, inPlace = false) {
+  if (a.kind === BITSET || b.kind === BITSET) {
+    const base = a.kind === BITSET ? a : b;
+    const other = base === a ? b : a;
+    if (other.kind === BITSET) {
+      const x = words32(a);
+      const y = words32(b);
+      const out = inPlace ? x : new Uint32Array(WORDS);
+      xorWords(out, x, y);
+      return fromWordsCard(out, popcountWords(out));
+    }
+    const words2 = inPlace && base === a ? words32(base) : words32(base).slice();
+    if (other.kind === ARRAY2) {
+      return fromWordsCard(words2, flipValues(words2, other, base.card));
+    }
+    const pairs = lows16(other);
+    for (let r = 0; r < other.len; r++) {
+      const start = pairs[other.off + 2 * r];
+      flipRange(words2, start, start + pairs[other.off + 2 * r + 1]);
+    }
+    return fromWordsCard(words2, popcountWords(words2));
+  }
+  if (a.kind === ARRAY2 && b.kind === ARRAY2) return xorArrays(a, b);
+  if (a.kind === RUN2 && b.kind === RUN2) return xorRuns(a, b);
+  const runs = a.kind === RUN2 ? a : b;
+  const array = runs === a ? b : a;
+  const words = toWords(runs);
+  return fromWordsCard(words, flipValues(words, array, runs.card));
+}
+function flipValues(words, array, card) {
+  const u16 = lows16(array);
+  let n = card;
+  for (let i = array.off; i < array.off + array.len; i++) {
+    const v = u16[i];
+    const w = words[v >>> 5];
+    words[v >>> 5] = w ^ 1 << (v & 31);
+    n += 1 - 2 * (w >>> (v & 31) & 1);
+  }
+  return n;
+}
+function bitsInRange(words, start, end) {
+  const first = start >>> 5;
+  const last = end >>> 5;
+  const head = 4294967295 << (start & 31) >>> 0;
+  const tail = 4294967295 >>> 31 - (end & 31);
+  if (first === last) return popcount32(words[first] & head & tail);
+  let n = popcount32(words[first] & head) + popcount32(words[last] & tail);
+  for (let i = first + 1; i < last; i++) n += popcount32(words[i]);
+  return n;
+}
+function andCountArrays(a, b) {
+  const small = a.len <= b.len ? a : b;
+  const big = small === a ? b : a;
+  const s = lows16(small);
+  const l = lows16(big);
+  const se = small.off + small.len;
+  const le = big.off + big.len;
+  let n = 0;
+  if (skewed(small.len, big.len)) {
+    let at = big.off;
+    for (let i2 = small.off; i2 < se; i2++) {
+      const v = s[i2];
+      at = gallop(l, 0, at, le, v);
+      if (at === le) break;
+      if (l[at] === v) n++;
+    }
+    return n;
+  }
+  if (small.len >= PROBE_MIN) {
+    const first = s[small.off];
+    const last = s[se - 1];
+    if (last < l[big.off] || first > l[le - 1]) return 0;
+    const from = gallop(l, 0, big.off, le, first);
+    const to = gallop(l, 0, from, le, last + 1);
+    const words = probeWords;
+    for (let i2 = small.off; i2 < se; i2++) {
+      const v = s[i2];
+      words[v >>> 5] = words[v >>> 5] | 1 << (v & 31);
+    }
+    for (let j2 = from; j2 < to; j2++) {
+      const v = l[j2];
+      n += words[v >>> 5] >>> (v & 31) & 1;
+    }
+    for (let i2 = small.off; i2 < se; i2++) words[s[i2] >>> 5] = 0;
+    return n;
+  }
+  let i = small.off;
+  let j = big.off;
+  while (i < se && j < le) {
+    const x = s[i];
+    const y = l[j];
+    n += x === y ? 1 : 0;
+    i += x <= y ? 1 : 0;
+    j += x >= y ? 1 : 0;
+  }
+  return n;
+}
+function andCountArrayBitset(a, b) {
+  const u16 = lows16(a);
+  const words = words32(b);
+  let n = 0;
+  for (let i = a.off; i < a.off + a.len; i++) {
+    const v = u16[i];
+    n += words[v >>> 5] >>> (v & 31) & 1;
+  }
+  return n;
+}
+function andCountArrayRuns(a, b) {
+  const u16 = lows16(a);
+  const pairs = lows16(b);
+  const ae = a.off + a.len;
+  let n = 0;
+  if (skewed(a.len, b.len)) {
+    for (let i2 = a.off; i2 < ae; i2++) {
+      const v = u16[i2];
+      const after = lowerBound(pairs, b.off, b.len, v + 1, 2);
+      if (after === 0) continue;
+      const r = b.off + 2 * (after - 1);
+      if (v <= pairs[r] + pairs[r + 1]) n++;
+    }
+    return n;
+  }
+  let i = a.off;
+  for (let r = 0; r < b.len && i < ae; r++) {
+    const start = pairs[b.off + 2 * r];
+    const end = start + pairs[b.off + 2 * r + 1];
+    while (i < ae && u16[i] < start) i++;
+    while (i < ae && u16[i] <= end) {
+      n++;
+      i++;
+    }
+  }
+  return n;
+}
+function andCountBitsetRuns(a, b) {
+  const words = words32(a);
+  const pairs = lows16(b);
+  let n = 0;
+  for (let r = 0; r < b.len; r++) {
+    const start = pairs[b.off + 2 * r];
+    n += bitsInRange(words, start, start + pairs[b.off + 2 * r + 1]);
+  }
+  return n;
+}
+function andCountRuns(a, b) {
+  const x = lows16(a);
+  const y = lows16(b);
+  let n = 0;
+  let i = 0;
+  let j = 0;
+  while (i < a.len && j < b.len) {
+    const as = x[a.off + 2 * i];
+    const ae = as + x[a.off + 2 * i + 1];
+    const bs = y[b.off + 2 * j];
+    const be = bs + y[b.off + 2 * j + 1];
+    const lo = as > bs ? as : bs;
+    const hi = ae < be ? ae : be;
+    if (lo <= hi) n += hi - lo + 1;
+    if (ae < be) i++;
+    else j++;
+  }
+  return n;
+}
+function containerAndCard(a, b) {
+  if (a.kind === BITSET && b.kind === BITSET) {
+    return popcountAnd(words32(a), words32(b));
+  }
+  if (a.kind > b.kind) return containerAndCard(b, a);
+  if (a.kind === ARRAY2) {
+    if (b.kind === ARRAY2) return andCountArrays(a, b);
+    return b.kind === BITSET ? andCountArrayBitset(a, b) : andCountArrayRuns(a, b);
+  }
+  return b.kind === RUN2 && a.kind === RUN2 ? andCountRuns(a, b) : andCountBitsetRuns(a, b);
+}
+function anyBitInRange(words, start, end) {
+  const first = start >>> 5;
+  const last = end >>> 5;
+  const head = 4294967295 << (start & 31) >>> 0;
+  const tail = 4294967295 >>> 31 - (end & 31);
+  if (first === last) return (words[first] & head & tail) !== 0;
+  if ((words[first] & head) !== 0 || (words[last] & tail) !== 0)
+    return true;
+  for (let i = first + 1; i < last; i++) if (words[i] !== 0) return true;
+  return false;
+}
+function allBitsInRange(words, start, end) {
+  const first = start >>> 5;
+  const last = end >>> 5;
+  const head = 4294967295 << (start & 31) >>> 0;
+  const tail = 4294967295 >>> 31 - (end & 31);
+  if (first === last) return (~words[first] & head & tail) === 0;
+  if ((~words[first] & head) !== 0 || (~words[last] & tail) !== 0)
+    return false;
+  for (let i = first + 1; i < last; i++) if (words[i] !== 4294967295) return false;
+  return true;
+}
+function subsetArrays(a, b) {
+  const x = lows16(a);
+  const y = lows16(b);
+  const ie = a.off + a.len;
+  const je = b.off + b.len;
+  let j = b.off;
+  if (skewed(a.len, b.len)) {
+    for (let i2 = a.off; i2 < ie; i2++) {
+      const v = x[i2];
+      j = gallop(y, 0, j, je, v);
+      if (j === je || y[j] !== v) return false;
+    }
+    return true;
+  }
+  let i = a.off;
+  while (i < ie && j < je) {
+    const p = x[i];
+    const q = y[j];
+    if (p < q) return false;
+    i += p === q ? 1 : 0;
+    j++;
+  }
+  return i === ie;
+}
+function subsetArrayRuns(a, b) {
+  const u16 = lows16(a);
+  const pairs = lows16(b);
+  let r = 0;
+  for (let i = a.off; i < a.off + a.len; i++) {
+    const v = u16[i];
+    while (r < b.len && pairs[b.off + 2 * r] + pairs[b.off + 2 * r + 1] < v)
+      r++;
+    if (r === b.len || pairs[b.off + 2 * r] > v) return false;
+  }
+  return true;
+}
+function subsetRunsArray(a, b) {
+  const pairs = lows16(a);
+  const y = lows16(b);
+  const je = b.off + b.len;
+  let j = b.off;
+  for (let r = 0; r < a.len; r++) {
+    const start = pairs[a.off + 2 * r];
+    const last = start + pairs[a.off + 2 * r + 1];
+    j = gallop(y, 0, j, je, start);
+    const end = j + (last - start);
+    if (end >= je || y[j] !== start || y[end] !== last) return false;
+    j = end + 1;
+  }
+  return true;
+}
+function subsetRuns(a, b) {
+  const x = lows16(a);
+  const y = lows16(b);
+  let j = 0;
+  for (let i = 0; i < a.len; i++) {
+    const start = x[a.off + 2 * i];
+    const last = start + x[a.off + 2 * i + 1];
+    while (j < b.len && y[b.off + 2 * j] + y[b.off + 2 * j + 1] < start)
+      j++;
+    if (j === b.len || y[b.off + 2 * j] > start) return false;
+    if (y[b.off + 2 * j] + y[b.off + 2 * j + 1] < last) return false;
+  }
+  return true;
+}
+function subsetBitsetRuns(a, b) {
+  const words = words32(a);
+  const pairs = lows16(b);
+  let from = 0;
+  for (let r = 0; r < b.len; r++) {
+    const start = pairs[b.off + 2 * r];
+    if (start > from && anyBitInRange(words, from, start - 1)) return false;
+    from = start + pairs[b.off + 2 * r + 1] + 1;
+  }
+  return from > 65535 || !anyBitInRange(words, from, 65535);
+}
+function containersSubset(a, b) {
+  if (a.card > b.card) return false;
+  if (a.kind === ARRAY2) {
+    if (b.kind === ARRAY2) return subsetArrays(a, b);
+    if (b.kind === RUN2) return subsetArrayRuns(a, b);
+    const u16 = lows16(a);
+    const words2 = words32(b);
+    for (let i = a.off; i < a.off + a.len; i++) {
+      const v = u16[i];
+      if ((words2[v >>> 5] >>> (v & 31) & 1) === 0) return false;
+    }
+    return true;
+  }
+  if (a.kind === BITSET) {
+    if (b.kind === BITSET) {
+      const x = words32(a);
+      const y = words32(b);
+      for (let i = 0; i < WORDS; i += 8) {
+        const lack = x[i] & ~y[i] | x[i + 1] & ~y[i + 1] | x[i + 2] & ~y[i + 2] | x[i + 3] & ~y[i + 3] | x[i + 4] & ~y[i + 4] | x[i + 5] & ~y[i + 5] | x[i + 6] & ~y[i + 6] | x[i + 7] & ~y[i + 7];
+        if (lack !== 0) return false;
+      }
+      return true;
+    }
+    if (b.kind === RUN2) return subsetBitsetRuns(a, b);
+    return containerAndCard(a, b) === a.card;
+  }
+  if (b.kind === ARRAY2) return subsetRunsArray(a, b);
+  if (b.kind === RUN2) return subsetRuns(a, b);
+  const words = words32(b);
+  const pairs = lows16(a);
+  for (let r = 0; r < a.len; r++) {
+    const start = pairs[a.off + 2 * r];
+    if (!allBitsInRange(words, start, start + pairs[a.off + 2 * r + 1])) return false;
+  }
+  return true;
+}
+function containersEqual(a, b) {
+  if (a.card !== b.card) return false;
+  if (a.kind !== b.kind) return containerAndCard(a, b) === a.card;
+  if (a.kind === BITSET) return equalWords(words32(a), 0, words32(b), 0, WORDS);
+  if (a.len !== b.len) return false;
+  const x = lows16(a);
+  const y = lows16(b);
+  const n = a.kind === ARRAY2 ? a.len : 2 * a.len;
+  if (n < EQUAL_VIEW_MIN) {
+    if (a.off === 0 && b.off === 0) return equalU16(x, 0, y, 0, n);
+    return equalU16(x, a.off, y, b.off, n);
+  }
+  const xb = x.byteOffset + 2 * a.off;
+  const yb = y.byteOffset + 2 * b.off;
+  if (usesEqualView(n, xb, yb)) {
+    const m = n >>> 1;
+    if (!equalWords(new Uint32Array(x.buffer, xb, m), 0, new Uint32Array(y.buffer, yb, m), 0, m))
+      return false;
+    return (n & 1) === 0 || x[a.off + n - 1] === y[b.off + n - 1];
+  }
+  return equalU16(x, a.off, y, b.off, n);
+}
+var EQUAL_VIEW_MIN = 512;
+function usesEqualView(n, xb, yb) {
+  return n >= EQUAL_VIEW_MIN && (xb & 3) === 0 && (yb & 3) === 0;
+}
+function equalWords(x, xo, y, yo, n) {
+  let i = 0;
+  for (const end = n - 7; i < end; i += 8) {
+    const d = x[xo + i] ^ y[yo + i] | x[xo + i + 1] ^ y[yo + i + 1] | x[xo + i + 2] ^ y[yo + i + 2] | x[xo + i + 3] ^ y[yo + i + 3] | x[xo + i + 4] ^ y[yo + i + 4] | x[xo + i + 5] ^ y[yo + i + 5] | x[xo + i + 6] ^ y[yo + i + 6] | x[xo + i + 7] ^ y[yo + i + 7];
+    if (d !== 0) return false;
+  }
+  for (; i < n; i++) if (x[xo + i] !== y[yo + i]) return false;
+  return true;
+}
+function equalU16(x, xo, y, yo, n) {
+  let i = 0;
+  for (const end = n - 7; i < end; i += 8) {
+    const d = x[xo + i] ^ y[yo + i] | x[xo + i + 1] ^ y[yo + i + 1] | x[xo + i + 2] ^ y[yo + i + 2] | x[xo + i + 3] ^ y[yo + i + 3] | x[xo + i + 4] ^ y[yo + i + 4] | x[xo + i + 5] ^ y[yo + i + 5] | x[xo + i + 6] ^ y[yo + i + 6] | x[xo + i + 7] ^ y[yo + i + 7];
+    if (d !== 0) return false;
+  }
+  for (; i < n; i++) if (x[xo + i] !== y[yo + i]) return false;
+  return true;
+}
+function intersectsArrays(a, b) {
+  const small = a.len <= b.len ? a : b;
+  const big = small === a ? b : a;
+  const s = lows16(small);
+  const l = lows16(big);
+  const se = small.off + small.len;
+  const le = big.off + big.len;
+  if (s[se - 1] < l[big.off] || s[small.off] > l[le - 1]) {
+    return false;
+  }
+  if (skewed(small.len, big.len)) {
+    let at = big.off;
+    for (let i2 = small.off; i2 < se; i2++) {
+      const v = s[i2];
+      at = gallop(l, 0, at, le, v);
+      if (at === le) return false;
+      if (l[at] === v) return true;
+    }
+    return false;
+  }
+  let i = small.off;
+  let j = big.off;
+  if (small.len >= PROBE_MIN) {
+    for (let step = 0; step < MERGE_FIRST && i < se && j < le; step++) {
+      const x = s[i];
+      const y = l[j];
+      if (x === y) return true;
+      if (x < y) i++;
+      else j++;
+    }
+    if (i === se || j === le) return false;
+    const left = i;
+    const from = gallop(l, 0, j, le, s[left]);
+    const to = gallop(l, 0, from, le, s[se - 1] + 1);
+    const words = probeWords;
+    for (let k = left; k < se; k++) {
+      const v = s[k];
+      words[v >>> 5] = words[v >>> 5] | 1 << (v & 31);
+    }
+    let hit = false;
+    for (let k = from; k < to; k++) {
+      const v = l[k];
+      if ((words[v >>> 5] >>> (v & 31) & 1) === 1) {
+        hit = true;
+        break;
+      }
+    }
+    for (let k = left; k < se; k++) words[s[k] >>> 5] = 0;
+    return hit;
+  }
+  while (i < se && j < le) {
+    const x = s[i];
+    const y = l[j];
+    if (x === y) return true;
+    if (x < y) i++;
+    else j++;
+  }
+  return false;
+}
+function intersectsArrayRuns(a, b) {
+  const u16 = lows16(a);
+  const pairs = lows16(b);
+  let r = 0;
+  for (let i = a.off; i < a.off + a.len; i++) {
+    const v = u16[i];
+    while (r < b.len && pairs[b.off + 2 * r] + pairs[b.off + 2 * r + 1] < v) {
+      r++;
+    }
+    if (r === b.len) return false;
+    if (pairs[b.off + 2 * r] <= v) return true;
+  }
+  return false;
+}
+function containersIntersect(a, b) {
+  if (a.kind > b.kind) return containersIntersect(b, a);
+  if (a.kind === ARRAY2) {
+    if (b.kind === ARRAY2) return intersectsArrays(a, b);
+    if (b.kind === RUN2) return intersectsArrayRuns(a, b);
+    const u16 = lows16(a);
+    const words = words32(b);
+    for (let i2 = a.off; i2 < a.off + a.len; i2++) {
+      const v = u16[i2];
+      if ((words[v >>> 5] >>> (v & 31) & 1) === 1) return true;
+    }
+    return false;
+  }
+  if (a.kind === BITSET) {
+    const x2 = words32(a);
+    if (b.kind === BITSET) {
+      const y2 = words32(b);
+      for (let i2 = 0; i2 < WORDS; i2 += 8) {
+        const both = x2[i2] & y2[i2] | x2[i2 + 1] & y2[i2 + 1] | x2[i2 + 2] & y2[i2 + 2] | x2[i2 + 3] & y2[i2 + 3] | x2[i2 + 4] & y2[i2 + 4] | x2[i2 + 5] & y2[i2 + 5] | x2[i2 + 6] & y2[i2 + 6] | x2[i2 + 7] & y2[i2 + 7];
+        if (both !== 0) return true;
+      }
+      return false;
+    }
+    const pairs = lows16(b);
+    for (let r = 0; r < b.len; r++) {
+      const start = pairs[b.off + 2 * r];
+      if (anyBitInRange(x2, start, start + pairs[b.off + 2 * r + 1])) return true;
+    }
+    return false;
+  }
+  const x = lows16(a);
+  const y = lows16(b);
+  let i = 0;
+  let j = 0;
+  while (i < a.len && j < b.len) {
+    const as = x[a.off + 2 * i];
+    const ae = as + x[a.off + 2 * i + 1];
+    const bs = y[b.off + 2 * j];
+    const be = bs + y[b.off + 2 * j + 1];
+    if ((as > bs ? as : bs) <= (ae < be ? ae : be)) return true;
+    if (ae < be) i++;
+    else j++;
+  }
+  return false;
+}
+
+// src/ts-roaring/iterator.ts
+var DONE = { done: true, value: void 0 };
+var BitmapIterator = class {
+  #keys;
+  #conts;
+  /** The container being walked, as an index into `#conts`, and its kind, storage and offset. */
+  #at = -1;
+  #kind = ARRAY2;
+  #u16 = new Uint16Array(0);
+  #words = new Uint32Array(0);
+  #off = 0;
+  /** Added to every remainder: the container's key times 65,536. */
+  #base = 0;
+  /** An array: the next index and one past the last. A run container: the next run's index and the run count. A bitset: the word index. */
+  #pos = 0;
+  #end = 0;
+  /** A run container: the next value and the last of the current run. A bitset: what is left of the current word. */
+  #next = 0;
+  #last = -1;
+  constructor(keys, conts) {
+    this.#keys = keys;
+    this.#conts = conts;
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  next() {
+    for (; ; ) {
+      if (this.#kind === ARRAY2) {
+        if (this.#pos < this.#end) {
+          return { done: false, value: this.#base + this.#u16[this.#pos++] };
         }
       } else if (this.#kind === BITSET) {
         let w = this.#next;
@@ -1292,7 +2321,16 @@ function bodySize(c) {
   if (c.kind === BITSET) return BITSET_BYTES;
   return 2 + 4 * c.len;
 }
+var SMALL_BODY = 64;
 function putU16s(out, at, src, from, count) {
+  if (count < SMALL_BODY) {
+    for (let i = 0; i < count; i++) {
+      const v = src[from + i];
+      out[at++] = v & 255;
+      out[at++] = v >>> 8;
+    }
+    return;
+  }
   if (LITTLE_ENDIAN) {
     out.set(new Uint8Array(src.buffer, src.byteOffset + 2 * from, 2 * count), at);
     return;
@@ -1347,7 +2385,7 @@ function serializeContainers(keys, conts) {
   }
   return out;
 }
-function decodeContainers(input) {
+function decodeContainers(input, detached = false) {
   const bytes = Uint8Array.prototype.slice.call(input);
   const layout = parsePortableLayout(bytes);
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
@@ -1357,18 +2395,21 @@ function decodeContainers(input) {
   let end = bytes.byteLength === 0 ? 0 : 8;
   let slabLength = 0;
   let small = 0;
-  for (const { cardinality, kind, offset } of layout) {
-    if (kind === ARRAY) {
-      slabLength += cardinality;
-      small++;
-    } else if (kind !== BITMAP) {
-      slabLength += 2 * view.getUint16(offset, true);
-      small++;
+  if (!detached) {
+    for (const { cardinality, kind, offset } of layout) {
+      if (kind === ARRAY) {
+        slabLength += cardinality;
+        small++;
+      } else if (kind !== BITMAP) {
+        slabLength += 2 * view.getUint16(offset, true);
+        small++;
+      }
     }
   }
   const own = LITTLE_ENDIAN && bytes.byteOffset === 0 && bytes.buffer instanceof ArrayBuffer && bytes.buffer.byteLength === bytes.byteLength;
-  const alias = own && small === 1;
-  const slab = alias ? NO_U16 : new Uint16Array(slabLength);
+  const alias = !detached && own && small === 1;
+  const solo = alias || detached;
+  const slab = solo ? NO_U16 : new Uint16Array(slabLength);
   let used = 0;
   for (const { key, cardinality, kind, offset } of layout) {
     keys[n] = key;
@@ -1377,22 +2418,22 @@ function decodeContainers(input) {
         const values = new Uint16Array(bytes.buffer, offset, cardinality);
         conts[n++] = new Container(ARRAY2, values, 0, cardinality, cardinality, false);
       } else {
-        const into = alias ? new Uint16Array(cardinality) : slab;
-        getU16s(bytes, view, offset, into, alias ? 0 : used, cardinality);
+        const into = solo ? new Uint16Array(cardinality) : slab;
+        getU16s(bytes, view, offset, into, solo ? 0 : used, cardinality);
         conts[n++] = new Container(
           ARRAY2,
           into,
-          alias ? 0 : used,
+          solo ? 0 : used,
           cardinality,
           cardinality,
-          small > 1
+          !solo && small > 1
         );
         used += cardinality;
       }
       end = offset + 2 * cardinality;
     } else if (kind === BITMAP) {
       let words;
-      if (own && offset % 4 === 0) {
+      if (!detached && own && offset % 4 === 0) {
         words = new Uint32Array(bytes.buffer, offset, WORDS);
       } else {
         words = new Uint32Array(WORDS);
@@ -1410,9 +2451,16 @@ function decodeContainers(input) {
         const pairs = new Uint16Array(bytes.buffer, offset + 2, 2 * runs);
         conts[n++] = new Container(RUN2, pairs, 0, runs, cardinality, false);
       } else {
-        const into = alias ? new Uint16Array(2 * runs) : slab;
-        getU16s(bytes, view, offset + 2, into, alias ? 0 : used, 2 * runs);
-        conts[n++] = new Container(RUN2, into, alias ? 0 : used, runs, cardinality, small > 1);
+        const into = solo ? new Uint16Array(2 * runs) : slab;
+        getU16s(bytes, view, offset + 2, into, solo ? 0 : used, 2 * runs);
+        conts[n++] = new Container(
+          RUN2,
+          into,
+          solo ? 0 : used,
+          runs,
+          cardinality,
+          !solo && small > 1
+        );
         used += 2 * runs;
       }
       end = offset + 2 + 4 * runs;
@@ -1439,11 +2487,8 @@ var MAX_ID = 4294967295;
 function isId(value) {
   return Number.isInteger(value) && value >= 0 && value <= MAX_ID;
 }
-function badId(value) {
-  return new ValidationError2(`${String(value)} is not an integer from 0 to ${MAX_ID}`);
-}
 function checkedId(value) {
-  if (!isId(value)) throw badId(value);
+  if (!isId(value)) throw refusalOfId(value);
   return value;
 }
 function collect(values) {
@@ -1451,10 +2496,17 @@ function collect(values) {
   if (Array.isArray(values)) {
     const list = values;
     const out2 = new Uint32Array(list.length);
-    for (let i = 0; i < list.length; i++) {
+    let i = 0;
+    try {
+      for (; i < list.length; i++) {
+        const v = list[i];
+        if (v >>> 0 !== v) throw refusalOfId(v);
+        out2[i] = v;
+      }
+    } catch (error) {
       const v = list[i];
-      if (v >>> 0 !== v) throw badId(v);
-      out2[i] = v;
+      if (typeof v !== "number") throw refusalOfId(v);
+      throw error;
     }
     return out2;
   }
@@ -1471,6 +2523,7 @@ function collect(values) {
   return out.subarray(0, n);
 }
 function collectLenient(values) {
+  if (values instanceof Uint32Array) return values.slice();
   const list = Array.isArray(values) ? values : Array.from(values);
   const out = new Uint32Array(list.length);
   let n = 0;
@@ -1480,6 +2533,11 @@ function collectLenient(values) {
   }
   return out.subarray(0, n);
 }
+var FEW_IDS = 4;
+function groupPath(before, count) {
+  if (count <= FEW_IDS) return "few";
+  return walksRunIds(before, count) ? "walk" : "merge";
+}
 function sortedIds(ids, owned) {
   for (let i = 1; i < ids.length; i++) {
     if (ids[i - 1] > ids[i]) return (owned ? ids : ids.slice()).sort();
@@ -1520,9 +2578,11 @@ function lowerBoundIn(keys, key, from, to) {
 var OR = 0;
 var AND = 1;
 var AND_NOT = 2;
+var XOR = 3;
 function combineContainers(op, a, b) {
-  if (op === OR) return containerOr(a, b, !a.shared);
+  if (op === OR) return containerOr(a, b, !a.shared || a.kind === RUN2);
   if (op === AND) return containerAnd(a, b, !a.shared);
+  if (op === XOR) return containerXor(a, b, !a.shared);
   return containerAndNot(a, b, !a.shared);
 }
 var TsBitmap = class _TsBitmap {
@@ -1544,7 +2604,9 @@ var TsBitmap = class _TsBitmap {
   }
   /**
    * Cap the size, check the structure, then build the containers. With `whole`, bytes after the last container are
-   * refused too; without it they are ignored.
+   * refused too; without it they are ignored. With `detached`, every container gets storage of its own, copied out of
+   * the input, so nothing the result holds is a view of one shared buffer: a bitmap that is kept and then reduced
+   * does not keep the whole input alive.
    *
    * @throws {IntegrityError} if the input exceeds `maxBytes`, is not a well-formed portable bitmap, or (with `whole`)
    * has bytes after it.
@@ -1553,7 +2615,7 @@ var TsBitmap = class _TsBitmap {
     if (bytes.length > maxBytes) {
       throw new IntegrityError3(`serialized bitmap is ${bytes.length}B, exceeds cap ${maxBytes}B`);
     }
-    const { keys, conts, end } = decodeContainers(bytes);
+    const { keys, conts, end } = decodeContainers(bytes, options.detached === true);
     if (options.whole === true && end !== bytes.byteLength) {
       throw trailingBytes(bytes.byteLength, end);
     }
@@ -1569,6 +2631,12 @@ var TsBitmap = class _TsBitmap {
     const conts = this.#conts;
     for (let i = 0; i < conts.length; i++) conts[i] = optimize(conts[i]);
   }
+  /** Whether at least one container is held as runs. */
+  hasRunContainer() {
+    for (let i = 0; i < this.#conts.length; i++)
+      if (this.#conts[i].kind === RUN2) return true;
+    return false;
+  }
   /**
    * The set as storage chunks: each payload is the portable bytes of a one-container bitmap holding that chunk's low 16
    * bits, optimized the way {@link optimize} does. Nothing is built until a chunk is asked for, so a writer that yields
@@ -1593,6 +2661,11 @@ var TsBitmap = class _TsBitmap {
       }
     };
   }
+  /** The smallest id, or `undefined` when the bitmap is empty. */
+  minimum() {
+    if (this.#conts.length === 0) return void 0;
+    return this.#keys[0] * 65536 + containerMin(this.#conts[0]);
+  }
   maximum() {
     const last = this.#conts.length - 1;
     if (last < 0) return void 0;
@@ -1626,36 +2699,50 @@ var TsBitmap = class _TsBitmap {
       const key = ids[i] >>> 16;
       let end = i + 1;
       while (end < ids.length && ids[end] >>> 16 === key) end++;
-      const group = fromSortedIds(ids, i, end);
+      const first = i;
       i = end;
       at = gallopKeys(this.#keys, key, at);
       if (this.#keys[at] === key) {
         const before = this.#conts[at];
-        const after = containerOr(before, group, !before.shared);
+        const path = groupPath(before, end - first);
+        const after = path === "few" ? containerAddSorted(before, ids, first, end) : path === "walk" ? orRunIdsWalk(before, ids, first, end) : containerOr(
+          before,
+          fromSortedIds(ids, first, end),
+          !before.shared || before.kind === RUN2
+        );
         this.#conts[at] = after;
         this.#size += after.card - before.card;
       } else {
+        const group = fromSortedIds(ids, first, end);
         fresh.push({ key, group });
         this.#size += group.card;
       }
     }
     if (fresh.length > 0) this.#insertAll(fresh);
   }
+  /** Remove the id (anything that is not an id is ignored); whether it was there. */
   remove(value) {
-    if (!isId(value)) return;
+    if (!isId(value)) return false;
     const key = value >>> 16;
     const at = lowerBound2(this.#keys, key);
-    if (this.#keys[at] !== key) return;
+    if (this.#keys[at] !== key) return false;
     const before = this.#conts[at];
     const after = containerRemove(before, value & 65535);
     if (after === null) {
       this.#keys.splice(at, 1);
       this.#conts.splice(at, 1);
       this.#size -= before.card;
-      return;
+      return true;
     }
     this.#conts[at] = after;
     this.#size += after.card - before.card;
+    return after.card !== before.card;
+  }
+  /** Remove every id. Containers a clone shares are left to it. */
+  clear() {
+    this.#keys = [];
+    this.#conts = [];
+    this.#size = 0;
   }
   /** Remove the ids (anything that is not an id is ignored), grouped by key; the keys left empty go in one pass. */
   removeMany(values) {
@@ -1715,6 +2802,90 @@ var TsBitmap = class _TsBitmap {
   andNotInPlace(other) {
     this.#combine(_TsBitmap.#of(other), AND_NOT);
   }
+  /** Flip the ids `other` holds, in one pass over the pair of each key. */
+  xorInPlace(other) {
+    this.#combine(_TsBitmap.#of(other), XOR);
+  }
+  /** How many ids both bitmaps hold, counted without building the intersection. */
+  andCardinality(other) {
+    const that = _TsBitmap.#of(other);
+    const a = this.#keys;
+    const b = that.#keys;
+    let n = 0;
+    let i = 0;
+    let j = 0;
+    while (i < a.length && j < b.length) {
+      const ka = a[i];
+      const kb = b[j];
+      if (ka === kb) {
+        n += containerAndCard(this.#conts[i++], that.#conts[j++]);
+      } else if (ka < kb) {
+        i = gallopKeys(a, kb, i + 1);
+      } else {
+        j = gallopKeys(b, ka, j + 1);
+      }
+    }
+    return n;
+  }
+  /** How many ids either bitmap holds. */
+  orCardinality(other) {
+    return this.#size + _TsBitmap.#of(other).#size - this.andCardinality(other);
+  }
+  /** How many ids exactly one of the bitmaps holds. */
+  xorCardinality(other) {
+    return this.#size + _TsBitmap.#of(other).#size - 2 * this.andCardinality(other);
+  }
+  /** How many ids this bitmap holds that `other` lacks. */
+  andNotCardinality(other) {
+    return this.#size - this.andCardinality(other);
+  }
+  /** Whether the bitmaps share an id; stops at the first one found. */
+  intersects(other) {
+    const that = _TsBitmap.#of(other);
+    const a = this.#keys;
+    const b = that.#keys;
+    let i = 0;
+    let j = 0;
+    while (i < a.length && j < b.length) {
+      const ka = a[i];
+      const kb = b[j];
+      if (ka === kb) {
+        if (containersIntersect(this.#conts[i++], that.#conts[j++])) {
+          return true;
+        }
+      } else if (ka < kb) {
+        i = gallopKeys(a, kb, i + 1);
+      } else {
+        j = gallopKeys(b, ka, j + 1);
+      }
+    }
+    return false;
+  }
+  /** Whether every id of this bitmap is in `other`; stops at the first container that is not inside its partner. */
+  isSubset(other) {
+    const that = _TsBitmap.#of(other);
+    if (this.#size > that.#size) return false;
+    const a = this.#keys;
+    const b = that.#keys;
+    let j = 0;
+    for (let i = 0; i < a.length; i++) {
+      j = gallopKeys(b, a[i], j);
+      if (j === b.length || b[j] !== a[i]) return false;
+      const c = this.#conts[i];
+      if (!containersSubset(c, that.#conts[j++])) return false;
+    }
+    return true;
+  }
+  /** Whether both hold the same ids, whatever the kinds of their containers. */
+  isEqual(other) {
+    const that = _TsBitmap.#of(other);
+    if (this.#size !== that.#size || this.#keys.length !== that.#keys.length) return false;
+    for (let i = 0; i < this.#keys.length; i++) {
+      if (this.#keys[i] !== that.#keys[i]) return false;
+      if (!containersEqual(this.#conts[i], that.#conts[i])) return false;
+    }
+    return true;
+  }
   [Symbol.iterator]() {
     return new BitmapIterator(this.#keys, this.#conts);
   }
@@ -1804,7 +2975,114 @@ var TsBitmap = class _TsBitmap {
       const ka = a[i];
       const kb = b[j];
       if (ka === kb) {
-        const c = combineContainers(op, ca[i++], cb[j++]);
+        const c = combineContainers(op, ca[i++], cb[j++]);
+        if (c !== null) {
+          keys.push(ka);
+          conts.push(c);
+          size += c.card;
+        }
+      } else if (ka < kb) {
+        if (op === AND) {
+          i = gallopKeys(a, kb, i + 1);
+        } else {
+          keys.push(ka);
+          conts.push(ca[i]);
+          size += ca[i++].card;
+        }
+      } else if (op === AND) {
+        j = gallopKeys(b, ka, j + 1);
+      } else {
+        if (op === OR || op === XOR) {
+          keys.push(kb);
+          conts.push(cloneContainer(cb[j]));
+          size += cb[j].card;
+        }
+        j++;
+      }
+    }
+    if (op !== AND) {
+      for (; i < a.length; i++) {
+        keys.push(a[i]);
+        conts.push(ca[i]);
+        size += ca[i].card;
+      }
+    }
+    if (op === OR || op === XOR) {
+      for (; j < b.length; j++) {
+        keys.push(b[j]);
+        conts.push(cloneContainer(cb[j]));
+        size += cb[j].card;
+      }
+    }
+    this.#keys = keys;
+    this.#conts = conts;
+    this.#size = size;
+  }
+  /** The ids both bitmaps hold, as a new bitmap; neither operand changes and no container of either is kept. */
+  static and(a, b) {
+    return _TsBitmap.#fresh(_TsBitmap.#of(a), _TsBitmap.#of(b), AND);
+  }
+  /** The ids either holds, as a new bitmap; neither operand changes. */
+  static or(a, b) {
+    return _TsBitmap.#fresh(_TsBitmap.#of(a), _TsBitmap.#of(b), OR);
+  }
+  /**
+   * The ids any of `bitmaps` holds, as a new bitmap that owns all its storage; no operand changes and none is flagged.
+   * The containers of each key are gathered across the inputs and united in one pass (see {@link orManyContainers}),
+   * counted once. A key only one input holds is copied as it is, a run included.
+   */
+  static orMany(bitmaps) {
+    const byKey = /* @__PURE__ */ new Map();
+    for (const input of bitmaps) {
+      const that = _TsBitmap.#of(input);
+      for (let i = 0; i < that.#keys.length; i++) {
+        const key = that.#keys[i];
+        const held = byKey.get(key);
+        if (held === void 0) byKey.set(key, [that.#conts[i]]);
+        else held.push(that.#conts[i]);
+      }
+    }
+    const keys = Array.from(byKey.keys()).sort((x, y) => x - y);
+    const conts = [];
+    let size = 0;
+    for (const key of keys) {
+      const held = byKey.get(key);
+      const c = held.length === 1 ? cloneContainer(held[0]) : orManyContainers(held);
+      conts.push(c);
+      size += c.card;
+    }
+    return new _TsBitmap(keys, conts, size);
+  }
+  /** The ids exactly one holds, as a new bitmap; neither operand changes. */
+  static xor(a, b) {
+    return _TsBitmap.#fresh(_TsBitmap.#of(a), _TsBitmap.#of(b), XOR);
+  }
+  /** The ids of `a` that `b` lacks, as a new bitmap; neither operand changes. */
+  static andNot(a, b) {
+    return _TsBitmap.#fresh(_TsBitmap.#of(a), _TsBitmap.#of(b), AND_NOT);
+  }
+  /**
+   * The same walk as {@link TsBitmap.#combine}, building a new bitmap and leaving both operands whole. Where both hold
+   * a key, the pair combines into a fresh container (the in-place form is never taken, so no storage of either operand
+   * is written). A container only `x` holds is kept by reference and flagged shared, so a later write to `x` or to the
+   * result copies it once; for an intersection nothing of `x` is kept, so nothing is flagged. A container only `y`
+   * holds is copied in for a union or a symmetric difference.
+   */
+  static #fresh(x, y, op) {
+    const a = x.#keys;
+    const b = y.#keys;
+    const ca = x.#conts;
+    const cb = y.#conts;
+    const keys = [];
+    const conts = [];
+    let size = 0;
+    let i = 0;
+    let j = 0;
+    while (i < a.length && j < b.length) {
+      const ka = a[i];
+      const kb = b[j];
+      if (ka === kb) {
+        const c = freshPair(op, ca[i++], cb[j++]);
         if (c !== null) {
           keys.push(ka);
           conts.push(c);
@@ -1814,14 +3092,16 @@ var TsBitmap = class _TsBitmap {
         if (op === AND) {
           i = gallopKeys(a, kb, i + 1);
         } else {
+          const c = ca[i++];
+          c.shared = true;
           keys.push(ka);
-          conts.push(ca[i]);
-          size += ca[i++].card;
+          conts.push(c);
+          size += c.card;
         }
       } else if (op === AND) {
         j = gallopKeys(b, ka, j + 1);
       } else {
-        if (op === OR) {
+        if (op === OR || op === XOR) {
           keys.push(kb);
           conts.push(cloneContainer(cb[j]));
           size += cb[j].card;
@@ -1831,23 +3111,29 @@ var TsBitmap = class _TsBitmap {
     }
     if (op !== AND) {
       for (; i < a.length; i++) {
+        const c = ca[i];
+        c.shared = true;
         keys.push(a[i]);
-        conts.push(ca[i]);
-        size += ca[i].card;
+        conts.push(c);
+        size += c.card;
       }
     }
-    if (op === OR) {
+    if (op === OR || op === XOR) {
       for (; j < b.length; j++) {
         keys.push(b[j]);
         conts.push(cloneContainer(cb[j]));
         size += cb[j].card;
       }
     }
-    this.#keys = keys;
-    this.#conts = conts;
-    this.#size = size;
+    return new _TsBitmap(keys, conts, size);
   }
 };
+function freshPair(op, a, b) {
+  if (op === OR) return containerOr(a, b, false);
+  if (op === AND) return containerAnd(a, b, false);
+  if (op === AND_NOT) return containerAndNot(a, b, false);
+  return containerXor(a, b, false);
+}
 var EMPTIED = arrayContainer(new Uint16Array(0), 0);
 var tsRoaringCodec = {
   empty: () => TsBitmap.empty(),
@@ -1868,34 +3154,6 @@ var activeCodec = tsRoaringCodec;
 function flagshipCodec() {
   return activeCodec;
 }
-var ReadonlyRoaringView = class {
-  #bitmap;
-  constructor(bitmap) {
-    this.#bitmap = bitmap;
-  }
-  get size() {
-    return this.#bitmap.size;
-  }
-  has(id) {
-    return this.#bitmap.has(id);
-  }
-  [Symbol.iterator]() {
-    return this.#bitmap[Symbol.iterator]();
-  }
-  /** The portable bytes, for exactly the argument `'portable'`; any other call is a `ValidationError`. */
-  serialize(...args) {
-    if (args.length !== 1 || args[0] !== "portable") {
-      const got = args.length === 0 ? "no argument" : args.map((a) => typeof a === "string" ? `'${a}'` : typeof a).join(", ");
-      throw new ValidationError3(
-        `a decoded bitmap serializes only as serialize('portable'); got ${got}`
-      );
-    }
-    return this.#bitmap.serialize();
-  }
-};
-function deserializePortable(bytes) {
-  return new ReadonlyRoaringView(decodeSerialized(bytes, flagshipCodec()));
-}
 
 // src/system-clock.ts
 var SystemClock = class {
@@ -2035,7 +3293,7 @@ import {
   DEFAULT_RETRY_POLICY,
   NOOP_METRICS,
   RetryingStorageChunkSource,
-  ValidationError as ValidationError4,
+  ValidationError as ValidationError3,
   isStorageBackend
 } from "@cloudbitmaps/core";
 function resolveRetryPolicy(partial) {
@@ -2059,7 +3317,7 @@ function wireStore(options, clock, rng, metrics) {
   if (options.retry !== false) {
     const { onRetry: userOnRetry, ...ov } = options.retry ?? {};
     if (userOnRetry !== void 0 && typeof userOnRetry !== "function") {
-      throw new ValidationError4("retry.onRetry must be a function");
+      throw new ValidationError3("retry.onRetry must be a function");
     }
     retryOptions = {
       clock,
@@ -2090,7 +3348,7 @@ function wireStore(options, clock, rng, metrics) {
 function resolveStorageSource(options, clock) {
   const storage = options.storage;
   if (storage === null || typeof storage !== "object") {
-    throw new ValidationError4(
+    throw new ValidationError3(
       "`storage` must be a StorageBackend, an IStorageDriver, or a StorageChunkSource"
     );
   }
@@ -2100,14 +3358,14 @@ function resolveStorageSource(options, clock) {
   const hasPutImmutable = typeof storage.putImmutable === "function";
   const isBackend = isStorageBackend(storage);
   if (isBackend && (hasGetChunk || hasPutImmutable)) {
-    throw new ValidationError4(
+    throw new ValidationError3(
       `\`storage\` is a StorageBackend that also exposes ${hasGetChunk ? "`getChunk`" : "`putImmutable`"} \u2014 ambiguous. A backend must not also be a driver or a source; pass whichever one you mean.`
     );
   }
   const hasStorageHalf = isObject(asBackend.storage);
   const hasRegistryHalf = isObject(asBackend.registry);
   if (!isBackend && hasPutImmutable && hasRegistryHalf) {
-    throw new ValidationError4(
+    throw new ValidationError3(
       "`storage` looks like a driver that also carries a `registry`. Passed as a bare driver it would have no pointer at all \u2014 generations would resolve by list-scan, so reads could serve a generation that was written but never published. If you meant a backend, use a backend class \u2014 S3Storage, GcsStorage, AzureBlobStorage, LocalFsStorage or MemoryStorage \u2014 or, to pair a driver of your own with a registry, brand the pair with `brandAsBackend` from `@cloudbitmaps/core/driver-kit`."
     );
   }
@@ -2116,11 +3374,11 @@ function resolveStorageSource(options, clock) {
     const registryOk = typeof asBackend.registry.compareAndSwap === "function";
     if (!storageOk || !registryOk) {
       const bad = !storageOk ? "`storage` half is not an IStorageDriver (no `putImmutable`)" : "`registry` half is not an IRegistryDriver (no `compareAndSwap`)";
-      throw new ValidationError4(
+      throw new ValidationError3(
         "`storage` looks like a backend but its " + bad + " \u2014 use a backend class, or brand a pair of drivers with `brandAsBackend` from `@cloudbitmaps/core/driver-kit`."
       );
     }
-    throw new ValidationError4(
+    throw new ValidationError3(
       "`storage` must be a backend \u2014 S3Storage, GcsStorage, AzureBlobStorage, LocalFsStorage or MemoryStorage. An object with `.storage` and `.registry` is not one: a backend builds both halves from a single bucket and prefix, so they cannot disagree, and hand-assembling them re-opens exactly that mismatch \u2014 a store whose pointer and generations live in different places reads as empty rather than failing. A driver author who genuinely wants halves of their own \u2014 an instrumented driver, a registry in a database you already run \u2014 brands the pair with `brandAsBackend` from `@cloudbitmaps/core/driver-kit`, which is taking on that they agree."
     );
   }
@@ -2141,18 +3399,18 @@ function resolveStorageSource(options, clock) {
     };
   }
   if (hasGetChunk && hasPutImmutable) {
-    throw new ValidationError4(
+    throw new ValidationError3(
       "`storage` exposes both `getChunk` and `putImmutable` \u2014 ambiguous; pass a StorageBackend, an IStorageDriver, or a StorageChunkSource, not a hybrid"
     );
   }
   if (!hasGetChunk && !hasPutImmutable) {
-    throw new ValidationError4(
+    throw new ValidationError3(
       "`storage` must be a StorageBackend, an IStorageDriver, or a StorageChunkSource"
     );
   }
   if (hasGetChunk) {
     if (options.encryption?.keystore !== void 0 || options.encryption?.required === true) {
-      throw new ValidationError4(
+      throw new ValidationError3(
         "keystore/requireEncryption apply only when the store builds its own read path: a StorageChunkSource of your own reads an encrypted segment by itself, if it must; to have the store decrypt, pass a backend"
       );
     }
@@ -2174,32 +3432,32 @@ function resolveStorageSource(options, clock) {
 }
 
 // src/options.ts
-import { ValidationError as ValidationError5 } from "@cloudbitmaps/core";
+import { ValidationError as ValidationError4 } from "@cloudbitmaps/core";
 var keysOf = () => (keys) => keys;
 var kindOf = (v) => v === null ? "null" : Array.isArray(v) ? "an array" : `a ${typeof v}`;
 function optionsError(options, op, known, booleans = [], misplaced = []) {
   if (options === void 0 || options === null) return void 0;
   if (typeof options !== "object" || Array.isArray(options)) {
-    return new ValidationError5(`${op}: options must be an object; got ${kindOf(options)}`);
+    return new ValidationError4(`${op}: options must be an object; got ${kindOf(options)}`);
   }
   const bag = options;
   const unknown = Object.keys(bag).filter((k) => !known.includes(k) && bag[k] !== void 0);
   for (const k of misplaced) if (!unknown.includes(k) && bag[k] !== void 0) unknown.push(k);
   if (unknown.length > 0) {
-    return new ValidationError5(
+    return new ValidationError4(
       `${op}: unknown option${unknown.length > 1 ? "s" : ""} ${unknown.map((k) => `"${k}"`).join(", ")}; it takes { ${known.join(", ")} }`
     );
   }
   const audit = bag.audit;
   if (audit !== void 0 && audit !== null && typeof audit.onEvent !== "function") {
-    return new ValidationError5(
+    return new ValidationError4(
       `${op}: audit must be a sink with an onEvent(event) method, such as a RecordingAuditSink`
     );
   }
   for (const name of booleans) {
     const v = bag[name];
     if (v !== void 0 && typeof v !== "boolean") {
-      return new ValidationError5(`${op}: \`${name}\` must be a boolean; got ${kindOf(v)}`);
+      return new ValidationError4(`${op}: \`${name}\` must be a boolean; got ${kindOf(v)}`);
     }
   }
   return void 0;
@@ -2220,6 +3478,407 @@ function checkOptions(options, op, known, booleans, misplaced) {
 
 // src/index.ts
 import { MemoryStorage, LocalFsStorage, InProcessKeystore } from "@cloudbitmaps/core/node";
+
+// src/bitmap.ts
+import {
+  MAX_SERIALIZED_LOAD_BYTES,
+  ValidationError as ValidationError5,
+  decodeSerialized,
+  refusalOfId as refusalOfId2
+} from "@cloudbitmaps/core";
+
+// src/count-route.ts
+var COUNT_BY_KERNELS = true;
+
+// src/bitmap.ts
+function tagOf(value) {
+  return Object.prototype.toString.call(value).slice(8, -1);
+}
+var VIEW = Object.getPrototypeOf(Uint8Array.prototype);
+var viewGetter = (name) => Object.getOwnPropertyDescriptor(VIEW, name)?.get;
+var bufferOf = viewGetter("buffer");
+var plainByteLength = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength")?.get;
+var hasSharedMemory = typeof SharedArrayBuffer === "function";
+function inSharedMemory(ids) {
+  if (!hasSharedMemory) return false;
+  try {
+    plainByteLength.call(bufferOf.call(ids));
+    return false;
+  } catch {
+    return true;
+  }
+}
+function checkedId2(id) {
+  if (typeof id !== "number" || id >>> 0 !== id) throw refusalOfId2(id);
+  return id;
+}
+function oneIdOnly(method, bulk) {
+  return new ValidationError5(`${method} takes one id; use ${bulk} for several`);
+}
+function idsOf(values) {
+  if (typeof values !== "object" || values === null || !(Symbol.iterator in values)) {
+    throw new ValidationError5("values must be an iterable of ids");
+  }
+  const tag = tagOf(values);
+  if (tag === "Uint8Array" || tag === "Uint8ClampedArray") {
+    throw new ValidationError5(
+      `values are ids, and this is a ${tag === "Uint8Array" ? "Uint8Array or Buffer" : tag}: each byte would be read as an id. To read portable bytes, call RoaringBitmap.deserialize(bytes).`
+    );
+  }
+  if (values instanceof Uint32Array && inSharedMemory(values)) return new Uint32Array(values);
+  return values;
+}
+var detachedCodec = {
+  ...tsRoaringCodec,
+  safeDeserialize: (bytes, maxBytes, options) => TsBitmap.safeDeserialize(bytes, maxBytes, { ...options, detached: true })
+};
+function maxBytesOf(options) {
+  if (options === void 0) return MAX_SERIALIZED_LOAD_BYTES;
+  if (typeof options !== "object" || options === null) {
+    throw new ValidationError5(
+      `deserialize takes no format argument, the format is always portable; its second argument is { maxBytes } or nothing, not ${kindOf(options)}`
+    );
+  }
+  checkOptions(options, "RoaringBitmap.deserialize", ["maxBytes"]);
+  const { maxBytes } = picked(options, ["maxBytes"]);
+  if (maxBytes === void 0) return MAX_SERIALIZED_LOAD_BYTES;
+  if (!Number.isInteger(maxBytes) || maxBytes < 0 || maxBytes > MAX_SERIALIZED_LOAD_BYTES) {
+    throw new ValidationError5(
+      `maxBytes must be an integer from 0 to ${MAX_SERIALIZED_LOAD_BYTES}, the size no canonical bitmap exceeds`
+    );
+  }
+  return maxBytes;
+}
+var RoaringBitmap = class _RoaringBitmap {
+  #bitmap;
+  /**
+   * A bitmap of `values`: an array or another iterable of ids, a `Uint32Array` (read in place when it already ascends,
+   * else sorted on a copy; it is never changed or kept), or another `RoaringBitmap` (a copy-on-write `clone()`).
+   * With no argument it is empty.
+   *
+   * @throws {ValidationError} for an id that is not an integer from 0 to 4294967295; for a value that is not an
+   * iterable (`null`, a number, a string, an object, an `ArrayBuffer`); and for a `Uint8Array`, `Uint8ClampedArray` or
+   * `Buffer`, which would read each byte as an id: call {@link RoaringBitmap.deserialize} for bytes.
+   */
+  constructor(values) {
+    if (values === void 0) {
+      this.#bitmap = TsBitmap.empty();
+    } else if (_RoaringBitmap.#is(values)) {
+      this.#bitmap = values.#bitmap.clone();
+    } else {
+      this.#bitmap = TsBitmap.fromValues(idsOf(values));
+    }
+  }
+  /**
+   * Decode portable Roaring bytes you hold, through the check a `{ serialized }` load makes first: a size cap, a
+   * structural check and one whole bitmap, and only then the decoder. The result owns its storage: it keeps nothing
+   * of `bytes`, so a large input that is decoded and then reduced can be freed.
+   *
+   * @param bytes a `Uint8Array`, which a Node `Buffer` is.
+   * @param options `{ maxBytes }` lowers the size cap below the default of 537,403,396 bytes.
+   * @throws {ValidationError} for something that is not a `Uint8Array`; an empty or detached one (an empty buffer is
+   * not a bitmap: `new RoaringBitmap()` is the empty set); one over the cap or `maxBytes`; bytes that are not exactly
+   * one well-formed portable bitmap, including bytes after its last container; a second argument that is not
+   * `undefined` or an object whose only key is `maxBytes` (a format argument such as `'portable'` is one); and a
+   * `maxBytes` that is not an integer from 0 to the cap.
+   */
+  static deserialize(bytes, options) {
+    const maxBytes = maxBytesOf(options);
+    return _RoaringBitmap.#wrap(
+      decodeSerialized(bytes, detachedCodec, "the buffer", {
+        maxBytes,
+        refuseEmpty: true
+      })
+    );
+  }
+  /** Whether `value` is a `RoaringBitmap` of this copy of the package. */
+  static #is(value) {
+    return typeof value === "object" && value !== null && #bitmap in value;
+  }
+  static #wrap(bitmap) {
+    const out = new _RoaringBitmap();
+    out.#bitmap = bitmap;
+    return out;
+  }
+  /** The codec bitmap of an operand, or a refusal that says what combines with what. */
+  static #operand(other) {
+    if (!_RoaringBitmap.#is(other)) {
+      throw new ValidationError5(
+        "a RoaringBitmap combines only with another RoaringBitmap of this copy of the package"
+      );
+    }
+    return other.#bitmap;
+  }
+  /** How many ids it holds. */
+  get size() {
+    return this.#bitmap.size;
+  }
+  /** Whether it holds no id. */
+  get isEmpty() {
+    return this.#bitmap.isEmpty;
+  }
+  /**
+   * Whether it holds `id`.
+   *
+   * @throws {ValidationError} for a value that is not an integer from 0 to 4294967295.
+   */
+  has(id) {
+    return this.#bitmap.has(checkedId2(id));
+  }
+  /** The smallest id, or `undefined` when it is empty. */
+  minimum() {
+    return this.#bitmap.minimum();
+  }
+  /** The largest id, or `undefined` when it is empty. */
+  maximum() {
+    return this.#bitmap.maximum();
+  }
+  /**
+   * Add one id; returns this bitmap, for chaining.
+   *
+   * @throws {ValidationError} for a value that is not an integer from 0 to 4294967295, and for a second argument:
+   * use {@link RoaringBitmap.addMany} to add several.
+   */
+  add(id) {
+    if (arguments.length !== 1) throw oneIdOnly("add", "addMany");
+    this.#bitmap.add(checkedId2(id));
+    return this;
+  }
+  /**
+   * Add every id of `values` (an iterable of ids, or a `Uint32Array`); returns this bitmap. Nothing is added if any
+   * of them is refused.
+   *
+   * @throws {ValidationError} as the constructor does.
+   */
+  addMany(values) {
+    if (_RoaringBitmap.#is(values)) this.#bitmap.orInPlace(values.#bitmap);
+    else this.#bitmap.addMany(idsOf(values));
+    return this;
+  }
+  /**
+   * Remove one id; whether it was there.
+   *
+   * @throws {ValidationError} for a value that is not an integer from 0 to 4294967295, and for a second argument:
+   * use {@link RoaringBitmap.removeMany} to remove several.
+   */
+  remove(id) {
+    if (arguments.length !== 1) throw oneIdOnly("remove", "removeMany");
+    return this.#bitmap.remove(checkedId2(id));
+  }
+  /**
+   * Remove every id of `values` (an iterable of ids, or a `Uint32Array`); returns this bitmap. Nothing is removed if
+   * any of them is refused.
+   *
+   * @throws {ValidationError} as the constructor does.
+   */
+  removeMany(values) {
+    if (_RoaringBitmap.#is(values)) this.#bitmap.andNotInPlace(values.#bitmap);
+    else this.#bitmap.removeMany(collect(idsOf(values)));
+    return this;
+  }
+  /** Remove every id. */
+  clear() {
+    this.#bitmap.clear();
+  }
+  /**
+   * A copy. It is copy-on-write: the copy costs the key list and one flag per container, not the ids, and the first
+   * write to a container on either side copies that container once.
+   */
+  clone() {
+    return _RoaringBitmap.#wrap(this.#bitmap.clone());
+  }
+  /**
+   * Keep only the ids `other` also holds; returns this bitmap. `other` is not changed, and may be this bitmap.
+   *
+   * @throws {ValidationError} if `other` is not a `RoaringBitmap` of this copy of the package.
+   */
+  andInPlace(other) {
+    this.#bitmap.andInPlace(_RoaringBitmap.#operand(other));
+    return this;
+  }
+  /**
+   * Add the ids `other` holds; returns this bitmap. `other` is not changed, and may be this bitmap.
+   *
+   * @throws {ValidationError} if `other` is not a `RoaringBitmap` of this copy of the package.
+   */
+  orInPlace(other) {
+    this.#bitmap.orInPlace(_RoaringBitmap.#operand(other));
+    return this;
+  }
+  /**
+   * Remove the ids `other` holds; returns this bitmap. `other` is not changed, and may be this bitmap.
+   *
+   * @throws {ValidationError} if `other` is not a `RoaringBitmap` of this copy of the package.
+   */
+  andNotInPlace(other) {
+    this.#bitmap.andNotInPlace(_RoaringBitmap.#operand(other));
+    return this;
+  }
+  /**
+   * Flip the ids `other` holds: keep those only this bitmap holds, add those only `other` holds; returns this bitmap.
+   * `other` is not changed, and may be this bitmap (the result is then empty).
+   *
+   * @throws {ValidationError} if `other` is not a `RoaringBitmap` of this copy of the package.
+   */
+  xorInPlace(other) {
+    this.#bitmap.xorInPlace(_RoaringBitmap.#operand(other));
+    return this;
+  }
+  /**
+   * How many ids both bitmaps hold, without building the intersection. Neither bitmap changes; `other` may be this one.
+   *
+   * @throws {ValidationError} if `other` is not a `RoaringBitmap` of this copy of the package.
+   */
+  andCardinality(other) {
+    const that = _RoaringBitmap.#operand(other);
+    return COUNT_BY_KERNELS ? this.#bitmap.andCardinality(that) : TsBitmap.and(this.#bitmap, that).size;
+  }
+  /**
+   * How many ids either bitmap holds. Neither bitmap changes; `other` may be this one.
+   *
+   * @throws {ValidationError} if `other` is not a `RoaringBitmap` of this copy of the package.
+   */
+  orCardinality(other) {
+    const that = _RoaringBitmap.#operand(other);
+    return COUNT_BY_KERNELS ? this.#bitmap.orCardinality(that) : TsBitmap.or(this.#bitmap, that).size;
+  }
+  /**
+   * How many ids exactly one of the bitmaps holds. Neither bitmap changes; `other` may be this one.
+   *
+   * @throws {ValidationError} if `other` is not a `RoaringBitmap` of this copy of the package.
+   */
+  xorCardinality(other) {
+    const that = _RoaringBitmap.#operand(other);
+    return COUNT_BY_KERNELS ? this.#bitmap.xorCardinality(that) : TsBitmap.xor(this.#bitmap, that).size;
+  }
+  /**
+   * How many ids this bitmap holds that `other` lacks. Neither bitmap changes; `other` may be this one.
+   *
+   * @throws {ValidationError} if `other` is not a `RoaringBitmap` of this copy of the package.
+   */
+  andNotCardinality(other) {
+    const that = _RoaringBitmap.#operand(other);
+    return COUNT_BY_KERNELS ? this.#bitmap.andNotCardinality(that) : TsBitmap.andNot(this.#bitmap, that).size;
+  }
+  /**
+   * Whether the bitmaps share an id. Neither bitmap changes; `other` may be this one.
+   *
+   * @throws {ValidationError} if `other` is not a `RoaringBitmap` of this copy of the package.
+   */
+  intersects(other) {
+    const that = _RoaringBitmap.#operand(other);
+    return COUNT_BY_KERNELS ? this.#bitmap.intersects(that) : !TsBitmap.and(this.#bitmap, that).isEmpty;
+  }
+  /**
+   * Whether every id of this bitmap is in `other` (an empty bitmap is a subset of every bitmap, itself included). Neither
+   * bitmap changes. Unlike the `roaring` package, which answers `false`, a value that is not a bitmap is refused.
+   *
+   * @throws {ValidationError} if `other` is not a `RoaringBitmap` of this copy of the package.
+   */
+  isSubset(other) {
+    return this.#bitmap.isSubset(_RoaringBitmap.#operand(other));
+  }
+  /**
+   * Whether both bitmaps hold exactly the same ids, whatever the kinds of their containers or the bytes they would
+   * serialize to. Neither bitmap changes.
+   *
+   * @throws {ValidationError} if `other` is not a `RoaringBitmap` of this copy of the package.
+   */
+  isEqual(other) {
+    return this.#bitmap.isEqual(_RoaringBitmap.#operand(other));
+  }
+  /**
+   * The ids both bitmaps hold, as a new bitmap. Neither operand changes, and the result holds storage of its own.
+   *
+   * @throws {ValidationError} if an operand is not a `RoaringBitmap` of this copy of the package.
+   */
+  static and(a, b) {
+    return _RoaringBitmap.#wrap(TsBitmap.and(_RoaringBitmap.#operand(a), _RoaringBitmap.#operand(b)));
+  }
+  /**
+   * The ids either bitmap holds, as a new bitmap. Neither operand changes. A container only `a` holds is shared with
+   * the result copy-on-write, so the next write to it, on either side, copies it once.
+   *
+   * @throws {ValidationError} if an operand is not a `RoaringBitmap` of this copy of the package.
+   */
+  static or(a, b) {
+    return _RoaringBitmap.#wrap(TsBitmap.or(_RoaringBitmap.#operand(a), _RoaringBitmap.#operand(b)));
+  }
+  /**
+   * The ids exactly one of the bitmaps holds, as a new bitmap. Neither operand changes (see {@link RoaringBitmap.or}
+   * for what is shared).
+   *
+   * @throws {ValidationError} if an operand is not a `RoaringBitmap` of this copy of the package.
+   */
+  static xor(a, b) {
+    return _RoaringBitmap.#wrap(TsBitmap.xor(_RoaringBitmap.#operand(a), _RoaringBitmap.#operand(b)));
+  }
+  /**
+   * The ids of `a` that `b` lacks, as a new bitmap. Neither operand changes (see {@link RoaringBitmap.or} for what is
+   * shared).
+   *
+   * @throws {ValidationError} if an operand is not a `RoaringBitmap` of this copy of the package.
+   */
+  static andNot(a, b) {
+    return _RoaringBitmap.#wrap(
+      TsBitmap.andNot(_RoaringBitmap.#operand(a), _RoaringBitmap.#operand(b))
+    );
+  }
+  /**
+   * The union of every bitmap of `bitmaps`, as a new bitmap that owns its storage (an empty list gives the empty set).
+   * No operand changes, and none is flagged: the result accumulates in containers of its own.
+   *
+   * @throws {ValidationError} if `bitmaps` is not an iterable, or holds anything that is not a `RoaringBitmap` of this
+   * copy of the package; nothing is combined then.
+   */
+  static orMany(bitmaps) {
+    if (typeof bitmaps !== "object" || bitmaps === null || !(Symbol.iterator in bitmaps)) {
+      throw new ValidationError5("orMany takes an iterable of RoaringBitmap");
+    }
+    const parts = Array.from(bitmaps, (b) => _RoaringBitmap.#operand(b));
+    return _RoaringBitmap.#wrap(TsBitmap.orMany(parts));
+  }
+  /** The ids in ascending order, each once. A bitmap that changes during the walk gives unspecified ids, and no error. */
+  [Symbol.iterator]() {
+    return this.#bitmap[Symbol.iterator]();
+  }
+  /** The ids as a new ascending array. A bitmap too large to allocate as one throws the runtime's `RangeError`. */
+  toArray() {
+    return this.#bitmap.toArray();
+  }
+  /** The ids as a new ascending `Uint32Array` the caller owns, never a view of the bitmap's storage. */
+  toUint32Array() {
+    return this.#bitmap.toUint32Array();
+  }
+  /**
+   * The portable Roaring bytes, in a new `Uint8Array`. Call {@link RoaringBitmap.runOptimize} first when the bitmap was
+   * decoded from bytes another writer made: its run containers stay as they were, and a bitmap that serializes over
+   * the size cap is refused by a load.
+   *
+   * @param format `'portable'`, the only format there is, or nothing.
+   * @throws {ValidationError} for any other argument.
+   */
+  serialize(format) {
+    if (format !== void 0 && format !== "portable") {
+      throw new ValidationError5(
+        `a bitmap serializes only as serialize() or serialize('portable'); got ${kindOf(format)}`
+      );
+    }
+    return this.#bitmap.serialize();
+  }
+  /**
+   * Re-encode every container in the smallest form (a run container only where it is strictly smaller than the plain
+   * one), so `serialize()` afterwards depends on the set alone. Membership is unchanged.
+   *
+   * @returns whether the bitmap holds at least one run container afterwards, not whether anything changed.
+   */
+  runOptimize() {
+    this.#bitmap.optimize();
+    return this.#bitmap.hasRunContainer();
+  }
+};
+
+// src/index.ts
 import {
   excludingReservedRows as excludingReservedRows2,
   readRetentionPolicy,
@@ -2314,6 +3973,29 @@ var CALL_KEYS = {
     "allowAbsentOperands",
     "exclude"
   ]),
+  intersectCount: keysOf()([
+    "after",
+    "through",
+    "concurrency",
+    "budget",
+    "allowAbsentOperands",
+    "exclude"
+  ]),
+  unionCount: keysOf()([
+    "after",
+    "through",
+    "concurrency",
+    "budget",
+    "allowAbsentOperands",
+    "exclude"
+  ]),
+  andNotCount: keysOf()([
+    "after",
+    "through",
+    "concurrency",
+    "budget",
+    "allowAbsentOperands"
+  ]),
   into: keysOf()([
     "after",
     "through",
@@ -2391,6 +4073,9 @@ var MISPLACED = {
   range: outside(CALL_KEYS.into, CALL_KEYS.range),
   andNot: outside(CALL_KEYS.into, CALL_KEYS.andNot),
   combine: outside(CALL_KEYS.into, CALL_KEYS.combine),
+  intersectCount: outside(CALL_KEYS.into, CALL_KEYS.intersectCount),
+  unionCount: outside(CALL_KEYS.into, CALL_KEYS.unionCount),
+  andNotCount: outside(CALL_KEYS.into, CALL_KEYS.andNotCount),
   andNotInto: outside(CALL_KEYS.into, CALL_KEYS.andNotInto),
   exportSegments: ["codec"]
 };
@@ -3494,8 +5179,8 @@ var CloudRoaring = class _CloudRoaring {
    * with `serialize('portable')` such as `roaring`'s `RoaringBitmap32`, or `{ serialized }`, portable Roaring bytes.
    * A bitmap is checked (size cap, structure, safe deserializer) before the first request, written from its own
    * containers with no per-id work, and gives the generation chunk for chunk what its ids would. An
-   * iterable with a `serialize` method (a `RoaringBitmap32`, another copy's bitmap, or a bitmap `deserializePortable`
-   * returned) passed as ids loads as `{ bitmap }` and is not iterated. A `Uint8Array` or `Buffer` passed as ids is
+   * iterable with a `serialize` method (a `RoaringBitmap32`, another copy's bitmap, or a `RoaringBitmap`
+   * of this package) passed as ids loads as `{ bitmap }` and is not iterated. A `Uint8Array` or `Buffer` passed as ids is
    * refused with `ValidationError`, since each byte would load as an id, even when it has a `serialize` of its own:
    * pass bytes as `{ serialized }`.
    *
@@ -4101,7 +5786,7 @@ var CloudRoaring = class _CloudRoaring {
   /**
    * **Export ("eject") every registered segment's current generation** through the injected `sink`, using only
    * public read APIs — so your data is readable **without CloudRoaring** (the exit path; see the README's "Your
-   * data stays yours"). `format: 'roaring'` (default) writes one **portable RoaringBitmap32** per segment
+   * data stays yours"). `format: 'roaring'` (default) writes one **portable Roaring bitmap** per segment
    * (loadable by any roaring library); `'ndjson'` writes newline-delimited ids (zero-dependency, streaming).
    * Enumerates via the store's **own** registry (needs one — throws {@link UnsupportedError} otherwise) so the
    * enumeration and the read path provably share one registry. Encrypted segments are decrypted transparently
@@ -4157,7 +5842,7 @@ function operandsLabel(verb) {
 }
 function refuseNoOperands(verb) {
   throw new ValidationError6(
-    verb === "intersect" ? "intersect requires at least one segment to intersect with; to read every id of one segment, use iterate()" : "intersectInto requires at least one segment to intersect with; to copy this segment into dest, call materializeMany({ operands: { src: thisSegment }, outputs: [{ dest, expr: { or: ['src'] } }], keep })"
+    verb === "intersect" ? "intersect requires at least one segment to intersect with; to read every id of one segment, use iterate()" : verb === "intersectCount" ? "intersectCount requires at least one segment to intersect with; to count one segment, use count()" : "intersectInto requires at least one segment to intersect with; to copy this segment into dest, call materializeMany({ operands: { src: thisSegment }, outputs: [{ dest, expr: { or: ['src'] } }], keep })"
   );
 }
 var AS_IDS = {
@@ -4867,6 +6552,111 @@ var Segment = class _Segment {
     );
     return this.combineInto("andNotInto", dest, excludes, options);
   }
+  /**
+   * How many ids `this ∩ others…` holds (minus `exclude`): the length of what {@link intersect} streams, without
+   * streaming it. Every key all the operands hold is decoded and counted as the stream reads it, and a key only some
+   * operands hold is not read, so the call makes the requests {@link intersect} makes and returns a number instead of
+   * the ids. It is exact: it never answers a key from an index, so it trusts nothing {@link count} trusts.
+   *
+   * The range, `concurrency`, `budget`, `allowAbsentOperands` and `exclude` are {@link intersect}'s; a write option fails
+   * the call with {@link ValidationError} before any request, and so does an empty `others` (to count one segment, use
+   * {@link count}).
+   *
+   * Like a stream, a count that runs while a segment is erased or reloaded can describe two instants, within the bound
+   * the streams state. A union or a difference, and an intersection with an `exclude`, looks at its operands'
+   * generations every `concurrency` keys; an intersection with no `exclude` makes no such look, since it decodes every
+   * key and so shows a move in the chunks it decodes, as its stream does. Either way it plans again above the last key
+   * it took when one moved. A pinned handle counts the generation it pinned, and each pinned operand's object is
+   * looked up once before the first key (one footer read each, which `budget` does not charge, and which the stream
+   * does not make), and again at each look where there is one, so an erasure of what it pinned fails the count with
+   * {@link NotFoundError}; a
+   * fault the look meets other than a transient one, which is retried, is raised as it is. A call that involves a
+   * handle whose lease has ended, or has ended by the next look, throws {@link LeaseExpiredError}.
+   */
+  async intersectCount(others, options) {
+    checkOptions(
+      options,
+      "intersectCount",
+      CALL_KEYS.intersectCount,
+      ["allowAbsentOperands"],
+      MISPLACED.intersectCount
+    );
+    return this.countCombine("intersect", others, options ?? void 0);
+  }
+  /**
+   * How many ids `this ∪ others…` holds (minus `exclude`): the length of what {@link union} streams, without streaming
+   * it. A chunk key only one operand holds, that no `exclude` holds and the range does not cut, is answered from that
+   * operand's index, so a union of segments that mostly do not overlap reads little of them; every other key is
+   * decoded and counted. On handles that are not pinned it makes no more requests than {@link union} does, and reads
+   * fewer bytes when the shared keys are few. An empty `others`, with no `exclude` and no range, is {@link count} of
+   * `this`, answered from the registry row when it can be; when that figure is 0 it adds one registry read, to refuse
+   * a segment that does not exist as the stream does.
+   *
+   * What it trusts: the index, for each key it answers without decoding, as {@link count} does, so a party who can write
+   * an object's index can make that key's figure wrong; a decoded key is exact. A source with no per-chunk counts
+   * decodes every key. It takes the options {@link intersectCount} takes; the erasure bound, the lease checks and the
+   * pinned handles are as for {@link intersectCount}, a pinned operand adding a footer read before the first key and at
+   * each look. An empty `others` on a pinned handle is {@link count} of the pin, with no look.
+   */
+  async unionCount(others, options) {
+    checkOptions(
+      options,
+      "unionCount",
+      CALL_KEYS.unionCount,
+      ["allowAbsentOperands"],
+      MISPLACED.unionCount
+    );
+    return this.countCombine("union", others, options ?? void 0);
+  }
+  /**
+   * How many ids `this \ (excludes…)` holds: the length of what {@link andNot} streams, without streaming it. A chunk
+   * key of `this` that no exclude holds and the range does not cut is answered from its index and not read; a key an
+   * exclude shares is decoded and counted. On handles that are not pinned it makes no more requests than {@link andNot}
+   * does, and reads fewer bytes when the excludes overlap little of `this`. An empty `excludes`, with no range, is
+   * {@link count} of `this` (the stream of it is the whole of `this`), answered from the registry row when it can be,
+   * with one registry read added when that figure is 0.
+   *
+   * It takes the options {@link andNot} takes (every one of {@link intersectCount}'s but `exclude`, which a count of a
+   * difference has no use for, since `excludes` is its subtraction) and trusts what {@link unionCount} trusts. The
+   * erasure bound, the lease checks and the pinned handles are as for {@link intersectCount}.
+   */
+  async andNotCount(excludes, options) {
+    checkOptions(
+      options,
+      "andNotCount",
+      CALL_KEYS.andNotCount,
+      ["allowAbsentOperands"],
+      MISPLACED.andNotCount
+    );
+    return this.countCombine("andNot", excludes, options ?? void 0);
+  }
+  /** The one body of the three count methods, after each has checked its own options. */
+  async countCombine(verb, operands, options) {
+    const name = `${verb}Count`;
+    const exclude = verb === "andNot" ? NO_SEGMENTS : this.excludesOf(options);
+    const others = segmentList(
+      operands,
+      verb === "andNot" ? `${name}: \`excludes\`` : `${name}: \`others\``
+    );
+    if (verb === "intersect" && others.length === 0) refuseNoOperands("intersectCount");
+    const handles = [this, ...others, ...exclude];
+    this.assertSegments(name, verb === "andNot" ? "an exclude" : "an operand", others);
+    this.assertSegments(name, "an exclude", exclude);
+    this.assertLeases(handles);
+    const engine = this.combineEngine(handles) ?? this.engine;
+    const read = options == null ? void 0 : readOptions(options);
+    const guard2 = handles.some((h) => h.leaseHold !== void 0) ? () => this.assertLeases(handles) : void 0;
+    const opts = guard2 === void 0 ? read : { ...read, guard: guard2 };
+    const refs = others.map((o) => o.ref);
+    if (verb === "andNot") return engine.combineCount([this.ref], refs, "all", verb, opts);
+    return engine.combineCount(
+      [this.ref, ...refs],
+      exclude.map((o) => o.ref),
+      verb === "union" ? "any" : "all",
+      verb,
+      opts
+    );
+  }
   /**
    * The one body of the three combines, read as ids or as chunks. `operands` is `others` for `intersect` and
    * `union`, and `excludes` for `andNot`, which takes no `exclude` option.
@@ -4945,13 +6735,13 @@ export {
   MemoryStorage,
   NotFoundError2 as NotFoundError,
   RecordingAuditSink,
+  RoaringBitmap,
   Segment,
   StaleOperandError,
   TransientError,
   UnsupportedError3 as UnsupportedError,
   ValidationError7 as ValidationError,
   WriteConflictError2 as WriteConflictError,
-  deserializePortable,
   destroySegment,
   eraseNamespace,
   errorKind2 as errorKind,