@xiping/react-components 1.0.20 → 1.0.22

package/dist/es/node_modules/.pnpm/bowser@2.11.0/node_modules/bowser/src/utils.js

@@ -0,0 +1,280 @@
+import { BROWSER_ALIASES_MAP as d, BROWSER_MAP as h } from "./constants.js";
+class c {
+  /**
+   * Get first matched item for a string
+   * @param {RegExp} regexp
+   * @param {String} ua
+   * @return {Array|{index: number, input: string}|*|boolean|string}
+   */
+  static getFirstMatch(r, e) {
+    const t = e.match(r);
+    return t && t.length > 0 && t[1] || "";
+  }
+  /**
+   * Get second matched item for a string
+   * @param regexp
+   * @param {String} ua
+   * @return {Array|{index: number, input: string}|*|boolean|string}
+   */
+  static getSecondMatch(r, e) {
+    const t = e.match(r);
+    return t && t.length > 1 && t[2] || "";
+  }
+  /**
+   * Match a regexp and return a constant or undefined
+   * @param {RegExp} regexp
+   * @param {String} ua
+   * @param {*} _const Any const that will be returned if regexp matches the string
+   * @return {*}
+   */
+  static matchAndReturnConst(r, e, t) {
+    if (r.test(e))
+      return t;
+  }
+  static getWindowsVersionName(r) {
+    switch (r) {
+      case "NT":
+        return "NT";
+      case "XP":
+        return "XP";
+      case "NT 5.0":
+        return "2000";
+      case "NT 5.1":
+        return "XP";
+      case "NT 5.2":
+        return "2003";
+      case "NT 6.0":
+        return "Vista";
+      case "NT 6.1":
+        return "7";
+      case "NT 6.2":
+        return "8";
+      case "NT 6.3":
+        return "8.1";
+      case "NT 10.0":
+        return "10";
+      default:
+        return;
+    }
+  }
+  /**
+   * Get macOS version name
+   *    10.5 - Leopard
+   *    10.6 - Snow Leopard
+   *    10.7 - Lion
+   *    10.8 - Mountain Lion
+   *    10.9 - Mavericks
+   *    10.10 - Yosemite
+   *    10.11 - El Capitan
+   *    10.12 - Sierra
+   *    10.13 - High Sierra
+   *    10.14 - Mojave
+   *    10.15 - Catalina
+   *
+   * @example
+   *   getMacOSVersionName("10.14") // 'Mojave'
+   *
+   * @param  {string} version
+   * @return {string} versionName
+   */
+  static getMacOSVersionName(r) {
+    const e = r.split(".").splice(0, 2).map((t) => parseInt(t, 10) || 0);
+    if (e.push(0), e[0] === 10)
+      switch (e[1]) {
+        case 5:
+          return "Leopard";
+        case 6:
+          return "Snow Leopard";
+        case 7:
+          return "Lion";
+        case 8:
+          return "Mountain Lion";
+        case 9:
+          return "Mavericks";
+        case 10:
+          return "Yosemite";
+        case 11:
+          return "El Capitan";
+        case 12:
+          return "Sierra";
+        case 13:
+          return "High Sierra";
+        case 14:
+          return "Mojave";
+        case 15:
+          return "Catalina";
+        default:
+          return;
+      }
+  }
+  /**
+   * Get Android version name
+   *    1.5 - Cupcake
+   *    1.6 - Donut
+   *    2.0 - Eclair
+   *    2.1 - Eclair
+   *    2.2 - Froyo
+   *    2.x - Gingerbread
+   *    3.x - Honeycomb
+   *    4.0 - Ice Cream Sandwich
+   *    4.1 - Jelly Bean
+   *    4.4 - KitKat
+   *    5.x - Lollipop
+   *    6.x - Marshmallow
+   *    7.x - Nougat
+   *    8.x - Oreo
+   *    9.x - Pie
+   *
+   * @example
+   *   getAndroidVersionName("7.0") // 'Nougat'
+   *
+   * @param  {string} version
+   * @return {string} versionName
+   */
+  static getAndroidVersionName(r) {
+    const e = r.split(".").splice(0, 2).map((t) => parseInt(t, 10) || 0);
+    if (e.push(0), !(e[0] === 1 && e[1] < 5)) {
+      if (e[0] === 1 && e[1] < 6) return "Cupcake";
+      if (e[0] === 1 && e[1] >= 6) return "Donut";
+      if (e[0] === 2 && e[1] < 2) return "Eclair";
+      if (e[0] === 2 && e[1] === 2) return "Froyo";
+      if (e[0] === 2 && e[1] > 2) return "Gingerbread";
+      if (e[0] === 3) return "Honeycomb";
+      if (e[0] === 4 && e[1] < 1) return "Ice Cream Sandwich";
+      if (e[0] === 4 && e[1] < 4) return "Jelly Bean";
+      if (e[0] === 4 && e[1] >= 4) return "KitKat";
+      if (e[0] === 5) return "Lollipop";
+      if (e[0] === 6) return "Marshmallow";
+      if (e[0] === 7) return "Nougat";
+      if (e[0] === 8) return "Oreo";
+      if (e[0] === 9) return "Pie";
+    }
+  }
+  /**
+   * Get version precisions count
+   *
+   * @example
+   *   getVersionPrecision("1.10.3") // 3
+   *
+   * @param  {string} version
+   * @return {number}
+   */
+  static getVersionPrecision(r) {
+    return r.split(".").length;
+  }
+  /**
+   * Calculate browser version weight
+   *
+   * @example
+   *   compareVersions('1.10.2.1',  '1.8.2.1.90')    // 1
+   *   compareVersions('1.010.2.1', '1.09.2.1.90');  // 1
+   *   compareVersions('1.10.2.1',  '1.10.2.1');     // 0
+   *   compareVersions('1.10.2.1',  '1.0800.2');     // -1
+   *   compareVersions('1.10.2.1',  '1.10',  true);  // 0
+   *
+   * @param {String} versionA versions versions to compare
+   * @param {String} versionB versions versions to compare
+   * @param {boolean} [isLoose] enable loose comparison
+   * @return {Number} comparison result: -1 when versionA is lower,
+   * 1 when versionA is bigger, 0 when both equal
+   */
+  /* eslint consistent-return: 1 */
+  static compareVersions(r, e, t = !1) {
+    const i = c.getVersionPrecision(r), a = c.getVersionPrecision(e);
+    let n = Math.max(i, a), u = 0;
+    const s = c.map([r, e], (o) => {
+      const l = n - c.getVersionPrecision(o), p = o + new Array(l + 1).join(".0");
+      return c.map(p.split("."), (f) => new Array(20 - f.length).join("0") + f).reverse();
+    });
+    for (t && (u = n - Math.min(i, a)), n -= 1; n >= u; ) {
+      if (s[0][n] > s[1][n])
+        return 1;
+      if (s[0][n] === s[1][n]) {
+        if (n === u)
+          return 0;
+        n -= 1;
+      } else if (s[0][n] < s[1][n])
+        return -1;
+    }
+  }
+  /**
+   * Array::map polyfill
+   *
+   * @param  {Array} arr
+   * @param  {Function} iterator
+   * @return {Array}
+   */
+  static map(r, e) {
+    const t = [];
+    let i;
+    if (Array.prototype.map)
+      return Array.prototype.map.call(r, e);
+    for (i = 0; i < r.length; i += 1)
+      t.push(e(r[i]));
+    return t;
+  }
+  /**
+   * Array::find polyfill
+   *
+   * @param  {Array} arr
+   * @param  {Function} predicate
+   * @return {Array}
+   */
+  static find(r, e) {
+    let t, i;
+    if (Array.prototype.find)
+      return Array.prototype.find.call(r, e);
+    for (t = 0, i = r.length; t < i; t += 1) {
+      const a = r[t];
+      if (e(a, t))
+        return a;
+    }
+  }
+  /**
+   * Object::assign polyfill
+   *
+   * @param  {Object} obj
+   * @param  {Object} ...objs
+   * @return {Object}
+   */
+  static assign(r, ...e) {
+    const t = r;
+    let i, a;
+    if (Object.assign)
+      return Object.assign(r, ...e);
+    for (i = 0, a = e.length; i < a; i += 1) {
+      const n = e[i];
+      typeof n == "object" && n !== null && Object.keys(n).forEach((s) => {
+        t[s] = n[s];
+      });
+    }
+    return r;
+  }
+  /**
+   * Get short version/alias for a browser name
+   *
+   * @example
+   *   getBrowserAlias('Microsoft Edge') // edge
+   *
+   * @param  {string} browserName
+   * @return {string}
+   */
+  static getBrowserAlias(r) {
+    return d[r];
+  }
+  /**
+   * Get short version/alias for a browser name
+   *
+   * @example
+   *   getBrowserAlias('edge') // Microsoft Edge
+   *
+   * @param  {string} browserAlias
+   * @return {string}
+   */
+  static getBrowserTypeByAlias(r) {
+    return h[r] || "";
+  }
+}
+export {
+  c as default
+};

