@atlaspack/graph 3.4.1-canary.52 → 3.4.1-canary.521

package/src/{AdjacencyList.js → AdjacencyList.ts}

@@ -1,4 +1,3 @@
-// @flow
 import assert from 'assert';
 import nullthrows from 'nullthrows';
 import {SharedBuffer} from './shared-buffer';
@@ -6,52 +5,59 @@ import {fromNodeId, toNodeId} from './types';
 import {
   ALL_EDGE_TYPES,
   NULL_EDGE_TYPE,
-  type NullEdgeType,
-  type AllEdgeTypes,
+  NullEdgeType,
+  AllEdgeTypes,
 } from './Graph';
 import type {NodeId} from './types';
 
 /** The address of the node in the nodes map. */
-opaque type NodeAddress = number;
+type NodeAddress = number;
 
-opaque type EdgeHash = number;
+type EdgeHash = number;
 
 /** The address of the edge in the edges map. */
-opaque type EdgeAddress = number;
+type EdgeAddress = number;
 
 // eslint-disable-next-line no-unused-vars
-export type SerializedAdjacencyList<TEdgeType> = {|
-  nodes: Uint32Array,
-  edges: Uint32Array,
-|};
+export type SerializedAdjacencyList<TEdgeType> = {
+  nodes: Uint32Array;
+  edges: Uint32Array;
+};
 
 // eslint-disable-next-line no-unused-vars
