@fecp/designer 5.6.5 → 5.6.8

package/es/node_modules/dagre-d3-es/src/graphlib/graph.mjs

@@ -0,0 +1,786 @@
+import constant from "../../../lodash-es/constant.mjs";
+import isFunction from "../../../lodash-es/isFunction.mjs";
+import keys from "../../../lodash-es/keys.mjs";
+import filter from "../../../lodash-es/filter.mjs";
+import forEach from "../../../lodash-es/forEach.mjs";
+import isUndefined from "../../../lodash-es/isUndefined.mjs";
+import union from "../../../lodash-es/union.mjs";
+import values from "../../../lodash-es/values.mjs";
+import reduce from "../../../lodash-es/reduce.mjs";
+import isEmpty from "../../../lodash-es/isEmpty.mjs";
+var DEFAULT_EDGE_NAME = "\0";
+var GRAPH_NODE = "\0";
+var EDGE_KEY_DELIM = "
";
+class Graph {
+  /**
+   * @param {GraphOptions} [opts] - Graph options.
+   */
+  constructor(opts = {}) {
+    this._isDirected = Object.prototype.hasOwnProperty.call(opts, "directed") ? opts.directed : true;
+    this._isMultigraph = Object.prototype.hasOwnProperty.call(opts, "multigraph") ? opts.multigraph : false;
+    this._isCompound = Object.prototype.hasOwnProperty.call(opts, "compound") ? opts.compound : false;
+    this._label = void 0;
+    this._defaultNodeLabelFn = constant(void 0);
+    this._defaultEdgeLabelFn = constant(void 0);
+    this._nodes = {};
+    if (this._isCompound) {
+      this._parent = {};
+      this._children = {};
+      this._children[GRAPH_NODE] = {};
+    }
+    this._in = {};
+    this._preds = {};
+    this._out = {};
+    this._sucs = {};
+    this._edgeObjs = {};
+    this._edgeLabels = {};
+  }
+  /* === Graph functions ========= */
+  /**
+   *
+   * @returns {boolean} `true` if the graph is [directed](https://en.wikipedia.org/wiki/Directed_graph).
+   * A directed graph treats the order of nodes in an edge as significant whereas an
+   * [undirected](https://en.wikipedia.org/wiki/Graph_(mathematics)#Undirected_graph)
+   * graph does not.
+   * This example demonstrates the difference:
+   *
+   * @example
+   *
+   * ```js
+   * var directed = new Graph({ directed: true });
+   * directed.setEdge("a", "b", "my-label");
+   * directed.edge("a", "b"); // returns "my-label"
+   * directed.edge("b", "a"); // returns undefined
+   *
+   * var undirected = new Graph({ directed: false });
+   * undirected.setEdge("a", "b", "my-label");
+   * undirected.edge("a", "b"); // returns "my-label"
+   * undirected.edge("b", "a"); // returns "my-label"
+   * ```
+   */
+  isDirected() {
+    return this._isDirected;
+  }
+  /**
+   * @returns {boolean} `true` if the graph is a multigraph.
+   */
+  isMultigraph() {
+    return this._isMultigraph;
+  }
+  /**
+   * @returns {boolean} `true` if the graph is compound.
+   */
+  isCompound() {
+    return this._isCompound;
+  }
+  /**
+   * Sets the label for the graph to `label`.
+   *
+   * @param {GraphLabel} label - Label for the graph.
+   * @returns {this}
+   */
+  setGraph(label) {
+    this._label = label;
+    return this;
+  }
+  /**
+   * @returns {GraphLabel | undefined} the currently assigned label for the graph.
+   * If no label has been assigned, returns `undefined`.
+   *
+   * @example
+   *
+   * ```js
+   * var g = new Graph();
+   * g.graph(); // returns undefined
+   * g.setGraph("graph-label");
+   *  g.graph(); // returns "graph-label"
+   * ```
+   */
+  graph() {
+    return this._label;
+  }
+  /* === Node functions ========== */
+  /**
+   * Sets a new default value that is assigned to nodes that are created without
+   * a label.
+   *
+   * @param {typeof this._defaultNodeLabelFn | NodeLabel} newDefault - If a function,
+   * it is called with the id of the node being created.
+   * Otherwise, it is assigned as the label directly.
+   * @returns {this}
+   */
+  setDefaultNodeLabel(newDefault) {
+    if (!isFunction(newDefault)) {
+      newDefault = constant(newDefault);
+    }
+    this._defaultNodeLabelFn = newDefault;
+    return this;
+  }
+  /**
+   * @returns {number} the number of nodes in the graph.
+   */
+  nodeCount() {
+    return this._nodeCount;
+  }
+  /**
+   * @returns {NodeID[]} the ids of the nodes in the graph.
+   *
+   * @remarks
+   * Use {@link node()} to get the label for each node.
+   * Takes `O(|V|)` time.
+   */
+  nodes() {
+    return keys(this._nodes);
+  }
+  /**
+   * @returns {NodeID[]} those nodes in the graph that have no in-edges.
+   * @remarks Takes `O(|V|)` time.
+   */
+  sources() {
+    var self = this;
+    return filter(this.nodes(), function(v) {
+      return isEmpty(self._in[v]);
+    });
+  }
+  /**
+   * @returns {NodeID[]} those nodes in the graph that have no out-edges.
+   * @remarks Takes `O(|V|)` time.
+   */
+  sinks() {
+    var self = this;
+    return filter(this.nodes(), function(v) {
+      return isEmpty(self._out[v]);
+    });
+  }
+  /**
+   * Invokes setNode method for each node in `vs` list.
+   *
+   * @param {Collection<NodeID | number>} vs - List of node IDs to create/set.
+   * @param {NodeLabel} [value] - If set, update all nodes with this value.
+   * @returns {this}
+   * @remarks Complexity: O(|names|).
+   */
+  setNodes(vs, value) {
+    var args = arguments;
+    var self = this;
+    forEach(vs, function(v) {
+      if (args.length > 1) {
+        self.setNode(v, value);
+      } else {
+        self.setNode(v);
+      }
+    });
+    return this;
+  }
+  /**
+   * Creates or updates the value for the node `v` in the graph.
+   *
+   * @param {NodeID | number} v - ID of the node to create/set.
+   * @param {NodeLabel} [value] - If supplied, it is set as the value for the node.
+   * If not supplied and the node was created by this call then
+   * {@link setDefaultNodeLabel} will be used to set the node's value.
+   * @returns {this} the graph, allowing this to be chained with other functions.
+   * @remarks Takes `O(1)` time.
+   */
+  setNode(v, value) {
+    if (Object.prototype.hasOwnProperty.call(this._nodes, v)) {
+      if (arguments.length > 1) {
+        this._nodes[v] = value;
+      }
+      return this;
+    }
+    this._nodes[v] = arguments.length > 1 ? value : this._defaultNodeLabelFn(v);
+    if (this._isCompound) {
+      this._parent[v] = GRAPH_NODE;
+      this._children[v] = {};
+      this._children[GRAPH_NODE][v] = true;
+    }
+    this._in[v] = {};
+    this._preds[v] = {};
+    this._out[v] = {};
+    this._sucs[v] = {};
+    ++this._nodeCount;
+    return this;
+  }
+  /**
+   * Gets the label of node with specified name.
+   *
+   * @param {NodeID | number} v - Node ID.
+   * @returns {NodeLabel | undefined} the label assigned to the node with the id `v`
+   * if it is in the graph.
+   * Otherwise returns `undefined`.
+   * @remarks Takes `O(1)` time.
+   */
+  node(v) {
+    return this._nodes[v];
+  }
+  /**
+   * Detects whether graph has a node with specified name or not.
+   *
+   * @param {NodeID | number} v - Node ID.
+   * @returns {boolean} Returns `true` the graph has a node with the id.
+   * @remarks Takes `O(1)` time.
+   */
+  hasNode(v) {
+    return Object.prototype.hasOwnProperty.call(this._nodes, v);
+  }
+  /**
+   * Remove the node with the id `v` in the graph or do nothing if the node is
+   * not in the graph.
+   *
+   * If the node was removed this function also removes any incident edges.
+   *
+   * @param {NodeID | number} v - Node ID to remove.
+   * @returns {this} the graph, allowing this to be chained with other functions.
+   * @remarks Takes `O(|E|)` time.
+   */
+  removeNode(v) {
+    if (Object.prototype.hasOwnProperty.call(this._nodes, v)) {
+      var removeEdge = (e) => this.removeEdge(this._edgeObjs[e]);
+      delete this._nodes[v];
+      if (this._isCompound) {
+        this._removeFromParentsChildList(v);
+        delete this._parent[v];
+        forEach(this.children(v), (child) => {
+          this.setParent(child);
+        });
+        delete this._children[v];
+      }
+      forEach(keys(this._in[v]), removeEdge);
+      delete this._in[v];
+      delete this._preds[v];
+      forEach(keys(this._out[v]), removeEdge);
+      delete this._out[v];
+      delete this._sucs[v];
+      --this._nodeCount;
+    }
+    return this;
+  }
+  /**
+   * Sets the parent for `v` to `parent` if it is defined or removes the parent
+   * for `v` if `parent` is undefined.
+   *
+   * @param {NodeID | number} v - Node ID to set the parent for.
+   * @param {NodeID | number} [parent] - Parent node ID. If not defined, removes the parent.
+   * @returns {this} the graph, allowing this to be chained with other functions.
+   * @throws if the graph is not compound.
+   * @throws if setting the parent would create a cycle.
+   * @remarks Takes `O(1)` time.
+   */
+  setParent(v, parent) {
+    if (!this._isCompound) {
+      throw new Error("Cannot set parent in a non-compound graph");
+    }
+    if (isUndefined(parent)) {
+      parent = GRAPH_NODE;
+    } else {
+      parent += "";
+      for (var ancestor = parent; !isUndefined(ancestor); ancestor = this.parent(ancestor)) {
+        if (ancestor === v) {
+          throw new Error("Setting " + parent + " as parent of " + v + " would create a cycle");
+        }
+      }
+      this.setNode(parent);
+    }
+    this.setNode(v);
+    this._removeFromParentsChildList(v);
+    this._parent[v] = parent;
+    this._children[parent][v] = true;
+    return this;
+  }
+  /**
+   * @private
+   * @param {NodeID | number} v - Node ID.
+   */
+  _removeFromParentsChildList(v) {
+    delete this._children[this._parent[v]][v];
+  }
+  /**
+   * Get parent node for node `v`.
+   *
+   * @param {NodeID | number} v - Node ID.
+   * @returns {NodeID | undefined} the node that is a parent of node `v`
+   * or `undefined` if node `v` does not have a parent or is not a member of
+   * the graph.
+   * Always returns `undefined` for graphs that are not compound.
+   * @remarks Takes `O(1)` time.
+   */
+  parent(v) {
+    if (this._isCompound) {
+      var parent = this._parent[v];
+      if (parent !== GRAPH_NODE) {
+        return parent;
+      }
+    }
+  }
+  /**
+   * Gets list of direct children of node v.
+   *
+   * @param {NodeID | number} [v] - Node ID. If not specified, gets nodes
+   * with no parent (top-level nodes).
+   * @returns {NodeID[] | undefined} all nodes that are children of node `v` or
+   * `undefined` if node `v` is not in the graph.
+   * Always returns `[]` for graphs that are not compound.
+   * @remarks Takes `O(|V|)` time.
+   */
+  children(v) {
+    if (isUndefined(v)) {
+      v = GRAPH_NODE;
+    }
+    if (this._isCompound) {
+      var children = this._children[v];
+      if (children) {
+        return keys(children);
+      }
+    } else if (v === GRAPH_NODE) {
+      return this.nodes();
+    } else if (this.hasNode(v)) {
+      return [];
+    }
+  }
+  /**
+   * @param {NodeID | number} v - Node ID.
+   * @returns {NodeID[] | undefined} all nodes that are predecessors of the
+   * specified node or `undefined` if node `v` is not in the graph.
+   * @remarks
+   * Behavior is undefined for undirected graphs - use {@link neighbors} instead.
+   * Takes `O(|V|)` time.
+   */
+  predecessors(v) {
+    var predsV = this._preds[v];
+    if (predsV) {
+      return keys(predsV);
+    }
+  }
+  /**
+   * @param {NodeID | number} v - Node ID.
+   * @returns {NodeID[] | undefined} all nodes that are successors of the
+   * specified node or `undefined` if node `v` is not in the graph.
+   * @remarks
+   * Behavior is undefined for undirected graphs - use {@link neighbors} instead.
+   * Takes `O(|V|)` time.
+   */
+  successors(v) {
+    var sucsV = this._sucs[v];
+    if (sucsV) {
+      return keys(sucsV);
+    }
+  }
+  /**
+   * @param {NodeID | number} v - Node ID.
+   * @returns {NodeID[] | undefined} all nodes that are predecessors or
+   * successors of the specified node
+   * or `undefined` if node `v` is not in the graph.
+   * @remarks Takes `O(|V|)` time.
+   */
+  neighbors(v) {
+    var preds = this.predecessors(v);
+    if (preds) {
+      return union(preds, this.successors(v));
+    }
+  }
+  /**
+   * @param {NodeID | number} v - Node ID.
+   * @returns {boolean} True if the node is a leaf (has no successors), false otherwise.
+   */
+  isLeaf(v) {
+    var neighbors;
+    if (this.isDirected()) {
+      neighbors = this.successors(v);
+    } else {
+      neighbors = this.neighbors(v);
+    }
+    return neighbors.length === 0;
+  }
+  /**
+     * Creates new graph with nodes filtered via `filter`.
+     * Edges incident to rejected node
+     * are also removed.
+     * 
+     * In case of compound graph, if parent is rejected by `filter`,
+     * than all its children are rejected too.
+  
+     * @param {(v: NodeID) => boolean} filter - Function that returns `true` for nodes to keep.
+     * @returns {Graph<GraphLabel, NodeLabel, EdgeLabel>} A new graph containing only the nodes for which `filter` returns `true`.
+     * @remarks Average-case complexity: O(|E|+|V|).
+     */
+  filterNodes(filter2) {
+    var copy = new this.constructor({
+      directed: this._isDirected,
+      multigraph: this._isMultigraph,
+      compound: this._isCompound
+    });
+    copy.setGraph(this.graph());
+    var self = this;
+    forEach(this._nodes, function(value, v) {
+      if (filter2(v)) {
+        copy.setNode(v, value);
+      }
+    });
+    forEach(this._edgeObjs, function(e) {
+      if (copy.hasNode(e.v) && copy.hasNode(e.w)) {
+        copy.setEdge(e, self.edge(e));
+      }
+    });
+    var parents = {};
+    function findParent(v) {
+      var parent = self.parent(v);
+      if (parent === void 0 || copy.hasNode(parent)) {
+        parents[v] = parent;
+        return parent;
+      } else if (parent in parents) {
+        return parents[parent];
+      } else {
+        return findParent(parent);
+      }
+    }
+    if (this._isCompound) {
+      forEach(copy.nodes(), function(v) {
+        copy.setParent(v, findParent(v));
+      });
+    }
+    return copy;
+  }
+  /* === Edge functions ========== */
+  /**
+   * Sets a new default value that is assigned to edges that are created without
+   * a label.
+   *
+   * @param {typeof this._defaultEdgeLabelFn | EdgeLabel} newDefault - If a function,
+   * it is called with the parameters `(v, w, name)`.
+   * Otherwise, it is assigned as the label directly.
+   * @returns {this}
+   */
+  setDefaultEdgeLabel(newDefault) {
+    if (!isFunction(newDefault)) {
+      newDefault = constant(newDefault);
+    }
+    this._defaultEdgeLabelFn = newDefault;
+    return this;
+  }
+  /**
+   * @returns {number} the number of edges in the graph.
+   * @remarks Complexity: O(1).
+   */
+  edgeCount() {
+    return this._edgeCount;
+  }
+  /**
+   * Gets edges of the graph.
+   *
+   * @returns {EdgeObj[]} the {@link EdgeObj} for each edge in the graph.
+   *
+   * @remarks
+   * In case of compound graph subgraphs are not considered.
+   * Use {@link edge()} to get the label for each edge.
+   * Takes `O(|E|)` time.
+   */
+  edges() {
+    return values(this._edgeObjs);
+  }
+  /**
+   * Establish an edges path over the nodes in nodes list.
+   *
+   * If some edge is already exists, it will update its label, otherwise it will
+   * create an edge between pair of nodes with label provided or default label
+   * if no label provided.
+   *
+   * @param {Collection<NodeID>} vs - List of node IDs to create edges between.
+   * @param {EdgeLabel} [value] - If set, update all edges with this value.
+   * @returns {this}
+   * @remarks Complexity: O(|nodes|).
+   */
+  setPath(vs, value) {
+    var self = this;
+    var args = arguments;
+    reduce(vs, function(v, w) {
+      if (args.length > 1) {
+        self.setEdge(v, w, value);
+      } else {
+        self.setEdge(v, w);
+      }
+      return w;
+    });
+    return this;
+  }
+  /**
+   * Creates or updates the label for the edge (`v`, `w`) with the optionally
+   * supplied `name`.
+   *
+   * @overload
+   * @param {EdgeObj} arg0 - Edge object.
+   * @param {EdgeLabel} [value] - If supplied, it is set as the label for the edge.
+   * If not supplied and the edge was created by this call then
+   * {@link setDefaultEdgeLabel} will be used to assign the edge's label.
+   * @returns {this} the graph, allowing this to be chained with other functions.
+   * @remarks Takes `O(1)` time.
+   */
+  /**
+   * Creates or updates the label for the edge (`v`, `w`) with the optionally
+   * supplied `name`.
+   *
+   * @overload
+   * @param {NodeID | number} v - Source node ID. Number values will be coerced to strings.
+   * @param {NodeID | number} w - Target node ID. Number values will be coerced to strings.
+   * @param {EdgeLabel} [value] - If supplied, it is set as the label for the edge.
+   * If not supplied and the edge was created by this call then
+   * {@link setDefaultEdgeLabel} will be used to assign the edge's label.
+   * @param {string | number} [name] - Edge name. Only useful with multigraphs.
+   * @returns {this} the graph, allowing this to be chained with other functions.
+   * @remarks Takes `O(1)` time.
+   */
+  setEdge() {
+    var v, w, name, value;
+    var valueSpecified = false;
+    var arg0 = arguments[0];
+    if (typeof arg0 === "object" && arg0 !== null && "v" in arg0) {
+      v = arg0.v;
+      w = arg0.w;
+      name = arg0.name;
+      if (arguments.length === 2) {
+        value = arguments[1];
+        valueSpecified = true;
+      }
+    } else {
+      v = arg0;
+      w = arguments[1];
+      name = arguments[3];
+      if (arguments.length > 2) {
+        value = arguments[2];
+        valueSpecified = true;
+      }
+    }
+    v = "" + v;
+    w = "" + w;
+    if (!isUndefined(name)) {
+      name = "" + name;
+    }
+    var e = edgeArgsToId(this._isDirected, v, w, name);
+    if (Object.prototype.hasOwnProperty.call(this._edgeLabels, e)) {
+      if (valueSpecified) {
+        this._edgeLabels[e] = value;
+      }
+      return this;
+    }
+    if (!isUndefined(name) && !this._isMultigraph) {
+      throw new Error("Cannot set a named edge when isMultigraph = false");
+    }
+    this.setNode(v);
+    this.setNode(w);
+    this._edgeLabels[e] = valueSpecified ? value : this._defaultEdgeLabelFn(v, w, name);
+    var edgeObj = edgeArgsToObj(this._isDirected, v, w, name);
+    v = edgeObj.v;
+    w = edgeObj.w;
+    Object.freeze(edgeObj);
+    this._edgeObjs[e] = edgeObj;
+    incrementOrInitEntry(this._preds[w], v);
+    incrementOrInitEntry(this._sucs[v], w);
+    this._in[w][e] = edgeObj;
+    this._out[v][e] = edgeObj;
+    this._edgeCount++;
+    return this;
+  }
+  /**
+   * Gets the label for the specified edge.
+   *
+   * @overload
+   * @param {EdgeObj} v - Edge object.
+   * @returns {EdgeLabel | undefined} the label for the edge (`v`, `w`) if the
+   * graph has an edge between `v` and `w` with the optional `name`.
+   * Returned `undefined` if there is no such edge in the graph.
+   * @remarks
+   * `v` and `w` can be interchanged for undirected graphs.
+   * Takes `O(1)` time.
+   */
+  /**
+   * Gets the label for the specified edge.
+   *
+   * @overload
+   * @param {NodeID | number} v - Source node ID.
+   * @param {NodeID | number} w - Target node ID.
+   * @param {string | number} [name] - Edge name. Only useful with multigraphs.
+   * @returns {EdgeLabel | undefined} the label for the edge (`v`, `w`) if the
+   * graph has an edge between `v` and `w` with the optional `name`.
+   * Returned `undefined` if there is no such edge in the graph.
+   * @remarks
+   * `v` and `w` can be interchanged for undirected graphs.
+   * Takes `O(1)` time.
+   */
+  edge(v, w, name) {
+    var e = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v, w, name);
+    return this._edgeLabels[e];
+  }
+  /**
+   * Detects whether the graph contains specified edge or not.
+   *
+   * @overload
+   * @param {EdgeObj} v - Edge object.
+   * @returns {boolean} `true` if the graph has an edge between `v` and `w`
+   * with the optional `name`.
+   * @remarks
+   * `v` and `w` can be interchanged for undirected graphs.
+   * No subgraphs are considered.
+   * Takes `O(1)` time.
+   */
+  /**
+   * Detects whether the graph contains specified edge or not.
+   *
+   * @overload
+   * @param {NodeID | number} v - Source node ID.
+   * @param {NodeID | number} w - Target node ID.
+   * @param {string | number} [name] - Edge name. Only useful with multigraphs.
+   * @returns {boolean} `true` if the graph has an edge between `v` and `w`
+   * with the optional `name`.
+   * @remarks
+   * `v` and `w` can be interchanged for undirected graphs.
+   * No subgraphs are considered.
+   * Takes `O(1)` time.
+   */
+  hasEdge(v, w, name) {
+    var e = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v, w, name);
+    return Object.prototype.hasOwnProperty.call(this._edgeLabels, e);
+  }
+  /**
+   * Removes the edge (`v`, `w`) if the graph has an edge between `v` and `w`
+   * with the optional `name`. If not this function does nothing.
+   *
+   * @overload
+   * @param {EdgeObj} v - Edge object.
+   * @returns {this}
+   * @remarks
+   * `v` and `w` can be interchanged for undirected graphs.
+   * No subgraphs are considered.
+   * Takes `O(1)` time.
+   */
+  /**
+   * Removes the edge (`v`, `w`) if the graph has an edge between `v` and `w`
+   * with the optional `name`. If not this function does nothing.
+   *
+   * @overload
+   * @param {NodeID | number} v - Source node ID.
+   * @param {NodeID | number} w - Target node ID.
+   * @param {string | number} [name] - Edge name. Only useful with multigraphs.
+   * @returns {this}
+   * @remarks
+   * `v` and `w` can be interchanged for undirected graphs.
+   * Takes `O(1)` time.
+   */
+  removeEdge(v, w, name) {
+    var e = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v, w, name);
+    var edge = this._edgeObjs[e];
+    if (edge) {
+      v = edge.v;
+      w = edge.w;
+      delete this._edgeLabels[e];
+      delete this._edgeObjs[e];
+      decrementOrRemoveEntry(this._preds[w], v);
+      decrementOrRemoveEntry(this._sucs[v], w);
+      delete this._in[w][e];
+      delete this._out[v][e];
+      this._edgeCount--;
+    }
+    return this;
+  }
+  /**
+   * @param {NodeID | number} v - Target node ID.
+   * @param {NodeID | number} [u] - Optionally filters edges down to just those
+   * coming from node `u`.
+   * @returns {EdgeObj[] | undefined} all edges that point to the node `v`.
+   * Returns `undefined` if node `v` is not in the graph.
+   * @remarks
+   * Behavior is undefined for undirected graphs - use {@link nodeEdges} instead.
+   * Takes `O(|E|)` time.
+   */
+  inEdges(v, u) {
+    var inV = this._in[v];
+    if (inV) {
+      var edges = values(inV);
+      if (!u) {
+        return edges;
+      }
+      return filter(edges, function(edge) {
+        return edge.v === u;
+      });
+    }
+  }
+  /**
+   * @param {NodeID | number} v - Target node ID.
+   * @param {NodeID | number} [w] - Optionally filters edges down to just those
+   * that point to `w`.
+   * @returns {EdgeObj[] | undefined} all edges that point to the node `v`.
+   * Returns `undefined` if node `v` is not in the graph.
+   * @remarks
+   * Behavior is undefined for undirected graphs - use {@link nodeEdges} instead.
+   * Takes `O(|E|)` time.
+   */
+  outEdges(v, w) {
+    var outV = this._out[v];
+    if (outV) {
+      var edges = values(outV);
+      if (!w) {
+        return edges;
+      }
+      return filter(edges, function(edge) {
+        return edge.w === w;
+      });
+    }
+  }
+  /**
+   * @param {NodeID | number} v - Target Node ID.
+   * @param {NodeID | number} [w] - If set, filters those edges down to just
+   * those between nodes `v` and `w` regardless of direction
+   * @returns {EdgeObj[] | undefined} all edges to or from node `v` regardless
+   * of direction. Returns `undefined` if node `v` is not in the graph.
+   * @remarks Takes `O(|E|)` time.
+   */
+  nodeEdges(v, w) {
+    var inEdges = this.inEdges(v, w);
+    if (inEdges) {
+      return inEdges.concat(this.outEdges(v, w));
+    }
+  }
+}
+Graph.prototype._nodeCount = 0;
+Graph.prototype._edgeCount = 0;
+function incrementOrInitEntry(map, k) {
+  if (map[k]) {
+    map[k]++;
+  } else {
+    map[k] = 1;
+  }
+}
+function decrementOrRemoveEntry(map, k) {
+  if (!--map[k]) {
+    delete map[k];
+  }
+}
+function edgeArgsToId(isDirected, v_, w_, name) {
+  var v = "" + v_;
+  var w = "" + w_;
+  if (!isDirected && v > w) {
+    var tmp = v;
+    v = w;
+    w = tmp;
+  }
+  return v + EDGE_KEY_DELIM + w + EDGE_KEY_DELIM + (isUndefined(name) ? DEFAULT_EDGE_NAME : name);
+}
+function edgeArgsToObj(isDirected, v_, w_, name) {
+  var v = "" + v_;
+  var w = "" + w_;
+  if (!isDirected && v > w) {
+    var tmp = v;
+    v = w;
+    w = tmp;
+  }
+  var edgeObj = { v, w };
+  if (name) {
+    edgeObj.name = name;
+  }
+  return edgeObj;
+}
+function edgeObjToId(isDirected, edgeObj) {
+  return edgeArgsToId(isDirected, edgeObj.v, edgeObj.w, edgeObj.name);
+}
+export {
+  Graph
+};