@parcel/graph 2.8.4-nightly.2926 → 2.8.4-nightly.2937

package/lib/AdjacencyList.js

@@ -4,62 +4,45 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = exports.SharedTypeMap = exports.NodeTypeMap = exports.EdgeTypeMap = void 0;
-
 function _assert() {
   const data = _interopRequireDefault(require("assert"));
-
   _assert = function () {
     return data;
   };
-
   return data;
 }
-
 function _nullthrows() {
   const data = _interopRequireDefault(require("nullthrows"));
-
   _nullthrows = function () {
     return data;
   };
-
   return data;
 }
-
 var _sharedBuffer = require("./shared-buffer");
-
 var _types = require("./types");
-
 var _Graph = require("./Graph");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+/** The address of the node in the nodes map. */
+/** The address of the edge in the edges map. */
+// eslint-disable-next-line no-unused-vars
+// eslint-disable-next-line no-unused-vars
 /** The upper bound above which capacity should be increased. */
 const LOAD_FACTOR = 0.7;
 /** The lower bound below which capacity should be decreased. */
-
 const UNLOAD_FACTOR = 0.3;
 /** The max amount by which to grow the capacity. */
-
 const MAX_GROW_FACTOR = 8;
 /** The min amount by which to grow the capacity. */
-
 const MIN_GROW_FACTOR = 2;
 /** The amount by which to shrink the capacity. */
-
 const SHRINK_FACTOR = 0.5;
