@dagrejs/dagre 1.1.0 → 1.1.2

package/lib/debug.js

@@ -1,42 +1,31 @@
-"use strict";
+let util = require("./util");
+let Graph = require("@dagrejs/graphlib").Graph;
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = debugOrdering;
-var util = _interopRequireWildcard(require("./util.js"));
-var _graphlib = require("@dagrejs/graphlib");
-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; }
-// web-devs write a <script type="importmap"> to map
-// nodejs paths to actual http://paths
+module.exports = {
+  debugOrdering: debugOrdering
+};
 
 /* istanbul ignore next */
 function debugOrdering(g) {
   let layerMatrix = util.buildLayerMatrix(g);
-  let h = new _graphlib.Graph({
-    compound: true,
-    multigraph: true
-  }).setGraph({});
+
+  let h = new Graph({ compound: true, multigraph: true }).setGraph({});
+
   g.nodes().forEach(v => {
-    h.setNode(v, {
-      label: v
-    });
+    h.setNode(v, { label: v });
     h.setParent(v, "layer" + g.node(v).rank);
   });
+
   g.edges().forEach(e => h.setEdge(e.v, e.w, {}, e.name));
+
   layerMatrix.forEach((layer, i) => {
     let layerV = "layer" + i;
-    h.setNode(layerV, {
-      rank: "same"
-    });
+    h.setNode(layerV, { rank: "same" });
     layer.reduce((u, v) => {
-      h.setEdge(u, v, {
-        style: "invis"
-      });
+      h.setEdge(u, v, { style: "invis" });
       return v;
     });
   });
+
   return h;
 }
-module.exports = exports.default;

package/lib/greedy-fas.js

