laif-ds 0.1.73 → 0.1.75

package/dist/node_modules/d3-interpolate/src/numberArray.js

@@ -0,0 +1,16 @@
+"use client";
+function f(r, e) {
+  e || (e = []);
+  var u = r ? Math.min(e.length, r.length) : 0, i = e.slice(), n;
+  return function(t) {
+    for (n = 0; n < u; ++n) i[n] = r[n] * (1 - t) + e[n] * t;
+    return i;
+  };
+}
+function a(r) {
+  return ArrayBuffer.isView(r) && !(r instanceof DataView);
+}
+export {
+  f as default,
+  a as isNumberArray
+};

package/dist/node_modules/d3-interpolate/src/object.js

@@ -0,0 +1,15 @@
+"use client";
+import r from "./value.js";
+function u(n, t) {
+  var o = {}, i = {}, e;
+  (n === null || typeof n != "object") && (n = {}), (t === null || typeof t != "object") && (t = {});
+  for (e in t)
+    e in n ? o[e] = r(n[e], t[e]) : i[e] = t[e];
+  return function(f) {
+    for (e in o) i[e] = o[e](f);
+    return i;
+  };
+}
+export {
+  u as default
+};

package/dist/node_modules/d3-interpolate/src/piecewise.js

@@ -0,0 +1,13 @@
+"use client";
+import a from "./value.js";
+function m(r, n) {
+  n === void 0 && (n = r, r = a);
+  for (var t = 0, i = n.length - 1, e = n[0], f = new Array(i < 0 ? 0 : i); t < i; ) f[t] = r(e, e = n[++t]);
+  return function(o) {
+    var h = Math.max(0, Math.min(i - 1, Math.floor(o *= i)));
+    return f[h](o - h);
+  };
+}
+export {
+  m as default
+};

package/dist/node_modules/d3-interpolate/src/rgb.js

@@ -0,0 +1,16 @@
+"use client";
+import y, { gamma as e } from "./color.js";
+import { rgb as i } from "../../d3-color/src/color.js";
+const x = function b(a) {
+  var m = e(a);
+  function c(o, r) {
+    var n = m((o = i(o)).r, (r = i(r)).r), u = m(o.g, r.g), p = m(o.b, r.b), f = y(o.opacity, r.opacity);
+    return function(g) {
+      return o.r = n(g), o.g = u(g), o.b = p(g), o.opacity = f(g), o + "";
+    };
+  }
+  return c.gamma = b, c;
+}(1);
+export {
+  x as default
+};

package/dist/node_modules/d3-interpolate/src/round.js

@@ -0,0 +1,9 @@
+"use client";
+function u(n, t) {
+  return n = +n, t = +t, function(e) {
+    return Math.round(n * (1 - e) + t * e);
+  };
+}
+export {
+  u as default
+};

package/dist/node_modules/d3-interpolate/src/string.js

@@ -0,0 +1,25 @@
+"use client";
+import g from "./number.js";
+var x = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g, c = new RegExp(x.source, "g");
+function h(i) {
+  return function() {
+    return i;
+  };
+}
+function m(i) {
+  return function(n) {
+    return i(n) + "";
+  };
+}
+function v(i, n) {
+  var u = x.lastIndex = c.lastIndex = 0, f, l, t, r = -1, e = [], s = [];
+  for (i = i + "", n = n + ""; (f = x.exec(i)) && (l = c.exec(n)); )
+    (t = l.index) > u && (t = n.slice(u, t), e[r] ? e[r] += t : e[++r] = t), (f = f[0]) === (l = l[0]) ? e[r] ? e[r] += l : e[++r] = l : (e[++r] = null, s.push({ i: r, x: g(f, l) })), u = c.lastIndex;
+  return u < n.length && (t = n.slice(u), e[r] ? e[r] += t : e[++r] = t), e.length < 2 ? s[0] ? m(s[0].x) : h(n) : (n = s.length, function(a) {
+    for (var o = 0, d; o < n; ++o) e[(d = s[o]).i] = d.x(a);
+    return e.join("");
+  });
+}
+export {
+  v as default
+};

package/dist/node_modules/d3-interpolate/src/value.js