package/dist/es/node_modules/.pnpm/canvas-confetti@1.9.3/node_modules/canvas-confetti/dist/confetti.module.js

@@ -0,0 +1,409 @@
+var R = {};
+(function V(M, T, B, I) {
+  var k = !!(M.Worker && M.Blob && M.Promise && M.OffscreenCanvas && M.OffscreenCanvasRenderingContext2D && M.HTMLCanvasElement && M.HTMLCanvasElement.prototype.transferControlToOffscreen && M.URL && M.URL.createObjectURL), A = typeof Path2D == "function" && typeof DOMMatrix == "function", Z = function() {
+    if (!M.OffscreenCanvas)
+      return !1;
+    var e = new OffscreenCanvas(1, 1), r = e.getContext("2d");
+    r.fillRect(0, 0, 1, 1);
+    var a = e.transferToImageBitmap();
+    try {
+      r.createPattern(a, "no-repeat");
+    } catch {
+      return !1;
+    }
+    return !0;
+  }();
+  function L() {
+  }
+  function P(e) {
+    var r = T.exports.Promise, a = r !== void 0 ? r : M.Promise;
+    return typeof a == "function" ? new a(e) : (e(L, L), null);
+  }
+  var x = /* @__PURE__ */ function(e, r) {
+    return {
+      transform: function(a) {
+        if (e)
+          return a;
+        if (r.has(a))
+          return r.get(a);
+        var t = new OffscreenCanvas(a.width, a.height), o = t.getContext("2d");
+        return o.drawImage(a, 0, 0), r.set(a, t), t;
+      },
+      clear: function() {
+        r.clear();
+      }
+    };
+  }(Z, /* @__PURE__ */ new Map()), F = function() {
+    var e = Math.floor(16.666666666666668), r, a, t = {}, o = 0;
+    return typeof requestAnimationFrame == "function" && typeof cancelAnimationFrame == "function" ? (r = function(i) {
+      var l = Math.random();
+      return t[l] = requestAnimationFrame(function n(s) {
+        o === s || o + e - 1 < s ? (o = s, delete t[l], i()) : t[l] = requestAnimationFrame(n);
+      }), l;
+    }, a = function(i) {
+      t[i] && cancelAnimationFrame(t[i]);
+    }) : (r = function(i) {
+      return setTimeout(i, e);
+    }, a = function(i) {
+      return clearTimeout(i);
+    }), { frame: r, cancel: a };
+  }(), _ = /* @__PURE__ */ function() {
+    var e, r, a = {};
+    function t(o) {
+      function i(l, n) {
+        o.postMessage({ options: l || {}, callback: n });
+      }
+      o.init = function(n) {
+        var s = n.transferControlToOffscreen();
+        o.postMessage({ canvas: s }, [s]);
+      }, o.fire = function(n, s, h) {
+        if (r)
+          return i(n, null), r;
+        var d = Math.random().toString(36).slice(2);
+        return r = P(function(u) {
+          function f(m) {
+            m.data.callback === d && (delete a[d], o.removeEventListener("message", f), r = null, x.clear(), h(), u());
+          }
+          o.addEventListener("message", f), i(n, d), a[d] = f.bind(null, { data: { callback: d } });
+        }), r;
+      }, o.reset = function() {
+        o.postMessage({ reset: !0 });
+        for (var n in a)
+          a[n](), delete a[n];
+      };
+    }
+    return function() {
+      if (e)
+        return e;
+      if (!B && k) {
+        var o = [
+          "var CONFETTI, SIZE = {}, module = {};",
+          "(" + V.toString() + ")(this, module, true, SIZE);",
+          "onmessage = function(msg) {",
+          "  if (msg.data.options) {",
+          "    CONFETTI(msg.data.options).then(function () {",
+          "      if (msg.data.callback) {",
+          "        postMessage({ callback: msg.data.callback });",
+          "      }",
+          "    });",
+          "  } else if (msg.data.reset) {",
+          "    CONFETTI && CONFETTI.reset();",
+          "  } else if (msg.data.resize) {",
+          "    SIZE.width = msg.data.resize.width;",
+          "    SIZE.height = msg.data.resize.height;",
+          "  } else if (msg.data.canvas) {",
+          "    SIZE.width = msg.data.canvas.width;",
+          "    SIZE.height = msg.data.canvas.height;",
+          "    CONFETTI = module.exports.create(msg.data.canvas);",
+          "  }",
+          "}"
+        ].join(`
+`);
+        try {
+          e = new Worker(URL.createObjectURL(new Blob([o])));
+        } catch (i) {
+          return typeof console !== void 0 && typeof console.warn == "function" && console.warn("🎊 Could not load worker", i), null;
+        }
+        t(e);
+      }
+      return e;
+    };
+  }(), q = {
+    particleCount: 50,
+    angle: 90,
+    spread: 45,
+    startVelocity: 45,
+    decay: 0.9,
+    gravity: 1,
+    drift: 0,
+    ticks: 200,
+    x: 0.5,
+    y: 0.5,
+    shapes: ["square", "circle"],
+    zIndex: 100,
+    colors: [
+      "#26ccff",
+      "#a25afd",
+      "#ff5e7e",
+      "#88ff5a",
+      "#fcff42",
+      "#ffa62d",
+      "#ff36ff"
+    ],
+    // probably should be true, but back-compat
+    disableForReducedMotion: !1,
+    scalar: 1
+  };
+  function H(e, r) {
+    return r ? r(e) : e;
+  }
+  function G(e) {
+    return e != null;
+  }
+  function v(e, r, a) {
+    return H(
+      e && G(e[r]) ? e[r] : q[r],
+      a
+    );
+  }
+  function J(e) {
+    return e < 0 ? 0 : Math.floor(e);
+  }
+  function K(e, r) {
+    return Math.floor(Math.random() * (r - e)) + e;
+  }
+  function E(e) {
+    return parseInt(e, 16);
+  }
+  function Q(e) {
+    return e.map($);
+  }
+  function $(e) {
+    var r = String(e).replace(/[^0-9a-f]/gi, "");
+    return r.length < 6 && (r = r[0] + r[0] + r[1] + r[1] + r[2] + r[2]), {
+      r: E(r.substring(0, 2)),
+      g: E(r.substring(2, 4)),
+      b: E(r.substring(4, 6))
+    };
+  }
+  function X(e) {
+    var r = v(e, "origin", Object);
+    return r.x = v(r, "x", Number), r.y = v(r, "y", Number), r;
+  }
+  function Y(e) {
+    e.width = document.documentElement.clientWidth, e.height = document.documentElement.clientHeight;
+  }
+  function rr(e) {
+    var r = e.getBoundingClientRect();
+    e.width = r.width, e.height = r.height;
+  }
+  function er(e) {
+    var r = document.createElement("canvas");
+    return r.style.position = "fixed", r.style.top = "0px", r.style.left = "0px", r.style.pointerEvents = "none", r.style.zIndex = e, r;
+  }
+  function ar(e, r, a, t, o, i, l, n, s) {
+    e.save(), e.translate(r, a), e.rotate(i), e.scale(t, o), e.arc(0, 0, 1, l, n, s), e.restore();
+  }
+  function nr(e) {
+    var r = e.angle * (Math.PI / 180), a = e.spread * (Math.PI / 180);
+    return {
+      x: e.x,
+      y: e.y,
+      wobble: Math.random() * 10,
+      wobbleSpeed: Math.min(0.11, Math.random() * 0.1 + 0.05),
+      velocity: e.startVelocity * 0.5 + Math.random() * e.startVelocity,
+      angle2D: -r + (0.5 * a - Math.random() * a),
+      tiltAngle: (Math.random() * (0.75 - 0.25) + 0.25) * Math.PI,
+      color: e.color,
+      shape: e.shape,
+      tick: 0,
+      totalTicks: e.ticks,
+      decay: e.decay,
+      drift: e.drift,
+      random: Math.random() + 2,
+      tiltSin: 0,
+      tiltCos: 0,
+      wobbleX: 0,
+      wobbleY: 0,
+      gravity: e.gravity * 3,
+      ovalScalar: 0.6,
+      scalar: e.scalar,
+      flat: e.flat
+    };
+  }
+  function tr(e, r) {
+    r.x += Math.cos(r.angle2D) * r.velocity + r.drift, r.y += Math.sin(r.angle2D) * r.velocity + r.gravity, r.velocity *= r.decay, r.flat ? (r.wobble = 0, r.wobbleX = r.x + 10 * r.scalar, r.wobbleY = r.y + 10 * r.scalar, r.tiltSin = 0, r.tiltCos = 0, r.random = 1) : (r.wobble += r.wobbleSpeed, r.wobbleX = r.x + 10 * r.scalar * Math.cos(r.wobble), r.wobbleY = r.y + 10 * r.scalar * Math.sin(r.wobble), r.tiltAngle += 0.1, r.tiltSin = Math.sin(r.tiltAngle), r.tiltCos = Math.cos(r.tiltAngle), r.random = Math.random() + 2);
+    var a = r.tick++ / r.totalTicks, t = r.x + r.random * r.tiltCos, o = r.y + r.random * r.tiltSin, i = r.wobbleX + r.random * r.tiltCos, l = r.wobbleY + r.random * r.tiltSin;
+    if (e.fillStyle = "rgba(" + r.color.r + ", " + r.color.g + ", " + r.color.b + ", " + (1 - a) + ")", e.beginPath(), A && r.shape.type === "path" && typeof r.shape.path == "string" && Array.isArray(r.shape.matrix))
+      e.fill(ir(
+        r.shape.path,
+        r.shape.matrix,
+        r.x,
+        r.y,
+        Math.abs(i - t) * 0.1,
+        Math.abs(l - o) * 0.1,
+        Math.PI / 10 * r.wobble
+      ));
+    else if (r.shape.type === "bitmap") {
+      var n = Math.PI / 10 * r.wobble, s = Math.abs(i - t) * 0.1, h = Math.abs(l - o) * 0.1, d = r.shape.bitmap.width * r.scalar, u = r.shape.bitmap.height * r.scalar, f = new DOMMatrix([
+        Math.cos(n) * s,
+        Math.sin(n) * s,
+        -Math.sin(n) * h,
+        Math.cos(n) * h,
+        r.x,
+        r.y
+      ]);
+      f.multiplySelf(new DOMMatrix(r.shape.matrix));
+      var m = e.createPattern(x.transform(r.shape.bitmap), "no-repeat");
+      m.setTransform(f), e.globalAlpha = 1 - a, e.fillStyle = m, e.fillRect(
+        r.x - d / 2,
+        r.y - u / 2,
+        d,
+        u
+      ), e.globalAlpha = 1;
+    } else if (r.shape === "circle")
+      e.ellipse ? e.ellipse(r.x, r.y, Math.abs(i - t) * r.ovalScalar, Math.abs(l - o) * r.ovalScalar, Math.PI / 10 * r.wobble, 0, 2 * Math.PI) : ar(e, r.x, r.y, Math.abs(i - t) * r.ovalScalar, Math.abs(l - o) * r.ovalScalar, Math.PI / 10 * r.wobble, 0, 2 * Math.PI);
+    else if (r.shape === "star")
+      for (var c = Math.PI / 2 * 3, g = 4 * r.scalar, p = 8 * r.scalar, y = r.x, w = r.y, C = 5, b = Math.PI / C; C--; )
+        y = r.x + Math.cos(c) * p, w = r.y + Math.sin(c) * p, e.lineTo(y, w), c += b, y = r.x + Math.cos(c) * g, w = r.y + Math.sin(c) * g, e.lineTo(y, w), c += b;
+    else
+      e.moveTo(Math.floor(r.x), Math.floor(r.y)), e.lineTo(Math.floor(r.wobbleX), Math.floor(o)), e.lineTo(Math.floor(i), Math.floor(l)), e.lineTo(Math.floor(t), Math.floor(r.wobbleY));
+    return e.closePath(), e.fill(), r.tick < r.totalTicks;
+  }
+  function or(e, r, a, t, o) {
+    var i = r.slice(), l = e.getContext("2d"), n, s, h = P(function(d) {
+      function u() {
+        n = s = null, l.clearRect(0, 0, t.width, t.height), x.clear(), o(), d();
+      }
+      function f() {
+        B && !(t.width === I.width && t.height === I.height) && (t.width = e.width = I.width, t.height = e.height = I.height), !t.width && !t.height && (a(e), t.width = e.width, t.height = e.height), l.clearRect(0, 0, t.width, t.height), i = i.filter(function(m) {
+          return tr(l, m);
+        }), i.length ? n = F.frame(f) : u();
+      }
+      n = F.frame(f), s = u;
+    });
+    return {
+      addFettis: function(d) {
+        return i = i.concat(d), h;
+      },
+      canvas: e,
+      promise: h,
+      reset: function() {
+        n && F.cancel(n), s && s();
+      }
+    };
+  }
+  function N(e, r) {
+    var a = !e, t = !!v(r || {}, "resize"), o = !1, i = v(r, "disableForReducedMotion", Boolean), l = k && !!v(r || {}, "useWorker"), n = l ? _() : null, s = a ? Y : rr, h = e && n ? !!e.__confetti_initialized : !1, d = typeof matchMedia == "function" && matchMedia("(prefers-reduced-motion)").matches, u;
+    function f(c, g, p) {
+      for (var y = v(c, "particleCount", J), w = v(c, "angle", Number), C = v(c, "spread", Number), b = v(c, "startVelocity", Number), cr = v(c, "decay", Number), hr = v(c, "gravity", Number), ur = v(c, "drift", Number), j = v(c, "colors", Q), dr = v(c, "ticks", Number), D = v(c, "shapes"), fr = v(c, "scalar"), vr = !!v(c, "flat"), U = X(c), z = y, O = [], mr = e.width * U.x, gr = e.height * U.y; z--; )
+        O.push(
+          nr({
+            x: mr,
+            y: gr,
+            angle: w,
+            spread: C,
+            startVelocity: b,
+            color: j[z % j.length],
+            shape: D[K(0, D.length)],
+            ticks: dr,
+            decay: cr,
+            gravity: hr,
+            drift: ur,
+            scalar: fr,
+            flat: vr
+          })
+        );
+      return u ? u.addFettis(O) : (u = or(e, O, s, g, p), u.promise);
+    }
+    function m(c) {
+      var g = i || v(c, "disableForReducedMotion", Boolean), p = v(c, "zIndex", Number);
+      if (g && d)
+        return P(function(b) {
+          b();
+        });
+      a && u ? e = u.canvas : a && !e && (e = er(p), document.body.appendChild(e)), t && !h && s(e);
+      var y = {
+        width: e.width,
+        height: e.height
+      };
+      n && !h && n.init(e), h = !0, n && (e.__confetti_initialized = !0);
+      function w() {
+        if (n) {
+          var b = {
+            getBoundingClientRect: function() {
+              if (!a)
+                return e.getBoundingClientRect();
+            }
+          };
+          s(b), n.postMessage({
+            resize: {
+              width: b.width,
+              height: b.height
+            }
+          });
+          return;
+        }
+        y.width = y.height = null;
+      }
+      function C() {
+        u = null, t && (o = !1, M.removeEventListener("resize", w)), a && e && (document.body.contains(e) && document.body.removeChild(e), e = null, h = !1);
+      }
+      return t && !o && (o = !0, M.addEventListener("resize", w, !1)), n ? n.fire(c, y, C) : f(c, y, C);
+    }
+    return m.reset = function() {
+      n && n.reset(), u && u.reset();
+    }, m;
+  }
+  var S;
+  function W() {
+    return S || (S = N(null, { useWorker: !0, resize: !0 })), S;
+  }
+  function ir(e, r, a, t, o, i, l) {
+    var n = new Path2D(e), s = new Path2D();
+    s.addPath(n, new DOMMatrix(r));
+    var h = new Path2D();
+    return h.addPath(s, new DOMMatrix([
+      Math.cos(l) * o,
+      Math.sin(l) * o,
+      -Math.sin(l) * i,
+      Math.cos(l) * i,
+      a,
+      t
+    ])), h;
+  }
+  function lr(e) {
+    if (!A)
+      throw new Error("path confetti are not supported in this browser");
+    var r, a;
+    typeof e == "string" ? r = e : (r = e.path, a = e.matrix);
+    var t = new Path2D(r), o = document.createElement("canvas"), i = o.getContext("2d");
+    if (!a) {
+      for (var l = 1e3, n = l, s = l, h = 0, d = 0, u, f, m = 0; m < l; m += 2)
+        for (var c = 0; c < l; c += 2)
+          i.isPointInPath(t, m, c, "nonzero") && (n = Math.min(n, m), s = Math.min(s, c), h = Math.max(h, m), d = Math.max(d, c));
+      u = h - n, f = d - s;
+      var g = 10, p = Math.min(g / u, g / f);
+      a = [
+        p,
+        0,
+        0,
+        p,
+        -Math.round(u / 2 + n) * p,
+        -Math.round(f / 2 + s) * p
+      ];
+    }
+    return {
+      type: "path",
+      path: r,
+      matrix: a
+    };
+  }
+  function sr(e) {
+    var r, a = 1, t = "#000000", o = '"Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji", "EmojiOne Color", "Android Emoji", "Twemoji Mozilla", "system emoji", sans-serif';
+    typeof e == "string" ? r = e : (r = e.text, a = "scalar" in e ? e.scalar : a, o = "fontFamily" in e ? e.fontFamily : o, t = "color" in e ? e.color : t);
+    var i = 10 * a, l = "" + i + "px " + o, n = new OffscreenCanvas(i, i), s = n.getContext("2d");
+    s.font = l;
+    var h = s.measureText(r), d = Math.ceil(h.actualBoundingBoxRight + h.actualBoundingBoxLeft), u = Math.ceil(h.actualBoundingBoxAscent + h.actualBoundingBoxDescent), f = 2, m = h.actualBoundingBoxLeft + f, c = h.actualBoundingBoxAscent + f;
+    d += f + f, u += f + f, n = new OffscreenCanvas(d, u), s = n.getContext("2d"), s.font = l, s.fillStyle = t, s.fillText(r, m, c);
+    var g = 1 / a;
+    return {
+      type: "bitmap",
+      // TODO these probably need to be transfered for workers
+      bitmap: n.transferToImageBitmap(),
+      matrix: [g, 0, 0, g, -d * g / 2, -u * g / 2]
+    };
+  }
+  T.exports = function() {
+    return W().apply(this, arguments);
+  }, T.exports.reset = function() {
+    W().reset();
+  }, T.exports.create = N, T.exports.shapeFromPath = lr, T.exports.shapeFromText = sr;
+})(/* @__PURE__ */ function() {
+  return typeof window < "u" ? window : typeof self < "u" ? self : this || {};
+}(), R, !1);
+const Mr = R.exports;
+R.exports.create;
+export {
+  Mr as default
+};

package/dist/es/node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/max.js

@@ -0,0 +1,15 @@
+function l(d, i) {
+  let e;
+  if (i === void 0)
+    for (const n of d)
+      n != null && (e < n || e === void 0 && n >= n) && (e = n);
+  else {
+    let n = -1;
+    for (let f of d)
+      (f = i(f, ++n, d)) != null && (e < f || e === void 0 && f >= f) && (e = f);
+  }
+  return e;
+}
+export {
+  l as default
+};