@percepta/kaizen 0.2.2 → 0.2.3

package/dashboard/.next/standalone/node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/add-border-segments.js

@@ -1,36 +0,0 @@
-import * as _ from 'lodash-es';
-import * as util from './util.js';
-
-export { addBorderSegments };
-
-function addBorderSegments(g) {
-  function dfs(v) {
-    var children = g.children(v);
-    var node = g.node(v);
-    if (children.length) {
-      _.forEach(children, dfs);
-    }
-
-    if (Object.prototype.hasOwnProperty.call(node, 'minRank')) {
-      node.borderLeft = [];
-      node.borderRight = [];
-      for (var rank = node.minRank, maxRank = node.maxRank + 1; rank < maxRank; ++rank) {
-        addBorderNode(g, 'borderLeft', '_bl', v, node, rank);
-        addBorderNode(g, 'borderRight', '_br', v, node, rank);
-      }
-    }
-  }
-
-  _.forEach(g.children(), dfs);
-}
-
-function addBorderNode(g, prop, prefix, sg, sgNode, rank) {
-  var label = { width: 0, height: 0, rank: rank, borderType: prop };
-  var prev = sgNode[prop][rank - 1];
-  var curr = util.addDummyNode(g, 'border', label, prefix);
-  sgNode[prop][rank] = curr;
-  g.setParent(curr, sg);
-  if (prev) {
-    g.setEdge(prev, curr, { weight: 1 });
-  }
-}

package/dashboard/.next/standalone/node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/coordinate-system.js

@@ -1,75 +0,0 @@
-import * as _ from 'lodash-es';
-
-export { adjust, undo };
-
-function adjust(g) {
-  var rankDir = g.graph().rankdir.toLowerCase();
-  if (rankDir === 'lr' || rankDir === 'rl') {
-    swapWidthHeight(g);
-  }
-}
-
-function undo(g) {
-  var rankDir = g.graph().rankdir.toLowerCase();
-  if (rankDir === 'bt' || rankDir === 'rl') {
-    reverseY(g);
-  }
-
-  if (rankDir === 'lr' || rankDir === 'rl') {
-    swapXY(g);
-    swapWidthHeight(g);
-  }
-}
-
-function swapWidthHeight(g) {
-  _.forEach(g.nodes(), function (v) {
-    swapWidthHeightOne(g.node(v));
-  });
-  _.forEach(g.edges(), function (e) {
-    swapWidthHeightOne(g.edge(e));
-  });
-}
-
-function swapWidthHeightOne(attrs) {
-  var w = attrs.width;
-  attrs.width = attrs.height;
-  attrs.height = w;
-}
-
-function reverseY(g) {
-  _.forEach(g.nodes(), function (v) {
-    reverseYOne(g.node(v));
-  });
-
-  _.forEach(g.edges(), function (e) {
-    var edge = g.edge(e);
-    _.forEach(edge.points, reverseYOne);
-    if (Object.prototype.hasOwnProperty.call(edge, 'y')) {
-      reverseYOne(edge);
-    }
-  });
-}
-
-function reverseYOne(attrs) {
-  attrs.y = -attrs.y;
-}
-
-function swapXY(g) {
-  _.forEach(g.nodes(), function (v) {
-    swapXYOne(g.node(v));
-  });
-
-  _.forEach(g.edges(), function (e) {
-    var edge = g.edge(e);
-    _.forEach(edge.points, swapXYOne);
-    if (Object.prototype.hasOwnProperty.call(edge, 'x')) {
-      swapXYOne(edge);
-    }
-  });
-}
-
-function swapXYOne(attrs) {
-  var x = attrs.x;
-  attrs.x = attrs.y;
-  attrs.y = x;
-}

package/dashboard/.next/standalone/node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/data/list.js

@@ -1,55 +0,0 @@
-/*
- * Simple doubly linked list implementation derived from Cormen, et al.,
- * "Introduction to Algorithms".
- */
-
-export { List };
-
-class List {
-  constructor() {
-    var sentinel = {};
-    sentinel._next = sentinel._prev = sentinel;
-    this._sentinel = sentinel;
-  }
-  dequeue() {
-    var sentinel = this._sentinel;
-    var entry = sentinel._prev;
-    if (entry !== sentinel) {
-      unlink(entry);
-      return entry;
-    }
-  }
-  enqueue(entry) {
-    var sentinel = this._sentinel;
-    if (entry._prev && entry._next) {
-      unlink(entry);
-    }
-    entry._next = sentinel._next;
-    sentinel._next._prev = entry;
-    sentinel._next = entry;
-    entry._prev = sentinel;
-  }
-  toString() {
-    var strs = [];
-    var sentinel = this._sentinel;
-    var curr = sentinel._prev;
-    while (curr !== sentinel) {
-      strs.push(JSON.stringify(curr, filterOutLinks));
-      curr = curr._prev;
-    }
-    return '[' + strs.join(', ') + ']';
-  }
-}
-
-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;
-  }
-}