@@ -0,0 +1,17 @@
+"use client";
+import e from "./rgb.js";
+import { genericArray as f } from "./array.js";
+import a from "./date.js";
+import i from "./number.js";
+import p from "./object.js";
+import u from "./string.js";
+import c from "./constant.js";
+import s, { isNumberArray as l } from "./numberArray.js";
+import n from "../../d3-color/src/color.js";
+function O(m, r) {
+  var o = typeof r, t;
+  return r == null || o === "boolean" ? c(r) : (o === "number" ? i : o === "string" ? (t = n(r)) ? (r = t, e) : u : r instanceof n ? e : r instanceof Date ? a : l(r) ? s : Array.isArray(r) ? f : typeof r.valueOf != "function" && typeof r.toString != "function" || isNaN(r) ? p : i)(m, r);
+}
+export {
+  O as default
+};

package/dist/node_modules/d3-scale/src/band.js

@@ -0,0 +1,52 @@
+"use client";
+import { initRange as I } from "./init.js";
+import O from "./ordinal.js";
+import w from "../../d3-array/src/range.js";
+function s() {
+  var n = O().unknown(void 0), d = n.domain, v = n.range, t = 0, e = 1, i, f, o = !1, a = 0, p = 0, m = 0.5;
+  delete n.unknown;
+  function u() {
+    var r = d().length, l = e < t, g = l ? e : t, h = l ? t : e;
+    i = (h - g) / Math.max(1, r - a + p * 2), o && (i = Math.floor(i)), g += (h - g - i * (r - a)) * m, f = i * (1 - a), o && (g = Math.round(g), f = Math.round(f));
+    var c = w(r).map(function(y) {
+      return g + i * y;
+    });
+    return v(l ? c.reverse() : c);
+  }
+  return n.domain = function(r) {
+    return arguments.length ? (d(r), u()) : d();
+  }, n.range = function(r) {
+    return arguments.length ? ([t, e] = r, t = +t, e = +e, u()) : [t, e];
+  }, n.rangeRound = function(r) {
+    return [t, e] = r, t = +t, e = +e, o = !0, u();
+  }, n.bandwidth = function() {
+    return f;
+  }, n.step = function() {
+    return i;
+  }, n.round = function(r) {
+    return arguments.length ? (o = !!r, u()) : o;
+  }, n.padding = function(r) {
+    return arguments.length ? (a = Math.min(1, p = +r), u()) : a;
+  }, n.paddingInner = function(r) {
+    return arguments.length ? (a = Math.min(1, r), u()) : a;
+  }, n.paddingOuter = function(r) {
+    return arguments.length ? (p = +r, u()) : p;
+  }, n.align = function(r) {
+    return arguments.length ? (m = Math.max(0, Math.min(1, r)), u()) : m;
+  }, n.copy = function() {
+    return s(d(), [t, e]).round(o).paddingInner(a).paddingOuter(p).align(m);
+  }, I.apply(u(), arguments);
+}
+function M(n) {
+  var d = n.copy;
+  return n.padding = n.paddingOuter, delete n.paddingInner, delete n.paddingOuter, n.copy = function() {
+    return M(d());
+  }, n;
+}
+function k() {
+  return M(s.apply(null, arguments).paddingInner(1));
+}
+export {
+  s as default,
+  k as point
+};

package/dist/node_modules/d3-scale/src/constant.js

@@ -0,0 +1,9 @@
+"use client";
+function t(n) {
+  return function() {
+    return n;
+  };
+}
+export {
+  t as default
+};

package/dist/node_modules/d3-scale/src/continuous.js