@@ -1,14 +1,5 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = greedyFAS;
-var _graphlib = require("@dagrejs/graphlib");
-var _list = _interopRequireDefault(require("./data/list.js"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-// web-devs write a <script type="importmap"> to map
-// nodejs paths to actual http://paths
+let Graph = require("@dagrejs/graphlib").Graph;
+let List = require("./data/list");
 
 /*
  * A greedy heuristic for finding a feedback arc set for a graph. A feedback
@@ -17,8 +8,10 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * effective heuristic for the feedback arc set problem." This implementation
  * adjusts that from the paper to allow for weighted edges.
  */
+module.exports = greedyFAS;
 
 let DEFAULT_WEIGHT_FN = () => 1;
+
 function greedyFAS(g, weightFn) {
   if (g.nodeCount() <= 1) {
     return [];
@@ -29,18 +22,16 @@ function greedyFAS(g, weightFn) {
   // Expand multi-edges
   return results.flatMap(e => g.outEdges(e.v, e.w));
 }
+
 function doGreedyFAS(g, buckets, zeroIdx) {
   let results = [];
   let sources = buckets[buckets.length - 1];
   let sinks = buckets[0];
+
   let entry;
   while (g.nodeCount()) {
-    while (entry = sinks.dequeue()) {
-      removeNode(g, buckets, zeroIdx, entry);
-    }
-    while (entry = sources.dequeue()) {
-      removeNode(g, buckets, zeroIdx, entry);
-    }
+    while ((entry = sinks.dequeue()))   { removeNode(g, buckets, zeroIdx, entry); }
+    while ((entry = sources.dequeue())) { removeNode(g, buckets, zeroIdx, entry); }
     if (g.nodeCount()) {
       for (let i = buckets.length - 2; i > 0; --i) {
         entry = buckets[i].dequeue();
@@ -51,22 +42,25 @@ function doGreedyFAS(g, buckets, zeroIdx) {
       }
     }
   }
+
   return results;
 }
+
 function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
   let results = collectPredecessors ? [] : undefined;
+
   g.inEdges(entry.v).forEach(edge => {
     let weight = g.edge(edge);
     let uEntry = g.node(edge.v);
+
     if (collectPredecessors) {
-      results.push({
-        v: edge.v,
-        w: edge.w
-      });
+      results.push({ v: edge.v, w: edge.w });
     }
+
     uEntry.out -= weight;
     assignBucket(buckets, zeroIdx, uEntry);
   });
+
   g.outEdges(entry.v).forEach(edge => {
     let weight = g.edge(edge);
     let w = edge.w;
@@ -74,19 +68,19 @@ function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
     wEntry["in"] -= weight;
     assignBucket(buckets, zeroIdx, wEntry);
   });
+
   g.removeNode(entry.v);
+
   return results;
 }
+
 function buildState(g, weightFn) {
-  let fasGraph = new _graphlib.Graph();
+  let fasGraph = new Graph();
   let maxIn = 0;
   let maxOut = 0;
+
   g.nodes().forEach(v => {
-    fasGraph.setNode(v, {
-      v: v,
-      "in": 0,
-      out: 0
-    });
+    fasGraph.setNode(v, { v: v, "in": 0, out: 0 });
   });
 
   // Aggregate weights on nodes, but also sum the weights across multi-edges
@@ -97,19 +91,19 @@ function buildState(g, weightFn) {
     let edgeWeight = prevWeight + weight;
     fasGraph.setEdge(e.v, e.w, edgeWeight);
     maxOut = Math.max(maxOut, fasGraph.node(e.v).out += weight);
-    maxIn = Math.max(maxIn, fasGraph.node(e.w)["in"] += weight);
+    maxIn  = Math.max(maxIn,  fasGraph.node(e.w)["in"]  += weight);
   });
-  let buckets = range(maxOut + maxIn + 3).map(() => new _list.default());
+
+  let buckets = range(maxOut + maxIn + 3).map(() => new List());
   let zeroIdx = maxIn + 1;
+
   fasGraph.nodes().forEach(v => {
     assignBucket(buckets, zeroIdx, fasGraph.node(v));
   });
-  return {
-    graph: fasGraph,
-    buckets: buckets,
-    zeroIdx: zeroIdx
-  };
+
+  return { graph: fasGraph, buckets: buckets, zeroIdx: zeroIdx };
 }
+
 function assignBucket(buckets, zeroIdx, entry) {
   if (!entry.out) {
     buckets[0].enqueue(entry);
@@ -119,11 +113,12 @@ function assignBucket(buckets, zeroIdx, entry) {
     buckets[entry.out - entry["in"] + zeroIdx].enqueue(entry);
   }
 }
+
 function range(limit) {
   const range = [];
   for (let i = 0; i < limit; i++) {
     range.push(i);
   }
+
   return range;
 }
-module.exports = exports.default;

package/lib/layout.js

@@ -1,61 +1,59 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = layout;
-var acyclic = _interopRequireWildcard(require("./acyclic.js"));
-var normalize = _interopRequireWildcard(require("./normalize.js"));
-var _index = _interopRequireDefault(require("./rank/index.js"));
-var _parentDummyChains = _interopRequireDefault(require("./parent-dummy-chains.js"));
-var nestingGraph = _interopRequireWildcard(require("./nesting-graph.js"));
-var _addBorderSegments = _interopRequireDefault(require("./add-border-segments.js"));
-var coordinateSystem = _interopRequireWildcard(require("./coordinate-system.js"));
-var _index2 = _interopRequireDefault(require("./order/index.js"));
-var _index3 = _interopRequireDefault(require("./position/index.js"));
-var util = _interopRequireWildcard(require("./util.js"));
-var _graphlib = require("@dagrejs/graphlib");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-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; }
-const removeEmptyRanks = util.removeEmptyRanks;
-const normalizeRanks = util.normalizeRanks;
+let acyclic = require("./acyclic");
+let normalize = require("./normalize");
+let rank = require("./rank");
+let normalizeRanks = require("./util").normalizeRanks;
+let parentDummyChains = require("./parent-dummy-chains");
+let removeEmptyRanks = require("./util").removeEmptyRanks;
+let nestingGraph = require("./nesting-graph");
+let addBorderSegments = require("./add-border-segments");
+let coordinateSystem = require("./coordinate-system");
+let order = require("./order");
+let position = require("./position");
+let util = require("./util");
+let Graph = require("@dagrejs/graphlib").Graph;
+
+module.exports = layout;
+
 function layout(g, opts) {
   let time = opts && opts.debugTiming ? util.time : util.notime;
   time("layout", () => {
-    let layoutGraph = time("  buildLayoutGraph", () => buildLayoutGraph(g));
-    time("  runLayout", () => runLayout(layoutGraph, time));
+    let layoutGraph =
+      time("  buildLayoutGraph", () => buildLayoutGraph(g));
+    time("  runLayout",        () => runLayout(layoutGraph, time));
     time("  updateInputGraph", () => updateInputGraph(g, layoutGraph));
   });
 }
+
 function runLayout(g, time) {
   time("    makeSpaceForEdgeLabels", () => makeSpaceForEdgeLabels(g));
-  time("    removeSelfEdges", () => removeSelfEdges(g));
-  time("    acyclic", () => acyclic.run(g));
-  time("    nestingGraph.run", () => nestingGraph.run(g));
-  time("    rank", () => (0, _index.default)(util.asNonCompoundGraph(g)));
+  time("    removeSelfEdges",        () => removeSelfEdges(g));
+  time("    acyclic",                () => acyclic.run(g));
+  time("    nestingGraph.run",       () => nestingGraph.run(g));
+  time("    rank",                   () => rank(util.asNonCompoundGraph(g)));
   time("    injectEdgeLabelProxies", () => injectEdgeLabelProxies(g));
-  time("    removeEmptyRanks", () => removeEmptyRanks(g));
-  time("    nestingGraph.cleanup", () => nestingGraph.cleanup(g));
-  time("    normalizeRanks", () => normalizeRanks(g));
-  time("    assignRankMinMax", () => assignRankMinMax(g));
+  time("    removeEmptyRanks",       () => removeEmptyRanks(g));
+  time("    nestingGraph.cleanup",   () => nestingGraph.cleanup(g));
+  time("    normalizeRanks",         () => normalizeRanks(g));
+  time("    assignRankMinMax",       () => assignRankMinMax(g));
   time("    removeEdgeLabelProxies", () => removeEdgeLabelProxies(g));
-  time("    normalize.run", () => normalize.run(g));
-  time("    parentDummyChains", () => (0, _parentDummyChains.default)(g));
-  time("    addBorderSegments", () => (0, _addBorderSegments.default)(g));
-  time("    order", () => (0, _index2.default)(g));
-  time("    insertSelfEdges", () => insertSelfEdges(g));
+  time("    normalize.run",          () => normalize.run(g));
+  time("    parentDummyChains",      () => parentDummyChains(g));
+  time("    addBorderSegments",      () => addBorderSegments(g));
+  time("    order",                  () => order(g));
+  time("    insertSelfEdges",        () => insertSelfEdges(g));
   time("    adjustCoordinateSystem", () => coordinateSystem.adjust(g));
-  time("    position", () => (0, _index3.default)(g));
-  time("    positionSelfEdges", () => positionSelfEdges(g));
-  time("    removeBorderNodes", () => removeBorderNodes(g));
-  time("    normalize.undo", () => normalize.undo(g));
-  time("    fixupEdgeLabelCoords", () => fixupEdgeLabelCoords(g));
-  time("    undoCoordinateSystem", () => coordinateSystem.undo(g));
-  time("    translateGraph", () => translateGraph(g));
-  time("    assignNodeIntersects", () => assignNodeIntersects(g));
-  time("    reversePoints", () => reversePointsForReversedEdges(g));
-  time("    acyclic.undo", () => acyclic.undo(g));
+  time("    position",               () => position(g));
+  time("    positionSelfEdges",      () => positionSelfEdges(g));
+  time("    removeBorderNodes",      () => removeBorderNodes(g));
+  time("    normalize.undo",         () => normalize.undo(g));
+  time("    fixupEdgeLabelCoords",   () => fixupEdgeLabelCoords(g));
+  time("    undoCoordinateSystem",   () => coordinateSystem.undo(g));
+  time("    translateGraph",         () => translateGraph(g));
+  time("    assignNodeIntersects",   () => assignNodeIntersects(g));
+  time("    reversePoints",          () => reversePointsForReversedEdges(g));
+  time("    acyclic.undo",           () => acyclic.undo(g));
 }
 
 /*
@@ -68,49 +66,43 @@ function updateInputGraph(inputGraph, layoutGraph) {
   inputGraph.nodes().forEach(v => {
     let inputLabel = inputGraph.node(v);
     let layoutLabel = layoutGraph.node(v);
+
     if (inputLabel) {
       inputLabel.x = layoutLabel.x;
       inputLabel.y = layoutLabel.y;
       inputLabel.rank = layoutLabel.rank;
+
       if (layoutGraph.children(v).length) {
         inputLabel.width = layoutLabel.width;
         inputLabel.height = layoutLabel.height;
       }
     }
   });
+
   inputGraph.edges().forEach(e => {
     let inputLabel = inputGraph.edge(e);
     let layoutLabel = layoutGraph.edge(e);
+
     inputLabel.points = layoutLabel.points;
     if (layoutLabel.hasOwnProperty("x")) {
       inputLabel.x = layoutLabel.x;
       inputLabel.y = layoutLabel.y;
     }
   });
+
   inputGraph.graph().width = layoutGraph.graph().width;
   inputGraph.graph().height = layoutGraph.graph().height;
 }
+
 let graphNumAttrs = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"];
-let graphDefaults = {
-  ranksep: 50,
-  edgesep: 20,
-  nodesep: 50,
-  rankdir: "tb"
-};
+let graphDefaults = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" };
 let graphAttrs = ["acyclicer", "ranker", "rankdir", "align"];
 let nodeNumAttrs = ["width", "height"];
-let nodeDefaults = {
-  width: 0,
-  height: 0
-};
+let nodeDefaults = { width: 0, height: 0 };
 let edgeNumAttrs = ["minlen", "weight", "width", "height", "labeloffset"];
 let edgeDefaults = {
-  minlen: 1,
-  weight: 1,
-  width: 0,
-  height: 0,
-  labeloffset: 10,
-  labelpos: "r"
+  minlen: 1, weight: 1, width: 0, height: 0,
+  labeloffset: 10, labelpos: "r"
 };
 let edgeAttrs = ["labelpos"];
 
@@ -121,12 +113,14 @@ let edgeAttrs = ["labelpos"];
  * attributes can influence layout.
  */
 function buildLayoutGraph(inputGraph) {
-  let g = new _graphlib.Graph({
-    multigraph: true,
-    compound: true
-  });
+  let g = new Graph({ multigraph: true, compound: true });
   let graph = canonicalize(inputGraph.graph());
-  g.setGraph(Object.assign({}, graphDefaults, selectNumberAttrs(graph, graphNumAttrs), util.pick(graph, graphAttrs)));
+
+  g.setGraph(Object.assign({},
+    graphDefaults,
+    selectNumberAttrs(graph, graphNumAttrs),
+    util.pick(graph, graphAttrs)));
+
   inputGraph.nodes().forEach(v => {
     let node = canonicalize(inputGraph.node(v));
     const newNode = selectNumberAttrs(node, nodeNumAttrs);
@@ -135,13 +129,19 @@ function buildLayoutGraph(inputGraph) {
         newNode[k] = nodeDefaults[k];
       }
     });
+
     g.setNode(v, newNode);
     g.setParent(v, inputGraph.parent(v));
   });
+
   inputGraph.edges().forEach(e => {
     let edge = canonicalize(inputGraph.edge(e));
-    g.setEdge(e, Object.assign({}, edgeDefaults, selectNumberAttrs(edge, edgeNumAttrs), util.pick(edge, edgeAttrs)));
+    g.setEdge(e, Object.assign({},
+      edgeDefaults,
+      selectNumberAttrs(edge, edgeNumAttrs),
+      util.pick(edge, edgeAttrs)));
   });
+
   return g;
 }
 
@@ -181,14 +181,12 @@ function injectEdgeLabelProxies(g) {
     if (edge.width && edge.height) {
       let v = g.node(e.v);
       let w = g.node(e.w);
-      let label = {
-        rank: (w.rank - v.rank) / 2 + v.rank,
-        e: e
-      };
+      let label = { rank: (w.rank - v.rank) / 2 + v.rank, e: e };
       util.addDummyNode(g, "edge-proxy", label, "_ep");
     }
   });
 }
