@elmethis/core 1.0.0-alpha.149 → 1.0.0-alpha.150

package/dist/node_modules/.pnpm/d3-sankey@0.12.3/node_modules/d3-sankey/src/sankey.mjs

@@ -1,326 +0,0 @@
-import { justify } from "./align.mjs";
-import constant from "./constant.mjs";
-import sum from "../../../../d3-array@2.12.1/node_modules/d3-array/src/sum.mjs";
-import max from "../../../../d3-array@2.12.1/node_modules/d3-array/src/max.mjs";
-import min from "../../../../d3-array@2.12.1/node_modules/d3-array/src/min.mjs";
-function ascendingSourceBreadth(a, b) {
-  return ascendingBreadth(a.source, b.source) || a.index - b.index;
-}
-function ascendingTargetBreadth(a, b) {
-  return ascendingBreadth(a.target, b.target) || a.index - b.index;
-}
-function ascendingBreadth(a, b) {
-  return a.y0 - b.y0;
-}
-function value(d) {
-  return d.value;
-}
-function defaultId(d) {
-  return d.index;
-}
-function defaultNodes(graph) {
-  return graph.nodes;
-}
-function defaultLinks(graph) {
-  return graph.links;
-}
-function find(nodeById, id) {
-  const node = nodeById.get(id);
-  if (!node) throw new Error("missing: " + id);
-  return node;
-}
-function computeLinkBreadths({ nodes }) {
-  for (const node of nodes) {
-    let y0 = node.y0;
-    let y1 = y0;
-    for (const link of node.sourceLinks) {
-      link.y0 = y0 + link.width / 2;
-      y0 += link.width;
-    }
-    for (const link of node.targetLinks) {
-      link.y1 = y1 + link.width / 2;
-      y1 += link.width;
-    }
-  }
-}
-function Sankey() {
-  let x0 = 0, y0 = 0, x1 = 1, y1 = 1;
-  let dx = 24;
-  let dy = 8, py;
-  let id = defaultId;
-  let align = justify;
-  let sort;
-  let linkSort;
-  let nodes = defaultNodes;
-  let links = defaultLinks;
-  let iterations = 6;
-  function sankey() {
-    const graph = { nodes: nodes.apply(null, arguments), links: links.apply(null, arguments) };
-    computeNodeLinks(graph);
-    computeNodeValues(graph);
-    computeNodeDepths(graph);
-    computeNodeHeights(graph);
-    computeNodeBreadths(graph);
-    computeLinkBreadths(graph);
-    return graph;
-  }
-  sankey.update = function(graph) {
-    computeLinkBreadths(graph);
-    return graph;
-  };
-  sankey.nodeId = function(_) {
-    return arguments.length ? (id = typeof _ === "function" ? _ : constant(_), sankey) : id;
-  };
-  sankey.nodeAlign = function(_) {
-    return arguments.length ? (align = typeof _ === "function" ? _ : constant(_), sankey) : align;
-  };
-  sankey.nodeSort = function(_) {
-    return arguments.length ? (sort = _, sankey) : sort;
-  };
-  sankey.nodeWidth = function(_) {
-    return arguments.length ? (dx = +_, sankey) : dx;
-  };
-  sankey.nodePadding = function(_) {
-    return arguments.length ? (dy = py = +_, sankey) : dy;
-  };
-  sankey.nodes = function(_) {
-    return arguments.length ? (nodes = typeof _ === "function" ? _ : constant(_), sankey) : nodes;
-  };
-  sankey.links = function(_) {
-    return arguments.length ? (links = typeof _ === "function" ? _ : constant(_), sankey) : links;
-  };
-  sankey.linkSort = function(_) {
-    return arguments.length ? (linkSort = _, sankey) : linkSort;
-  };
-  sankey.size = function(_) {
-    return arguments.length ? (x0 = y0 = 0, x1 = +_[0], y1 = +_[1], sankey) : [x1 - x0, y1 - y0];
-  };
-  sankey.extent = function(_) {
-    return arguments.length ? (x0 = +_[0][0], x1 = +_[1][0], y0 = +_[0][1], y1 = +_[1][1], sankey) : [[x0, y0], [x1, y1]];
-  };
-  sankey.iterations = function(_) {
-    return arguments.length ? (iterations = +_, sankey) : iterations;
-  };
-  function computeNodeLinks({ nodes: nodes2, links: links2 }) {
-    for (const [i, node] of nodes2.entries()) {
-      node.index = i;
-      node.sourceLinks = [];
-      node.targetLinks = [];
-    }
-    const nodeById = new Map(nodes2.map((d, i) => [id(d, i, nodes2), d]));
-    for (const [i, link] of links2.entries()) {
-      link.index = i;
-      let { source, target } = link;
-      if (typeof source !== "object") source = link.source = find(nodeById, source);
-      if (typeof target !== "object") target = link.target = find(nodeById, target);
-      source.sourceLinks.push(link);
-      target.targetLinks.push(link);
-    }
-    if (linkSort != null) {
-      for (const { sourceLinks, targetLinks } of nodes2) {
-        sourceLinks.sort(linkSort);
-        targetLinks.sort(linkSort);
-      }
-    }
-  }
-  function computeNodeValues({ nodes: nodes2 }) {
-    for (const node of nodes2) {
-      node.value = node.fixedValue === void 0 ? Math.max(sum(node.sourceLinks, value), sum(node.targetLinks, value)) : node.fixedValue;
-    }
-  }
-  function computeNodeDepths({ nodes: nodes2 }) {
-    const n = nodes2.length;
-    let current = new Set(nodes2);
-    let next = /* @__PURE__ */ new Set();
-    let x = 0;
-    while (current.size) {
-      for (const node of current) {
-        node.depth = x;
-        for (const { target } of node.sourceLinks) {
-          next.add(target);
-        }
-      }
-      if (++x > n) throw new Error("circular link");
-      current = next;
-      next = /* @__PURE__ */ new Set();
-    }
-  }
-  function computeNodeHeights({ nodes: nodes2 }) {
-    const n = nodes2.length;
-    let current = new Set(nodes2);
-    let next = /* @__PURE__ */ new Set();
-    let x = 0;
-    while (current.size) {
-      for (const node of current) {
-        node.height = x;
-        for (const { source } of node.targetLinks) {
-          next.add(source);
-        }
-      }
-      if (++x > n) throw new Error("circular link");
-      current = next;
-      next = /* @__PURE__ */ new Set();
-    }
-  }
-  function computeNodeLayers({ nodes: nodes2 }) {
-    const x = max(nodes2, (d) => d.depth) + 1;
-    const kx = (x1 - x0 - dx) / (x - 1);
-    const columns = new Array(x);
-    for (const node of nodes2) {
-      const i = Math.max(0, Math.min(x - 1, Math.floor(align.call(null, node, x))));
-      node.layer = i;
-      node.x0 = x0 + i * kx;
-      node.x1 = node.x0 + dx;
-      if (columns[i]) columns[i].push(node);
-      else columns[i] = [node];
-    }
-    if (sort) for (const column of columns) {
-      column.sort(sort);
-    }
-    return columns;
-  }
-  function initializeNodeBreadths(columns) {
-    const ky = min(columns, (c) => (y1 - y0 - (c.length - 1) * py) / sum(c, value));
-    for (const nodes2 of columns) {
-      let y = y0;
-      for (const node of nodes2) {
-        node.y0 = y;
-        node.y1 = y + node.value * ky;
-        y = node.y1 + py;
-        for (const link of node.sourceLinks) {
-          link.width = link.value * ky;
-        }
-      }
-      y = (y1 - y + py) / (nodes2.length + 1);
-      for (let i = 0; i < nodes2.length; ++i) {
-        const node = nodes2[i];
-        node.y0 += y * (i + 1);
-        node.y1 += y * (i + 1);
-      }
-      reorderLinks(nodes2);
-    }
-  }
-  function computeNodeBreadths(graph) {
-    const columns = computeNodeLayers(graph);
-    py = Math.min(dy, (y1 - y0) / (max(columns, (c) => c.length) - 1));
-    initializeNodeBreadths(columns);
-    for (let i = 0; i < iterations; ++i) {
-      const alpha = Math.pow(0.99, i);
-      const beta = Math.max(1 - alpha, (i + 1) / iterations);
-      relaxRightToLeft(columns, alpha, beta);
-      relaxLeftToRight(columns, alpha, beta);
-    }
-  }
-  function relaxLeftToRight(columns, alpha, beta) {
-    for (let i = 1, n = columns.length; i < n; ++i) {
-      const column = columns[i];
-      for (const target of column) {
-        let y = 0;
-        let w = 0;
-        for (const { source, value: value2 } of target.targetLinks) {
-          let v = value2 * (target.layer - source.layer);
-          y += targetTop(source, target) * v;
-          w += v;
-        }
-        if (!(w > 0)) continue;
-        let dy2 = (y / w - target.y0) * alpha;
-        target.y0 += dy2;
-        target.y1 += dy2;
-        reorderNodeLinks(target);
-      }
-      if (sort === void 0) column.sort(ascendingBreadth);
-      resolveCollisions(column, beta);
-    }
-  }
-  function relaxRightToLeft(columns, alpha, beta) {
-    for (let n = columns.length, i = n - 2; i >= 0; --i) {
-      const column = columns[i];
-      for (const source of column) {
-        let y = 0;
-        let w = 0;
-        for (const { target, value: value2 } of source.sourceLinks) {
-          let v = value2 * (target.layer - source.layer);
-          y += sourceTop(source, target) * v;
-          w += v;
-        }
-        if (!(w > 0)) continue;
-        let dy2 = (y / w - source.y0) * alpha;
-        source.y0 += dy2;
-        source.y1 += dy2;
-        reorderNodeLinks(source);
-      }
-      if (sort === void 0) column.sort(ascendingBreadth);
-      resolveCollisions(column, beta);
-    }
-  }
-  function resolveCollisions(nodes2, alpha) {
-    const i = nodes2.length >> 1;
-    const subject = nodes2[i];
-    resolveCollisionsBottomToTop(nodes2, subject.y0 - py, i - 1, alpha);
-    resolveCollisionsTopToBottom(nodes2, subject.y1 + py, i + 1, alpha);
-    resolveCollisionsBottomToTop(nodes2, y1, nodes2.length - 1, alpha);
-    resolveCollisionsTopToBottom(nodes2, y0, 0, alpha);
-  }
-  function resolveCollisionsTopToBottom(nodes2, y, i, alpha) {
-    for (; i < nodes2.length; ++i) {
-      const node = nodes2[i];
-      const dy2 = (y - node.y0) * alpha;
-      if (dy2 > 1e-6) node.y0 += dy2, node.y1 += dy2;
-      y = node.y1 + py;
-    }
-  }
-  function resolveCollisionsBottomToTop(nodes2, y, i, alpha) {
-    for (; i >= 0; --i) {
-      const node = nodes2[i];
-      const dy2 = (node.y1 - y) * alpha;
-      if (dy2 > 1e-6) node.y0 -= dy2, node.y1 -= dy2;
-      y = node.y0 - py;
-    }
-  }
-  function reorderNodeLinks({ sourceLinks, targetLinks }) {
-    if (linkSort === void 0) {
-      for (const { source: { sourceLinks: sourceLinks2 } } of targetLinks) {
-        sourceLinks2.sort(ascendingTargetBreadth);
-      }
-      for (const { target: { targetLinks: targetLinks2 } } of sourceLinks) {
-        targetLinks2.sort(ascendingSourceBreadth);
-      }
-    }
-  }
-  function reorderLinks(nodes2) {
-    if (linkSort === void 0) {
-      for (const { sourceLinks, targetLinks } of nodes2) {
-        sourceLinks.sort(ascendingTargetBreadth);
-        targetLinks.sort(ascendingSourceBreadth);
-      }
-    }
-  }
-  function targetTop(source, target) {
-    let y = source.y0 - (source.sourceLinks.length - 1) * py / 2;
-    for (const { target: node, width } of source.sourceLinks) {
-      if (node === target) break;
-      y += width + py;
-    }
-    for (const { source: node, width } of target.targetLinks) {
-      if (node === source) break;
-      y -= width;
-    }
-    return y;
-  }
-  function sourceTop(source, target) {
-    let y = target.y0 - (target.targetLinks.length - 1) * py / 2;
-    for (const { source: node, width } of target.targetLinks) {
-      if (node === source) break;
-      y += width + py;
-    }
-    for (const { target: node, width } of source.sourceLinks) {
-      if (node === target) break;
-      y -= width;
-    }
-    return y;
-  }
-  return sankey;
-}
-export {
-  Sankey as default
-};