@@ -0,0 +1,76 @@
+"use client";
+import w from "./constant.js";
+import y from "./number.js";
+import N from "../../d3-interpolate/src/number.js";
+import A from "../../d3-interpolate/src/value.js";
+import { bisectRight as k } from "../../d3-array/src/bisect.js";
+import M from "../../d3-interpolate/src/round.js";
+var h = [0, 1];
+function p(n) {
+  return n;
+}
+function g(n, r) {
+  return (r -= n = +n) ? function(i) {
+    return (i - n) / r;
+  } : w(isNaN(r) ? NaN : 0.5);
+}
+function d(n, r) {
+  var i;
+  return n > r && (i = n, n = r, r = i), function(e) {
+    return Math.max(n, Math.min(r, e));
+  };
+}
+function R(n, r, i) {
+  var e = n[0], a = n[1], o = r[0], u = r[1];
+  return a < e ? (e = g(a, e), o = i(u, o)) : (e = g(e, a), o = i(o, u)), function(l) {
+    return o(e(l));
+  };
+}
+function j(n, r, i) {
+  var e = Math.min(n.length, r.length) - 1, a = new Array(e), o = new Array(e), u = -1;
+  for (n[e] < n[0] && (n = n.slice().reverse(), r = r.slice().reverse()); ++u < e; )
+    a[u] = g(n[u], n[u + 1]), o[u] = i(r[u], r[u + 1]);
+  return function(l) {
+    var c = k(n, l, 1, e) - 1;
+    return o[c](a[c](l));
+  };
+}
+function F(n, r) {
+  return r.domain(n.domain()).range(n.range()).interpolate(n.interpolate()).clamp(n.clamp()).unknown(n.unknown());
+}
+function z() {
+  var n = h, r = h, i = A, e, a, o, u = p, l, c, s;
+  function m() {
+    var t = Math.min(n.length, r.length);
+    return u !== p && (u = d(n[0], n[t - 1])), l = t > 2 ? j : R, c = s = null, f;
+  }
+  function f(t) {
+    return t == null || isNaN(t = +t) ? o : (c || (c = l(n.map(e), r, i)))(e(u(t)));
+  }
+  return f.invert = function(t) {
+    return u(a((s || (s = l(r, n.map(e), N)))(t)));
+  }, f.domain = function(t) {
+    return arguments.length ? (n = Array.from(t, y), m()) : n.slice();
+  }, f.range = function(t) {
+    return arguments.length ? (r = Array.from(t), m()) : r.slice();
+  }, f.rangeRound = function(t) {
+    return r = Array.from(t), i = M, m();
+  }, f.clamp = function(t) {
+    return arguments.length ? (u = t ? !0 : p, m()) : u !== p;
+  }, f.interpolate = function(t) {
+    return arguments.length ? (i = t, m()) : i;
+  }, f.unknown = function(t) {
+    return arguments.length ? (o = t, f) : o;
+  }, function(t, v) {
+    return e = t, a = v, m();
+  };
+}
+function G() {
+  return z()(p, p);
+}
+export {
+  F as copy,
+  G as default,
+  p as identity,
+  z as transformer
+};

package/dist/node_modules/d3-scale/src/diverging.js

@@ -0,0 +1,69 @@
+"use client";
+import { identity as M } from "./continuous.js";
+import { initInterpolator as g } from "./init.js";
+import { linearish as S } from "./linear.js";
+import { loggish as q } from "./log.js";
+import { copy as f } from "./sequential.js";
+import { symlogish as x } from "./symlog.js";
+import { powish as I } from "./pow.js";
+import L from "../../d3-interpolate/src/piecewise.js";
+import P from "../../d3-interpolate/src/value.js";
+import j from "../../d3-interpolate/src/round.js";
+function s() {
+  var n = 0, a = 0.5, m = 1, c = 1, o, t, u, l, y, i = M, p, d = !1, h;
+  function e(r) {
+    return isNaN(r = +r) ? h : (r = 0.5 + ((r = +p(r)) - t) * (c * r < c * t ? l : y), i(d ? Math.max(0, Math.min(1, r)) : r));
+  }
+  e.domain = function(r) {
+    return arguments.length ? ([n, a, m] = r, o = p(n = +n), t = p(a = +a), u = p(m = +m), l = o === t ? 0 : 0.5 / (t - o), y = t === u ? 0 : 0.5 / (u - t), c = t < o ? -1 : 1, e) : [n, a, m];
+  }, e.clamp = function(r) {
+    return arguments.length ? (d = !!r, e) : d;
+  }, e.interpolator = function(r) {
+    return arguments.length ? (i = r, e) : i;
+  };
+  function v(r) {
+    return function(R) {
+      var w, k, b;
+      return arguments.length ? ([w, k, b] = R, i = L(r, [w, k, b]), e) : [i(0), i(0.5), i(1)];
+    };
+  }
+  return e.range = v(P), e.rangeRound = v(j), e.unknown = function(r) {
+    return arguments.length ? (h = r, e) : h;
+  }, function(r) {
+    return p = r, o = r(n), t = r(a), u = r(m), l = o === t ? 0 : 0.5 / (t - o), y = t === u ? 0 : 0.5 / (u - t), c = t < o ? -1 : 1, e;
+  };
+}
+function z() {
+  var n = S(s()(M));
+  return n.copy = function() {
+    return f(n, z());
+  }, g.apply(n, arguments);
+}
+function A() {
+  var n = q(s()).domain([0.1, 1, 10]);
+  return n.copy = function() {
+    return f(n, A()).base(n.base());
+  }, g.apply(n, arguments);
+}
+function B() {
+  var n = x(s());
+  return n.copy = function() {
+    return f(n, B()).constant(n.constant());
+  }, g.apply(n, arguments);
+}
+function N() {
+  var n = I(s());
+  return n.copy = function() {
+    return f(n, N()).exponent(n.exponent());
+  }, g.apply(n, arguments);
+}
+function T() {
+  return N.apply(null, arguments).exponent(0.5);
+}
+export {
+  z as default,
+  A as divergingLog,
+  N as divergingPow,
+  T as divergingSqrt,
+  B as divergingSymlog
+};