-export type AdjacencyListOptions<TEdgeType> = {|
+export type AdjacencyListOptions<TEdgeType> = {
   /** The initial number of edges to accommodate. */
-  initialCapacity?: number,
+  initialCapacity?: number;
+  /** The initial number of nodes to accommodate. */
+  initialNodeCapacity?: number;
   /** The max amount by which to grow the capacity. */
-  maxGrowFactor?: number,
+  maxGrowFactor?: number;
   /** The min amount by which to grow the capacity. */
-  minGrowFactor?: number,
+  minGrowFactor?: number;
   /** The size after which to grow the capacity by the minimum factor. */
-  peakCapacity?: number,
+  peakCapacity?: number;
   /** The percentage of deleted edges above which the capacity should shrink. */
-  unloadFactor?: number,
+  unloadFactor?: number;
   /** The amount by which to shrink the capacity. */
-  shrinkFactor?: number,
-|};
-
-type AdjacencyListParams = {|
-  initialCapacity: number,
-  unloadFactor: number,
-  maxGrowFactor: number,
-  minGrowFactor: number,
-  peakCapacity: number,
-  shrinkFactor: number,
-|};
+  shrinkFactor?: number;
+};
+
+type AdjacencyListParams = {
+  initialCapacity: number;
+  initialNodeCapacity: number;
+  unloadFactor: number;
+  maxGrowFactor: number;
+  minGrowFactor: number;
+  peakCapacity: number;
+  shrinkFactor: number;
+};
 
 const DEFAULT_PARAMS: AdjacencyListParams = {
   initialCapacity: 2,
+  // TODO: Find a heuristic for right-sizing nodes.
+  // e.g., given an average ratio of `e` edges for every `n` nodes,
+  // init nodes with `capacity * n / e`.
+  initialNodeCapacity: 2,
   unloadFactor: 0.3,
   maxGrowFactor: 8,
   minGrowFactor: 2,
@@ -68,18 +74,18 @@ const DEFAULT_PARAMS: AdjacencyListParams = {
  * `TooManyDeletes`  = `3`: the edge map has too many deleted edges
  * `NodesOverloaded` = `4`: the node map is overloaded
  */
-const LinkResult: {|
+const LinkResult: {
   /** The edge was successfully linked */
-  EdgeAdded: 0,
+  EdgeAdded: 0;
   /** The edge already exists */
-  EdgeExists: 1,
+  EdgeExists: 1;
   /** The edge map is overloaded */
-  EdgesOverloaded: 2,
+  EdgesOverloaded: 2;
   /** The edge map has too many deleted edges */
-  TooManyDeletes: 3,
+  TooManyDeletes: 3;
   /** The node map is overloaded */
-  NodesOverloaded: 4,
-|} = {
+  NodesOverloaded: 4;
+} = {
   EdgeAdded: 0,
   EdgeExists: 1,
   EdgesOverloaded: 2,
@@ -121,7 +127,7 @@ const MAX_LINK_TRIES: 3 = 3;
  * `getInboundEdgesByType` methods.
  *
  */
-export default class AdjacencyList<TEdgeType: number = NullEdgeType> {
+export default class AdjacencyList<TEdgeType extends number = NullEdgeType> {
   #nodes: NodeTypeMap<TEdgeType | NullEdgeType>;
   #edges: EdgeTypeMap<TEdgeType | NullEdgeType>;
 
@@ -140,7 +146,9 @@ export default class AdjacencyList<TEdgeType: number = NullEdgeType> {
     let nodes;
     let edges;
 
+    // @ts-expect-error TS2339
     if (opts?.nodes) {
+      // @ts-expect-error TS2339
       ({nodes, edges} = opts);
       this.#nodes = new NodeTypeMap(nodes);
       this.#edges = new EdgeTypeMap(edges);
@@ -148,12 +156,7 @@ export default class AdjacencyList<TEdgeType: number = NullEdgeType> {
     } else {
       this.#params = {...DEFAULT_PARAMS, ...opts};
 
-      let {initialCapacity} = this.#params;
-
-      // TODO: Find a heuristic for right-sizing nodes.
-      // e.g., given an average ratio of `e` edges for every `n` nodes,
-      // init nodes with `capacity * n / e`.
-      let initialNodeCapacity = 2;
+      let {initialCapacity, initialNodeCapacity} = this.#params;
 
       NodeTypeMap.assertMaxCapacity(initialNodeCapacity);
       EdgeTypeMap.assertMaxCapacity(initialCapacity);
@@ -167,7 +170,7 @@ export default class AdjacencyList<TEdgeType: number = NullEdgeType> {
    * Create a new `AdjacencyList` with data serialized
    * from another `AdjacencyList`.
    */
-  static deserialize(
+  static deserialize<TEdgeType extends number = NullEdgeType>(
     opts: SerializedAdjacencyList<TEdgeType>,
   ): AdjacencyList<TEdgeType> {
     return new AdjacencyList(opts);
@@ -184,35 +187,35 @@ export default class AdjacencyList<TEdgeType: number = NullEdgeType> {
   }
 
   /** Statistics about the current state of the `AdjacencyList`. */
-  get stats(): {|
+  get stats(): {
     /** The maximum number of edges the graph can contain. */
-    capacity: number,
+    capacity: number;
     /** The number of nodes in the graph. */
-    nodes: number,
+    nodes: number;
     /** The number of edge types associated with nodes in the graph. */
-    nodeEdgeTypes: number,
+    nodeEdgeTypes: number;
     /** The size of the raw nodes buffer, in mb. */
-    nodeBufferSize: string,
+    nodeBufferSize: string;
     /** The current load on the nodes array. */
-    nodeLoad: string,
+    nodeLoad: string;
     /** The number of edges in the graph. */
-    edges: number,
+    edges: number;
     /** The number of edges deleted from the graph. */
-    deleted: number,
+    deleted: number;
     /** The number of unique edge types in the graph. */
-    edgeTypes: number,
+    edgeTypes: number;
     /** The size of the raw edges buffer, in mb. */
-    edgeBufferSize: string,
+    edgeBufferSize: string;
     /** The current load on the edges array, including deletes. */
-    edgeLoadWithDeletes: string,
+    edgeLoadWithDeletes: string;
     /** The current load on the edges array. */
-    edgeLoad: string,
+    edgeLoad: string;
     /** The total number of edge hash collisions. */
-    collisions: number,
+    collisions: number;
     /** The number of collisions for the most common hash. */
-    maxCollisions: number,
+    maxCollisions: number;
     /** The average number of collisions per hash. */
-    avgCollisions: number,
+    avgCollisions: number;
     /**
      * The actual distribution of hashes vs. the expected (uniform) distribution.
      *
@@ -221,10 +224,11 @@ export default class AdjacencyList<TEdgeType: number = NullEdgeType> {
      * > A ratio within one confidence interval (0.95 - 1.05) is indicative
      * > that the hash function...has an expected uniform distribution.
      */
-    uniformity: number,
-  |} {
+    uniformity: number;
+  } {
     let edgeTypes = new Set();
     let buckets = new Map();
+    // @ts-expect-error TS2488
     for (let {from, to, type} of this.getAllEdges()) {
       let hash = this.#edges.hash(from, to, type);
       let bucket = buckets.get(hash) || new Set();
@@ -311,6 +315,7 @@ export default class AdjacencyList<TEdgeType: number = NullEdgeType> {
           this.#edges.from(edge),
           this.#edges.to(edge),
           this.#edges.typeOf(edge),
+          // @ts-expect-error TS2345
           edges,
           nodes,
           this.#params.unloadFactor,
@@ -324,7 +329,9 @@ export default class AdjacencyList<TEdgeType: number = NullEdgeType> {
     );
 
     // Finally, copy the new data arrays over to this graph.
+    // @ts-expect-error TS2322
     this.#nodes = nodes;
+    // @ts-expect-error TS2322
     this.#edges = edges;
   }
 
@@ -418,11 +425,11 @@ export default class AdjacencyList<TEdgeType: number = NullEdgeType> {
   /**
    * Iterate over all edges in insertion order.
    */
-  *getAllEdges(): Iterator<{|
-    type: TEdgeType | NullEdgeType,
-    from: NodeId,
-    to: NodeId,
-  |}> {
+  *getAllEdges(): Iterator<{
+    type: TEdgeType | NullEdgeType;
+    from: NodeId;
+    to: NodeId;
+  }> {
     for (let edge of this.#edges) {
       yield {
         from: this.#edges.from(edge),
@@ -523,10 +530,14 @@ export default class AdjacencyList<TEdgeType: number = NullEdgeType> {
    * Get a list of every node (labeled `from`) connecting _to_
    * the given `to` node, along with the edge `type` connecting them.
    */
-  getInboundEdgesByType(
-    to: NodeId,
-  ): {|type: TEdgeType | NullEdgeType, from: NodeId|}[] {
-    let edges = [];
+  getInboundEdgesByType(to: NodeId): {
+    type: TEdgeType | NullEdgeType;
+    from: NodeId;
+  }[] {
+    let edges: Array<{
+      from: NodeId;
+      type: TEdgeType | NullEdgeType;
+    }> = [];
     let node = this.#nodes.head(to);
     while (node !== null) {
       let type = this.#nodes.typeOf(node);
@@ -545,10 +556,14 @@ export default class AdjacencyList<TEdgeType: number = NullEdgeType> {
    * Get a list of every node (labeled `to`) connected _from_
    * the given `from` node, along with the edge `type` connecting them.
    */
-  getOutboundEdgesByType(
-    from: NodeId,
-  ): {|type: TEdgeType | NullEdgeType, to: NodeId|}[] {
-    let edges = [];
+  getOutboundEdgesByType(from: NodeId): {
+    type: TEdgeType | NullEdgeType;
+    to: NodeId;
+  }[] {
+    let edges: Array<{
+      to: NodeId;
+      type: TEdgeType | NullEdgeType;
+    }> = [];
     let node = this.#nodes.head(from);
     while (node !== null) {
       let type = this.#nodes.typeOf(node);
@@ -578,12 +593,12 @@ export default class AdjacencyList<TEdgeType: number = NullEdgeType> {
       | NullEdgeType
       | Array<TEdgeType | NullEdgeType> = NULL_EDGE_TYPE,
   ): NodeId[] {
-    let matches = (node) =>
+    let matches = (node: number) =>
       type === ALL_EDGE_TYPES ||
       (Array.isArray(type)
         ? type.includes(this.#nodes.typeOf(node))
         : type === this.#nodes.typeOf(node));
-    let nodes = [];
+    let nodes: Array<NodeId> = [];
     let seen = new Set<NodeId>();
     let node = this.#nodes.head(from);
     while (node !== null) {
@@ -608,7 +623,7 @@ export default class AdjacencyList<TEdgeType: number = NullEdgeType> {
     fn: (nodeId: NodeId) => boolean,
     type: AllEdgeTypes | TEdgeType | NullEdgeType = ALL_EDGE_TYPES,
   ) {
-    const matches = (node) =>
+    const matches = (node: number) =>
       type === ALL_EDGE_TYPES || type === this.#nodes.typeOf(node);
 
     let node = this.#nodes.head(from);
@@ -629,10 +644,10 @@ export default class AdjacencyList<TEdgeType: number = NullEdgeType> {
 
   forEachNodeIdConnectedTo(
     to: NodeId,
-    fn: (nodeId: NodeId) => boolean | void,
+    fn: (nodeId: NodeId) => boolean | undefined,
     type: AllEdgeTypes | TEdgeType | NullEdgeType = NULL_EDGE_TYPE,
   ) {
-    const matches = (node) =>
+    const matches = (node: number) =>
       type === ALL_EDGE_TYPES || type === this.#nodes.typeOf(node);
 
     let node = this.#nodes.head(to);
@@ -666,13 +681,13 @@ export default class AdjacencyList<TEdgeType: number = NullEdgeType> {
       | NullEdgeType
       | Array<TEdgeType | NullEdgeType> = NULL_EDGE_TYPE,
   ): NodeId[] {
-    let matches = (node) =>
+    let matches = (node: number) =>
       type === ALL_EDGE_TYPES ||
       (Array.isArray(type)
         ? type.includes(this.#nodes.typeOf(node))
         : type === this.#nodes.typeOf(node));
 
-    let nodes = [];
+    let nodes: Array<NodeId> = [];
     let seen = new Set<NodeId>();
     let node = this.#nodes.head(to);
     while (node !== null) {
@@ -739,7 +754,7 @@ export default class AdjacencyList<TEdgeType: number = NullEdgeType> {
  *        └────┼─────────┴─────────────────┘                 │
  *             └─────────────────────────────────────────────┘
  */
-export class SharedTypeMap<TItemType, THash, TAddress: number>
+export class SharedTypeMap<TItemType, THash, TAddress extends number>
   implements Iterable<TAddress>
 {
   /**
@@ -779,7 +794,8 @@ export class SharedTypeMap<TItemType, THash, TAddress: number>
   static #TYPE: 1 = 1;
 
   /** The largest possible capacity. */
-  static get MAX_CAPACITY(): number {
+  // @ts-expect-error TS1094
+  static get MAX_CAPACITY<TItemType, THash, TAddress extends number>(): number {
     return Math.floor(
       // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_array_length#what_went_wrong
       (2 ** 31 - 1 - this.HEADER_SIZE) / this.ITEM_SIZE,
@@ -787,7 +803,9 @@ export class SharedTypeMap<TItemType, THash, TAddress: number>
   }
 
   /** Assert that the given `capacity` does not exceed `MAX_CAPACITY`. */
-  static assertMaxCapacity(capacity: number): void {
+  static assertMaxCapacity<TItemType, THash, TAddress extends number>(
+    capacity: number,
+  ): void {
     assert(capacity <= this.MAX_CAPACITY, `${this.name} capacity overflow!`);
   }
 
@@ -815,6 +833,7 @@ export class SharedTypeMap<TItemType, THash, TAddress: number>
 
   /** The address of the first item in the map. */
   get addressableLimit(): number {
+    // @ts-expect-error TS2339
     return this.constructor.HEADER_SIZE + this.capacity;
   }
 
@@ -835,7 +854,6 @@ export class SharedTypeMap<TItemType, THash, TAddress: number>
     if (typeof capacityOrData === 'number') {
       let {BYTES_PER_ELEMENT} = Uint32Array;
       let CAPACITY = SharedTypeMap.#CAPACITY;
-      // $FlowFixMe[incompatible-call]
       this.data = new Uint32Array(
         new SharedBuffer(this.getLength(capacityOrData) * BYTES_PER_ELEMENT),
       );
@@ -854,6 +872,7 @@ export class SharedTypeMap<TItemType, THash, TAddress: number>
    * and is expected to be of equal or smaller capacity to this map.
    */
   set(data: Uint32Array): void {
+    // @ts-expect-error TS2339
     let {HEADER_SIZE, ITEM_SIZE} = this.constructor;
     let NEXT = SharedTypeMap.#NEXT;
     let COUNT = SharedTypeMap.#COUNT;
@@ -902,31 +921,34 @@ export class SharedTypeMap<TItemType, THash, TAddress: number>
    * get the length of the map, in bytes.
    */
   getLength(capacity: number = this.capacity): number {
+    // @ts-expect-error TS2339
     let {HEADER_SIZE, ITEM_SIZE} = this.constructor;
     return capacity + HEADER_SIZE + ITEM_SIZE * capacity;
   }
 
   /** Get the next available address in the map. */
   getNextAddress(): TAddress {
+    // @ts-expect-error TS2339
     let {HEADER_SIZE, ITEM_SIZE} = this.constructor;
-    return (HEADER_SIZE + this.capacity + this.count * ITEM_SIZE: any);
+    return (HEADER_SIZE + this.capacity + this.count * ITEM_SIZE) as any;
   }
 
   /** Get the address of the first item with the given hash. */
   head(hash: THash): TAddress | null {
+    // @ts-expect-error TS2339
     let {HEADER_SIZE} = this.constructor;
-    return (this.data[HEADER_SIZE + (hash: any)]: any) || null;
+    return (this.data[HEADER_SIZE + (hash as any)] as any) || null;
   }
 
   /** Get the address of the next item with the same hash as the given item. */
   next(item: TAddress): TAddress | null {
     let NEXT = SharedTypeMap.#NEXT;
-    return (this.data[(item: any) + NEXT]: any) || null;
+    return (this.data[(item as any) + NEXT] as any) || null;
   }
 
   /** Get the type of the item at the given `item` address. */
   typeOf(item: TAddress): TItemType {
-    return (this.data[item + SharedTypeMap.#TYPE]: any);
+    return this.data[item + SharedTypeMap.#TYPE] as any;
   }
 
   /**
@@ -937,9 +959,10 @@ export class SharedTypeMap<TItemType, THash, TAddress: number>
     let COUNT = SharedTypeMap.#COUNT;
     let NEXT = SharedTypeMap.#NEXT;
     let TYPE = SharedTypeMap.#TYPE;
+    // @ts-expect-error TS2339
     let {HEADER_SIZE} = this.constructor;
 
-    this.data[item + TYPE] = (type: any);
+    this.data[item + TYPE] = type as any;
 
     let prev = this.head(hash);
     if (prev !== null) {
@@ -951,7 +974,7 @@ export class SharedTypeMap<TItemType, THash, TAddress: number>
       this.data[prev + NEXT] = item;
     } else {
       // This is the first item in the bucket!
-      this.data[HEADER_SIZE + (hash: any)] = item;
+      this.data[HEADER_SIZE + (hash as any)] = item;
     }
     this.data[COUNT]++;
   }
@@ -963,6 +986,7 @@ export class SharedTypeMap<TItemType, THash, TAddress: number>
     let COUNT = SharedTypeMap.#COUNT;
     let NEXT = SharedTypeMap.#NEXT;
     let TYPE = SharedTypeMap.#TYPE;
+    // @ts-expect-error TS2339
     let {HEADER_SIZE} = this.constructor;
 
     this.data[item + TYPE] = 0;
@@ -976,6 +1000,7 @@ export class SharedTypeMap<TItemType, THash, TAddress: number>
     let candidate = head;
     while (candidate !== null && candidate !== item) {
       prev = candidate;
+      // @ts-expect-error TS2322
       candidate = this.next(candidate);
     }
     if (prev !== null && next !== null) {
@@ -983,9 +1008,9 @@ export class SharedTypeMap<TItemType, THash, TAddress: number>
     } else if (prev !== null) {
       this.data[prev + NEXT] = 0;
     } else if (next !== null) {
-      this.data[HEADER_SIZE + (hash: any)] = next;
+      this.data[HEADER_SIZE + (hash as any)] = next;
     } else {
-      this.data[HEADER_SIZE + (hash: any)] = 0;
+      this.data[HEADER_SIZE + (hash as any)] = 0;
     }
     this.data[item + NEXT] = 0;
     this.data[COUNT]--;
@@ -994,6 +1019,7 @@ export class SharedTypeMap<TItemType, THash, TAddress: number>
   forEach(cb: (item: TAddress) => void): void {
     let max = this.count;
     let len = this.length;
+    // @ts-expect-error TS2339
     let {ITEM_SIZE} = this.constructor;
     for (
       let i = this.addressableLimit, count = 0;
@@ -1001,8 +1027,8 @@ export class SharedTypeMap<TItemType, THash, TAddress: number>
       i += ITEM_SIZE
     ) {
       // Skip items that don't have a type.
-      if (this.typeOf((i: any))) {
-        cb((i: any));
+      if (this.typeOf(i as any)) {
+        cb(i as any);
         count++;
       }
     }
@@ -1012,10 +1038,10 @@ export class SharedTypeMap<TItemType, THash, TAddress: number>
   // See https://github.com/facebook/flow/issues/1163#issuecomment-353523840
   /*:: @@iterator(): Iterator<TAddress> { return ({}: any); } */
 
-  // $FlowFixMe[unsupported-syntax]
   *[Symbol.iterator](): Iterator<TAddress> {
     let max = this.count;
     let len = this.length;
+    // @ts-expect-error TS2339
     let {ITEM_SIZE} = this.constructor;
     for (
       let i = this.addressableLimit, count = 0;
@@ -1023,17 +1049,18 @@ export class SharedTypeMap<TItemType, THash, TAddress: number>
       i += ITEM_SIZE
     ) {
       if (this.data.subarray(i, i + ITEM_SIZE).some(Boolean)) {
-        yield (i: any);
+        yield i as any;
         count++;
       }
     }
   }
 
-  inspect(): {|
-    header: Uint32Array,
-    table: Uint32Array,
-    data: Uint32Array,
-  |} {
+  inspect(): {
+    header: Uint32Array;
+    table: Uint32Array;
+    data: Uint32Array;
+  } {
+    // @ts-expect-error TS2339
     const {HEADER_SIZE} = this.constructor;
     let min = this.addressableLimit;
 
@@ -1063,7 +1090,7 @@ export class SharedTypeMap<TItemType, THash, TAddress: number>
 export class NodeTypeMap<TEdgeType> extends SharedTypeMap<
   TEdgeType,
   NodeId,
-  NodeAddress,
+  NodeAddress
 > {
   /**
    * In addition to the header defined by `SharedTypeMap`, the header for
@@ -1305,7 +1332,7 @@ export class NodeTypeMap<TEdgeType> extends SharedTypeMap<
 export class EdgeTypeMap<TEdgeType> extends SharedTypeMap<
   TEdgeType,
   EdgeHash,
-  EdgeAddress,
+  EdgeAddress
 > {
   /**
    * In addition to the header defined by `SharedTypeMap`, the header for
@@ -1376,6 +1403,7 @@ export class EdgeTypeMap<TEdgeType> extends SharedTypeMap<
 
   /** Get the next available address in the map. */
   getNextAddress(): EdgeAddress {
+    // @ts-expect-error TS2339
     let {ITEM_SIZE} = this.constructor;
     return this.addressableLimit + (this.count + this.deletes) * ITEM_SIZE;
   }
@@ -1535,9 +1563,9 @@ export class EdgeTypeMap<TEdgeType> extends SharedTypeMap<
     // the output widely. Then we do a series of prime multiplications and
     // additions to combine the hashes into one value.
     let hash = 17;
-    hash = hash * 37 + hash32shift((from: any));
-    hash = hash * 37 + hash32shift((to: any));
-    hash = hash * 37 + hash32shift((type: any));
+    hash = hash * 37 + hash32shift(from as any);
+    hash = hash * 37 + hash32shift(to as any);
+    hash = hash * 37 + hash32shift(type as any);
     // Finally, we map the hash to a value modulo the edge capacity.
     hash %= this.capacity;
     return hash;
@@ -1554,14 +1582,14 @@ export class EdgeTypeMap<TEdgeType> extends SharedTypeMap<
  * - `3` TooManyDeletes: the edge map has too many deleted edges
  * - `4` NodesOverloaded: the node map is overloaded
  */
-function link<TEdgeType: number>(
+function link<TEdgeType extends number>(
   from: NodeId,
   to: NodeId,
   type: TEdgeType | NullEdgeType,
   edges: EdgeTypeMap<TEdgeType | NullEdgeType>,
   nodes: NodeTypeMap<TEdgeType | NullEdgeType>,
   unloadFactor: number = DEFAULT_PARAMS.unloadFactor,
-): $Values<typeof LinkResult> {
+): (typeof LinkResult)[keyof typeof LinkResult] {
   let hash = edges.hash(from, to, type);
   let edge = edges.addressOf(hash, from, to, type);
 

package/src/{BitSet.js → BitSet.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32#implementing_count_leading_ones_and_beyond
 function ctz32(n: number): number {
   if (n === 0) {
@@ -28,6 +26,12 @@ export class BitSet {
     return res;
   }
 
+  static intersect(a: BitSet, b: BitSet): BitSet {
+    let res = a.clone();
+    res.intersect(b);
+    return res;
+  }
+
   get capacity(): number {
     return this.bits.length * 32;
   }
@@ -82,6 +86,31 @@ export class BitSet {
     }
   }
 
+  size(): number {
+    let bits = this.bits;
+    let setBitsCount = 0;
+
+    for (let k = 0; k < bits.length; k++) {
+      let chunk = bits[k];
+
+      while (chunk !== 0) {
+        chunk &= chunk - 1; // Clear the least significant bit set
+        setBitsCount++;
+      }
+    }
+
+    return setBitsCount;
+  }
+
+  equals(other: BitSet): boolean {
+    for (let i = 0; i < this.bits.length; i++) {
+      if (this.bits[i] !== other.bits[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   forEach(fn: (bit: number) => void) {
     // https://lemire.me/blog/2018/02/21/iterating-over-set-bits-quickly/
     let bits = this.bits;
@@ -89,7 +118,6 @@ export class BitSet {
       let v = bits[k];
       while (v !== 0) {
         let t = (v & -v) >>> 0;
-        // $FlowFixMe
         fn((k << 5) + ctz32(v));
         v ^= t;
       }