package/dist/node_modules/.pnpm/d3-sankey@0.12.3/node_modules/d3-sankey/src/sankeyLinkHorizontal.mjs

@@ -1,13 +0,0 @@
-import { linkHorizontal } from "../../../../d3-shape@1.3.7/node_modules/d3-shape/src/link/index.mjs";
-function horizontalSource(d) {
-  return [d.source.x1, d.y0];
-}
-function horizontalTarget(d) {
-  return [d.target.x0, d.y1];
-}
-function d3SankeyLinkHorizontal() {
-  return linkHorizontal().source(horizontalSource).target(horizontalTarget);
-}
-export {
-  d3SankeyLinkHorizontal as default
-};

package/dist/node_modules/.pnpm/d3-scale-chromatic@3.1.0/node_modules/d3-scale-chromatic/src/categorical/Tableau10.mjs

@@ -1,5 +0,0 @@
-import colors from "../colors.mjs";
-const d3schemeTableau10 = colors("4e79a7f28e2ce1575976b7b259a14fedc949af7aa1ff9da79c755fbab0ab");
-export {
-  d3schemeTableau10 as default
-};

package/dist/node_modules/.pnpm/d3-scale-chromatic@3.1.0/node_modules/d3-scale-chromatic/src/colors.mjs

@@ -1,8 +0,0 @@
-function colors(specifier) {
-  var n = specifier.length / 6 | 0, colors2 = new Array(n), i = 0;
-  while (i < n) colors2[i] = "#" + specifier.slice(i * 6, ++i * 6);
-  return colors2;
-}
-export {
-  colors as default
-};