package/dist/node_modules/d3-scale/src/identity.js

@@ -0,0 +1,19 @@
+"use client";
+import { linearish as o } from "./linear.js";
+import u from "./number.js";
+function i(t) {
+  var e;
+  function n(r) {
+    return r == null || isNaN(r = +r) ? e : r;
+  }
+  return n.invert = n, n.domain = n.range = function(r) {
+    return arguments.length ? (t = Array.from(r, u), n) : t.slice();
+  }, n.unknown = function(r) {
+    return arguments.length ? (e = r, n) : e;
+  }, n.copy = function() {
+    return i(t).unknown(e);
+  }, t = arguments.length ? Array.from(t, u) : [0, 1], o(n);
+}
+export {
+  i as default
+};

package/dist/node_modules/d3-scale/src/init.js

@@ -0,0 +1,33 @@
+"use client";
+function n(e, t) {
+  switch (arguments.length) {
+    case 0:
+      break;
+    case 1:
+      this.range(e);
+      break;
+    default:
+      this.range(t).domain(e);
+      break;
+  }
+  return this;
+}
+function i(e, t) {
+  switch (arguments.length) {
+    case 0:
+      break;
+    case 1: {
+      typeof e == "function" ? this.interpolator(e) : this.range(e);
+      break;
+    }
+    default: {
+      this.domain(e), typeof t == "function" ? this.interpolator(t) : this.range(t);
+      break;
+    }
+  }
+  return this;
+}
+export {
+  i as initInterpolator,
+  n as initRange
+};

package/dist/node_modules/d3-scale/src/linear.js

@@ -0,0 +1,40 @@
+"use client";
+import p, { copy as v } from "./continuous.js";
+import { initRange as c } from "./init.js";
+import s from "./tickFormat.js";
+import h, { tickIncrement as d } from "../../d3-array/src/ticks.js";
+function k(i) {
+  var f = i.domain;
+  return i.ticks = function(n) {
+    var t = f();
+    return h(t[0], t[t.length - 1], n ?? 10);
+  }, i.tickFormat = function(n, t) {
+    var o = f();
+    return s(o[0], o[o.length - 1], n ?? 10, t);
+  }, i.nice = function(n) {
+    n == null && (n = 10);
+    var t = f(), o = 0, l = t.length - 1, e = t[o], a = t[l], u, r, m = 10;
+    for (a < e && (r = e, e = a, a = r, r = o, o = l, l = r); m-- > 0; ) {
+      if (r = d(e, a, n), r === u)
+        return t[o] = e, t[l] = a, f(t);
+      if (r > 0)
+        e = Math.floor(e / r) * r, a = Math.ceil(a / r) * r;
+      else if (r < 0)
+        e = Math.ceil(e * r) / r, a = Math.floor(a * r) / r;
+      else
+        break;
+      u = r;
+    }
+    return i;
+  }, i;
+}
+function g() {
+  var i = p();
+  return i.copy = function() {
+    return v(i, g());
+  }, c.apply(i, arguments), k(i);
+}
+export {
+  g as default,
+  k as linearish
+};

package/dist/node_modules/d3-scale/src/log.js