package/dashboard/.next/standalone/node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/greedy-fas.js

@@ -1,126 +0,0 @@
-import * as _ from 'lodash-es';
-import { Graph } from '../graphlib/index.js';
-import { List } from './data/list.js';
-
-/*
- * A greedy heuristic for finding a feedback arc set for a graph. A feedback
- * arc set is a set of edges that can be removed to make a graph acyclic.
- * The algorithm comes from: P. Eades, X. Lin, and W. F. Smyth, "A fast and
- * effective heuristic for the feedback arc set problem." This implementation
- * adjusts that from the paper to allow for weighted edges.
- */
-export { greedyFAS };
-
-var DEFAULT_WEIGHT_FN = _.constant(1);
-
-function greedyFAS(g, weightFn) {
-  if (g.nodeCount() <= 1) {
-    return [];
-  }
-  var state = buildState(g, weightFn || DEFAULT_WEIGHT_FN);
-  var results = doGreedyFAS(state.graph, state.buckets, state.zeroIdx);
-
-  // Expand multi-edges
-  return _.flatten(
-    _.map(results, function (e) {
-      return g.outEdges(e.v, e.w);
-    }),
-  );
-}
-
-function doGreedyFAS(g, buckets, zeroIdx) {
-  var results = [];
-  var sources = buckets[buckets.length - 1];
-  var sinks = buckets[0];
-
-  var entry;
-  while (g.nodeCount()) {
-    while ((entry = sinks.dequeue())) {
-      removeNode(g, buckets, zeroIdx, entry);
-    }
-    while ((entry = sources.dequeue())) {
-      removeNode(g, buckets, zeroIdx, entry);
-    }
-    if (g.nodeCount()) {
-      for (var i = buckets.length - 2; i > 0; --i) {
-        entry = buckets[i].dequeue();
-        if (entry) {
-          results = results.concat(removeNode(g, buckets, zeroIdx, entry, true));
-          break;
-        }
-      }
-    }
-  }
-
-  return results;
-}
-
-function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
-  var results = collectPredecessors ? [] : undefined;
-
-  _.forEach(g.inEdges(entry.v), function (edge) {
-    var weight = g.edge(edge);
-    var uEntry = g.node(edge.v);
-
-    if (collectPredecessors) {
-      results.push({ v: edge.v, w: edge.w });
-    }
-
-    uEntry.out -= weight;
-    assignBucket(buckets, zeroIdx, uEntry);
-  });
-
-  _.forEach(g.outEdges(entry.v), function (edge) {
-    var weight = g.edge(edge);
-    var w = edge.w;
-    var wEntry = g.node(w);
-    wEntry['in'] -= weight;
-    assignBucket(buckets, zeroIdx, wEntry);
-  });
-
-  g.removeNode(entry.v);
-
-  return results;
-}
-
-function buildState(g, weightFn) {
-  var fasGraph = new Graph();
-  var maxIn = 0;
-  var maxOut = 0;
-
-  _.forEach(g.nodes(), function (v) {
-    fasGraph.setNode(v, { v: v, in: 0, out: 0 });
-  });
-
-  // Aggregate weights on nodes, but also sum the weights across multi-edges
-  // into a single edge for the fasGraph.
-  _.forEach(g.edges(), function (e) {
-    var prevWeight = fasGraph.edge(e.v, e.w) || 0;
-    var weight = weightFn(e);
-    var 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));
-  });
-
-  var buckets = _.range(maxOut + maxIn + 3).map(function () {
-    return new List();
-  });
-  var zeroIdx = maxIn + 1;
-
-  _.forEach(fasGraph.nodes(), function (v) {
-    assignBucket(buckets, zeroIdx, fasGraph.node(v));
-  });
-
-  return { graph: fasGraph, buckets: buckets, zeroIdx: zeroIdx };
-}
-
-function assignBucket(buckets, zeroIdx, entry) {
-  if (!entry.out) {
-    buckets[0].enqueue(entry);
-  } else if (!entry['in']) {
-    buckets[buckets.length - 1].enqueue(entry);
-  } else {
-    buckets[entry.out - entry['in'] + zeroIdx].enqueue(entry);
-  }
-}