package/dist/node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/band.mjs

@@ -1,56 +0,0 @@
-import { initRange } from "./init.mjs";
-import ordinal from "./ordinal.mjs";
-import range from "../../../../d3-array@3.2.4/node_modules/d3-array/src/range.mjs";
-function band() {
-  var scale = ordinal().unknown(void 0), domain = scale.domain, ordinalRange = scale.range, r0 = 0, r1 = 1, step, bandwidth, round = false, paddingInner = 0, paddingOuter = 0, align = 0.5;
-  delete scale.unknown;
-  function rescale() {
-    var n = domain().length, reverse = r1 < r0, start = reverse ? r1 : r0, stop = reverse ? r0 : r1;
-    step = (stop - start) / Math.max(1, n - paddingInner + paddingOuter * 2);
-    if (round) step = Math.floor(step);
-    start += (stop - start - step * (n - paddingInner)) * align;
-    bandwidth = step * (1 - paddingInner);
-    if (round) start = Math.round(start), bandwidth = Math.round(bandwidth);
-    var values = range(n).map(function(i) {
-      return start + step * i;
-    });
-    return ordinalRange(reverse ? values.reverse() : values);
-  }
-  scale.domain = function(_) {
-    return arguments.length ? (domain(_), rescale()) : domain();
-  };
-  scale.range = function(_) {
-    return arguments.length ? ([r0, r1] = _, r0 = +r0, r1 = +r1, rescale()) : [r0, r1];
-  };
-  scale.rangeRound = function(_) {
-    return [r0, r1] = _, r0 = +r0, r1 = +r1, round = true, rescale();
-  };
-  scale.bandwidth = function() {
-    return bandwidth;
-  };
-  scale.step = function() {
-    return step;
-  };
-  scale.round = function(_) {
-    return arguments.length ? (round = !!_, rescale()) : round;
-  };
-  scale.padding = function(_) {
-    return arguments.length ? (paddingInner = Math.min(1, paddingOuter = +_), rescale()) : paddingInner;
-  };
-  scale.paddingInner = function(_) {
-    return arguments.length ? (paddingInner = Math.min(1, _), rescale()) : paddingInner;
-  };
-  scale.paddingOuter = function(_) {
-    return arguments.length ? (paddingOuter = +_, rescale()) : paddingOuter;
-  };
-  scale.align = function(_) {
-    return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align;
-  };
-  scale.copy = function() {
-    return band(domain(), [r0, r1]).round(round).paddingInner(paddingInner).paddingOuter(paddingOuter).align(align);
-  };
-  return initRange.apply(rescale(), arguments);
-}
-export {
-  band as default
-};