@@ -0,0 +1,87 @@
+"use client";
+import E from "./nice.js";
+import { transformer as v, copy as F } from "./continuous.js";
+import { initRange as L } from "./init.js";
+import d from "../../d3-array/src/ticks.js";
+import j from "../../d3-format/src/formatSpecifier.js";
+import { format as z } from "../../d3-format/src/defaultLocale.js";
+function y(t) {
+  return Math.log(t);
+}
+function w(t) {
+  return Math.exp(t);
+}
+function I(t) {
+  return -Math.log(-t);
+}
+function R(t) {
+  return -Math.exp(-t);
+}
+function S(t) {
+  return isFinite(t) ? +("1e" + t) : t < 0 ? 0 : t;
+}
+function q(t) {
+  return t === 10 ? S : t === Math.E ? Math.exp : (n) => Math.pow(t, n);
+}
+function A(t) {
+  return t === Math.E ? Math.log : t === 10 && Math.log10 || t === 2 && Math.log2 || (t = Math.log(t), (n) => Math.log(n) / t);
+}
+function x(t) {
+  return (n, m) => -t(-n, m);
+}
+function B(t) {
+  const n = t(y, w), m = n.domain;
+  let l = 10, c, i;
+  function k() {
+    return c = A(l), i = q(l), m()[0] < 0 ? (c = x(c), i = x(i), t(I, R)) : t(y, w), n;
+  }
+  return n.base = function(o) {
+    return arguments.length ? (l = +o, k()) : l;
+  }, n.domain = function(o) {
+    return arguments.length ? (m(o), k()) : m();
+  }, n.ticks = (o) => {
+    const e = m();
+    let f = e[0], u = e[e.length - 1];
+    const M = u < f;
+    M && ([f, u] = [u, f]);
+    let r = c(f), g = c(u), a, h;
+    const p = o == null ? 10 : +o;
+    let s = [];
+    if (!(l % 1) && g - r < p) {
+      if (r = Math.floor(r), g = Math.ceil(g), f > 0) {
+        for (; r <= g; ++r)
+          for (a = 1; a < l; ++a)
+            if (h = r < 0 ? a / i(-r) : a * i(r), !(h < f)) {
+              if (h > u) break;
+              s.push(h);
+            }
+      } else for (; r <= g; ++r)
+        for (a = l - 1; a >= 1; --a)
+          if (h = r > 0 ? a / i(-r) : a * i(r), !(h < f)) {
+            if (h > u) break;
+            s.push(h);
+          }
+      s.length * 2 < p && (s = d(f, u, p));
+    } else
+      s = d(r, g, Math.min(g - r, p)).map(i);
+    return M ? s.reverse() : s;
+  }, n.tickFormat = (o, e) => {
+    if (o == null && (o = 10), e == null && (e = l === 10 ? "s" : ","), typeof e != "function" && (!(l % 1) && (e = j(e)).precision == null && (e.trim = !0), e = z(e)), o === 1 / 0) return e;
+    const f = Math.max(1, l * o / n.ticks().length);
+    return (u) => {
+      let M = u / i(Math.round(c(u)));
+      return M * l < l - 0.5 && (M *= l), M <= f ? e(u) : "";
+    };
+  }, n.nice = () => m(E(m(), {
+    floor: (o) => i(Math.floor(c(o))),
+    ceil: (o) => i(Math.ceil(c(o)))
+  })), n;
+}
+function C() {
+  const t = B(v()).domain([1, 10]);
+  return t.copy = () => F(t, C()).base(t.base()), L.apply(t, arguments), t;
+}
+export {
+  C as default,
+  B as loggish
+};

package/dist/node_modules/d3-scale/src/nice.js

@@ -0,0 +1,9 @@
+"use client";
+function s(e, u) {
+  e = e.slice();
+  var t = 0, c = e.length - 1, l = e[t], f = e[c], r;
+  return f < l && (r = t, t = c, c = r, r = l, l = f, f = r), e[t] = u.floor(l), e[c] = u.ceil(f), e;
+}
+export {
+  s as default
+};

package/dist/node_modules/d3-scale/src/number.js

@@ -0,0 +1,7 @@
+"use client";
+function n(e) {
+  return +e;
+}
+export {
+  n as default
+};

package/dist/node_modules/d3-scale/src/ordinal.js

@@ -0,0 +1,32 @@
+"use client";
+import { initRange as c } from "./init.js";
+import { InternMap as a } from "../../internmap/src/index.js";
+const f = Symbol("implicit");
+function l() {
+  var r = new a(), i = [], u = [], o = f;
+  function n(e) {
+    let t = r.get(e);
+    if (t === void 0) {
+      if (o !== f) return o;
+      r.set(e, t = i.push(e) - 1);
+    }
+    return u[t % u.length];
+  }
+  return n.domain = function(e) {
+    if (!arguments.length) return i.slice();
+    i = [], r = new a();
+    for (const t of e)
+      r.has(t) || r.set(t, i.push(t) - 1);
+    return n;
+  }, n.range = function(e) {
+    return arguments.length ? (u = Array.from(e), n) : u.slice();
+  }, n.unknown = function(e) {
+    return arguments.length ? (o = e, n) : o;
+  }, n.copy = function() {
+    return l(i, u).unknown(o);
+  }, c.apply(n, arguments), n;
+}
+export {
+  l as default,
+  f as implicit
+};

