@elmethis/core 1.0.0-alpha.146 → 1.0.0-alpha.148

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

@@ -0,0 +1,326 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,34 @@
+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
+};