package/dist/node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/constant.mjs

@@ -1,8 +0,0 @@
-function constants(x) {
-  return function() {
-    return x;
-  };
-}
-export {
-  constants as default
-};

package/dist/node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/continuous.mjs

@@ -1,95 +0,0 @@
-import constants from "./constant.mjs";
-import number from "./number.mjs";
-import interpolateNumber from "../../../../d3-interpolate@3.0.1/node_modules/d3-interpolate/src/number.mjs";
-import interpolate from "../../../../d3-interpolate@3.0.1/node_modules/d3-interpolate/src/value.mjs";
-import { bisectRight } from "../../../../d3-array@3.2.4/node_modules/d3-array/src/bisect.mjs";
-import interpolateRound from "../../../../d3-interpolate@3.0.1/node_modules/d3-interpolate/src/round.mjs";
-var unit = [0, 1];
-function identity(x) {
-  return x;
-}
-function normalize(a, b) {
-  return (b -= a = +a) ? function(x) {
-    return (x - a) / b;
-  } : constants(isNaN(b) ? NaN : 0.5);
-}
-function clamper(a, b) {
-  var t;
-  if (a > b) t = a, a = b, b = t;
-  return function(x) {
-    return Math.max(a, Math.min(b, x));
-  };
-}
-function bimap(domain, range, interpolate2) {
-  var d0 = domain[0], d1 = domain[1], r0 = range[0], r1 = range[1];
-  if (d1 < d0) d0 = normalize(d1, d0), r0 = interpolate2(r1, r0);
-  else d0 = normalize(d0, d1), r0 = interpolate2(r0, r1);
-  return function(x) {
-    return r0(d0(x));
-  };
-}
-function polymap(domain, range, interpolate2) {
-  var j = Math.min(domain.length, range.length) - 1, d = new Array(j), r = new Array(j), i = -1;
-  if (domain[j] < domain[0]) {
-    domain = domain.slice().reverse();
-    range = range.slice().reverse();
-  }
-  while (++i < j) {
-    d[i] = normalize(domain[i], domain[i + 1]);
-    r[i] = interpolate2(range[i], range[i + 1]);
-  }
-  return function(x) {
-    var i2 = bisectRight(domain, x, 1, j) - 1;
-    return r[i2](d[i2](x));
-  };
-}
-function copy(source, target) {
-  return target.domain(source.domain()).range(source.range()).interpolate(source.interpolate()).clamp(source.clamp()).unknown(source.unknown());
-}
-function transformer() {
-  var domain = unit, range = unit, interpolate$1 = interpolate, transform, untransform, unknown, clamp = identity, piecewise, output, input;
-  function rescale() {
-    var n = Math.min(domain.length, range.length);
-    if (clamp !== identity) clamp = clamper(domain[0], domain[n - 1]);
-    piecewise = n > 2 ? polymap : bimap;
-    output = input = null;
-    return scale;
-  }
-  function scale(x) {
-    return x == null || isNaN(x = +x) ? unknown : (output || (output = piecewise(domain.map(transform), range, interpolate$1)))(transform(clamp(x)));
-  }
-  scale.invert = function(y) {
-    return clamp(untransform((input || (input = piecewise(range, domain.map(transform), interpolateNumber)))(y)));
-  };
-  scale.domain = function(_) {
-    return arguments.length ? (domain = Array.from(_, number), rescale()) : domain.slice();
-  };
-  scale.range = function(_) {
-    return arguments.length ? (range = Array.from(_), rescale()) : range.slice();
-  };
-  scale.rangeRound = function(_) {
-    return range = Array.from(_), interpolate$1 = interpolateRound, rescale();
-  };
-  scale.clamp = function(_) {
-    return arguments.length ? (clamp = _ ? true : identity, rescale()) : clamp !== identity;
-  };
-  scale.interpolate = function(_) {
-    return arguments.length ? (interpolate$1 = _, rescale()) : interpolate$1;
-  };
-  scale.unknown = function(_) {
-    return arguments.length ? (unknown = _, scale) : unknown;
-  };
-  return function(t, u) {
-    transform = t, untransform = u;
-    return rescale();
-  };
-}
-function continuous() {
-  return transformer()(identity, identity);
-}
-export {
-  copy,
-  continuous as default,
-  identity,
-  transformer
-};