-
 class AdjacencyList {
-  #nodes
-  /*: NodeTypeMap<TEdgeType | NullEdgeType> */
-  ;
-  #edges
-  /*: EdgeTypeMap<TEdgeType | NullEdgeType> */
-  ;
+  #nodes /*: NodeTypeMap<TEdgeType | NullEdgeType> */;
+  #edges /*: EdgeTypeMap<TEdgeType | NullEdgeType> */;
 
   constructor(opts) {
     let nodes;
     let edges;
-
     if (opts !== null && opts !== void 0 && opts.nodes) {
       ({
         nodes,
@@ -78,29 +61,25 @@ class AdjacencyList {
       this.#edges = new EdgeTypeMap(edgeCapacity);
     }
   }
+
   /**
    * Create a new `AdjacencyList` from the given options.
    */
-
-
   static deserialize(opts) {
     return new AdjacencyList(opts);
   }
+
   /**
    * Returns a serializable object of the nodes and edges in the graph.
    */
-
-
   serialize() {
     return {
       nodes: this.#nodes.data,
       edges: this.#edges.data
     };
   }
-
   get stats() {
     let buckets = new Map();
-
     for (let {
       from,
       to,
@@ -113,17 +92,14 @@ class AdjacencyList {
       bucket.add(key);
       buckets.set(hash, bucket);
     }
-
     let maxCollisions = 0;
     let collisions = 0;
     let distribution = 0;
-
     for (let bucket of buckets.values()) {
       maxCollisions = Math.max(maxCollisions, bucket.size - 1);
       collisions += bucket.size - 1;
       distribution += bucket.size * (bucket.size + 1) / 2;
     }
-
     let uniformity = distribution / (this.#edges.count / (2 * this.#edges.capacity) * (this.#edges.count + 2 * this.#edges.capacity - 1));
     return {
       nodes: (0, _types.fromNodeId)(this.#nodes.nextId),
@@ -143,83 +119,82 @@ class AdjacencyList {
       uniformity: Math.round(uniformity * 100) / 100 || 0
     };
   }
+
   /**
    * Resize the internal nodes array.
    *
    * This is used in `addNode` when the `numNodes` meets or exceeds
    * the allocated size of the `nodes` array.
    */
-
-
   resizeNodes(size) {
-    let nodes = this.#nodes; // Allocate the required space for a `nodes` map of the given `size`.
-
-    this.#nodes = new NodeTypeMap(size); // Copy the existing nodes into the new array.
-
+    let nodes = this.#nodes;
+    // Allocate the required space for a `nodes` map of the given `size`.
+    this.#nodes = new NodeTypeMap(size);
+    // Copy the existing nodes into the new array.
     this.#nodes.set(nodes.data);
   }
+
   /**
    * Resize the internal edges array.
    *
    * This is used in `addEdge` when the `numEdges` meets or exceeds
    * the allocated size of the `edges` array.
    */
-
-
   resizeEdges(size) {
     // Allocate the required space for new `nodes` and `edges` maps.
     let copy = new AdjacencyList({
       nodeCapacity: this.#nodes.capacity,
       edgeCapacity: size
-    }); // Copy the existing edges into the new array.
+    });
 
+    // Copy the existing edges into the new array.
     copy.#nodes.nextId = this.#nodes.nextId;
-    this.#edges.forEach(edge => void copy.addEdge(this.#edges.from(edge), this.#edges.to(edge), this.#edges.typeOf(edge))); // We expect to preserve the same number of edges.
+    this.#edges.forEach(edge => void copy.addEdge(this.#edges.from(edge), this.#edges.to(edge), this.#edges.typeOf(edge)));
 
-    (0, _assert().default)(this.#edges.count === copy.#edges.count, `Edge mismatch! ${this.#edges.count} does not match ${copy.#edges.count}.`); // Finally, copy the new data arrays over to this graph.
+    // We expect to preserve the same number of edges.
+    (0, _assert().default)(this.#edges.count === copy.#edges.count, `Edge mismatch! ${this.#edges.count} does not match ${copy.#edges.count}.`);
 
+    // Finally, copy the new data arrays over to this graph.
     this.#nodes = copy.#nodes;
     this.#edges = copy.#edges;
   }
+
   /**
    * Adds a node to the graph.
    *
    * Returns the id of the added node.
    */
-
-
   addNode() {
-    let id = this.#nodes.getId(); // If we're in danger of overflowing the `nodes` array, resize it.
-
+    let id = this.#nodes.getId();
+    // If we're in danger of overflowing the `nodes` array, resize it.
     if (this.#nodes.load > LOAD_FACTOR) {
       this.resizeNodes(increaseNodeCapacity(this.#nodes.capacity));
     }
-
     return id;
   }
+
   /**
    * Adds an edge to the graph.
    *
    * Returns `true` if the edge was added,
    * or `false` if the edge already exists.
    */
-
-
   addEdge(from, to, type = 1) {
     (0, _assert().default)(type > 0, `Unsupported edge type ${type}`);
     let hash = this.#edges.hash(from, to, type);
-    let edge = this.#edges.addressOf(hash, from, to, type); // The edge is already in the graph; do nothing.
+    let edge = this.#edges.addressOf(hash, from, to, type);
 
+    // The edge is already in the graph; do nothing.
     if (edge !== null) return false;
-    let capacity = this.#edges.capacity; // We add 1 to account for the edge we are adding.
-
-    let count = this.#edges.count + 1; // Since the space occupied by deleted edges isn't reclaimed,
+    let capacity = this.#edges.capacity;
+    // We add 1 to account for the edge we are adding.
+    let count = this.#edges.count + 1;
+    // Since the space occupied by deleted edges isn't reclaimed,
     // we include them in our count to avoid overflowing the `edges` array.
-
     let deletes = this.#edges.deletes;
-    let total = count + deletes; // If we have enough space to keep adding edges, we can
+    let total = count + deletes;
+    // If we have enough space to keep adding edges, we can
     // put off reclaiming the deleted space until the next resize.
-
     if (this.#edges.getLoad(total) > LOAD_FACTOR) {
       if (this.#edges.getLoad(deletes) > UNLOAD_FACTOR) {
         // If we have a significant number of deletes, we compute our new
@@ -229,38 +204,36 @@ class AdjacencyList {
         this.resizeEdges(getNextEdgeCapacity(capacity, count, this.#edges.getLoad(count)));
       } else {
         this.resizeEdges(getNextEdgeCapacity(capacity, total, this.#edges.getLoad(total)));
-      } // We must rehash because the capacity has changed.
-
-
+      }
+      // We must rehash because the capacity has changed.
       hash = this.#edges.hash(from, to, type);
     }
-
     let toNode = this.#nodes.addressOf(to, type);
     let fromNode = this.#nodes.addressOf(from, type);
-
     if (toNode === null || fromNode === null) {
       // If we're in danger of overflowing the `nodes` array, resize it.
       if (this.#nodes.load >= LOAD_FACTOR) {
-        this.resizeNodes(increaseNodeCapacity(this.#nodes.capacity)); // We need to update our indices since the `nodes` array has changed.
-
+        this.resizeNodes(increaseNodeCapacity(this.#nodes.capacity));
+        // We need to update our indices since the `nodes` array has changed.
         toNode = this.#nodes.addressOf(to, type);
         fromNode = this.#nodes.addressOf(from, type);
       }
     }
-
     if (toNode === null) toNode = this.#nodes.add(to, type);
-    if (fromNode === null) fromNode = this.#nodes.add(from, type); // Add our new edge to its hash bucket.
+    if (fromNode === null) fromNode = this.#nodes.add(from, type);
 
-    edge = this.#edges.add(hash, from, to, type); // Link this edge to the node's list of incoming edges.
+    // Add our new edge to its hash bucket.
+    edge = this.#edges.add(hash, from, to, type);
 
+    // Link this edge to the node's list of incoming edges.
     let prevIn = this.#nodes.linkIn(toNode, edge);
-    if (prevIn !== null) this.#edges.linkIn(prevIn, edge); // Link this edge to the node's list of outgoing edges.
+    if (prevIn !== null) this.#edges.linkIn(prevIn, edge);
 
+    // Link this edge to the node's list of outgoing edges.
     let prevOut = this.#nodes.linkOut(fromNode, edge);
     if (prevOut !== null) this.#edges.linkOut(prevOut, edge);
     return true;
   }
-
   *getAllEdges() {
     for (let edge of this.#edges) {
       yield {
@@ -270,68 +243,62 @@ class AdjacencyList {
       };
     }
   }
+
   /**
    * Check if the graph has an edge connecting the `from` and `to` nodes.
    */
-
-
   hasEdge(from, to, type = 1) {
     let hasEdge = type => {
       let hash = this.#edges.hash(from, to, type);
       return this.#edges.addressOf(hash, from, to, type) !== null;
     };
-
     if (Array.isArray(type)) {
       return type.some(hasEdge);
     }
-
     return hasEdge(type);
   }
+
   /**
    *
    */
-
-
   removeEdge(from, to, type = 1) {
     let hash = this.#edges.hash(from, to, type);
-    let edge = this.#edges.addressOf(hash, from, to, type); // The edge is not in the graph; do nothing.
+    let edge = this.#edges.addressOf(hash, from, to, type);
 
+    // The edge is not in the graph; do nothing.
     if (edge === null) return;
     let toNode = (0, _nullthrows().default)(this.#nodes.addressOf(to, type));
-    let fromNode = (0, _nullthrows().default)(this.#nodes.addressOf(from, type)); // Update the terminating node's first and last incoming edges.
-
-    this.#nodes.unlinkIn(toNode, edge, this.#edges.prevIn(edge), this.#edges.nextIn(edge)); // Update the originating node's first and last outgoing edges.
+    let fromNode = (0, _nullthrows().default)(this.#nodes.addressOf(from, type));
 
-    this.#nodes.unlinkOut(fromNode, edge, this.#edges.prevOut(edge), this.#edges.nextOut(edge)); // Splice the removed edge out of the linked list of edges in the bucket.
+    // Update the terminating node's first and last incoming edges.
+    this.#nodes.unlinkIn(toNode, edge, this.#edges.prevIn(edge), this.#edges.nextIn(edge));
 
-    this.#edges.unlink(hash, edge); // Splice the removed edge out of the linked list of incoming edges.
-
-    this.#edges.unlinkIn(edge); // Splice the removed edge out of the linked list of outgoing edges.
-
-    this.#edges.unlinkOut(edge); // Finally, delete the edge.
+    // Update the originating node's first and last outgoing edges.
+    this.#nodes.unlinkOut(fromNode, edge, this.#edges.prevOut(edge), this.#edges.nextOut(edge));
 
+    // Splice the removed edge out of the linked list of edges in the bucket.
+    this.#edges.unlink(hash, edge);
+    // Splice the removed edge out of the linked list of incoming edges.
+    this.#edges.unlinkIn(edge);
+    // Splice the removed edge out of the linked list of outgoing edges.
+    this.#edges.unlinkOut(edge);
+    // Finally, delete the edge.
     this.#edges.delete(edge);
   }
-
   hasInboundEdges(to) {
     let node = this.#nodes.head(to);
-
     while (node !== null) {
       if (this.#nodes.firstIn(node) !== null) return true;
       node = this.#nodes.next(node);
     }
-
     return false;
   }
-
   getInboundEdgesByType(to) {
     let edges = [];
     let node = this.#nodes.head(to);
-
     while (node !== null) {
       let type = this.#nodes.typeOf(node);
       let edge = this.#nodes.firstIn(node);
-
       while (edge !== null) {
         let from = this.#edges.from(edge);
         edges.push({
@@ -340,21 +307,16 @@ class AdjacencyList {
         });
         edge = this.#edges.nextIn(edge);
       }
-
       node = this.#nodes.next(node);
     }
-
     return edges;
   }
-
   getOutboundEdgesByType(from) {
     let edges = [];
     let node = this.#nodes.head(from);
-
     while (node !== null) {
       let type = this.#nodes.typeOf(node);
       let edge = this.#nodes.firstOut(node);
-
       while (edge !== null) {
         let to = this.#edges.to(edge);
         edges.push({
@@ -363,87 +325,68 @@ class AdjacencyList {
         });
         edge = this.#edges.nextOut(edge);
       }
-
       node = this.#nodes.next(node);
     }
-
     return edges;
   }
+
   /**
    * Get the list of nodes connected from this node.
    */
-
-
   getNodeIdsConnectedFrom(from, type = 1) {
     let matches = node => type === _Graph.ALL_EDGE_TYPES || (Array.isArray(type) ? type.includes(this.#nodes.typeOf(node)) : type === this.#nodes.typeOf(node));
-
     let nodes = [];
     let seen = new Set();
     let node = this.#nodes.head(from);
-
     while (node !== null) {
       if (matches(node)) {
         let edge = this.#nodes.firstOut(node);
-
         while (edge !== null) {
           let to = this.#edges.to(edge);
-
           if (!seen.has(to)) {
             nodes.push(to);
             seen.add(to);
           }
-
           edge = this.#edges.nextOut(edge);
         }
       }
-
       node = this.#nodes.next(node);
     }
-
     return nodes;
   }
+
   /**
    * Get the list of nodes connected to this node.
    */
-
-
   getNodeIdsConnectedTo(to, type = 1) {
     let matches = node => type === _Graph.ALL_EDGE_TYPES || (Array.isArray(type) ? type.includes(this.#nodes.typeOf(node)) : type === this.#nodes.typeOf(node));
-
     let nodes = [];
     let seen = new Set();
     let node = this.#nodes.head(to);
-
     while (node !== null) {
       if (matches(node)) {
         let edge = this.#nodes.firstIn(node);
-
         while (edge !== null) {
           let from = this.#edges.from(edge);
-
           if (!seen.has(from)) {
             nodes.push(from);
             seen.add(from);
           }
-
           edge = this.#edges.nextIn(edge);
         }
       }
-
       node = this.#nodes.next(node);
     }
-
     return nodes;
   }
-
   inspect() {
     return {
       nodes: this.#nodes.inspect(),
       edges: this.#edges.inspect()
     };
   }
-
 }
+
 /**
  * `SharedTypeMap` is a hashmap of items,
  * where each item has its own 'type' field.
@@ -483,10 +426,7 @@ class AdjacencyList {
  *        └────┼─────────┴─────────────────┘                 │
  *             └─────────────────────────────────────────────┘
  */
-
-
 exports.default = AdjacencyList;
-
 class SharedTypeMap {
   /**
    * The header for the `SharedTypeMap` comprises 2 4-byte chunks:
@@ -502,11 +442,10 @@ class SharedTypeMap {
    */
   static HEADER_SIZE = 2;
   /** The offset from the header where the capacity is stored. */
-
   static #CAPACITY = 0;
   /** The offset from the header where the count is stored. */
-
   static #COUNT = 1;
+
   /**
    * Each item in `SharedTypeMap` comprises 2 4-byte chunks:
    *
@@ -519,52 +458,42 @@ class SharedTypeMap {
    * │ NEXT │ TYPE │
    * └──────┴──────┘
    */
-
   static ITEM_SIZE = 2;
   /** The offset at which a link to the next item in the same bucket is stored. */
-
   static #NEXT = 0;
   /** The offset at which an item's type is stored. */
-
   static #TYPE = 1;
-  /** The number of items to accommodate per hash bucket. */
 
+  /** The number of items to accommodate per hash bucket. */
   static BUCKET_SIZE = 2;
-
   get capacity() {
     return this.data[SharedTypeMap.#CAPACITY];
   }
-
   get count() {
     return this.data[SharedTypeMap.#COUNT];
   }
-
   get load() {
     return this.getLoad();
   }
-
   get length() {
     return this.getLength();
   }
-
   get addressableLimit() {
     return this.constructor.HEADER_SIZE + this.capacity;
   }
-
   get bufferSize() {
     return `${(this.data.byteLength / 1024 / 1024).toLocaleString(undefined, {
       minimumFractionDigits: 2,
       maximumFractionDigits: 2
     })} mb`;
   }
-
   constructor(capacityOrData) {
     if (typeof capacityOrData === 'number') {
       let {
         BYTES_PER_ELEMENT
       } = Uint32Array;
-      let CAPACITY = SharedTypeMap.#CAPACITY; // $FlowFixMe[incompatible-call]
-
+      let CAPACITY = SharedTypeMap.#CAPACITY;
+      // $FlowFixMe[incompatible-call]
       this.data = new Uint32Array(new _sharedBuffer.SharedBuffer(this.getLength(capacityOrData) * BYTES_PER_ELEMENT));
       this.data[CAPACITY] = capacityOrData;
     } else {
@@ -572,7 +501,6 @@ class SharedTypeMap {
       (0, _assert().default)(this.getLength() === this.data.length, 'Data appears corrupt.');
     }
   }
-
   set(data) {
     let {
       HEADER_SIZE,
@@ -582,37 +510,35 @@ class SharedTypeMap {
     let COUNT = SharedTypeMap.#COUNT;
     let CAPACITY = SharedTypeMap.#CAPACITY;
     let delta = this.capacity - data[CAPACITY];
-    (0, _assert().default)(delta >= 0, 'Cannot copy to a map with smaller capacity.'); // Copy the header.
+    (0, _assert().default)(delta >= 0, 'Cannot copy to a map with smaller capacity.');
 
-    this.data.set(data.subarray(COUNT, HEADER_SIZE), COUNT); // Copy the hash table.
+    // Copy the header.
+    this.data.set(data.subarray(COUNT, HEADER_SIZE), COUNT);
 
+    // Copy the hash table.
     let toTable = this.data.subarray(HEADER_SIZE, HEADER_SIZE + this.capacity);
-    toTable.set(data.subarray(HEADER_SIZE, HEADER_SIZE + data[CAPACITY])); // Offset first links to account for the change in table capacity.
-
+    toTable.set(data.subarray(HEADER_SIZE, HEADER_SIZE + data[CAPACITY]));
+    // Offset first links to account for the change in table capacity.
     let max = toTable.length;
-
     for (let i = 0; i < max; i++) {
       if (toTable[i]) toTable[i] += delta;
-    } // Copy the items.
-
+    }
 
+    // Copy the items.
     let toItems = this.data.subarray(HEADER_SIZE + this.capacity);
-    toItems.set(data.subarray(HEADER_SIZE + data[CAPACITY])); // Offset next links to account for the change in table capacity.
-
+    toItems.set(data.subarray(HEADER_SIZE + data[CAPACITY]));
+    // Offset next links to account for the change in table capacity.
     max = toItems.length;
-
     for (let i = 0; i < max; i += ITEM_SIZE) {
       if (toItems[i + NEXT]) toItems[i + NEXT] += delta;
     }
   }
-
   getLoad(count = this.count) {
     let {
       BUCKET_SIZE
     } = this.constructor;
     return count / (this.capacity * BUCKET_SIZE);
   }
-
   getLength(capacity = this.capacity) {
     let {
       HEADER_SIZE,
@@ -621,9 +547,8 @@ class SharedTypeMap {
     } = this.constructor;
     return capacity + HEADER_SIZE + ITEM_SIZE * BUCKET_SIZE * capacity;
   }
-  /** Get the next available address in the map. */
-
 
+  /** Get the next available address in the map. */
   getNextAddress() {
     let {
       HEADER_SIZE,
@@ -631,27 +556,23 @@ class SharedTypeMap {
     } = this.constructor;
     return HEADER_SIZE + this.capacity + this.count * ITEM_SIZE;
   }
-  /** Get the address of the first item with the given hash. */
-
 
+  /** Get the address of the first item with the given hash. */
   head(hash) {
     let {
       HEADER_SIZE
     } = this.constructor;
     return this.data[HEADER_SIZE + hash] || null;
   }
-  /** Get the address of the next item with the same hash as the given item. */
-
 
+  /** Get the address of the next item with the same hash as the given item. */
   next(item) {
     let NEXT = SharedTypeMap.#NEXT;
     return this.data[item + NEXT] || null;
   }
-
   typeOf(item) {
     return this.data[item + SharedTypeMap.#TYPE];
   }
-
   link(hash, item, type) {
     let COUNT = SharedTypeMap.#COUNT;
     let NEXT = SharedTypeMap.#NEXT;
@@ -661,24 +582,19 @@ class SharedTypeMap {
     } = this.constructor;
     this.data[item + TYPE] = type;
     let prev = this.head(hash);
-
     if (prev !== null) {
       let next = this.next(prev);
-
       while (next !== null) {
         prev = next;
         next = this.next(next);
       }
-
       this.data[prev + NEXT] = item;
     } else {
       // This is the first item in the bucket!
       this.data[HEADER_SIZE + hash] = item;
     }
-
     this.data[COUNT]++;
   }
-
   unlink(hash, item) {
     let COUNT = SharedTypeMap.#COUNT;
     let NEXT = SharedTypeMap.#NEXT;
@@ -687,18 +603,16 @@ class SharedTypeMap {
       HEADER_SIZE
     } = this.constructor;
     this.data[item + TYPE] = 0;
-    let head = this.head(hash); // No bucket to unlink from.
-
+    let head = this.head(hash);
+    // No bucket to unlink from.
     if (head === null) return;
     let next = this.next(item);
     let prev = null;
     let candidate = head;
-
     while (candidate !== null && candidate !== item) {
       prev = candidate;
       candidate = this.next(candidate);
     }
-
     if (prev !== null && next !== null) {
       this.data[prev + NEXT] = next;
     } else if (prev !== null) {
@@ -708,18 +622,15 @@ class SharedTypeMap {
     } else {
       this.data[HEADER_SIZE + hash] = 0;
     }
-
     this.data[item + NEXT] = 0;
     this.data[COUNT]--;
   }
-
   forEach(cb) {
     let max = this.count;
     let len = this.length;
     let {
       ITEM_SIZE
     } = this.constructor;
-
     for (let i = this.addressableLimit, count = 0; i < len && count < max; i += ITEM_SIZE) {
       // Skip items that don't have a type.
       if (this.typeOf(i)) {
@@ -727,20 +638,18 @@ class SharedTypeMap {
         count++;
       }
     }
-  } // Trick Flow into believing in `Symbol.iterator`.
-  // See https://github.com/facebook/flow/issues/1163#issuecomment-353523840
+  }
 
+  // Trick Flow into believing in `Symbol.iterator`.
+  // See https://github.com/facebook/flow/issues/1163#issuecomment-353523840
   /*:: @@iterator(): Iterator<TAddress> { return ({}: any); } */
   // $FlowFixMe[unsupported-syntax]
-
-
   *[Symbol.iterator]() {
     let max = this.count;
     let len = this.length;
     let {
       ITEM_SIZE
     } = this.constructor;
-
     for (let i = this.addressableLimit, count = 0; i < len && count < max; i += ITEM_SIZE) {
       if (this.data.subarray(i, i + ITEM_SIZE).some(Boolean)) {
         yield i;
@@ -748,7 +657,6 @@ class SharedTypeMap {
       }
     }
   }
-
   inspect() {
     const {
       HEADER_SIZE,
@@ -763,17 +671,14 @@ class SharedTypeMap {
       data: this.data.subarray(min, max)
     };
   }
-
 }
+
 /**
  * Nodes are stored in a `SharedTypeMap`, keyed on node id plus an edge type.
  * This means that for any given unique node id, there may be `e` nodes in the
  * map, where `e` is the number of possible edge types in the graph.
  */
-
-
 exports.SharedTypeMap = SharedTypeMap;
-
 class NodeTypeMap extends SharedTypeMap {
   /**
    * In addition to the header defined by `SharedTypeMap`, the header for
@@ -791,8 +696,8 @@ class NodeTypeMap extends SharedTypeMap {
    */
   static HEADER_SIZE = 3;
   /** The offset from the header where the next available node id is stored. */
-
   static #NEXT_ID = 2;
+
   /**
    * In addition to the item fields defined by `SharedTypeMap`,
    * each node includes another 4 4-byte chunks:
@@ -810,46 +715,36 @@ class NodeTypeMap extends SharedTypeMap {
    * │ NEXT │ TYPE │ FIRST_IN │ FIRST_OUT │ LAST_IN │ LAST_OUT │
    * └──────┴──────┴──────────┴───────────┴─────────┴──────────┘
    */
-
   static ITEM_SIZE = 6;
   /** The offset at which a node's first incoming edge of this type is stored. */
-
   static #FIRST_IN = 2;
   /** The offset at which a node's first outgoing edge of this type is stored. */
-
   static #FIRST_OUT = 3;
   /** The offset at which a node's last incoming edge of this type is stored. */
-
   static #LAST_IN = 4;
   /** The offset at which a node's last outgoing edge of this type is stored. */
-
   static #LAST_OUT = 5;
-  /** The smallest functional node map capacity. */
 
+  /** The smallest functional node map capacity. */
   static MIN_CAPACITY = 2;
   /** The largest possible node map capacity. */
-
-  static MAX_CAPACITY = Math.floor( // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_array_length#what_went_wrong
+  static MAX_CAPACITY = Math.floor(
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_array_length#what_went_wrong
   (2 ** 31 - 1 - NodeTypeMap.HEADER_SIZE) / NodeTypeMap.ITEM_SIZE / NodeTypeMap.BUCKET_SIZE);
-
   get nextId() {
     return (0, _types.toNodeId)(this.data[NodeTypeMap.#NEXT_ID]);
   }
-
   set nextId(nextId) {
     this.data[NodeTypeMap.#NEXT_ID] = (0, _types.fromNodeId)(nextId);
   }
-  /** Get a unique node id. */
-
 
+  /** Get a unique node id. */
   getId() {
     return (0, _types.toNodeId)(this.data[NodeTypeMap.#NEXT_ID]++);
   }
-
   getLoad(count = this.count) {
     return Math.max((0, _types.fromNodeId)(this.nextId) / this.capacity, super.getLoad(count));
   }
-
   add(node, type) {
     let index = (0, _types.fromNodeId)(node);
     (0, _assert().default)(index >= 0 && index < this.data[NodeTypeMap.#NEXT_ID], `Invalid node id ${String(node)} (${this.data[NodeTypeMap.#NEXT_ID]})`);
@@ -857,37 +752,28 @@ class NodeTypeMap extends SharedTypeMap {
     this.link(node, address, type);
     return address;
   }
-
   addressOf(node, type) {
     let address = this.head(node);
-
     while (address !== null) {
       if (this.typeOf(address) === type) {
         return address;
       }
-
       address = this.next(address);
     }
-
     return null;
   }
-
   firstIn(node) {
     return this.data[node + NodeTypeMap.#FIRST_IN] || null;
   }
-
   firstOut(node) {
     return this.data[node + NodeTypeMap.#FIRST_OUT] || null;
   }
-
   lastIn(node) {
     return this.data[node + NodeTypeMap.#LAST_IN] || null;
   }
-
   lastOut(node) {
     return this.data[node + NodeTypeMap.#LAST_OUT] || null;
   }
-
   linkIn(node, edge) {
     let first = this.firstIn(node);
     let last = this.lastIn(node);
@@ -895,20 +781,16 @@ class NodeTypeMap extends SharedTypeMap {
     this.data[node + NodeTypeMap.#LAST_IN] = edge;
     return last;
   }
-
   unlinkIn(node, edge, prev, next) {
     let first = this.firstIn(node);
     let last = this.lastIn(node);
-
     if (last === edge) {
       this.data[node + NodeTypeMap.#LAST_IN] = prev === null ? 0 : prev;
     }
-
     if (first === edge) {
       this.data[node + NodeTypeMap.#FIRST_IN] = next === null ? 0 : next;
     }
   }
-
   linkOut(node, edge) {
     let first = this.firstOut(node);
     let last = this.lastOut(node);
@@ -916,29 +798,23 @@ class NodeTypeMap extends SharedTypeMap {
     this.data[node + NodeTypeMap.#LAST_OUT] = edge;
     return last;
   }
-
   unlinkOut(node, edge, prev, next) {
     let first = this.firstOut(node);
     let last = this.lastOut(node);
-
     if (last === edge) {
       this.data[node + NodeTypeMap.#LAST_OUT] = prev === null ? 0 : prev;
     }
-
     if (first === edge) {
       this.data[node + NodeTypeMap.#FIRST_OUT] = next === null ? 0 : next;
     }
   }
-
 }
+
 /**
  * Edges are stored in a `SharedTypeMap`,
  * keyed on the 'from' and 'to' node ids, and the edge type.
  */
-
-
 exports.NodeTypeMap = NodeTypeMap;
-
 class EdgeTypeMap extends SharedTypeMap {
   /**
    * In addition to the header defined by `SharedTypeMap`, the header for
@@ -956,8 +832,8 @@ class EdgeTypeMap extends SharedTypeMap {
    */
   static HEADER_SIZE = 3;
   /** The offset from the header where the delete count is stored. */
-
   static #DELETES = 2;
+
   /**
    * In addition to the item fields defined by `SharedTypeMap`,
    * each edge includes another 6 4-byte chunks:
@@ -977,106 +853,83 @@ class EdgeTypeMap extends SharedTypeMap {
    * │ NEXT │ TYPE │ FROM │ TO │ NEXT_IN │ PREV_IN │ NEXT_OUT │ PREV_OUT │
    * └──────┴──────┴──────┴────┴─────────┴─────────┴──────────┴──────────┘
    */
-
   static ITEM_SIZE = 8;
   /** The offset at which an edge's 'from' node id is stored. */
-
   static #FROM = 2;
   /** The offset at which an edge's 'to' node id is stored. */
-
   static #TO = 3;
   /** The offset at which the 'to' node's next incoming edge is stored.  */
-
   static #NEXT_IN = 4;
   /** The offset at which the 'to' node's previous incoming edge is stored.  */
-
   static #PREV_IN = 5;
   /** The offset at which the 'from' node's next outgoing edge is stored.  */
-
   static #NEXT_OUT = 6;
   /** The offset at which the 'from' node's previous outgoing edge is stored.  */
-
   static #PREV_OUT = 7;
-  /** The smallest functional edge map capacity. */
 
+  /** The smallest functional edge map capacity. */
   static MIN_CAPACITY = 2;
   /** The largest possible edge map capacity. */
-
-  static MAX_CAPACITY = Math.floor( // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_array_length#what_went_wrong
+  static MAX_CAPACITY = Math.floor(
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_array_length#what_went_wrong
   (2 ** 31 - 1 - EdgeTypeMap.HEADER_SIZE) / EdgeTypeMap.ITEM_SIZE / EdgeTypeMap.BUCKET_SIZE);
   /** The size after which to grow the capacity by the minimum factor. */
-
   static PEAK_CAPACITY = 2 ** 18;
-
   get deletes() {
     return this.data[EdgeTypeMap.#DELETES];
   }
-
   getNextAddress() {
     let {
       ITEM_SIZE
     } = this.constructor;
     return this.addressableLimit + (this.count + this.deletes) * ITEM_SIZE;
   }
-
   add(hash, from, to, type) {
-    (0, _assert().default)(hash >= 0 && hash < this.capacity, `Invalid edge hash ${String(hash)}`); // Use the next available edge address.
-
-    let edge = this.getNextAddress(); // Add our new edge to its hash bucket.
-
+    (0, _assert().default)(hash >= 0 && hash < this.capacity, `Invalid edge hash ${String(hash)}`);
+    // Use the next available edge address.
+    let edge = this.getNextAddress();
+    // Add our new edge to its hash bucket.
     this.link(hash, edge, type);
     this.data[edge + EdgeTypeMap.#FROM] = (0, _types.fromNodeId)(from);
     this.data[edge + EdgeTypeMap.#TO] = (0, _types.fromNodeId)(to);
     return edge;
   }
-
   delete(edge) {
     this.data[edge + EdgeTypeMap.#FROM] = 0;
     this.data[edge + EdgeTypeMap.#TO] = 0;
     this.data[EdgeTypeMap.#DELETES]++;
   }
-
   addressOf(hash, from, to, type) {
     let address = this.head(hash);
-
     while (address !== null) {
       if (this.typeOf(address) === type && this.from(address) === from && this.to(address) === to) {
         return address;
       }
-
       address = this.next(address);
     }
-
     return null;
   }
-
   from(edge) {
     return (0, _types.toNodeId)(this.data[edge + EdgeTypeMap.#FROM]);
   }
-
   to(edge) {
     return (0, _types.toNodeId)(this.data[edge + EdgeTypeMap.#TO]);
   }
-
   nextIn(edge) {
     return this.data[edge + EdgeTypeMap.#NEXT_IN] || null;
   }
-
   prevIn(edge) {
     return this.data[edge + EdgeTypeMap.#PREV_IN] || null;
   }
-
   linkIn(edge, next) {
     this.data[edge + EdgeTypeMap.#NEXT_IN] = next;
     this.data[next + EdgeTypeMap.#PREV_IN] = edge;
   }
-
   unlinkIn(edge) {
     let next = this.nextIn(edge);
     let prev = this.prevIn(edge);
     this.data[edge + EdgeTypeMap.#NEXT_IN] = 0;
     this.data[edge + EdgeTypeMap.#PREV_IN] = 0;
-
     if (next !== null && prev !== null) {
       this.data[prev + EdgeTypeMap.#NEXT_IN] = next;
       this.data[next + EdgeTypeMap.#PREV_IN] = prev;
@@ -1086,26 +939,21 @@ class EdgeTypeMap extends SharedTypeMap {
       this.data[prev + EdgeTypeMap.#NEXT_IN] = 0;
     }
   }
-
   nextOut(edge) {
     return this.data[edge + EdgeTypeMap.#NEXT_OUT] || null;
   }
-
   prevOut(edge) {
     return this.data[edge + EdgeTypeMap.#PREV_OUT] || null;
   }
-
   linkOut(edge, next) {
     this.data[edge + EdgeTypeMap.#NEXT_OUT] = next;
     this.data[next + EdgeTypeMap.#PREV_OUT] = edge;
   }
-
   unlinkOut(edge) {
     let next = this.nextOut(edge);
     let prev = this.prevOut(edge);
     this.data[edge + EdgeTypeMap.#NEXT_OUT] = 0;
     this.data[edge + EdgeTypeMap.#PREV_OUT] = 0;
-
     if (next !== null && prev !== null) {
       this.data[prev + EdgeTypeMap.#NEXT_OUT] = next;
       this.data[next + EdgeTypeMap.#PREV_OUT] = prev;
@@ -1115,9 +963,8 @@ class EdgeTypeMap extends SharedTypeMap {
       this.data[prev + EdgeTypeMap.#NEXT_OUT] = 0;
     }
   }
-  /** Create a hash of the edge connecting the `from` and `to` nodes.  */
-
 
+  /** Create a hash of the edge connecting the `from` and `to` nodes.  */
   hash(from, to, type) {
     // Each parameter is hashed by mixing its upper bits into its lower bits to
     // increase the likelihood that a change to any bit of the input will vary
@@ -1126,33 +973,27 @@ class EdgeTypeMap extends SharedTypeMap {
     let hash = 17;
     hash = hash * 37 + hash32shift(from);
     hash = hash * 37 + hash32shift(to);
-    hash = hash * 37 + hash32shift(type); // Finally, we map the hash to a value modulo the edge capacity.
-
+    hash = hash * 37 + hash32shift(type);
+    // Finally, we map the hash to a value modulo the edge capacity.
     hash %= this.capacity;
     return hash;
   }
+}
 
-} // From https://gist.github.com/badboy/6267743#32-bit-mix-functions
-
-
+// From https://gist.github.com/badboy/6267743#32-bit-mix-functions
 exports.EdgeTypeMap = EdgeTypeMap;
-
 function hash32shift(key) {
   key = ~key + (key << 15); // key = (key << 15) - key - 1;
-
   key = key ^ key >> 12;
   key = key + (key << 2);
   key = key ^ key >> 4;
   key = key * 2057; // key = (key + (key << 3)) + (key << 11);
-
   key = key ^ key >> 16;
   return key;
 }
-
 function interpolate(x, y, t) {
   return x + (y - x) * Math.min(1, Math.max(0, t));
 }
-
 function increaseNodeCapacity(nodeCapacity) {
   let {
     MIN_CAPACITY,
@@ -1162,7 +1003,6 @@ function increaseNodeCapacity(nodeCapacity) {
   (0, _assert().default)(newCapacity <= MAX_CAPACITY, 'Node capacity overflow!');
   return Math.max(MIN_CAPACITY, newCapacity);
 }
-
 function getNextEdgeCapacity(capacity, count, load) {
   let {
     MIN_CAPACITY,
@@ -1170,12 +1010,12 @@ function getNextEdgeCapacity(capacity, count, load) {
     PEAK_CAPACITY
   } = EdgeTypeMap;
   let newCapacity = capacity;
-
   if (load > LOAD_FACTOR) {
     // This is intended to strike a balance between growing the edge capacity
     // in too small increments, which causes a lot of resizing, and growing
     // the edge capacity in too large increments, which results in a lot of
     // wasted memory.
+
     let growFactor = interpolate(MAX_GROW_FACTOR, MIN_GROW_FACTOR, capacity / PEAK_CAPACITY);
     newCapacity = Math.round(capacity * growFactor);
   } else if (load < UNLOAD_FACTOR) {
@@ -1183,7 +1023,6 @@ function getNextEdgeCapacity(capacity, count, load) {
     // but this is only likely to occur when a lot of edges have been removed.
     newCapacity = Math.round(capacity * SHRINK_FACTOR);
   }
-
   (0, _assert().default)(newCapacity <= MAX_CAPACITY, 'Edge capacity overflow!');
   return Math.max(MIN_CAPACITY, newCapacity);
 }