package/dist/node_modules/d3-scale/src/pow.js

@@ -0,0 +1,38 @@
+"use client";
+import { linearish as p } from "./linear.js";
+import { transformer as c, copy as f, identity as e } from "./continuous.js";
+import { initRange as s } from "./init.js";
+function o(n) {
+  return function(t) {
+    return t < 0 ? -Math.pow(-t, n) : Math.pow(t, n);
+  };
+}
+function l(n) {
+  return n < 0 ? -Math.sqrt(-n) : Math.sqrt(n);
+}
+function m(n) {
+  return n < 0 ? -n * n : n * n;
+}
+function h(n) {
+  var t = n(e, e), r = 1;
+  function i() {
+    return r === 1 ? n(e, e) : r === 0.5 ? n(l, m) : n(o(r), o(1 / r));
+  }
+  return t.exponent = function(a) {
+    return arguments.length ? (r = +a, i()) : r;
+  }, p(t);
+}
+function u() {
+  var n = h(c());
+  return n.copy = function() {
+    return f(n, u()).exponent(n.exponent());
+  }, s.apply(n, arguments), n;
+}
+function y() {
+  return u.apply(null, arguments).exponent(0.5);
+}
+export {
+  u as default,
+  h as powish,
+  y as sqrt
+};

package/dist/node_modules/d3-scale/src/quantile.js

@@ -0,0 +1,39 @@
+"use client";
+import { initRange as l } from "./init.js";
+import f from "../../d3-array/src/ascending.js";
+import { quantileSorted as s } from "../../d3-array/src/quantile.js";
+import { bisectRight as c } from "../../d3-array/src/bisect.js";
+function m() {
+  var t = [], u = [], i = [], a;
+  function o() {
+    var n = 0, r = Math.max(1, u.length);
+    for (i = new Array(r - 1); ++n < r; ) i[n - 1] = s(t, n / r);
+    return e;
+  }
+  function e(n) {
+    return n == null || isNaN(n = +n) ? a : u[c(i, n)];
+  }
+  return e.invertExtent = function(n) {
+    var r = u.indexOf(n);
+    return r < 0 ? [NaN, NaN] : [
+      r > 0 ? i[r - 1] : t[0],
+      r < i.length ? i[r] : t[t.length - 1]
+    ];
+  }, e.domain = function(n) {
+    if (!arguments.length) return t.slice();
+    t = [];
+    for (let r of n) r != null && !isNaN(r = +r) && t.push(r);
+    return t.sort(f), o();
+  }, e.range = function(n) {
+    return arguments.length ? (u = Array.from(n), o()) : u.slice();
+  }, e.unknown = function(n) {
+    return arguments.length ? (a = n, e) : a;
+  }, e.quantiles = function() {
+    return i.slice();
+  }, e.copy = function() {
+    return m().domain(t).range(u).unknown(a);
+  }, l.apply(e, arguments);
+}
+export {
+  m as default
+};

package/dist/node_modules/d3-scale/src/quantize.js

@@ -0,0 +1,32 @@
+"use client";
+import { linearish as f } from "./linear.js";
+import { initRange as m } from "./init.js";
+import { bisectRight as s } from "../../d3-array/src/bisect.js";
+function g() {
+  var i = 0, u = 1, t = 1, e = [0.5], a = [0, 1], c;
+  function r(n) {
+    return n != null && n <= n ? a[s(e, n, 0, t)] : c;
+  }
+  function l() {
+    var n = -1;
+    for (e = new Array(t); ++n < t; ) e[n] = ((n + 1) * u - (n - t) * i) / (t + 1);
+    return r;
+  }
+  return r.domain = function(n) {
+    return arguments.length ? ([i, u] = n, i = +i, u = +u, l()) : [i, u];
+  }, r.range = function(n) {
+    return arguments.length ? (t = (a = Array.from(n)).length - 1, l()) : a.slice();
+  }, r.invertExtent = function(n) {
+    var o = a.indexOf(n);
+    return o < 0 ? [NaN, NaN] : o < 1 ? [i, e[0]] : o >= t ? [e[t - 1], u] : [e[o - 1], e[o]];
+  }, r.unknown = function(n) {
+    return arguments.length && (c = n), r;
+  }, r.thresholds = function() {
+    return e.slice();
+  }, r.copy = function() {
+    return g().domain([i, u]).range(a).unknown(c);
+  }, m.apply(f(r), arguments);
+}
+export {
+  g as default
+};