package/dist/node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/init.mjs

@@ -1,16 +0,0 @@
-function initRange(domain, range) {
-  switch (arguments.length) {
-    case 0:
-      break;
-    case 1:
-      this.range(domain);
-      break;
-    default:
-      this.range(range).domain(domain);
-      break;
-  }
-  return this;
-}
-export {
-  initRange
-};

package/dist/node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/linear.mjs

@@ -1,61 +0,0 @@
-import continuous, { copy } from "./continuous.mjs";
-import { initRange } from "./init.mjs";
-import tickFormat from "./tickFormat.mjs";
-import ticks, { tickIncrement } from "../../../../d3-array@3.2.4/node_modules/d3-array/src/ticks.mjs";
-function linearish(scale) {
-  var domain = scale.domain;
-  scale.ticks = function(count) {
-    var d = domain();
-    return ticks(d[0], d[d.length - 1], count == null ? 10 : count);
-  };
-  scale.tickFormat = function(count, specifier) {
-    var d = domain();
-    return tickFormat(d[0], d[d.length - 1], count == null ? 10 : count, specifier);
-  };
-  scale.nice = function(count) {
-    if (count == null) count = 10;
-    var d = domain();
-    var i0 = 0;
-    var i1 = d.length - 1;
-    var start = d[i0];
-    var stop = d[i1];
-    var prestep;
-    var step;
-    var maxIter = 10;
-    if (stop < start) {
-      step = start, start = stop, stop = step;
-      step = i0, i0 = i1, i1 = step;
-    }
-    while (maxIter-- > 0) {
-      step = tickIncrement(start, stop, count);
-      if (step === prestep) {
-        d[i0] = start;
-        d[i1] = stop;
-        return domain(d);
-      } else if (step > 0) {
-        start = Math.floor(start / step) * step;
-        stop = Math.ceil(stop / step) * step;
-      } else if (step < 0) {
-        start = Math.ceil(start * step) / step;
-        stop = Math.floor(stop * step) / step;
-      } else {
-        break;
-      }
-      prestep = step;
-    }
-    return scale;
-  };
-  return scale;
-}
-function linear() {
-  var scale = continuous();
-  scale.copy = function() {
-    return copy(scale, linear());
-  };
-  initRange.apply(scale, arguments);
-  return linearish(scale);
-}
-export {
-  linear as default,
-  linearish
-};

