@dagrejs/dagre 1.1.0 → 1.1.2

package/dist/dagre.min.js

@@ -207,7 +207,7 @@ let cc=0;southEntries.forEach(entry=>{let index=entry.pos+firstIndex;tree[index]
  *
  *    1. Graph nodes will have an "order" attribute based on the results of the
  *       algorithm.
- */function order(g){let maxRank=util.maxRank(g),downLayerGraphs=buildLayerGraphs(g,util.range(1,maxRank+1),"inEdges"),upLayerGraphs=buildLayerGraphs(g,util.range(maxRank-1,-1,-1),"outEdges");let layering=initOrder(g);assignOrder(g,layering);let bestCC=Number.POSITIVE_INFINITY,best;for(let i=0,lastBest=0;lastBest<4;++i,++lastBest){sweepLayerGraphs(i%2?downLayerGraphs:upLayerGraphs,i%4>=2);layering=util.buildLayerMatrix(g);let cc=crossCount(g,layering);if(cc<bestCC){lastBest=0;best=Object.assign({},layering);bestCC=cc}}assignOrder(g,best)}function buildLayerGraphs(g,ranks,relationship){return ranks.map(function(rank){return buildLayerGraph(g,rank,relationship)})}function sweepLayerGraphs(layerGraphs,biasRight){let cg=new Graph;layerGraphs.forEach(function(lg){let root=lg.graph().root;let sorted=sortSubgraph(lg,root,cg,biasRight);sorted.vs.forEach((v,i)=>lg.node(v).order=i);addSubgraphConstraints(lg,cg,sorted.vs)})}function assignOrder(g,layering){Object.values(layering).forEach(layer=>layer.forEach((v,i)=>g.node(v).order=i))}},{"../util":27,"./add-subgraph-constraints":11,"./build-layer-graph":13,"./cross-count":14,"./init-order":16,"./sort-subgraph":18,"@dagrejs/graphlib":29}],16:[function(require,module,exports){"use strict";let util=require("../util");module.exports=initOrder;
+ */function order(g,opts){if(opts&&typeof opts.customOrder==="function"){opts.customOrder(g,order);return}let maxRank=util.maxRank(g),downLayerGraphs=buildLayerGraphs(g,util.range(1,maxRank+1),"inEdges"),upLayerGraphs=buildLayerGraphs(g,util.range(maxRank-1,-1,-1),"outEdges");let layering=initOrder(g);assignOrder(g,layering);if(opts&&opts.disableOptimalOrderHeuristic){return}let bestCC=Number.POSITIVE_INFINITY,best;for(let i=0,lastBest=0;lastBest<4;++i,++lastBest){sweepLayerGraphs(i%2?downLayerGraphs:upLayerGraphs,i%4>=2);layering=util.buildLayerMatrix(g);let cc=crossCount(g,layering);if(cc<bestCC){lastBest=0;best=Object.assign({},layering);bestCC=cc}}assignOrder(g,best)}function buildLayerGraphs(g,ranks,relationship){return ranks.map(function(rank){return buildLayerGraph(g,rank,relationship)})}function sweepLayerGraphs(layerGraphs,biasRight){let cg=new Graph;layerGraphs.forEach(function(lg){let root=lg.graph().root;let sorted=sortSubgraph(lg,root,cg,biasRight);sorted.vs.forEach((v,i)=>lg.node(v).order=i);addSubgraphConstraints(lg,cg,sorted.vs)})}function assignOrder(g,layering){Object.values(layering).forEach(layer=>layer.forEach((v,i)=>g.node(v).order=i))}},{"../util":27,"./add-subgraph-constraints":11,"./build-layer-graph":13,"./cross-count":14,"./init-order":16,"./sort-subgraph":18,"@dagrejs/graphlib":29}],16:[function(require,module,exports){"use strict";let util=require("../util");module.exports=initOrder;
 /*
  * Assigns an initial order value for each node by performing a DFS search
  * starting from nodes in the first rank. Nodes are assigned an order in their
@@ -277,7 +277,7 @@ parent=w;while((parent=g.parent(parent))!==lca){wPath.push(parent)}return{path:v
 k0=0,
 // Tracks the last node in this layer scanned for crossings with a type-1
 // segment.
-scanPos=0,prevLayerLength=prevLayer.length,lastNode=layer[layer.length-1];layer.forEach((v,i)=>{let w=findOtherInnerSegmentNode(g,v),k1=w?g.node(w).order:prevLayerLength;if(w||v===lastNode){layer.slice(scanPos,i+1).forEach(scanNode=>{g.predecessors(scanNode).forEach(u=>{let uLabel=g.node(u),uPos=uLabel.order;if((uPos<k0||k1<uPos)&&!(uLabel.dummy&&g.node(scanNode).dummy)){addConflict(conflicts,u,scanNode)}})});scanPos=i+1;k0=k1}});return layer}layering.reduce(visitLayer);return conflicts}function findType2Conflicts(g,layering){let conflicts={};function scan(south,southPos,southEnd,prevNorthBorder,nextNorthBorder){let v;util.range(southPos,southEnd).forEach(i=>{v=south[i];if(g.node(v).dummy){g.predecessors(v).forEach(u=>{let uNode=g.node(u);if(uNode.dummy&&(uNode.order<prevNorthBorder||uNode.order>nextNorthBorder)){addConflict(conflicts,u,v)}})}})}function visitLayer(north,south){let prevNorthPos=-1,nextNorthPos,southPos=0;south.forEach((v,southLookahead)=>{if(g.node(v).dummy==="border"){let predecessors=g.predecessors(v);if(predecessors.length){nextNorthPos=g.node(predecessors[0]).order;scan(south,southPos,southLookahead,prevNorthPos,nextNorthPos);southPos=southLookahead;prevNorthPos=nextNorthPos}}scan(south,southPos,south.length,nextNorthPos,north.length)});return south}layering.reduce(visitLayer);return conflicts}function findOtherInnerSegmentNode(g,v){if(g.node(v).dummy){return g.predecessors(v).find(u=>g.node(u).dummy)}}function addConflict(conflicts,v,w){if(v>w){let tmp=v;v=w;w=tmp}let conflictsV=conflicts[v];if(!conflictsV){conflicts[v]=conflictsV={}}conflictsV[w]=true}function hasConflict(conflicts,v,w){if(v>w){let tmp=v;v=w;w=tmp}return!!conflicts[v]&&conflicts[v].hasOwnProperty(w)}
+scanPos=0,prevLayerLength=prevLayer.length,lastNode=layer[layer.length-1];layer.forEach((v,i)=>{let w=findOtherInnerSegmentNode(g,v),k1=w?g.node(w).order:prevLayerLength;if(w||v===lastNode){layer.slice(scanPos,i+1).forEach(scanNode=>{g.predecessors(scanNode).forEach(u=>{let uLabel=g.node(u),uPos=uLabel.order;if((uPos<k0||k1<uPos)&&!(uLabel.dummy&&g.node(scanNode).dummy)){addConflict(conflicts,u,scanNode)}})});scanPos=i+1;k0=k1}});return layer}layering.length&&layering.reduce(visitLayer);return conflicts}function findType2Conflicts(g,layering){let conflicts={};function scan(south,southPos,southEnd,prevNorthBorder,nextNorthBorder){let v;util.range(southPos,southEnd).forEach(i=>{v=south[i];if(g.node(v).dummy){g.predecessors(v).forEach(u=>{let uNode=g.node(u);if(uNode.dummy&&(uNode.order<prevNorthBorder||uNode.order>nextNorthBorder)){addConflict(conflicts,u,v)}})}})}function visitLayer(north,south){let prevNorthPos=-1,nextNorthPos,southPos=0;south.forEach((v,southLookahead)=>{if(g.node(v).dummy==="border"){let predecessors=g.predecessors(v);if(predecessors.length){nextNorthPos=g.node(predecessors[0]).order;scan(south,southPos,southLookahead,prevNorthPos,nextNorthPos);southPos=southLookahead;prevNorthPos=nextNorthPos}}scan(south,southPos,south.length,nextNorthPos,north.length)});return south}layering.length&&layering.reduce(visitLayer);return conflicts}function findOtherInnerSegmentNode(g,v){if(g.node(v).dummy){return g.predecessors(v).find(u=>g.node(u).dummy)}}function addConflict(conflicts,v,w){if(v>w){let tmp=v;v=w;w=tmp}let conflictsV=conflicts[v];if(!conflictsV){conflicts[v]=conflictsV={}}conflictsV[w]=true}function hasConflict(conflicts,v,w){if(v>w){let tmp=v;v=w;w=tmp}return!!conflicts[v]&&conflicts[v].hasOwnProperty(w)}
 /*
  * Try to align nodes into vertical "blocks" where possible. This algorithm
  * attempts to align a node with one of its median neighbors. If the edge
@@ -495,7 +495,7 @@ let offset=Math.min(...g.nodes().map(v=>g.node(v).rank));let layers=[];g.nodes()
 /*
  * Returns a new function that wraps `fn` with a timer. The wrapper logs the
  * time it takes to execute the function.
- */function time(name,fn){let start=Date.now();try{return fn()}finally{console.log(name+" time: "+(Date.now()-start)+"ms")}}function notime(name,fn){return fn()}let idCounter=0;function uniqueId(prefix){var id=++idCounter;return toString(prefix)+id}function range(start,limit,step=1){if(limit==null){limit=start;start=0}let endCon=i=>i<limit;if(step<0){endCon=i=>limit<i}const range=[];for(let i=start;endCon(i);i+=step){range.push(i)}return range}function pick(source,keys){const dest={};for(const key of keys){if(source[key]!==undefined){dest[key]=source[key]}}return dest}function mapValues(obj,funcOrProp){let func=funcOrProp;if(typeof funcOrProp==="string"){func=val=>val[funcOrProp]}return Object.entries(obj).reduce((acc,[k,v])=>{acc[k]=func(v,k);return acc},{})}function zipObject(props,values){return props.reduce((acc,key,i)=>{acc[key]=values[i];return acc},{})}},{"@dagrejs/graphlib":29}],28:[function(require,module,exports){module.exports="1.0.4"},{}],29:[function(require,module,exports){
+ */function time(name,fn){let start=Date.now();try{return fn()}finally{console.log(name+" time: "+(Date.now()-start)+"ms")}}function notime(name,fn){return fn()}let idCounter=0;function uniqueId(prefix){var id=++idCounter;return toString(prefix)+id}function range(start,limit,step=1){if(limit==null){limit=start;start=0}let endCon=i=>i<limit;if(step<0){endCon=i=>limit<i}const range=[];for(let i=start;endCon(i);i+=step){range.push(i)}return range}function pick(source,keys){const dest={};for(const key of keys){if(source[key]!==undefined){dest[key]=source[key]}}return dest}function mapValues(obj,funcOrProp){let func=funcOrProp;if(typeof funcOrProp==="string"){func=val=>val[funcOrProp]}return Object.entries(obj).reduce((acc,[k,v])=>{acc[k]=func(v,k);return acc},{})}function zipObject(props,values){return props.reduce((acc,key,i)=>{acc[key]=values[i];return acc},{})}},{"@dagrejs/graphlib":29}],28:[function(require,module,exports){module.exports="1.1.2"},{}],29:[function(require,module,exports){
 /**
  * Copyright (c) 2014, Chris Pettitt
  * All rights reserved.
@@ -544,26 +544,26 @@ var results=[];function dfs(v){var entry=visited[v]={onStack:true,lowlink:index,
  * the queue. Adding and removing elements takes O(log n) time. A key can
  * have its priority decreased in O(log n) time.
  */
-class PriorityQueue{#arr=[];#keyIndices={};
+class PriorityQueue{_arr=[];_keyIndices={};
 /**
    * Returns the number of elements in the queue. Takes `O(1)` time.
-   */size(){return this.#arr.length}
+   */size(){return this._arr.length}
 /**
    * Returns the keys that are in the queue. Takes `O(n)` time.
-   */keys(){return this.#arr.map(function(x){return x.key})}
+   */keys(){return this._arr.map(function(x){return x.key})}
 /**
    * Returns `true` if **key** is in the queue and `false` if not.
-   */has(key){return this.#keyIndices.hasOwnProperty(key)}
+   */has(key){return this._keyIndices.hasOwnProperty(key)}
 /**
    * Returns the priority for **key**. If **key** is not present in the queue
    * then this function returns `undefined`. Takes `O(1)` time.
    *
    * @param {Object} key
-   */priority(key){var index=this.#keyIndices[key];if(index!==undefined){return this.#arr[index].priority}}
+   */priority(key){var index=this._keyIndices[key];if(index!==undefined){return this._arr[index].priority}}
 /**
    * Returns the key for the minimum element in this queue. If the queue is
    * empty this function throws an Error. Takes `O(1)` time.
-   */min(){if(this.size()===0){throw new Error("Queue underflow")}return this.#arr[0].key}
+   */min(){if(this.size()===0){throw new Error("Queue underflow")}return this._arr[0].key}
 /**
    * Inserts a new key into the priority queue. If the key already exists in
    * the queue this function returns `false`; otherwise it will return `true`.
@@ -571,17 +571,17 @@ class PriorityQueue{#arr=[];#keyIndices={};
    *
    * @param {Object} key the key to add
    * @param {Number} priority the initial priority for the key
-   */add(key,priority){var keyIndices=this.#keyIndices;key=String(key);if(!keyIndices.hasOwnProperty(key)){var arr=this.#arr;var index=arr.length;keyIndices[key]=index;arr.push({key:key,priority:priority});this.#decrease(index);return true}return false}
+   */add(key,priority){var keyIndices=this._keyIndices;key=String(key);if(!keyIndices.hasOwnProperty(key)){var arr=this._arr;var index=arr.length;keyIndices[key]=index;arr.push({key:key,priority:priority});this._decrease(index);return true}return false}
 /**
    * Removes and returns the smallest key in the queue. Takes `O(log n)` time.
-   */removeMin(){this.#swap(0,this.#arr.length-1);var min=this.#arr.pop();delete this.#keyIndices[min.key];this.#heapify(0);return min.key}
+   */removeMin(){this._swap(0,this._arr.length-1);var min=this._arr.pop();delete this._keyIndices[min.key];this._heapify(0);return min.key}
 /**
    * Decreases the priority for **key** to **priority**. If the new priority is
    * greater than the previous priority, this function will throw an Error.
    *
    * @param {Object} key the key for which to raise priority
    * @param {Number} priority the new priority for the key
-   */decrease(key,priority){var index=this.#keyIndices[key];if(priority>this.#arr[index].priority){throw new Error("New priority is greater than current priority. "+"Key: "+key+" Old: "+this.#arr[index].priority+" New: "+priority)}this.#arr[index].priority=priority;this.#decrease(index)}#heapify(i){var arr=this.#arr;var l=2*i;var r=l+1;var largest=i;if(l<arr.length){largest=arr[l].priority<arr[largest].priority?l:largest;if(r<arr.length){largest=arr[r].priority<arr[largest].priority?r:largest}if(largest!==i){this.#swap(i,largest);this.#heapify(largest)}}}#decrease(index){var arr=this.#arr;var priority=arr[index].priority;var parent;while(index!==0){parent=index>>1;if(arr[parent].priority<priority){break}this.#swap(index,parent);index=parent}}#swap(i,j){var arr=this.#arr;var keyIndices=this.#keyIndices;var origArrI=arr[i];var origArrJ=arr[j];arr[i]=origArrJ;arr[j]=origArrI;keyIndices[origArrJ.key]=i;keyIndices[origArrI.key]=j}}module.exports=PriorityQueue},{}],44:[function(require,module,exports){"use strict";var DEFAULT_EDGE_NAME="\0";var GRAPH_NODE="\0";var EDGE_KEY_DELIM="
";
+   */decrease(key,priority){var index=this._keyIndices[key];if(priority>this._arr[index].priority){throw new Error("New priority is greater than current priority. "+"Key: "+key+" Old: "+this._arr[index].priority+" New: "+priority)}this._arr[index].priority=priority;this._decrease(index)}_heapify(i){var arr=this._arr;var l=2*i;var r=l+1;var largest=i;if(l<arr.length){largest=arr[l].priority<arr[largest].priority?l:largest;if(r<arr.length){largest=arr[r].priority<arr[largest].priority?r:largest}if(largest!==i){this._swap(i,largest);this._heapify(largest)}}}_decrease(index){var arr=this._arr;var priority=arr[index].priority;var parent;while(index!==0){parent=index>>1;if(arr[parent].priority<priority){break}this._swap(index,parent);index=parent}}_swap(i,j){var arr=this._arr;var keyIndices=this._keyIndices;var origArrI=arr[i];var origArrJ=arr[j];arr[i]=origArrJ;arr[j]=origArrI;keyIndices[origArrJ.key]=i;keyIndices[origArrI.key]=j}}module.exports=PriorityQueue},{}],44:[function(require,module,exports){"use strict";var DEFAULT_EDGE_NAME="\0";var GRAPH_NODE="\0";var EDGE_KEY_DELIM="
";
 // Implementation notes:
 //
 //  * Node id query functions should return string ids for the nodes
@@ -591,49 +591,49 @@ class PriorityQueue{#arr=[];#keyIndices={};
 //    reference edges. This is because we need a performant way to look these
 //    edges up and, object properties, which have string keys, are the closest
 //    we're going to get to a performant hashtable in JavaScript.
-class Graph{#isDirected=true;#isMultigraph=false;#isCompound=false;
+class Graph{_isDirected=true;_isMultigraph=false;_isCompound=false;
 // Label for the graph itself
-#label;
+_label;
 // Defaults to be set when creating a new node
-#defaultNodeLabelFn=()=>undefined;
+_defaultNodeLabelFn=()=>undefined;
 // Defaults to be set when creating a new edge
-#defaultEdgeLabelFn=()=>undefined;
+_defaultEdgeLabelFn=()=>undefined;
 // v -> label
-#nodes={};
+_nodes={};
 // v -> edgeObj
-#in={};
+_in={};
 // u -> v -> Number
-#preds={};
+_preds={};
 // v -> edgeObj
-#out={};
+_out={};
 // v -> w -> Number
-#sucs={};
+_sucs={};
 // e -> edgeObj
-#edgeObjs={};
+_edgeObjs={};
 // e -> label
-#edgeLabels={};
-/* Number of nodes in the graph. Should only be changed by the implementation. */#nodeCount=0;
-/* Number of edges in the graph. Should only be changed by the implementation. */#edgeCount=0;#parent;#children;constructor(opts){if(opts){this.#isDirected=opts.hasOwnProperty("directed")?opts.directed:true;this.#isMultigraph=opts.hasOwnProperty("multigraph")?opts.multigraph:false;this.#isCompound=opts.hasOwnProperty("compound")?opts.compound:false}if(this.#isCompound){
+_edgeLabels={};
+/* Number of nodes in the graph. Should only be changed by the implementation. */_nodeCount=0;
+/* Number of edges in the graph. Should only be changed by the implementation. */_edgeCount=0;_parent;_children;constructor(opts){if(opts){this._isDirected=opts.hasOwnProperty("directed")?opts.directed:true;this._isMultigraph=opts.hasOwnProperty("multigraph")?opts.multigraph:false;this._isCompound=opts.hasOwnProperty("compound")?opts.compound:false}if(this._isCompound){
 // v -> parent
-this.#parent={};
+this._parent={};
 // v -> children
-this.#children={};this.#children[GRAPH_NODE]={}}}
+this._children={};this._children[GRAPH_NODE]={}}}
 /* === Graph functions ========= */
 /**
    * Whether graph was created with 'directed' flag set to true or not.
-   */isDirected(){return this.#isDirected}
+   */isDirected(){return this._isDirected}
 /**
    * Whether graph was created with 'multigraph' flag set to true or not.
-   */isMultigraph(){return this.#isMultigraph}
+   */isMultigraph(){return this._isMultigraph}
 /**
    * Whether graph was created with 'compound' flag set to true or not.
-   */isCompound(){return this.#isCompound}
+   */isCompound(){return this._isCompound}
 /**
    * Sets the label of the graph.
-   */setGraph(label){this.#label=label;return this}
+   */setGraph(label){this._label=label;return this}
 /**
    * Gets the graph label.
-   */graph(){return this.#label}
+   */graph(){return this._label}
 /* === Node functions ========== */
 /**
    * Sets the default node label. If newDefault is a function, it will be
@@ -641,24 +641,24 @@ this.#children={};this.#children[GRAPH_NODE]={}}}
    * will be assigned as default label in case if no label was specified while
    * setting a node.
    * Complexity: O(1).
-   */setDefaultNodeLabel(newDefault){this.#defaultNodeLabelFn=newDefault;if(typeof newDefault!=="function"){this.#defaultNodeLabelFn=()=>newDefault}return this}
+   */setDefaultNodeLabel(newDefault){this._defaultNodeLabelFn=newDefault;if(typeof newDefault!=="function"){this._defaultNodeLabelFn=()=>newDefault}return this}
 /**
    * Gets the number of nodes in the graph.
    * Complexity: O(1).
-   */nodeCount(){return this.#nodeCount}
+   */nodeCount(){return this._nodeCount}
 /**
    * Gets all nodes of the graph. Note, the in case of compound graph subnodes are
    * not included in list.
    * Complexity: O(1).
-   */nodes(){return Object.keys(this.#nodes)}
+   */nodes(){return Object.keys(this._nodes)}
 /**
    * Gets list of nodes without in-edges.
    * Complexity: O(|V|).
-   */sources(){var self=this;return this.nodes().filter(v=>Object.keys(self.#in[v]).length===0)}
+   */sources(){var self=this;return this.nodes().filter(v=>Object.keys(self._in[v]).length===0)}
 /**
    * Gets list of nodes without out-edges.
    * Complexity: O(|V|).
-   */sinks(){var self=this;return this.nodes().filter(v=>Object.keys(self.#out[v]).length===0)}
+   */sinks(){var self=this;return this.nodes().filter(v=>Object.keys(self._out[v]).length===0)}
 /**
    * Invokes setNode method for each node in names list.
    * Complexity: O(|names|).
@@ -668,46 +668,46 @@ this.#children={};this.#children[GRAPH_NODE]={}}}
    * it is set as the value for the node. If label is not supplied and the node was
    * created by this call then the default node label will be assigned.
    * Complexity: O(1).
-   */setNode(v,value){if(this.#nodes.hasOwnProperty(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}
+   */setNode(v,value){if(this._nodes.hasOwnProperty(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.
    * Complexity: O(|V|).
-   */node(v){return this.#nodes[v]}
+   */node(v){return this._nodes[v]}
 /**
    * Detects whether graph has a node with specified name or not.
-   */hasNode(v){return this.#nodes.hasOwnProperty(v)}
+   */hasNode(v){return this._nodes.hasOwnProperty(v)}
 /**
    * Remove the node with the name from 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.
    * Complexity: O(1).
-   */removeNode(v){var self=this;if(this.#nodes.hasOwnProperty(v)){var removeEdge=e=>self.removeEdge(self.#edgeObjs[e]);delete this.#nodes[v];if(this.#isCompound){this.#removeFromParentsChildList(v);delete this.#parent[v];this.children(v).forEach(function(child){self.setParent(child)});delete this.#children[v]}Object.keys(this.#in[v]).forEach(removeEdge);delete this.#in[v];delete this.#preds[v];Object.keys(this.#out[v]).forEach(removeEdge);delete this.#out[v];delete this.#sucs[v];--this.#nodeCount}return this}
+   */removeNode(v){var self=this;if(this._nodes.hasOwnProperty(v)){var removeEdge=e=>self.removeEdge(self._edgeObjs[e]);delete this._nodes[v];if(this._isCompound){this._removeFromParentsChildList(v);delete this._parent[v];this.children(v).forEach(function(child){self.setParent(child)});delete this._children[v]}Object.keys(this._in[v]).forEach(removeEdge);delete this._in[v];delete this._preds[v];Object.keys(this._out[v]).forEach(removeEdge);delete this._out[v];delete this._sucs[v];--this._nodeCount}return this}
 /**
    * Sets node p as a parent for node v if it is defined, or removes the
    * parent for v if p is undefined. Method throws an exception in case of
    * invoking it in context of noncompound graph.
    * Average-case complexity: O(1).
-   */setParent(v,parent){if(!this.#isCompound){throw new Error("Cannot set parent in a non-compound graph")}if(parent===undefined){parent=GRAPH_NODE}else{
+   */setParent(v,parent){if(!this._isCompound){throw new Error("Cannot set parent in a non-compound graph")}if(parent===undefined){parent=GRAPH_NODE}else{
 // Coerce parent to string
-parent+="";for(var ancestor=parent;ancestor!==undefined;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}#removeFromParentsChildList(v){delete this.#children[this.#parent[v]][v]}
+parent+="";for(var ancestor=parent;ancestor!==undefined;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}_removeFromParentsChildList(v){delete this._children[this._parent[v]][v]}
 /**
    * Gets parent node for node v.
    * Complexity: O(1).
-   */parent(v){if(this.#isCompound){var parent=this.#parent[v];if(parent!==GRAPH_NODE){return parent}}}
+   */parent(v){if(this._isCompound){var parent=this._parent[v];if(parent!==GRAPH_NODE){return parent}}}
 /**
    * Gets list of direct children of node v.
    * Complexity: O(1).
-   */children(v=GRAPH_NODE){if(this.#isCompound){var children=this.#children[v];if(children){return Object.keys(children)}}else if(v===GRAPH_NODE){return this.nodes()}else if(this.hasNode(v)){return[]}}
+   */children(v=GRAPH_NODE){if(this._isCompound){var children=this._children[v];if(children){return Object.keys(children)}}else if(v===GRAPH_NODE){return this.nodes()}else if(this.hasNode(v)){return[]}}
 /**
    * Return all nodes that are predecessors of the specified node or undefined if node v is not in
    * the graph. Behavior is undefined for undirected graphs - use neighbors instead.
    * Complexity: O(|V|).
-   */predecessors(v){var predsV=this.#preds[v];if(predsV){return Object.keys(predsV)}}
+   */predecessors(v){var predsV=this._preds[v];if(predsV){return Object.keys(predsV)}}
 /**
    * Return all nodes that are successors of the specified node or undefined if node v is not in
    * the graph. Behavior is undefined for undirected graphs - use neighbors instead.
    * Complexity: O(|V|).
-   */successors(v){var sucsV=this.#sucs[v];if(sucsV){return Object.keys(sucsV)}}
+   */successors(v){var sucsV=this._sucs[v];if(sucsV){return Object.keys(sucsV)}}
 /**
    * Return all nodes that are predecessors or successors of the specified node or undefined if
    * node v is not in the graph.
@@ -718,7 +718,7 @@ parent+="";for(var ancestor=parent;ancestor!==undefined;ancestor=this.parent(anc
    * are also removed. In case of compound graph, if parent is rejected by filter,
    * than all its children are rejected too.
    * Average-case complexity: O(|E|+|V|).
-   */filterNodes(filter){var copy=new this.constructor({directed:this.#isDirected,multigraph:this.#isMultigraph,compound:this.#isCompound});copy.setGraph(this.graph());var self=this;Object.entries(this.#nodes).forEach(function([v,value]){if(filter(v)){copy.setNode(v,value)}});Object.values(this.#edgeObjs).forEach(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===undefined||copy.hasNode(parent)){parents[v]=parent;return parent}else if(parent in parents){return parents[parent]}else{return findParent(parent)}}if(this.#isCompound){copy.nodes().forEach(v=>copy.setParent(v,findParent(v)))}return copy}
+   */filterNodes(filter){var copy=new this.constructor({directed:this._isDirected,multigraph:this._isMultigraph,compound:this._isCompound});copy.setGraph(this.graph());var self=this;Object.entries(this._nodes).forEach(function([v,value]){if(filter(v)){copy.setNode(v,value)}});Object.values(this._edgeObjs).forEach(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===undefined||copy.hasNode(parent)){parents[v]=parent;return parent}else if(parent in parents){return parents[parent]}else{return findParent(parent)}}if(this._isCompound){copy.nodes().forEach(v=>copy.setParent(v,findParent(v)))}return copy}
 /* === Edge functions ========== */
 /**
    * Sets the default edge label or factory function. This label will be
@@ -726,15 +726,15 @@ parent+="";for(var ancestor=parent;ancestor!==undefined;ancestor=this.parent(anc
    * an edge or this function will be invoked each time when setting an edge
    * with no label specified and returned value * will be used as a label for edge.
    * Complexity: O(1).
-   */setDefaultEdgeLabel(newDefault){this.#defaultEdgeLabelFn=newDefault;if(typeof newDefault!=="function"){this.#defaultEdgeLabelFn=()=>newDefault}return this}
+   */setDefaultEdgeLabel(newDefault){this._defaultEdgeLabelFn=newDefault;if(typeof newDefault!=="function"){this._defaultEdgeLabelFn=()=>newDefault}return this}
 /**
    * Gets the number of edges in the graph.
    * Complexity: O(1).
-   */edgeCount(){return this.#edgeCount}
+   */edgeCount(){return this._edgeCount}
 /**
    * Gets edges of the graph. In case of compound graph subgraphs are not considered.
    * Complexity: O(|E|).
-   */edges(){return Object.values(this.#edgeObjs)}
+   */edges(){return Object.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
@@ -746,16 +746,16 @@ parent+="";for(var ancestor=parent;ancestor!==undefined;ancestor=this.parent(anc
    * name. If label is supplied it is set as the value for the edge. If label is not
    * supplied and the edge was created by this call then the default edge label will
    * be assigned. The name parameter is only useful with multigraphs.
-   */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(name!==undefined){name=""+name}var e=edgeArgsToId(this.#isDirected,v,w,name);if(this.#edgeLabels.hasOwnProperty(e)){if(valueSpecified){this.#edgeLabels[e]=value}return this}if(name!==undefined&&!this.#isMultigraph){throw new Error("Cannot set a named edge when isMultigraph = false")}
+   */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(name!==undefined){name=""+name}var e=edgeArgsToId(this._isDirected,v,w,name);if(this._edgeLabels.hasOwnProperty(e)){if(valueSpecified){this._edgeLabels[e]=value}return this}if(name!==undefined&&!this._isMultigraph){throw new Error("Cannot set a named edge when isMultigraph = false")}
 // It didn't exist, so we need to create it.
 // First ensure the nodes exist.
-this.setNode(v);this.setNode(w);this.#edgeLabels[e]=valueSpecified?value:this.#defaultEdgeLabelFn(v,w,name);var edgeObj=edgeArgsToObj(this.#isDirected,v,w,name);
+this.setNode(v);this.setNode(w);this._edgeLabels[e]=valueSpecified?value:this._defaultEdgeLabelFn(v,w,name);var edgeObj=edgeArgsToObj(this._isDirected,v,w,name);
 // Ensure we add undirected edges in a consistent way.
-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}
+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.
    * Complexity: O(1).
-   */edge(v,w,name){var e=arguments.length===1?edgeObjToId(this.#isDirected,arguments[0]):edgeArgsToId(this.#isDirected,v,w,name);return this.#edgeLabels[e]}
+   */edge(v,w,name){var e=arguments.length===1?edgeObjToId(this._isDirected,arguments[0]):edgeArgsToId(this._isDirected,v,w,name);return this._edgeLabels[e]}
 /**
    * Gets the label for the specified edge and converts it to an object.
    * Complexity: O(1)
@@ -763,21 +763,21 @@ v=edgeObj.v;w=edgeObj.w;Object.freeze(edgeObj);this.#edgeObjs[e]=edgeObj;increme
 /**
    * Detects whether the graph contains specified edge or not. No subgraphs are considered.
    * Complexity: O(1).
-   */hasEdge(v,w,name){var e=arguments.length===1?edgeObjToId(this.#isDirected,arguments[0]):edgeArgsToId(this.#isDirected,v,w,name);return this.#edgeLabels.hasOwnProperty(e)}
+   */hasEdge(v,w,name){var e=arguments.length===1?edgeObjToId(this._isDirected,arguments[0]):edgeArgsToId(this._isDirected,v,w,name);return this._edgeLabels.hasOwnProperty(e)}
 /**
    * Removes the specified edge from the graph. No subgraphs are considered.
    * Complexity: O(1).
-   */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}
+   */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}
 /**
    * Return all edges that point to the node v. Optionally filters those edges down to just those
    * coming from node u. Behavior is undefined for undirected graphs - use nodeEdges instead.
    * Complexity: O(|E|).
-   */inEdges(v,u){var inV=this.#in[v];if(inV){var edges=Object.values(inV);if(!u){return edges}return edges.filter(edge=>edge.v===u)}}
+   */inEdges(v,u){var inV=this._in[v];if(inV){var edges=Object.values(inV);if(!u){return edges}return edges.filter(edge=>edge.v===u)}}
 /**
    * Return all edges that are pointed at by node v. Optionally filters those edges down to just
    * those point to w. Behavior is undefined for undirected graphs - use nodeEdges instead.
    * Complexity: O(|E|).
-   */outEdges(v,w){var outV=this.#out[v];if(outV){var edges=Object.values(outV);if(!w){return edges}return edges.filter(edge=>edge.w===w)}}
+   */outEdges(v,w){var outV=this._out[v];if(outV){var edges=Object.values(outV);if(!w){return edges}return edges.filter(edge=>edge.w===w)}}
 /**
    * Returns all edges to or from node v regardless of direction. Optionally filters those edges
    * down to just those between nodes v and w regardless of direction.
@@ -798,4 +798,4 @@ module.exports={Graph:require("./graph"),version:require("./version")}},{"./grap
  * // ['a', 'b']
  * g2.edges()
  * // [ { v: 'a', w: 'b' } ]
- */function read(json){var g=new Graph(json.options).setGraph(json.value);json.nodes.forEach(function(entry){g.setNode(entry.v,entry.value);if(entry.parent){g.setParent(entry.v,entry.parent)}});json.edges.forEach(function(entry){g.setEdge({v:entry.v,w:entry.w,name:entry.name},entry.value)});return g}},{"./graph":44}],47:[function(require,module,exports){module.exports="2.1.13"},{}]},{},[1])(1)});
+ */function read(json){var g=new Graph(json.options).setGraph(json.value);json.nodes.forEach(function(entry){g.setNode(entry.v,entry.value);if(entry.parent){g.setParent(entry.v,entry.parent)}});json.edges.forEach(function(entry){g.setEdge({v:entry.v,w:entry.w,name:entry.name},entry.value)});return g}},{"./graph":44}],47:[function(require,module,exports){module.exports="2.2.2"},{}]},{},[1])(1)});

package/lib/acyclic.js

@@ -1,32 +1,37 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.run = run;
-exports.undo = undo;
-var _greedyFas = _interopRequireDefault(require("./greedy-fas.js"));
-var _util = require("./util.js");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+let greedyFAS = require("./greedy-fas");
+let uniqueId = require("./util").uniqueId;
+
+module.exports = {
+  run: run,
+  undo: undo
+};
+
 function run(g) {
-  let fas = g.graph().acyclicer === "greedy" ? (0, _greedyFas.default)(g, weightFn(g)) : dfsFAS(g);
+  let fas = (g.graph().acyclicer === "greedy"
+    ? greedyFAS(g, weightFn(g))
+    : dfsFAS(g));
   fas.forEach(e => {
     let label = g.edge(e);
     g.removeEdge(e);
     label.forwardName = e.name;
     label.reversed = true;
-    g.setEdge(e.w, e.v, label, (0, _util.uniqueId)("rev"));
+    g.setEdge(e.w, e.v, label, uniqueId("rev"));
   });
+
   function weightFn(g) {
     return e => {
       return g.edge(e).weight;
     };
   }
 }
+
 function dfsFAS(g) {
   let fas = [];
   let stack = {};
   let visited = {};
+
   function dfs(v) {
     if (visited.hasOwnProperty(v)) {
       return;
@@ -42,14 +47,17 @@ function dfsFAS(g) {
     });
     delete stack[v];
   }
+
   g.nodes().forEach(dfs);
   return fas;
 }
+
 function undo(g) {
   g.edges().forEach(e => {
     let label = g.edge(e);
     if (label.reversed) {
       g.removeEdge(e);
+
       let forwardName = label.forwardName;
       delete label.reversed;
       delete label.forwardName;

package/lib/add-border-segments.js

@@ -1,12 +1,7 @@
-"use strict";
+let util = require("./util");
+
+module.exports = addBorderSegments;
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = addBorderSegments;
-var util = _interopRequireWildcard(require("./util.js"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function addBorderSegments(g) {
   function dfs(v) {
     let children = g.children(v);
@@ -14,32 +9,29 @@ function addBorderSegments(g) {
     if (children.length) {
       children.forEach(dfs);
     }
+
     if (node.hasOwnProperty("minRank")) {
       node.borderLeft = [];
       node.borderRight = [];
-      for (let rank = node.minRank, maxRank = node.maxRank + 1; rank < maxRank; ++rank) {
+      for (let rank = node.minRank, maxRank = node.maxRank + 1;
+        rank < maxRank;
+        ++rank) {
         addBorderNode(g, "borderLeft", "_bl", v, node, rank);
         addBorderNode(g, "borderRight", "_br", v, node, rank);
       }
     }
   }
+
   g.children().forEach(dfs);
 }
+
 function addBorderNode(g, prop, prefix, sg, sgNode, rank) {
-  let label = {
-    width: 0,
-    height: 0,
-    rank: rank,
-    borderType: prop
-  };
+  let label = { width: 0, height: 0, rank: rank, borderType: prop };
   let prev = sgNode[prop][rank - 1];
   let curr = util.addDummyNode(g, "border", label, prefix);
   sgNode[prop][rank] = curr;
   g.setParent(curr, sg);
   if (prev) {
-    g.setEdge(prev, curr, {
-      weight: 1
-    });
+    g.setEdge(prev, curr, { weight: 1 });
   }
 }
-module.exports = exports.default;

package/lib/coordinate-system.js

@@ -1,37 +1,43 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.adjust = adjust;
-exports.undo = undo;
+module.exports = {
+  adjust: adjust,
+  undo: undo
+};
+
 function adjust(g) {
   let rankDir = g.graph().rankdir.toLowerCase();
   if (rankDir === "lr" || rankDir === "rl") {
     swapWidthHeight(g);
   }
 }
+
 function undo(g) {
   let rankDir = g.graph().rankdir.toLowerCase();
   if (rankDir === "bt" || rankDir === "rl") {
     reverseY(g);
   }
+
   if (rankDir === "lr" || rankDir === "rl") {
     swapXY(g);
     swapWidthHeight(g);
   }
 }
+
 function swapWidthHeight(g) {
   g.nodes().forEach(v => swapWidthHeightOne(g.node(v)));
   g.edges().forEach(e => swapWidthHeightOne(g.edge(e)));
 }
+
 function swapWidthHeightOne(attrs) {
   let w = attrs.width;
   attrs.width = attrs.height;
   attrs.height = w;
 }
+
 function reverseY(g) {
   g.nodes().forEach(v => reverseYOne(g.node(v)));
+
   g.edges().forEach(e => {
     let edge = g.edge(e);
     edge.points.forEach(reverseYOne);
@@ -40,11 +46,14 @@ function reverseY(g) {
     }
   });
 }
+
 function reverseYOne(attrs) {
   attrs.y = -attrs.y;
 }
+
 function swapXY(g) {
   g.nodes().forEach(v => swapXYOne(g.node(v)));
+
   g.edges().forEach(e => {
     let edge = g.edge(e);
     edge.points.forEach(swapXYOne);
@@ -53,6 +62,7 @@ function swapXY(g) {
     }
   });
 }
+
 function swapXYOne(attrs) {
   let x = attrs.x;
   attrs.x = attrs.y;

package/lib/data/list.js

@@ -1,9 +1,3 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
 /*
  * Simple doubly linked list implementation derived from Cormen, et al.,
  * "Introduction to Algorithms".
@@ -15,6 +9,7 @@ class List {
     sentinel._next = sentinel._prev = sentinel;
     this._sentinel = sentinel;
   }
+
   dequeue() {
     let sentinel = this._sentinel;
     let entry = sentinel._prev;
@@ -23,6 +18,7 @@ class List {
       return entry;
     }
   }
+
   enqueue(entry) {
     let sentinel = this._sentinel;
     if (entry._prev && entry._next) {
@@ -33,6 +29,7 @@ class List {
     sentinel._next = entry;
     entry._prev = sentinel;
   }
+
   toString() {
     let strs = [];
     let sentinel = this._sentinel;
@@ -44,16 +41,18 @@ class List {
     return "[" + strs.join(", ") + "]";
   }
 }
-exports.default = List;
+
 function unlink(entry) {
   entry._prev._next = entry._next;
   entry._next._prev = entry._prev;
   delete entry._next;
   delete entry._prev;
 }
+
 function filterOutLinks(k, v) {
   if (k !== "_next" && k !== "_prev") {
     return v;
   }
 }
-module.exports = exports.default;
+
+module.exports = List;