package/dashboard/.next/standalone/node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/index.js

@@ -1,6 +0,0 @@
-import * as acyclic from './acyclic.js';
-import { layout } from './layout.js';
-import * as normalize from './normalize.js';
-import { rank } from './rank/index.js';
-
-export { acyclic, normalize, rank, layout };

package/dashboard/.next/standalone/node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/layout.js

@@ -1,406 +0,0 @@
-import * as _ from 'lodash-es';
-import { Graph } from '../graphlib/index.js';
-import { addBorderSegments } from './add-border-segments.js';
-import * as coordinateSystem from './coordinate-system.js';
-import * as acyclic from './acyclic.js';
-import * as normalize from './normalize.js';
-import { rank } from './rank/index.js';
-import * as nestingGraph from './nesting-graph.js';
-import { order } from './order/index.js';
-import { parentDummyChains } from './parent-dummy-chains.js';
-import { position } from './position/index.js';
-import * as util from './util.js';
-
-export { layout };
-
-function layout(g, opts) {
-  var time = opts && opts.debugTiming ? util.time : util.notime;
-  time('layout', () => {
-    var 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', () => rank(util.asNonCompoundGraph(g)));
-  time('    injectEdgeLabelProxies', () => injectEdgeLabelProxies(g));
-  time('    removeEmptyRanks', () => util.removeEmptyRanks(g));
-  time('    nestingGraph.cleanup', () => nestingGraph.cleanup(g));
-  time('    normalizeRanks', () => util.normalizeRanks(g));
-  time('    assignRankMinMax', () => assignRankMinMax(g));
-  time('    removeEdgeLabelProxies', () => removeEdgeLabelProxies(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', () => 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));
-}
-
-/*
- * Copies final layout information from the layout graph back to the input
- * graph. This process only copies whitelisted attributes from the layout graph
- * to the input graph, so it serves as a good place to determine what
- * attributes can influence layout.
- */
-function updateInputGraph(inputGraph, layoutGraph) {
-  _.forEach(inputGraph.nodes(), function (v) {
-    var inputLabel = inputGraph.node(v);
-    var layoutLabel = layoutGraph.node(v);
-
-    if (inputLabel) {
-      inputLabel.x = layoutLabel.x;
-      inputLabel.y = layoutLabel.y;
-
-      if (layoutGraph.children(v).length) {
-        inputLabel.width = layoutLabel.width;
-        inputLabel.height = layoutLabel.height;
-      }
-    }
-  });
-
-  _.forEach(inputGraph.edges(), function (e) {
-    var inputLabel = inputGraph.edge(e);
-    var layoutLabel = layoutGraph.edge(e);
-
-    inputLabel.points = layoutLabel.points;
-    if (Object.prototype.hasOwnProperty.call(layoutLabel, 'x')) {
-      inputLabel.x = layoutLabel.x;
-      inputLabel.y = layoutLabel.y;
-    }
-  });
-
-  inputGraph.graph().width = layoutGraph.graph().width;
-  inputGraph.graph().height = layoutGraph.graph().height;
-}
-
-var graphNumAttrs = ['nodesep', 'edgesep', 'ranksep', 'marginx', 'marginy'];
-var graphDefaults = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: 'tb' };
-var graphAttrs = ['acyclicer', 'ranker', 'rankdir', 'align'];
-var nodeNumAttrs = ['width', 'height'];
-var nodeDefaults = { width: 0, height: 0 };
-var edgeNumAttrs = ['minlen', 'weight', 'width', 'height', 'labeloffset'];
-var edgeDefaults = {
-  minlen: 1,
-  weight: 1,
-  width: 0,
-  height: 0,
-  labeloffset: 10,
-  labelpos: 'r',
-};
-var edgeAttrs = ['labelpos'];
-
-/*
- * Constructs a new graph from the input graph, which can be used for layout.
- * This process copies only whitelisted attributes from the input graph to the
- * layout graph. Thus this function serves as a good place to determine what
- * attributes can influence layout.
- */
-function buildLayoutGraph(inputGraph) {
-  var g = new Graph({ multigraph: true, compound: true });
-  var graph = canonicalize(inputGraph.graph());
-
-  g.setGraph(
-    _.merge({}, graphDefaults, selectNumberAttrs(graph, graphNumAttrs), _.pick(graph, graphAttrs)),
-  );
-
-  _.forEach(inputGraph.nodes(), function (v) {
-    var node = canonicalize(inputGraph.node(v));
-    g.setNode(v, _.defaults(selectNumberAttrs(node, nodeNumAttrs), nodeDefaults));
-    g.setParent(v, inputGraph.parent(v));
-  });
-
-  _.forEach(inputGraph.edges(), function (e) {
-    var edge = canonicalize(inputGraph.edge(e));
-    g.setEdge(
-      e,
-      _.merge({}, edgeDefaults, selectNumberAttrs(edge, edgeNumAttrs), _.pick(edge, edgeAttrs)),
-    );
-  });
-
-  return g;
-}
-
-/*
- * This idea comes from the Gansner paper: to account for edge labels in our
- * layout we split each rank in half by doubling minlen and halving ranksep.
- * Then we can place labels at these mid-points between nodes.
- *
- * We also add some minimal padding to the width to push the label for the edge
- * away from the edge itself a bit.
- */
-function makeSpaceForEdgeLabels(g) {
-  var graph = g.graph();
-  graph.ranksep /= 2;
-  _.forEach(g.edges(), function (e) {
-    var edge = g.edge(e);
-    edge.minlen *= 2;
-    if (edge.labelpos.toLowerCase() !== 'c') {
-      if (graph.rankdir === 'TB' || graph.rankdir === 'BT') {
-        edge.width += edge.labeloffset;
-      } else {
-        edge.height += edge.labeloffset;
-      }
-    }
-  });
-}
-
-/*
- * Creates temporary dummy nodes that capture the rank in which each edge's
- * label is going to, if it has one of non-zero width and height. We do this
- * so that we can safely remove empty ranks while preserving balance for the
- * label's position.
- */
-function injectEdgeLabelProxies(g) {
-  _.forEach(g.edges(), function (e) {
-    var edge = g.edge(e);
-    if (edge.width && edge.height) {
-      var v = g.node(e.v);
-      var w = g.node(e.w);
-      var label = { rank: (w.rank - v.rank) / 2 + v.rank, e: e };
-      util.addDummyNode(g, 'edge-proxy', label, '_ep');
-    }
-  });
-}
-
-function assignRankMinMax(g) {
-  var maxRank = 0;
-  _.forEach(g.nodes(), function (v) {
-    var node = g.node(v);
-    if (node.borderTop) {
-      node.minRank = g.node(node.borderTop).rank;
-      node.maxRank = g.node(node.borderBottom).rank;
-      // @ts-expect-error
-      maxRank = _.max(maxRank, node.maxRank);
-    }
-  });
-  g.graph().maxRank = maxRank;
-}
-
-function removeEdgeLabelProxies(g) {
-  _.forEach(g.nodes(), function (v) {
-    var node = g.node(v);
-    if (node.dummy === 'edge-proxy') {
-      g.edge(node.e).labelRank = node.rank;
-      g.removeNode(v);
-    }
-  });
-}
-
-function translateGraph(g) {
-  var minX = Number.POSITIVE_INFINITY;
-  var maxX = 0;
-  var minY = Number.POSITIVE_INFINITY;
-  var maxY = 0;
-  var graphLabel = g.graph();
-  var marginX = graphLabel.marginx || 0;
-  var marginY = graphLabel.marginy || 0;
-
-  function getExtremes(attrs) {
-    var x = attrs.x;
-    var y = attrs.y;
-    var w = attrs.width;
-    var h = attrs.height;
-    minX = Math.min(minX, x - w / 2);
-    maxX = Math.max(maxX, x + w / 2);
-    minY = Math.min(minY, y - h / 2);
-    maxY = Math.max(maxY, y + h / 2);
-  }
-
-  _.forEach(g.nodes(), function (v) {
-    getExtremes(g.node(v));
-  });
-  _.forEach(g.edges(), function (e) {
-    var edge = g.edge(e);
-    if (Object.prototype.hasOwnProperty.call(edge, 'x')) {
-      getExtremes(edge);
-    }
-  });
-
-  minX -= marginX;
-  minY -= marginY;
-
-  _.forEach(g.nodes(), function (v) {
-    var node = g.node(v);
-    node.x -= minX;
-    node.y -= minY;
-  });
-
-  _.forEach(g.edges(), function (e) {
-    var edge = g.edge(e);
-    _.forEach(edge.points, function (p) {
-      p.x -= minX;
-      p.y -= minY;
-    });
-    if (Object.prototype.hasOwnProperty.call(edge, 'x')) {
-      edge.x -= minX;
-    }
-    if (Object.prototype.hasOwnProperty.call(edge, 'y')) {
-      edge.y -= minY;
-    }
-  });
-
-  graphLabel.width = maxX - minX + marginX;
-  graphLabel.height = maxY - minY + marginY;
-}
-
-function assignNodeIntersects(g) {
-  _.forEach(g.edges(), function (e) {
-    var edge = g.edge(e);
-    var nodeV = g.node(e.v);
-    var nodeW = g.node(e.w);
-    var p1, p2;
-    if (!edge.points) {
-      edge.points = [];
-      p1 = nodeW;
-      p2 = nodeV;
-    } else {
-      p1 = edge.points[0];
-      p2 = edge.points[edge.points.length - 1];
-    }
-    edge.points.unshift(util.intersectRect(nodeV, p1));
-    edge.points.push(util.intersectRect(nodeW, p2));
-  });
-}
-
-function fixupEdgeLabelCoords(g) {
-  _.forEach(g.edges(), function (e) {
-    var edge = g.edge(e);
-    if (Object.prototype.hasOwnProperty.call(edge, 'x')) {
-      if (edge.labelpos === 'l' || edge.labelpos === 'r') {
-        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;
-      }
-    }
-  });
-}
-
-function reversePointsForReversedEdges(g) {
-  _.forEach(g.edges(), function (e) {
-    var edge = g.edge(e);
-    if (edge.reversed) {
-      edge.points.reverse();
-    }
-  });
-}
-
-function removeBorderNodes(g) {
-  _.forEach(g.nodes(), function (v) {
-    if (g.children(v).length) {
-      var node = g.node(v);
-      var t = g.node(node.borderTop);
-      var b = g.node(node.borderBottom);
-      var l = g.node(_.last(node.borderLeft));
-      var r = g.node(_.last(node.borderRight));
-
-      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;
-    }
-  });
-
-  _.forEach(g.nodes(), function (v) {
-    if (g.node(v).dummy === 'border') {
-      g.removeNode(v);
-    }
-  });
-}
-
-function removeSelfEdges(g) {
-  _.forEach(g.edges(), function (e) {
-    if (e.v === e.w) {
-      var node = g.node(e.v);
-      if (!node.selfEdges) {
-        node.selfEdges = [];
-      }
-      node.selfEdges.push({ e: e, label: g.edge(e) });
-      g.removeEdge(e);
-    }
-  });
-}
-
-function insertSelfEdges(g) {
-  var layers = util.buildLayerMatrix(g);
-  _.forEach(layers, function (layer) {
-    var orderShift = 0;
-    _.forEach(layer, function (v, i) {
-      var node = g.node(v);
-      node.order = i + orderShift;
-      _.forEach(node.selfEdges, function (selfEdge) {
-        util.addDummyNode(
-          g,
-          'selfedge',
-          {
-            width: selfEdge.label.width,
-            height: selfEdge.label.height,
-            rank: node.rank,
-            order: i + ++orderShift,
-            e: selfEdge.e,
-            label: selfEdge.label,
-          },
-          '_se',
-        );
-      });
-      delete node.selfEdges;
-    });
-  });
-}
-
-function positionSelfEdges(g) {
-  _.forEach(g.nodes(), function (v) {
-    var node = g.node(v);
-    if (node.dummy === 'selfedge') {
-      var selfNode = g.node(node.e.v);
-      var x = selfNode.x + selfNode.width / 2;
-      var y = selfNode.y;
-      var dx = node.x - x;
-      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.x = node.x;
-      node.label.y = node.y;
-    }
-  });
-}
-
-function selectNumberAttrs(obj, attrs) {
-  return _.mapValues(_.pick(obj, attrs), Number);
-}
-
-function canonicalize(attrs) {
-  var newAttrs = {};
-  _.forEach(attrs, function (v, k) {
-    newAttrs[k.toLowerCase()] = v;
-  });
-  return newAttrs;
-}