package/dist/node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/nice.mjs

@@ -1,14 +0,0 @@
-function nice(domain, interval) {
-  domain = domain.slice();
-  var i0 = 0, i1 = domain.length - 1, x0 = domain[i0], x1 = domain[i1], t;
-  if (x1 < x0) {
-    t = i0, i0 = i1, i1 = t;
-    t = x0, x0 = x1, x1 = t;
-  }
-  domain[i0] = interval.floor(x0);
-  domain[i1] = interval.ceil(x1);
-  return domain;
-}
-export {
-  nice as default
-};

package/dist/node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/number.mjs

@@ -1,6 +0,0 @@
-function number(x) {
-  return +x;
-}
-export {
-  number as default
-};

package/dist/node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/ordinal.mjs

@@ -1,38 +0,0 @@
-import { initRange } from "./init.mjs";
-import { InternMap } from "../../../../internmap@2.0.3/node_modules/internmap/src/index.mjs";
-const implicit = Symbol("implicit");
-function ordinal() {
-  var index = new InternMap(), domain = [], range = [], unknown = implicit;
-  function scale(d) {
-    let i = index.get(d);
-    if (i === void 0) {
-      if (unknown !== implicit) return unknown;
-      index.set(d, i = domain.push(d) - 1);
-    }
-    return range[i % range.length];
-  }
-  scale.domain = function(_) {
-    if (!arguments.length) return domain.slice();
-    domain = [], index = new InternMap();
-    for (const value of _) {
-      if (index.has(value)) continue;
-      index.set(value, domain.push(value) - 1);
-    }
-    return scale;
-  };
-  scale.range = function(_) {
-    return arguments.length ? (range = Array.from(_), scale) : range.slice();
-  };
-  scale.unknown = function(_) {
-    return arguments.length ? (unknown = _, scale) : unknown;
-  };
-  scale.copy = function() {
-    return ordinal(domain, range).unknown(unknown);
-  };
-  initRange.apply(scale, arguments);
-  return scale;
-}
-export {
-  ordinal as default,
-  implicit
-};

