@windrun-huaiin/third-ui 13.0.0 → 13.1.0

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/build-layer-graph.js

@@ -43,7 +43,7 @@ function buildLayerGraph(g, rank, relationship) {
         return g.node(v);
       });
 
-  forEach(g.nodes(), function (v) {
+  forEach.default(g.nodes(), function (v) {
     var node = g.node(v),
       parent = g.parent(v);
 
@@ -52,10 +52,10 @@ function buildLayerGraph(g, rank, relationship) {
       result.setParent(v, parent || root);
 
       // This assumes we have only short edges!
-      forEach(g[relationship](v), function (e) {
+      forEach.default(g[relationship](v), function (e) {
         var u = e.v === v ? e.w : e.v,
           edge = result.edge(u, v),
-          weight = !isUndefined(edge) ? edge.weight : 0;
+          weight = !isUndefined.default(edge) ? edge.weight : 0;
         result.setEdge(u, v, { weight: g.edge(e).weight + weight });
       });
 
@@ -73,7 +73,7 @@ function buildLayerGraph(g, rank, relationship) {
 
 function createRootNode(g) {
   var v;
-  while (g.hasNode((v = uniqueId('_root'))));
+  while (g.hasNode((v = uniqueId.default('_root'))));
   return v;
 }
 

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/cross-count.js

@@ -34,16 +34,16 @@ function twoLayerCrossCount(g, northLayer, southLayer) {
   // Sort all of the edges between the north and south layers by their position
   // in the north layer and then the south. Map these edges to the position of
   // their head in the south layer.
-  var southPos = zipObject(
+  var southPos = zipObject.default(
     southLayer,
-    map(southLayer, function (v, i) {
+    map.default(southLayer, function (v, i) {
       return i;
     }),
   );
-  var southEntries = flatten(
-    map(northLayer, function (v) {
-      return sortBy(
-        map(g.outEdges(v), function (e) {
+  var southEntries = flatten.default(
+    map.default(northLayer, function (v) {
+      return sortBy.default(
+        map.default(g.outEdges(v), function (e) {
           return { pos: southPos[e.w], weight: g.edge(e).weight };
         }),
         'pos',
@@ -56,13 +56,13 @@ function twoLayerCrossCount(g, northLayer, southLayer) {
   while (firstIndex < southLayer.length) firstIndex <<= 1;
   var treeSize = 2 * firstIndex - 1;
   firstIndex -= 1;
-  var tree = map(new Array(treeSize), function () {
+  var tree = map.default(new Array(treeSize), function () {
     return 0;
   });
 
   // Calculate the weighted crossings
   var cc = 0;
-  forEach(
+  forEach.default(
     // @ts-expect-error
     southEntries.forEach(function (entry) {
       var index = entry.pos + firstIndex;

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/index.js

@@ -29,8 +29,8 @@ var forEach = require('../../../../../../lodash-es@4.17.23/node_modules/lodash-e
  */
 function order(g) {
   var maxRank = util.maxRank(g),
-    downLayerGraphs = buildLayerGraphs(g, range(1, maxRank + 1), 'inEdges'),
-    upLayerGraphs = buildLayerGraphs(g, range(maxRank - 1, -1, -1), 'outEdges');
+    downLayerGraphs = buildLayerGraphs(g, range.default(1, maxRank + 1), 'inEdges'),
+    upLayerGraphs = buildLayerGraphs(g, range.default(maxRank - 1, -1, -1), 'outEdges');
 
   var layering = initOrder.initOrder(g);
   assignOrder(g, layering);
@@ -45,7 +45,7 @@ function order(g) {
     var cc = crossCount.crossCount(g, layering);
     if (cc < bestCC) {
       lastBest = 0;
-      best = cloneDeep(layering);
+      best = cloneDeep.default(layering);
       bestCC = cc;
     }
   }
@@ -54,17 +54,17 @@ function order(g) {
 }
 
 function buildLayerGraphs(g, ranks, relationship) {
-  return map(ranks, function (rank) {
+  return map.default(ranks, function (rank) {
     return buildLayerGraph.buildLayerGraph(g, rank, relationship);
   });
 }
 
 function sweepLayerGraphs(layerGraphs, biasRight) {
   var cg = new graph.Graph();
-  forEach(layerGraphs, function (lg) {
+  forEach.default(layerGraphs, function (lg) {
     var root = lg.graph().root;
     var sorted = sortSubgraph.sortSubgraph(lg, root, cg, biasRight);
-    forEach(sorted.vs, function (v, i) {
+    forEach.default(sorted.vs, function (v, i) {
       lg.node(v).order = i;
     });
     addSubgraphConstraints.addSubgraphConstraints(lg, cg, sorted.vs);
@@ -72,8 +72,8 @@ function sweepLayerGraphs(layerGraphs, biasRight) {
 }
 
 function assignOrder(g, layering) {
-  forEach(layering, function (layer) {
-    forEach(layer, function (v, i) {
+  forEach.default(layering, function (layer) {
+    forEach.default(layer, function (v, i) {
       g.node(v).order = i;
     });
   });

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/init-order.js

@@ -21,30 +21,30 @@ var has = require('../../../../../../lodash-es@4.17.23/node_modules/lodash-es/ha
  */
 function initOrder(g) {
   var visited = {};
-  var simpleNodes = filter(g.nodes(), function (v) {
+  var simpleNodes = filter.default(g.nodes(), function (v) {
     return !g.children(v).length;
   });
-  var maxRank = max(
-    map(simpleNodes, function (v) {
+  var maxRank = max.default(
+    map.default(simpleNodes, function (v) {
       return g.node(v).rank;
     }),
   );
-  var layers = map(range(maxRank + 1), function () {
+  var layers = map.default(range.default(maxRank + 1), function () {
     return [];
   });
 
   function dfs(v) {
-    if (has(visited, v)) return;
+    if (has.default(visited, v)) return;
     visited[v] = true;
     var node = g.node(v);
     layers[node.rank].push(v);
-    forEach(g.successors(v), dfs);
+    forEach.default(g.successors(v), dfs);
   }
 
-  var orderedVs = sortBy(simpleNodes, function (v) {
+  var orderedVs = sortBy.default(simpleNodes, function (v) {
     return g.node(v).rank;
   });
-  forEach(orderedVs, dfs);
+  forEach.default(orderedVs, dfs);
 
   return layers;
 }

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/resolve-conflicts.js

@@ -33,7 +33,7 @@ var pick = require('../../../../../../lodash-es@4.17.23/node_modules/lodash-es/p
  */
 function resolveConflicts(entries, cg) {
   var mappedEntries = {};
-  forEach(entries, function (entry, i) {
+  forEach.default(entries, function (entry, i) {
     var tmp = (mappedEntries[entry.v] = {
       indegree: 0,
       in: [],
@@ -41,7 +41,7 @@ function resolveConflicts(entries, cg) {
       vs: [entry.v],
       i: i,
     });
-    if (!isUndefined(entry.barycenter)) {
+    if (!isUndefined.default(entry.barycenter)) {
       // @ts-expect-error
       tmp.barycenter = entry.barycenter;
       // @ts-expect-error
@@ -49,16 +49,16 @@ function resolveConflicts(entries, cg) {
     }
   });
 
-  forEach(cg.edges(), function (e) {
+  forEach.default(cg.edges(), function (e) {
     var entryV = mappedEntries[e.v];
     var entryW = mappedEntries[e.w];
-    if (!isUndefined(entryV) && !isUndefined(entryW)) {
+    if (!isUndefined.default(entryV) && !isUndefined.default(entryW)) {
       entryW.indegree++;
       entryV.out.push(mappedEntries[e.w]);
     }
   });
 
-  var sourceSet = filter(mappedEntries, function (entry) {
+  var sourceSet = filter.default(mappedEntries, function (entry) {
     // @ts-expect-error
     return !entry.indegree;
   });
@@ -75,8 +75,8 @@ function doResolveConflicts(sourceSet) {
         return;
       }
       if (
-        isUndefined(uEntry.barycenter) ||
-        isUndefined(vEntry.barycenter) ||
+        isUndefined.default(uEntry.barycenter) ||
+        isUndefined.default(vEntry.barycenter) ||
         uEntry.barycenter >= vEntry.barycenter
       ) {
         mergeEntries(vEntry, uEntry);
@@ -96,16 +96,16 @@ function doResolveConflicts(sourceSet) {
   while (sourceSet.length) {
     var entry = sourceSet.pop();
     entries.push(entry);
-    forEach(entry['in'].reverse(), handleIn(entry));
-    forEach(entry.out, handleOut(entry));
+    forEach.default(entry['in'].reverse(), handleIn(entry));
+    forEach.default(entry.out, handleOut(entry));
   }
 
-  return map(
-    filter(entries, function (entry) {
+  return map.default(
+    filter.default(entries, function (entry) {
       return !entry.merged;
     }),
     function (entry) {
-      return pick(entry, ['vs', 'i', 'barycenter', 'weight']);
+      return pick.default(entry, ['vs', 'i', 'barycenter', 'weight']);
     },
   );
 }

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/sort-subgraph.js

@@ -16,13 +16,13 @@ function sortSubgraph(g, v, cg, biasRight) {
   var subgraphs = {};
 
   if (bl) {
-    movable = filter(movable, function (w) {
+    movable = filter.default(movable, function (w) {
       return w !== bl && w !== br;
     });
   }
 
   var barycenters = barycenter.barycenter(g, movable);
-  forEach(barycenters, function (entry) {
+  forEach.default(barycenters, function (entry) {
     if (g.children(entry.v).length) {
       var subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
       subgraphs[entry.v] = subgraphResult;
@@ -38,7 +38,7 @@ function sortSubgraph(g, v, cg, biasRight) {
   var result = sort.sort(entries, biasRight);
 
   if (bl) {
-    result.vs = flatten([bl, result.vs, br]);
+    result.vs = flatten.default([bl, result.vs, br]);
     if (g.predecessors(bl).length) {
       var blPred = g.node(g.predecessors(bl)[0]),
         brPred = g.node(g.predecessors(br)[0]);
@@ -56,8 +56,8 @@ function sortSubgraph(g, v, cg, biasRight) {
 }
 
 function expandSubgraphs(entries, subgraphs) {
-  forEach(entries, function (entry) {
-    entry.vs = flatten(
+  forEach.default(entries, function (entry) {
+    entry.vs = flatten.default(
       entry.vs.map(function (v) {
         if (subgraphs[v]) {
           return subgraphs[v].vs;
@@ -69,7 +69,7 @@ function expandSubgraphs(entries, subgraphs) {
 }
 
 function mergeBarycenters(target, other) {
-  if (!isUndefined(target.barycenter)) {
+  if (!isUndefined.default(target.barycenter)) {
     target.barycenter =
       (target.barycenter * target.weight + other.barycenter * other.weight) /
       (target.weight + other.weight);

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/sort.js

@@ -11,7 +11,7 @@ function sort(entries, biasRight) {
     return Object.prototype.hasOwnProperty.call(entry, 'barycenter');
   });
   var sortable = parts.lhs,
-    unsortable = sortBy(parts.rhs, function (entry) {
+    unsortable = sortBy.default(parts.rhs, function (entry) {
       return -entry.i;
     }),
     vs = [],
@@ -23,7 +23,7 @@ function sort(entries, biasRight) {
 
   vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
 
-  forEach(sortable, function (entry) {
+  forEach.default(sortable, function (entry) {
     vsIndex += entry.vs.length;
     vs.push(entry.vs);
     sum += entry.barycenter * entry.weight;
@@ -31,7 +31,7 @@ function sort(entries, biasRight) {
     vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
   });
 
-  var result = { vs: flatten(vs) };
+  var result = { vs: flatten.default(vs) };
   if (weight) {
     result.barycenter = sum / weight;
     result.weight = weight;
@@ -41,7 +41,7 @@ function sort(entries, biasRight) {
 
 function consumeUnsortable(vs, unsortable, index) {
   var last$1;
-  while (unsortable.length && (last$1 = last(unsortable)).i <= index) {
+  while (unsortable.length && (last$1 = last.default(unsortable)).i <= index) {
     unsortable.pop();
     vs.push(last$1.vs);
     index++;

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/parent-dummy-chains.js

@@ -5,7 +5,7 @@ var forEach = require('../../../../../lodash-es@4.17.23/node_modules/lodash-es/f
 function parentDummyChains(g) {
   var postorderNums = postorder(g);
 
-  forEach(g.graph().dummyChains, function (v) {
+  forEach.default(g.graph().dummyChains, function (v) {
     var node = g.node(v);
     var edgeObj = node.edgeObj;
     var pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
@@ -77,10 +77,10 @@ function postorder(g) {
 
   function dfs(v) {
     var low = lim;
-    forEach(g.children(v), dfs);
+    forEach.default(g.children(v), dfs);
     result[v] = { low: low, lim: lim++ };
   }
-  forEach(g.children(), dfs);
+  forEach.default(g.children(), dfs);
 
   return result;
 }

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/position/bk.js

@@ -46,15 +46,15 @@ function findType1Conflicts(g, layering) {
       // segment.
       scanPos = 0,
       prevLayerLength = prevLayer.length,
-      lastNode = last(layer);
+      lastNode = last.default(layer);
 
-    forEach(layer, function (v, i) {
+    forEach.default(layer, function (v, i) {
       var w = findOtherInnerSegmentNode(g, v),
         k1 = w ? g.node(w).order : prevLayerLength;
 
       if (w || v === lastNode) {
-        forEach(layer.slice(scanPos, i + 1), function (scanNode) {
-          forEach(g.predecessors(scanNode), function (u) {
+        forEach.default(layer.slice(scanPos, i + 1), function (scanNode) {
+          forEach.default(g.predecessors(scanNode), function (u) {
             var uLabel = g.node(u),
               uPos = uLabel.order;
             if ((uPos < k0 || k1 < uPos) && !(uLabel.dummy && g.node(scanNode).dummy)) {
@@ -71,7 +71,7 @@ function findType1Conflicts(g, layering) {
     return layer;
   }
 
-  reduce(layering, visitLayer);
+  reduce.default(layering, visitLayer);
   return conflicts;
 }
 
@@ -81,10 +81,10 @@ function findType2Conflicts(g, layering) {
 
   function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) {
     var v;
-    forEach(range(southPos, southEnd), function (i) {
+    forEach.default(range.default(southPos, southEnd), function (i) {
       v = south[i];
       if (g.node(v).dummy) {
-        forEach(g.predecessors(v), function (u) {
+        forEach.default(g.predecessors(v), function (u) {
           var uNode = g.node(u);
           if (uNode.dummy && (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) {
             addConflict(conflicts, u, v);
@@ -99,7 +99,7 @@ function findType2Conflicts(g, layering) {
       nextNorthPos,
       southPos = 0;
 
-    forEach(south, function (v, southLookahead) {
+    forEach.default(south, function (v, southLookahead) {
       if (g.node(v).dummy === 'border') {
         var predecessors = g.predecessors(v);
         if (predecessors.length) {
@@ -116,13 +116,13 @@ function findType2Conflicts(g, layering) {
     return south;
   }
 
-  reduce(layering, visitLayer);
+  reduce.default(layering, visitLayer);
   return conflicts;
 }
 
 function findOtherInnerSegmentNode(g, v) {
   if (g.node(v).dummy) {
-    return find(g.predecessors(v), function (u) {
+    return find.default(g.predecessors(v), function (u) {
       return g.node(u).dummy;
     });
   }
@@ -185,20 +185,20 @@ function verticalAlignment(g, layering, conflicts, neighborFn) {
   // We cache the position here based on the layering because the graph and
   // layering may be out of sync. The layering matrix is manipulated to
   // generate different extreme alignments.
-  forEach(layering, function (layer) {
-    forEach(layer, function (v, order) {
+  forEach.default(layering, function (layer) {
+    forEach.default(layer, function (v, order) {
       root[v] = v;
       align[v] = v;
       pos[v] = order;
     });
   });
 
-  forEach(layering, function (layer) {
+  forEach.default(layering, function (layer) {
     var prevIdx = -1;
-    forEach(layer, function (v) {
+    forEach.default(layer, function (v) {
       var ws = neighborFn(v);
       if (ws.length) {
-        ws = sortBy(ws, function (w) {
+        ws = sortBy.default(ws, function (w) {
           return pos[w];
         });
         var mp = (ws.length - 1) / 2;
@@ -267,7 +267,7 @@ function horizontalCompaction(g, layering, root, align, reverseSep) {
   iterate(pass2, blockG.successors.bind(blockG));
 
   // Assign x coordinates to all nodes
-  forEach(align, function (v) {
+  forEach.default(align, function (v) {
     xs[v] = xs[root[v]];
   });
 
@@ -279,9 +279,9 @@ function buildBlockGraph(g, layering, root, reverseSep) {
     graphLabel = g.graph(),
     sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
 
-  forEach(layering, function (layer) {
+  forEach.default(layering, function (layer) {
     var u;
-    forEach(layer, function (v) {
+    forEach.default(layer, function (v) {
       var vRoot = root[v];
       blockGraph.setNode(vRoot);
       if (u) {
@@ -300,11 +300,11 @@ function buildBlockGraph(g, layering, root, reverseSep) {
  * Returns the alignment that has the smallest width of the given alignments.
  */
 function findSmallestWidthAlignment(g, xss) {
-  return minBy(values(xss), function (xs) {
+  return minBy.default(values.default(xss), function (xs) {
     var max = Number.NEGATIVE_INFINITY;
     var min = Number.POSITIVE_INFINITY;
 
-    forIn(xs, function (x, v) {
+    forIn.default(xs, function (x, v) {
       var halfWidth = width(g, v) / 2;
 
       max = Math.max(x + halfWidth, max);
@@ -323,22 +323,22 @@ function findSmallestWidthAlignment(g, xss) {
  * coordinate of the smallest width alignment.
  */
 function alignCoordinates(xss, alignTo) {
-  var alignToVals = values(alignTo),
-    alignToMin = min(alignToVals),
-    alignToMax = max(alignToVals);
+  var alignToVals = values.default(alignTo),
+    alignToMin = min.default(alignToVals),
+    alignToMax = max.default(alignToVals);
 
-  forEach(['u', 'd'], function (vert) {
-    forEach(['l', 'r'], function (horiz) {
+  forEach.default(['u', 'd'], function (vert) {
+    forEach.default(['l', 'r'], function (horiz) {
       var alignment = vert + horiz,
         xs = xss[alignment],
         delta;
       if (xs === alignTo) return;
 
-      var xsVals = values(xs);
-      delta = horiz === 'l' ? alignToMin - min(xsVals) : alignToMax - max(xsVals);
+      var xsVals = values.default(xs);
+      delta = horiz === 'l' ? alignToMin - min.default(xsVals) : alignToMax - max.default(xsVals);
 
       if (delta) {
-        xss[alignment] = mapValues(xs, function (x) {
+        xss[alignment] = mapValues.default(xs, function (x) {
           return x + delta;
         });
       }
@@ -347,11 +347,11 @@ function alignCoordinates(xss, alignTo) {
 }
 
 function balance(xss, align) {
-  return mapValues(xss.ul, function (ignore, v) {
+  return mapValues.default(xss.ul, function (ignore, v) {
     if (align) {
       return xss[align.toLowerCase()][v];
     } else {
-      var xs = sortBy(map(xss, v));
+      var xs = sortBy.default(map.default(xss, v));
       return (xs[1] + xs[2]) / 2;
     }
   });
@@ -359,16 +359,16 @@ function balance(xss, align) {
 
 function positionX(g) {
   var layering = util.buildLayerMatrix(g);
-  var conflicts = merge(findType1Conflicts(g, layering), findType2Conflicts(g, layering));
+  var conflicts = merge.default(findType1Conflicts(g, layering), findType2Conflicts(g, layering));
 
   var xss = {};
   var adjustedLayering;
-  forEach(['u', 'd'], function (vert) {
-    adjustedLayering = vert === 'u' ? layering : values(layering).reverse();
-    forEach(['l', 'r'], function (horiz) {
+  forEach.default(['u', 'd'], function (vert) {
+    adjustedLayering = vert === 'u' ? layering : values.default(layering).reverse();
+    forEach.default(['l', 'r'], function (horiz) {
       if (horiz === 'r') {
-        adjustedLayering = map(adjustedLayering, function (inner) {
-          return values(inner).reverse();
+        adjustedLayering = map.default(adjustedLayering, function (inner) {
+          return values.default(inner).reverse();
         });
       }
 
@@ -376,7 +376,7 @@ function positionX(g) {
       var align = verticalAlignment(g, adjustedLayering, conflicts, neighborFn);
       var xs = horizontalCompaction(g, adjustedLayering, align.root, align.align, horiz === 'r');
       if (horiz === 'r') {
-        xs = mapValues(xs, function (x) {
+        xs = mapValues.default(xs, function (x) {
           return -x;
         });
       }

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/position/index.js

@@ -11,7 +11,7 @@ function position(g) {
   g = util.asNonCompoundGraph(g);
 
   positionY(g);
-  forOwn(bk.positionX(g), function (x, v) {
+  forOwn.default(bk.positionX(g), function (x, v) {
     g.node(v).x = x;
   });
 }
@@ -20,13 +20,13 @@ function positionY(g) {
   var layering = util.buildLayerMatrix(g);
   var rankSep = g.graph().ranksep;
   var prevY = 0;
-  forEach(layering, function (layer) {
-    var maxHeight = max(
-      map(layer, function (v) {
+  forEach.default(layering, function (layer) {
+    var maxHeight = max.default(
+      map.default(layer, function (v) {
         return g.node(v).height;
       }),
     );
-    forEach(layer, function (v) {
+    forEach.default(layer, function (v) {
       g.node(v).y = prevY + maxHeight / 2;
     });
     prevY += maxHeight + rankSep;

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/rank/feasible-tree.js

@@ -54,7 +54,7 @@ function feasibleTree(g) {
  */
 function tightTree(t, g) {
   function dfs(v) {
-    forEach(g.nodeEdges(v), function (e) {
+    forEach.default(g.nodeEdges(v), function (e) {
       var edgeV = e.v,
         w = v === edgeV ? e.w : edgeV;
       if (!t.hasNode(w) && !util.slack(g, e)) {
@@ -65,7 +65,7 @@ function tightTree(t, g) {
     });
   }
 
-  forEach(t.nodes(), dfs);
+  forEach.default(t.nodes(), dfs);
   return t.nodeCount();
 }
 
@@ -74,7 +74,7 @@ function tightTree(t, g) {
  * it.
  */
 function findMinSlackEdge(t, g) {
-  return minBy(g.edges(), function (e) {
+  return minBy.default(g.edges(), function (e) {
     if (t.hasNode(e.v) !== t.hasNode(e.w)) {
       return util.slack(g, e);
     }
@@ -82,7 +82,7 @@ function findMinSlackEdge(t, g) {
 }
 
 function shiftRanks(t, g, delta) {
-  forEach(t.nodes(), function (v) {
+  forEach.default(t.nodes(), function (v) {
     g.node(v).rank += delta;
   });
 }

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/rank/network-simplex.js

@@ -73,7 +73,7 @@ function networkSimplex(g) {
 function initCutValues(t, g) {
   var vs = postorder.postorder(t, t.nodes());
   vs = vs.slice(0, vs.length - 1);
-  forEach(vs, function (v) {
+  forEach.default(vs, function (v) {
     assignCutValue(t, g, v);
   });
 }
@@ -105,7 +105,7 @@ function calcCutValue(t, g, child) {
 
   cutValue = graphEdge.weight;
 
-  forEach(g.nodeEdges(child), function (e) {
+  forEach.default(g.nodeEdges(child), function (e) {
     var isOutEdge = e.v === child,
       other = isOutEdge ? e.w : e.v;
 
@@ -136,7 +136,7 @@ function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
   var label = tree.node(v);
 
   visited[v] = true;
-  forEach(tree.neighbors(v), function (w) {
+  forEach.default(tree.neighbors(v), function (w) {
     if (!Object.prototype.hasOwnProperty.call(visited, w)) {
       nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
     }
@@ -155,7 +155,7 @@ function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
 }
 
 function leaveEdge(tree) {
-  return find(tree.edges(), function (e) {
+  return find.default(tree.edges(), function (e) {
     return tree.edge(e).cutvalue < 0;
   });
 }
@@ -184,14 +184,14 @@ function enterEdge(t, g, edge) {
     flip = true;
   }
 
-  var candidates = filter(g.edges(), function (edge) {
+  var candidates = filter.default(g.edges(), function (edge) {
     return (
       flip === isDescendant(t, t.node(edge.v), tailLabel) &&
       flip !== isDescendant(t, t.node(edge.w), tailLabel)
     );
   });
 
-  return minBy(candidates, function (edge) {
+  return minBy.default(candidates, function (edge) {
     return util$1.slack(g, edge);
   });
 }
@@ -207,12 +207,12 @@ function exchangeEdges(t, g, e, f) {
 }
 
 function updateRanks(t, g) {
-  var root = find(t.nodes(), function (v) {
+  var root = find.default(t.nodes(), function (v) {
     return !g.node(v).parent;
   });
   var vs = preorder.preorder(t, root);
   vs = vs.slice(1);
-  forEach(vs, function (v) {
+  forEach.default(vs, function (v) {
     var parent = t.node(v).parent,
       edge = g.edge(v, parent),
       flipped = false;