+
 function assignRankMinMax(g) {
   let maxRank = 0;
   g.nodes().forEach(v => {
@@ -201,6 +199,7 @@ function assignRankMinMax(g) {
   });
   g.graph().maxRank = maxRank;
 }
+
 function removeEdgeLabelProxies(g) {
   g.nodes().forEach(v => {
     let node = g.node(v);
@@ -210,6 +209,7 @@ function removeEdgeLabelProxies(g) {
     }
   });
 }
+
 function translateGraph(g) {
   let minX = Number.POSITIVE_INFINITY;
   let maxX = 0;
@@ -218,6 +218,7 @@ function translateGraph(g) {
   let graphLabel = g.graph();
   let marginX = graphLabel.marginx || 0;
   let marginY = graphLabel.marginy || 0;
+
   function getExtremes(attrs) {
     let x = attrs.x;
     let y = attrs.y;
@@ -228,6 +229,7 @@ function translateGraph(g) {
     minY = Math.min(minY, y - h / 2);
     maxY = Math.max(maxY, y + h / 2);
   }
+
   g.nodes().forEach(v => getExtremes(g.node(v)));
   g.edges().forEach(e => {
     let edge = g.edge(e);
@@ -235,29 +237,30 @@ function translateGraph(g) {
       getExtremes(edge);
     }
   });
+
   minX -= marginX;
   minY -= marginY;
+
   g.nodes().forEach(v => {
     let node = g.node(v);
     node.x -= minX;
     node.y -= minY;
   });
+
   g.edges().forEach(e => {
     let edge = g.edge(e);
     edge.points.forEach(p => {
       p.x -= minX;
       p.y -= minY;
     });
-    if (edge.hasOwnProperty("x")) {
-      edge.x -= minX;
-    }
-    if (edge.hasOwnProperty("y")) {
-      edge.y -= minY;
-    }
+    if (edge.hasOwnProperty("x")) { edge.x -= minX; }
+    if (edge.hasOwnProperty("y")) { edge.y -= minY; }
   });
+
   graphLabel.width = maxX - minX + marginX;
   graphLabel.height = maxY - minY + marginY;
 }
+
 function assignNodeIntersects(g) {
   g.edges().forEach(e => {
     let edge = g.edge(e);
@@ -276,6 +279,7 @@ function assignNodeIntersects(g) {
     edge.points.push(util.intersectRect(nodeW, p2));
   });
 }
+
 function fixupEdgeLabelCoords(g) {
   g.edges().forEach(e => {
     let edge = g.edge(e);
@@ -284,16 +288,13 @@ function fixupEdgeLabelCoords(g) {
         edge.width -= edge.labeloffset;
       }
       switch (edge.labelpos) {
-        case "l":
-          edge.x -= edge.width / 2 + edge.labeloffset;
-          break;
-        case "r":
-          edge.x += edge.width / 2 + edge.labeloffset;
-          break;
+      case "l": edge.x -= edge.width / 2 + edge.labeloffset; break;
+      case "r": edge.x += edge.width / 2 + edge.labeloffset; break;
       }
     }
   });
 }
+
 function reversePointsForReversedEdges(g) {
   g.edges().forEach(e => {
     let edge = g.edge(e);
@@ -302,6 +303,7 @@ function reversePointsForReversedEdges(g) {
     }
   });
 }
+
 function removeBorderNodes(g) {
   g.nodes().forEach(v => {
     if (g.children(v).length) {
@@ -310,18 +312,21 @@ function removeBorderNodes(g) {
       let b = g.node(node.borderBottom);
       let l = g.node(node.borderLeft[node.borderLeft.length - 1]);
       let r = g.node(node.borderRight[node.borderRight.length - 1]);
+
       node.width = Math.abs(r.x - l.x);
       node.height = Math.abs(b.y - t.y);
       node.x = l.x + node.width / 2;
       node.y = t.y + node.height / 2;
     }
   });
+
   g.nodes().forEach(v => {
     if (g.node(v).dummy === "border") {
       g.removeNode(v);
     }
   });
 }
+
 function removeSelfEdges(g) {
   g.edges().forEach(e => {
     if (e.v === e.w) {
@@ -329,14 +334,12 @@ function removeSelfEdges(g) {
       if (!node.selfEdges) {
         node.selfEdges = [];
       }
-      node.selfEdges.push({
-        e: e,
-        label: g.edge(e)
-      });
+      node.selfEdges.push({ e: e, label: g.edge(e) });
       g.removeEdge(e);
     }
   });
 }
+
 function insertSelfEdges(g) {
   var layers = util.buildLayerMatrix(g);
   layers.forEach(layer => {
@@ -349,7 +352,7 @@ function insertSelfEdges(g) {
           width: selfEdge.label.width,
           height: selfEdge.label.height,
           rank: node.rank,
-          order: i + ++orderShift,
+          order: i + (++orderShift),
           e: selfEdge.e,
           label: selfEdge.label
         }, "_se");
@@ -358,6 +361,7 @@ function insertSelfEdges(g) {
     });
   });
 }
+
 function positionSelfEdges(g) {
   g.nodes().forEach(v => {
     var node = g.node(v);
@@ -369,30 +373,23 @@ function positionSelfEdges(g) {
       var dy = selfNode.height / 2;
       g.setEdge(node.e, node.label);
       g.removeNode(v);
-      node.label.points = [{
-        x: x + 2 * dx / 3,
-        y: y - dy
-      }, {
-        x: x + 5 * dx / 6,
-        y: y - dy
-      }, {
-        x: x + dx,
-        y: y
-      }, {
-        x: x + 5 * dx / 6,
-        y: y + dy
-      }, {
-        x: x + 2 * dx / 3,
-        y: y + dy
-      }];
+      node.label.points = [
+        { x: x + 2 * dx / 3, y: y - dy },
+        { x: x + 5 * dx / 6, y: y - dy },
+        { x: x +     dx    , y: y },
+        { x: x + 5 * dx / 6, y: y + dy },
+        { x: x + 2 * dx / 3, y: y + dy }
+      ];
       node.label.x = node.x;
       node.label.y = node.y;
     }
   });
 }
+
 function selectNumberAttrs(obj, attrs) {
   return util.mapValues(util.pick(obj, attrs), Number);
 }
+
 function canonicalize(attrs) {
   var newAttrs = {};
   if (attrs) {
@@ -400,9 +397,9 @@ function canonicalize(attrs) {
       if (typeof k === "string") {
         k = k.toLowerCase();
       }
+
       newAttrs[k] = v;
     });
   }
   return newAttrs;
 }
-module.exports = exports.default;