package/dist/node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/tickFormat.mjs

@@ -1,34 +0,0 @@
-import { tickStep } from "../../../../d3-array@3.2.4/node_modules/d3-array/src/ticks.mjs";
-import formatSpecifier from "../../../../d3-format@3.1.0/node_modules/d3-format/src/formatSpecifier.mjs";
-import precisionFixed from "../../../../d3-format@3.1.0/node_modules/d3-format/src/precisionFixed.mjs";
-import precisionRound from "../../../../d3-format@3.1.0/node_modules/d3-format/src/precisionRound.mjs";
-import precisionPrefix from "../../../../d3-format@3.1.0/node_modules/d3-format/src/precisionPrefix.mjs";
-import { formatPrefix, format } from "../../../../d3-format@3.1.0/node_modules/d3-format/src/defaultLocale.mjs";
-function tickFormat(start, stop, count, specifier) {
-  var step = tickStep(start, stop, count), precision;
-  specifier = formatSpecifier(specifier == null ? ",f" : specifier);
-  switch (specifier.type) {
-    case "s": {
-      var value = Math.max(Math.abs(start), Math.abs(stop));
-      if (specifier.precision == null && !isNaN(precision = precisionPrefix(step, value))) specifier.precision = precision;
-      return formatPrefix(specifier, value);
-    }
-    case "":
-    case "e":
-    case "g":
-    case "p":
-    case "r": {
-      if (specifier.precision == null && !isNaN(precision = precisionRound(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === "e");
-      break;
-    }
-    case "f":
-    case "%": {
-      if (specifier.precision == null && !isNaN(precision = precisionFixed(step))) specifier.precision = precision - (specifier.type === "%") * 2;
-      break;
-    }
-  }
-  return format(specifier);
-}
-export {
-  tickFormat as default
-};