import { k as v, n as F, o as Y, q as Q, r as ee, t as A, v as te, w as re, x as se, S as ne, y as ie, z as m, A as E, B as oe, C as Z, D as $, E as ae, F as M, G as y, H as K, I as ue, J as he, K as S } from "./index-Bh-wTBlD.js";
import { M as c, Z as j, q as _, Y as ce, X as de, K as le, b as _e, E as fe, a as R, c as pe, r as be, B as ge, d as ve } from "./_baseUniq-BM5nBlUE-Bqq-876b.js";
function je(t, e) {
  return t && m(e, c(e), t);
}
function ye(t, e) {
  return t && m(e, E(e), t);
}
function me(t, e) {
  return m(t, R(t), e);
}
var we = Object.getOwnPropertySymbols, T = we ? function(t) {
  for (var e = []; t; )
    be(e, R(t)), t = ae(t);
  return e;
} : ge;
function Oe(t, e) {
  return m(t, T(t), e);
}
function Ce(t) {
  return ve(t, E, T);
}
var Ae = Object.prototype, Ee = Ae.hasOwnProperty;
function Le(t) {
  var e = t.length, r = new t.constructor(e);
  return e && typeof t[0] == "string" && Ee.call(t, "index") && (r.index = t.index, r.input = t.input), r;
}
function Ne(t, e) {
  var r = e ? Z(t.buffer) : t.buffer;
  return new t.constructor(r, t.byteOffset, t.byteLength);
}
var De = /\w*$/;
function Pe(t) {
  var e = new t.constructor(t.source, De.exec(t));
  return e.lastIndex = t.lastIndex, e;
}
var x = M ? M.prototype : void 0, B = x ? x.valueOf : void 0;
function Fe(t) {
  return B ? Object(B.call(t)) : {};
}
var Me = "[object Boolean]", Se = "[object Date]", xe = "[object Map]", Be = "[object Number]", Ie = "[object RegExp]", Ue = "[object Set]", ke = "[object String]", qe = "[object Symbol]", Ge = "[object ArrayBuffer]", Ze = "[object DataView]", $e = "[object Float32Array]", Ke = "[object Float64Array]", Re = "[object Int8Array]", Te = "[object Int16Array]", Ve = "[object Int32Array]", Xe = "[object Uint8Array]", ze = "[object Uint8ClampedArray]", He = "[object Uint16Array]", Je = "[object Uint32Array]";
function We(t, e, r) {
  var s = t.constructor;
  switch (e) {
    case Ge:
      return Z(t);
    case Me:
    case Se:
      return new s(+t);
    case Ze:
      return Ne(t, r);
    case $e:
    case Ke:
    case Re:
    case Te:
    case Ve:
    case Xe:
    case ze:
    case He:
    case Je:
      return oe(t, r);
    case xe:
      return new s();
    case Be:
    case ke:
      return new s(t);
    case Ie:
      return Pe(t);
    case Ue:
      return new s();
    case qe:
      return Fe(t);
  }
}
var Ye = "[object Map]";
function Qe(t) {
  return K(t) && A(t) == Ye;
}
var I = y && y.isMap, et = I ? $(I) : Qe, tt = "[object Set]";
function rt(t) {
  return K(t) && A(t) == tt;
}
var U = y && y.isSet, st = U ? $(U) : rt, nt = 1, it = 2, ot = 4, V = "[object Arguments]", at = "[object Array]", ut = "[object Boolean]", ht = "[object Date]", ct = "[object Error]", X = "[object Function]", dt = "[object GeneratorFunction]", lt = "[object Map]", _t = "[object Number]", z = "[object Object]", ft = "[object RegExp]", pt = "[object Set]", bt = "[object String]", gt = "[object Symbol]", vt = "[object WeakMap]", jt = "[object ArrayBuffer]", yt = "[object DataView]", mt = "[object Float32Array]", wt = "[object Float64Array]", Ot = "[object Int8Array]", Ct = "[object Int16Array]", At = "[object Int32Array]", Et = "[object Uint8Array]", Lt = "[object Uint8ClampedArray]", Nt = "[object Uint16Array]", Dt = "[object Uint32Array]", a = {};
a[V] = a[at] = a[jt] = a[yt] = a[ut] = a[ht] = a[mt] = a[wt] = a[Ot] = a[Ct] = a[At] = a[lt] = a[_t] = a[z] = a[ft] = a[pt] = a[bt] = a[gt] = a[Et] = a[Lt] = a[Nt] = a[Dt] = !0;
a[ct] = a[X] = a[vt] = !1;
function w(t, e, r, s, n, o) {
  var i, u = e & nt, h = e & it, J = e & ot;
  if (i !== void 0)
    return i;
  if (!Q(t))
    return t;
  var L = ie(t);
  if (L) {
    if (i = Le(t), !u)
      return ee(t, i);
  } else {
    var p = A(t), N = p == X || p == dt;
    if (te(t))
      return re(t, u);
    if (p == z || p == V || N && !n) {
      if (i = h || N ? {} : se(t), !u)
        return h ? Oe(t, ye(i, t)) : me(t, je(i, t));
    } else {
      if (!a[p])
        return n ? t : {};
      i = We(t, p, u);
    }
  }
  o || (o = new ne());
  var D = o.get(t);
  if (D)
    return D;
  o.set(t, i), st(t) ? t.forEach(function(d) {
    i.add(w(d, e, r, d, t, o));
  }) : et(t) && t.forEach(function(d, l) {
    i.set(l, w(d, e, r, l, t, o));
  });
  var W = J ? h ? Ce : pe : h ? E : c, P = L ? void 0 : W(t);
  return fe(P || t, function(d, l) {
    P && (l = d, d = t[l]), ue(i, l, w(d, e, r, l, t, o));
  }), i;
}
function Pt(t, e) {
  return _e(e, function(r) {
    return t[r];
  });
}
function O(t) {
  return t == null ? [] : Pt(t, c(t));
}
function b(t) {
  return t === void 0;
}
var Ft = Y(function(t) {
  return de(le(t, 1, he, !0));
}), Mt = "\0", f = "\0", k = "";
class H {
  /**
   * @param {GraphOptions} [opts] - Graph options.
   */
  constructor(e = {}) {
    this._isDirected = Object.prototype.hasOwnProperty.call(e, "directed") ? e.directed : !0, this._isMultigraph = Object.prototype.hasOwnProperty.call(e, "multigraph") ? e.multigraph : !1, this._isCompound = Object.prototype.hasOwnProperty.call(e, "compound") ? e.compound : !1, this._label = void 0, this._defaultNodeLabelFn = v(void 0), this._defaultEdgeLabelFn = v(void 0), this._nodes = {}, this._isCompound && (this._parent = {}, this._children = {}, this._children[f] = {}), 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(e) {
    return this._label = e, 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(e) {
    return F(e) || (e = v(e)), this._defaultNodeLabelFn = e, 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 c(this._nodes);
  }
  /**
   * @returns {NodeID[]} those nodes in the graph that have no in-edges.
   * @remarks Takes `O(|V|)` time.
   */
  sources() {
    var e = this;
    return j(this.nodes(), function(r) {
      return S(e._in[r]);
    });
  }
  /**
   * @returns {NodeID[]} those nodes in the graph that have no out-edges.
   * @remarks Takes `O(|V|)` time.
   */
  sinks() {
    var e = this;
    return j(this.nodes(), function(r) {
      return S(e._out[r]);
    });
  }
  /**
   * 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(e, r) {
    var s = arguments, n = this;
    return _(e, function(o) {
      s.length > 1 ? n.setNode(o, r) : n.setNode(o);
    }), 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(e, r) {
    return Object.prototype.hasOwnProperty.call(this._nodes, e) ? (arguments.length > 1 && (this._nodes[e] = r), this) : (this._nodes[e] = arguments.length > 1 ? r : this._defaultNodeLabelFn(e), this._isCompound && (this._parent[e] = f, this._children[e] = {}, this._children[f][e] = !0), this._in[e] = {}, this._preds[e] = {}, this._out[e] = {}, this._sucs[e] = {}, ++this._nodeCount, 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(e) {
    return this._nodes[e];
  }
  /**
   * 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(e) {
    return Object.prototype.hasOwnProperty.call(this._nodes, e);
  }
  /**
   * 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(e) {
    if (Object.prototype.hasOwnProperty.call(this._nodes, e)) {
      var r = (s) => this.removeEdge(this._edgeObjs[s]);
      delete this._nodes[e], this._isCompound && (this._removeFromParentsChildList(e), delete this._parent[e], _(this.children(e), (s) => {
        this.setParent(s);
      }), delete this._children[e]), _(c(this._in[e]), r), delete this._in[e], delete this._preds[e], _(c(this._out[e]), r), delete this._out[e], delete this._sucs[e], --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(e, r) {
    if (!this._isCompound)
      throw new Error("Cannot set parent in a non-compound graph");
    if (b(r))
      r = f;
    else {
      r += "";
      for (var s = r; !b(s); s = this.parent(s))
        if (s === e)
          throw new Error("Setting " + r + " as parent of " + e + " would create a cycle");
      this.setNode(r);
    }
    return this.setNode(e), this._removeFromParentsChildList(e), this._parent[e] = r, this._children[r][e] = !0, this;
  }
  /**
   * @private
   * @param {NodeID | number} v - Node ID.
   */
  _removeFromParentsChildList(e) {
    delete this._children[this._parent[e]][e];
  }
  /**
   * 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(e) {
    if (this._isCompound) {
      var r = this._parent[e];
      if (r !== f)
        return r;
    }
  }
  /**
   * 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(e) {
    if (b(e) && (e = f), this._isCompound) {
      var r = this._children[e];
      if (r)
        return c(r);
    } else {
      if (e === f)
        return this.nodes();
      if (this.hasNode(e))
        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(e) {
    var r = this._preds[e];
    if (r)
      return c(r);
  }
  /**
   * @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(e) {
    var r = this._sucs[e];
    if (r)
      return c(r);
  }
  /**
   * @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(e) {
    var r = this.predecessors(e);
    if (r)
      return Ft(r, this.successors(e));
  }
  /**
   * @param {NodeID | number} v - Node ID.
   * @returns {boolean} True if the node is a leaf (has no successors), false otherwise.
   */
  isLeaf(e) {
    var r;
    return this.isDirected() ? r = this.successors(e) : r = this.neighbors(e), r.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(e) {
    var r = new this.constructor({
      directed: this._isDirected,
      multigraph: this._isMultigraph,
      compound: this._isCompound
    });
    r.setGraph(this.graph());
    var s = this;
    _(this._nodes, function(i, u) {
      e(u) && r.setNode(u, i);
    }), _(this._edgeObjs, function(i) {
      r.hasNode(i.v) && r.hasNode(i.w) && r.setEdge(i, s.edge(i));
    });
    var n = {};
    function o(i) {
      var u = s.parent(i);
      return u === void 0 || r.hasNode(u) ? (n[i] = u, u) : u in n ? n[u] : o(u);
    }
    return this._isCompound && _(r.nodes(), function(i) {
      r.setParent(i, o(i));
    }), r;
  }
  /* === 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(e) {
    return F(e) || (e = v(e)), this._defaultEdgeLabelFn = e, 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 O(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(e, r) {
    var s = this, n = arguments;
    return ce(e, function(o, i) {
      return n.length > 1 ? s.setEdge(o, i, r) : s.setEdge(o, i), i;
    }), 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 e, r, s, n, o = !1, i = arguments[0];
    typeof i == "object" && i !== null && "v" in i ? (e = i.v, r = i.w, s = i.name, arguments.length === 2 && (n = arguments[1], o = !0)) : (e = i, r = arguments[1], s = arguments[3], arguments.length > 2 && (n = arguments[2], o = !0)), e = "" + e, r = "" + r, b(s) || (s = "" + s);
    var u = g(this._isDirected, e, r, s);
    if (Object.prototype.hasOwnProperty.call(this._edgeLabels, u))
      return o && (this._edgeLabels[u] = n), this;
    if (!b(s) && !this._isMultigraph)
      throw new Error("Cannot set a named edge when isMultigraph = false");
    this.setNode(e), this.setNode(r), this._edgeLabels[u] = o ? n : this._defaultEdgeLabelFn(e, r, s);
    var h = St(this._isDirected, e, r, s);
    return e = h.v, r = h.w, Object.freeze(h), this._edgeObjs[u] = h, q(this._preds[r], e), q(this._sucs[e], r), this._in[r][u] = h, this._out[e][u] = h, this._edgeCount++, 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(e, r, s) {
    var n = arguments.length === 1 ? C(this._isDirected, arguments[0]) : g(this._isDirected, e, r, s);
    return this._edgeLabels[n];
  }
  /**
   * 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(e, r, s) {
    var n = arguments.length === 1 ? C(this._isDirected, arguments[0]) : g(this._isDirected, e, r, s);
    return Object.prototype.hasOwnProperty.call(this._edgeLabels, n);
  }
  /**
   * 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(e, r, s) {
    var n = arguments.length === 1 ? C(this._isDirected, arguments[0]) : g(this._isDirected, e, r, s), o = this._edgeObjs[n];
    return o && (e = o.v, r = o.w, delete this._edgeLabels[n], delete this._edgeObjs[n], G(this._preds[r], e), G(this._sucs[e], r), delete this._in[r][n], delete this._out[e][n], this._edgeCount--), 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(e, r) {
    var s = this._in[e];
    if (s) {
      var n = O(s);
      return r ? j(n, function(o) {
        return o.v === r;
      }) : n;
    }
  }
  /**
   * @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(e, r) {
    var s = this._out[e];
    if (s) {
      var n = O(s);
      return r ? j(n, function(o) {
        return o.w === r;
      }) : n;
    }
  }
  /**
   * @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(e, r) {
    var s = this.inEdges(e, r);
    if (s)
      return s.concat(this.outEdges(e, r));
  }
}
H.prototype._nodeCount = 0;
H.prototype._edgeCount = 0;
function q(t, e) {
  t[e] ? t[e]++ : t[e] = 1;
}
function G(t, e) {
  --t[e] || delete t[e];
}
function g(t, e, r, s) {
  var n = "" + e, o = "" + r;
  if (!t && n > o) {
    var i = n;
    n = o, o = i;
  }
  return n + k + o + k + (b(s) ? Mt : s);
}
function St(t, e, r, s) {
  var n = "" + e, o = "" + r;
  if (!t && n > o) {
    var i = n;
    n = o, o = i;
  }
  var u = { v: n, w: o };
  return s && (u.name = s), u;
}
function C(t, e) {
  return g(t, e.v, e.w, e.name);
}
export {
  O as A,
  w as O,
  H as Z,
  b as _
};
