qaema-ui 0.0.1

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

@@ -0,0 +1,68 @@
+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, u = 0.5, m = 1, c = 1, e, t, a, l, y, i = M, p, d = !1, h;
+  function o(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));
+  }
+  o.domain = function(r) {
+    return arguments.length ? ([n, u, m] = r, e = p(n = +n), t = p(u = +u), a = p(m = +m), l = e === t ? 0 : 0.5 / (t - e), y = t === a ? 0 : 0.5 / (a - t), c = t < e ? -1 : 1, o) : [n, u, m];
+  }, o.clamp = function(r) {
+    return arguments.length ? (d = !!r, o) : d;
+  }, o.interpolator = function(r) {
+    return arguments.length ? (i = r, o) : i;
+  };
+  function v(r) {
+    return function(R) {
+      var w, k, b;
+      return arguments.length ? ([w, k, b] = R, i = L(r, [w, k, b]), o) : [i(0), i(0.5), i(1)];
+    };
+  }
+  return o.range = v(P), o.rangeRound = v(j), o.unknown = function(r) {
+    return arguments.length ? (h = r, o) : h;
+  }, function(r) {
+    return p = r, e = r(n), t = r(u), a = r(m), l = e === t ? 0 : 0.5 / (t - e), y = t === a ? 0 : 0.5 / (a - t), c = t < e ? -1 : 1, o;
+  };
+}
+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,18 @@
+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,32 @@
+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,39 @@
+import p, { copy as v } from "./continuous.js";
+import { initRange as c } from "./init.js";
+import h from "./tickFormat.js";
+import s, { 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 s(t[0], t[t.length - 1], n ?? 10);
+  }, i.tickFormat = function(n, t) {
+    var o = f();
+    return h(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,86 @@
+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, h, i;
+  function k() {
+    return h = A(l), i = q(l), m()[0] < 0 ? (h = x(h), 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 u = e[0], f = e[e.length - 1];
+    const M = f < u;
+    M && ([u, f] = [f, u]);
+    let r = h(u), g = h(f), a, c;
+    const p = o == null ? 10 : +o;
+    let s = [];
+    if (!(l % 1) && g - r < p) {
+      if (r = Math.floor(r), g = Math.ceil(g), u > 0) {
+        for (; r <= g; ++r)
+          for (a = 1; a < l; ++a)
+            if (c = r < 0 ? a / i(-r) : a * i(r), !(c < u)) {
+              if (c > f) break;
+              s.push(c);
+            }
+      } else for (; r <= g; ++r)
+        for (a = l - 1; a >= 1; --a)
+          if (c = r > 0 ? a / i(-r) : a * i(r), !(c < u)) {
+            if (c > f) break;
+            s.push(c);
+          }
+      s.length * 2 < p && (s = d(u, f, 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 u = Math.max(1, l * o / n.ticks().length);
+    return (f) => {
+      let M = f / i(Math.round(h(f)));
+      return M * l < l - 0.5 && (M *= l), M <= u ? e(f) : "";
+    };
+  }, n.nice = () => m(E(m(), {
+    floor: (o) => i(Math.floor(h(o))),
+    ceil: (o) => i(Math.ceil(h(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,8 @@
+function x(e, u) {
+  e = e.slice();
+  var t = 0, c = e.length - 1, f = e[t], l = e[c], r;
+  return l < f && (r = t, t = c, c = r, r = f, f = l, l = r), e[t] = u.floor(f), e[c] = u.ceil(l), e;
+}
+export {
+  x as default
+};

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

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

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

@@ -0,0 +1,31 @@
+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(t) {
+    let e = r.get(t);
+    if (e === void 0) {
+      if (o !== f) return o;
+      r.set(t, e = i.push(t) - 1);
+    }
+    return u[e % u.length];
+  }
+  return n.domain = function(t) {
+    if (!arguments.length) return i.slice();
+    i = [], r = new a();
+    for (const e of t)
+      r.has(e) || r.set(e, i.push(e) - 1);
+    return n;
+  }, n.range = function(t) {
+    return arguments.length ? (u = Array.from(t), n) : u.slice();
+  }, n.unknown = function(t) {
+    return arguments.length ? (o = t, 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,37 @@
+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 a() {
+    return r === 1 ? n(e, e) : r === 0.5 ? n(l, m) : n(o(r), o(1 / r));
+  }
+  return t.exponent = function(i) {
+    return arguments.length ? (r = +i, a()) : 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,38 @@
+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,31 @@
+import { linearish as l } from "./linear.js";
+import { initRange as m } from "./init.js";
+import { bisectRight as g } from "../../d3-array/src/bisect.js";
+function s() {
+  var i = 0, u = 1, t = 1, e = [0.5], a = [0, 1], c;
+  function r(n) {
+    return n != null && n <= n ? a[g(e, n, 0, t)] : c;
+  }
+  function f() {
+    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, f()) : [i, u];
+  }, r.range = function(n) {
+    return arguments.length ? (t = (a = Array.from(n)).length - 1, f()) : 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 s().domain([i, u]).range(a).unknown(c);
+  }, m.apply(l(r), arguments);
+}
+export {
+  s as default
+};

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

@@ -0,0 +1,37 @@
+import m from "./continuous.js";
+import { initRange as c } from "./init.js";
+import { linearish as s } from "./linear.js";
+import f from "./number.js";
+function i(n) {
+  return Math.sign(n) * n * n;
+}
+function g(n) {
+  return Math.sign(n) * Math.sqrt(Math.abs(n));
+}
+function l() {
+  var n = m(), e = [0, 1], u = !1, a;
+  function r(t) {
+    var o = g(n(t));
+    return isNaN(o) ? a : u ? Math.round(o) : o;
+  }
+  return r.invert = function(t) {
+    return n.invert(i(t));
+  }, r.domain = function(t) {
+    return arguments.length ? (n.domain(t), r) : n.domain();
+  }, r.range = function(t) {
+    return arguments.length ? (n.range((e = Array.from(t, f)).map(i)), r) : e.slice();
+  }, r.rangeRound = function(t) {
+    return r.range(t).round(!0);
+  }, r.round = function(t) {
+    return arguments.length ? (u = !!t, r) : u;
+  }, r.clamp = function(t) {
+    return arguments.length ? (n.clamp(t), r) : n.clamp();
+  }, r.unknown = function(t) {
+    return arguments.length ? (a = t, r) : a;
+  }, r.copy = function() {
+    return l(n.domain(), e).round(u).clamp(n.clamp()).unknown(a);
+  }, c.apply(r, arguments), s(r);
+}
+export {
+  l as default
+};

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

@@ -0,0 +1,70 @@
+import { identity as d } from "./continuous.js";
+import { initInterpolator as m } from "./init.js";
+import { linearish as w } from "./linear.js";
+import { loggish as k } from "./log.js";
+import { symlogish as b } from "./symlog.js";
+import { powish as M } from "./pow.js";
+import N from "../../d3-interpolate/src/value.js";
+import R from "../../d3-interpolate/src/round.js";
+function p() {
+  var n = 0, o = 1, e, a, i, l, u = d, f = !1, s;
+  function r(t) {
+    return t == null || isNaN(t = +t) ? s : u(i === 0 ? 0.5 : (t = (l(t) - e) * i, f ? Math.max(0, Math.min(1, t)) : t));
+  }
+  r.domain = function(t) {
+    return arguments.length ? ([n, o] = t, e = l(n = +n), a = l(o = +o), i = e === a ? 0 : 1 / (a - e), r) : [n, o];
+  }, r.clamp = function(t) {
+    return arguments.length ? (f = !!t, r) : f;
+  }, r.interpolator = function(t) {
+    return arguments.length ? (u = t, r) : u;
+  };
+  function g(t) {
+    return function(v) {
+      var y, h;
+      return arguments.length ? ([y, h] = v, u = t(y, h), r) : [u(0), u(1)];
+    };
+  }
+  return r.range = g(N), r.rangeRound = g(R), r.unknown = function(t) {
+    return arguments.length ? (s = t, r) : s;
+  }, function(t) {
+    return l = t, e = t(n), a = t(o), i = e === a ? 0 : 1 / (a - e), r;
+  };
+}
+function c(n, o) {
+  return o.domain(n.domain()).interpolator(n.interpolator()).clamp(n.clamp()).unknown(n.unknown());
+}
+function S() {
+  var n = w(p()(d));
+  return n.copy = function() {
+    return c(n, S());
+  }, m.apply(n, arguments);
+}
+function x() {
+  var n = k(p()).domain([1, 10]);
+  return n.copy = function() {
+    return c(n, x()).base(n.base());
+  }, m.apply(n, arguments);
+}
+function I() {
+  var n = b(p());
+  return n.copy = function() {
+    return c(n, I()).constant(n.constant());
+  }, m.apply(n, arguments);
+}
+function q() {
+  var n = M(p());
+  return n.copy = function() {
+    return c(n, q()).exponent(n.exponent());
+  }, m.apply(n, arguments);
+}
+function E() {
+  return q.apply(null, arguments).exponent(0.5);
+}
+export {
+  c as copy,
+  S as default,
+  x as sequentialLog,
+  q as sequentialPow,
+  E as sequentialSqrt,
+  I as sequentialSymlog
+};

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

@@ -0,0 +1,28 @@
+import { identity as u } from "./continuous.js";
+import { initInterpolator as a } from "./init.js";
+import l from "../../d3-array/src/ascending.js";
+import f from "../../d3-array/src/quantile.js";
+import { bisectRight as m } from "../../d3-array/src/bisect.js";
+function p() {
+  var n = [], e = u;
+  function r(t) {
+    if (t != null && !isNaN(t = +t)) return e((m(n, t, 1) - 1) / (n.length - 1));
+  }
+  return r.domain = function(t) {
+    if (!arguments.length) return n.slice();
+    n = [];
+    for (let i of t) i != null && !isNaN(i = +i) && n.push(i);
+    return n.sort(l), r;
+  }, r.interpolator = function(t) {
+    return arguments.length ? (e = t, r) : e;
+  }, r.range = function() {
+    return n.map((t, i) => e(i / (n.length - 1)));
+  }, r.quantiles = function(t) {
+    return Array.from({ length: t + 1 }, (i, o) => f(n, o / t));
+  }, r.copy = function() {
+    return p(e).domain(n);
+  }, a.apply(r, arguments);
+}
+export {
+  p as default
+};

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

@@ -0,0 +1,29 @@
+import { linearish as u } from "./linear.js";
+import { transformer as i, copy as s } from "./continuous.js";
+import { initRange as c } from "./init.js";
+function o(n) {
+  return function(t) {
+    return Math.sign(t) * Math.log1p(Math.abs(t / n));
+  };
+}
+function a(n) {
+  return function(t) {
+    return Math.sign(t) * Math.expm1(Math.abs(t)) * n;
+  };
+}
+function m(n) {
+  var t = 1, r = n(o(t), a(t));
+  return r.constant = function(e) {
+    return arguments.length ? n(o(t = +e), a(t)) : t;
+  }, u(r);
+}
+function f() {
+  var n = m(i());
+  return n.copy = function() {
+    return s(n, f()).constant(n.constant());
+  }, c.apply(n, arguments);
+}
+export {
+  f as default,
+  m as symlogish
+};

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

@@ -0,0 +1,23 @@
+import { initRange as a } from "./init.js";
+import { bisectRight as g } from "../../d3-array/src/bisect.js";
+function l() {
+  var r = [0.5], e = [0, 1], i, u = 1;
+  function t(n) {
+    return n != null && n <= n ? e[g(r, n, 0, u)] : i;
+  }
+  return t.domain = function(n) {
+    return arguments.length ? (r = Array.from(n), u = Math.min(r.length, e.length - 1), t) : r.slice();
+  }, t.range = function(n) {
+    return arguments.length ? (e = Array.from(n), u = Math.min(r.length, e.length - 1), t) : e.slice();
+  }, t.invertExtent = function(n) {
+    var o = e.indexOf(n);
+    return [r[o - 1], r[o]];
+  }, t.unknown = function(n) {
+    return arguments.length ? (i = n, t) : i;
+  }, t.copy = function() {
+    return l().domain(r).range(e).unknown(i);
+  }, a.apply(t, arguments);
+}
+export {
+  l as default
+};

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

@@ -0,0 +1,32 @@
+import { tickStep as s } from "../../d3-array/src/ticks.js";
+import c from "../../d3-format/src/formatSpecifier.js";
+import e from "../../d3-format/src/precisionFixed.js";
+import p from "../../d3-format/src/precisionRound.js";
+import l from "../../d3-format/src/precisionPrefix.js";
+import { formatPrefix as u, format as h } from "../../d3-format/src/defaultLocale.js";
+function d(r, t, i, a) {
+  var n = s(r, t, i), o;
+  switch (a = c(a ?? ",f"), a.type) {
+    case "s": {
+      var m = Math.max(Math.abs(r), Math.abs(t));
+      return a.precision == null && !isNaN(o = l(n, m)) && (a.precision = o), u(a, m);
+    }
+    case "":
+    case "e":
+    case "g":
+    case "p":
+    case "r": {
+      a.precision == null && !isNaN(o = p(n, Math.max(Math.abs(r), Math.abs(t)))) && (a.precision = o - (a.type === "e"));
+      break;
+    }
+    case "f":
+    case "%": {
+      a.precision == null && !isNaN(o = e(n)) && (a.precision = o - (a.type === "%") * 2);
+      break;
+    }
+  }
+  return h(a);
+}
+export {
+  d as default
+};

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

@@ -0,0 +1,46 @@
+import H, { copy as I } from "./continuous.js";
+import { initRange as T } from "./init.js";
+import x from "./nice.js";
+import { timeFormat as A } from "../../d3-time-format/src/defaultLocale.js";
+import { second as B } from "../../d3-time/src/second.js";
+import { timeMinute as L } from "../../d3-time/src/minute.js";
+import { timeHour as R } from "../../d3-time/src/hour.js";
+import { timeDay as W } from "../../d3-time/src/day.js";
+import { timeSunday as j } from "../../d3-time/src/week.js";
+import { timeMonth as q } from "../../d3-time/src/month.js";
+import { timeYear as v } from "../../d3-time/src/year.js";
+import { timeTickInterval as z, timeTicks as C } from "../../d3-time/src/ticks.js";
+function E(i) {
+  return new Date(i);
+}
+function G(i) {
+  return i instanceof Date ? +i : +/* @__PURE__ */ new Date(+i);
+}
+function g(i, u, e, f, c, p, a, l, D, t) {
+  var r = H(), s = r.invert, m = r.domain, y = t(".%L"), M = t(":%S"), w = t("%I:%M"), h = t("%I %p"), k = t("%a %d"), F = t("%b %d"), S = t("%B"), Y = t("%Y");
+  function b(n) {
+    return (D(n) < n ? y : l(n) < n ? M : a(n) < n ? w : p(n) < n ? h : f(n) < n ? c(n) < n ? k : F : e(n) < n ? S : Y)(n);
+  }
+  return r.invert = function(n) {
+    return new Date(s(n));
+  }, r.domain = function(n) {
+    return arguments.length ? m(Array.from(n, G)) : m().map(E);
+  }, r.ticks = function(n) {
+    var o = m();
+    return i(o[0], o[o.length - 1], n ?? 10);
+  }, r.tickFormat = function(n, o) {
+    return o == null ? b : t(o);
+  }, r.nice = function(n) {
+    var o = m();
+    return (!n || typeof n.range != "function") && (n = u(o[0], o[o.length - 1], n ?? 10)), n ? m(x(o, n)) : r;
+  }, r.copy = function() {
+    return I(r, g(i, u, e, f, c, p, a, l, D, t));
+  }, r;
+}
+function d() {
+  return T.apply(g(C, z, v, q, j, W, R, L, B, A).domain([new Date(2e3, 0, 1), new Date(2e3, 0, 2)]), arguments);
+}
+export {
+  g as calendar,
+  d as default
+};