@televet/kibble-ui 4.0.1 → 5.0.0-beta.hotfix.1

package/dist/chunks/index-D1RhzPVz.js

@@ -0,0 +1,984 @@
+import { s as ae, o as B, ar as se, as as oe, r as G, at as le, au as x, av as ue, aw as ce, ae as me, a0 as O, x as q, ax as de, P as fe, E as pe, ay as ge, b as m, e as be, w as C, F as he, L as ye, az as D, c as H, g as ve, aA as Pe, h as _, aB as Ee, ao as Ne } from "./index-fHSGm2nC.js";
+import { c as Re } from "./use-locale-context-Bw4Gg9Z0.js";
+let A = /* @__PURE__ */ new Map(), L = !1;
+try {
+  L = new Intl.NumberFormat("de-DE", {
+    signDisplay: "exceptZero"
+  }).resolvedOptions().signDisplay === "exceptZero";
+} catch {
+}
+let w = !1;
+try {
+  w = new Intl.NumberFormat("de-DE", {
+    style: "unit",
+    unit: "degree"
+  }).resolvedOptions().style === "unit";
+} catch {
+}
+const K = {
+  degree: {
+    narrow: {
+      default: "°",
+      "ja-JP": " 度",
+      "zh-TW": "度",
+      "sl-SI": " °"
+    }
+  }
+};
+class Te {
+  /** Formats a number value as a string, according to the locale and options provided to the constructor. */
+  format(t) {
+    let r = "";
+    if (!L && this.options.signDisplay != null ? r = Se(this.numberFormatter, this.options.signDisplay, t) : r = this.numberFormatter.format(t), this.options.style === "unit" && !w) {
+      var n;
+      let { unit: i, unitDisplay: a = "short", locale: s } = this.resolvedOptions();
+      if (!i) return r;
+      let l = (n = K[i]) === null || n === void 0 ? void 0 : n[a];
+      r += l[s] || l.default;
+    }
+    return r;
+  }
+  /** Formats a number to an array of parts such as separators, digits, punctuation, and more. */
+  formatToParts(t) {
+    return this.numberFormatter.formatToParts(t);
+  }
+  /** Formats a number range as a string. */
+  formatRange(t, r) {
+    if (typeof this.numberFormatter.formatRange == "function") return this.numberFormatter.formatRange(t, r);
+    if (r < t) throw new RangeError("End date must be >= start date");
+    return `${this.format(t)} – ${this.format(r)}`;
+  }
+  /** Formats a number range as an array of parts. */
+  formatRangeToParts(t, r) {
+    if (typeof this.numberFormatter.formatRangeToParts == "function") return this.numberFormatter.formatRangeToParts(t, r);
+    if (r < t) throw new RangeError("End date must be >= start date");
+    let n = this.numberFormatter.formatToParts(t), i = this.numberFormatter.formatToParts(r);
+    return [
+      ...n.map((a) => ({
+        ...a,
+        source: "startRange"
+      })),
+      {
+        type: "literal",
+        value: " – ",
+        source: "shared"
+      },
+      ...i.map((a) => ({
+        ...a,
+        source: "endRange"
+      }))
+    ];
+  }
+  /** Returns the resolved formatting options based on the values passed to the constructor. */
+  resolvedOptions() {
+    let t = this.numberFormatter.resolvedOptions();
+    return !L && this.options.signDisplay != null && (t = {
+      ...t,
+      signDisplay: this.options.signDisplay
+    }), !w && this.options.style === "unit" && (t = {
+      ...t,
+      style: "unit",
+      unit: this.options.unit,
+      unitDisplay: this.options.unitDisplay
+    }), t;
+  }
+  constructor(t, r = {}) {
+    this.numberFormatter = Ie(t, r), this.options = r;
+  }
+}
+function Ie(e, t = {}) {
+  let { numberingSystem: r } = t;
+  if (r && e.includes("-nu-") && (e.includes("-u-") || (e += "-u-"), e += `-nu-${r}`), t.style === "unit" && !w) {
+    var n;
+    let { unit: s, unitDisplay: l = "short" } = t;
+    if (!s) throw new Error('unit option must be provided with style: "unit"');
+    if (!(!((n = K[s]) === null || n === void 0) && n[l])) throw new Error(`Unsupported unit ${s} with unitDisplay = ${l}`);
+    t = {
+      ...t,
+      style: "decimal"
+    };
+  }
+  let i = e + (t ? Object.entries(t).sort((s, l) => s[0] < l[0] ? -1 : 1).join() : "");
+  if (A.has(i)) return A.get(i);
+  let a = new Intl.NumberFormat(e, t);
+  return A.set(i, a), a;
+}
+function Se(e, t, r) {
+  if (t === "auto") return e.format(r);
+  if (t === "never") return e.format(Math.abs(r));
+  {
+    let n = !1;
+    if (t === "always" ? n = r > 0 || Object.is(r, 0) : t === "exceptZero" && (Object.is(r, -0) || Object.is(r, 0) ? r = Math.abs(r) : n = r > 0), n) {
+      let i = e.format(-r), a = e.format(r), s = i.replace(a, "").replace(/\u200e|\u061C/, "");
+      return [
+        ...s
+      ].length !== 1 && console.warn("@react-aria/i18n polyfill for NumberFormat signDisplay: Unsupported case"), i.replace(a, "!!!").replace(s, "+").replace("!!!", a);
+    } else return e.format(r);
+  }
+}
+const De = new RegExp("^.*\\(.*\\).*$"), xe = [
+  "latn",
+  "arab",
+  "hanidec",
+  "deva",
+  "beng"
+];
+class z {
+  /**
+  * Parses the given string to a number. Returns NaN if a valid number could not be parsed.
+  */
+  parse(t) {
+    return F(this.locale, this.options, t).parse(t);
+  }
+  /**
+  * Returns whether the given string could potentially be a valid number. This should be used to
+  * validate user input as the user types. If a `minValue` or `maxValue` is provided, the validity
+  * of the minus/plus sign characters can be checked.
+  */
+  isValidPartialNumber(t, r, n) {
+    return F(this.locale, this.options, t).isValidPartialNumber(t, r, n);
+  }
+  /**
+  * Returns a numbering system for which the given string is valid in the current locale.
+  * If no numbering system could be detected, the default numbering system for the current
+  * locale is returned.
+  */
+  getNumberingSystem(t) {
+    return F(this.locale, this.options, t).options.numberingSystem;
+  }
+  constructor(t, r = {}) {
+    this.locale = t, this.options = r;
+  }
+}
+const W = /* @__PURE__ */ new Map();
+function F(e, t, r) {
+  let n = k(e, t);
+  if (!e.includes("-nu-") && !n.isValidPartialNumber(r)) {
+    for (let i of xe) if (i !== n.options.numberingSystem) {
+      let a = k(e + (e.includes("-u-") ? "-nu-" : "-u-nu-") + i, t);
+      if (a.isValidPartialNumber(r)) return a;
+    }
+  }
+  return n;
+}
+function k(e, t) {
+  let r = e + (t ? Object.entries(t).sort((i, a) => i[0] < a[0] ? -1 : 1).join() : ""), n = W.get(r);
+  return n || (n = new we(e, t), W.set(r, n)), n;
+}
+class we {
+  parse(t) {
+    let r = this.sanitize(t);
+    if (this.symbols.group && (r = T(r, this.symbols.group, "")), this.symbols.decimal && (r = r.replace(this.symbols.decimal, ".")), this.symbols.minusSign && (r = r.replace(this.symbols.minusSign, "-")), r = r.replace(this.symbols.numeral, this.symbols.index), this.options.style === "percent") {
+      let s = r.indexOf("-");
+      r = r.replace("-", ""), r = r.replace("+", "");
+      let l = r.indexOf(".");
+      l === -1 && (l = r.length), r = r.replace(".", ""), l - 2 === 0 ? r = `0.${r}` : l - 2 === -1 ? r = `0.0${r}` : l - 2 === -2 ? r = "0.00" : r = `${r.slice(0, l - 2)}.${r.slice(l - 2)}`, s > -1 && (r = `-${r}`);
+    }
+    let n = r ? +r : NaN;
+    if (isNaN(n)) return NaN;
+    if (this.options.style === "percent") {
+      var i, a;
+      let s = {
+        ...this.options,
+        style: "decimal",
+        minimumFractionDigits: Math.min(((i = this.options.minimumFractionDigits) !== null && i !== void 0 ? i : 0) + 2, 20),
+        maximumFractionDigits: Math.min(((a = this.options.maximumFractionDigits) !== null && a !== void 0 ? a : 0) + 2, 20)
+      };
+      return new z(this.locale, s).parse(new Te(this.locale, s).format(n));
+    }
+    return this.options.currencySign === "accounting" && De.test(t) && (n = -1 * n), n;
+  }
+  sanitize(t) {
+    return t = t.replace(this.symbols.literals, ""), this.symbols.minusSign && (t = t.replace("-", this.symbols.minusSign)), this.options.numberingSystem === "arab" && (this.symbols.decimal && (t = t.replace(",", this.symbols.decimal), t = t.replace("،", this.symbols.decimal)), this.symbols.group && (t = T(t, ".", this.symbols.group))), this.options.locale === "fr-FR" && this.symbols.group && (t = T(t, " ", this.symbols.group), t = T(t, /\u00A0/g, this.symbols.group)), t;
+  }
+  isValidPartialNumber(t, r = -1 / 0, n = 1 / 0) {
+    return t = this.sanitize(t), this.symbols.minusSign && t.startsWith(this.symbols.minusSign) && r < 0 ? t = t.slice(this.symbols.minusSign.length) : this.symbols.plusSign && t.startsWith(this.symbols.plusSign) && n > 0 && (t = t.slice(this.symbols.plusSign.length)), this.symbols.group && t.startsWith(this.symbols.group) || this.symbols.decimal && t.indexOf(this.symbols.decimal) > -1 && this.options.maximumFractionDigits === 0 ? !1 : (this.symbols.group && (t = T(t, this.symbols.group, "")), t = t.replace(this.symbols.numeral, ""), this.symbols.decimal && (t = t.replace(this.symbols.decimal, "")), t.length === 0);
+  }
+  constructor(t, r = {}) {
+    this.locale = t, r.roundingIncrement !== 1 && r.roundingIncrement != null && (r.maximumFractionDigits == null && r.minimumFractionDigits == null ? (r.maximumFractionDigits = 0, r.minimumFractionDigits = 0) : r.maximumFractionDigits == null ? r.maximumFractionDigits = r.minimumFractionDigits : r.minimumFractionDigits == null && (r.minimumFractionDigits = r.maximumFractionDigits)), this.formatter = new Intl.NumberFormat(t, r), this.options = this.formatter.resolvedOptions(), this.symbols = $e(t, this.formatter, this.options, r);
+    var n, i;
+    this.options.style === "percent" && (((n = this.options.minimumFractionDigits) !== null && n !== void 0 ? n : 0) > 18 || ((i = this.options.maximumFractionDigits) !== null && i !== void 0 ? i : 0) > 18) && console.warn("NumberParser cannot handle percentages with greater than 18 decimal places, please reduce the number in your options.");
+  }
+}
+const j = /* @__PURE__ */ new Set([
+  "decimal",
+  "fraction",
+  "integer",
+  "minusSign",
+  "plusSign",
+  "group"
+]), Ve = [
+  0,
+  4,
+  2,
+  1,
+  11,
+  20,
+  3,
+  7,
+  100,
+  21,
+  0.1,
+  1.1
+];
+function $e(e, t, r, n) {
+  var i, a, s, l;
+  let u = new Intl.NumberFormat(e, {
+    ...r,
+    // Resets so we get the full range of symbols
+    minimumSignificantDigits: 1,
+    maximumSignificantDigits: 21,
+    roundingIncrement: 1,
+    roundingPriority: "auto",
+    roundingMode: "halfExpand"
+  }), d = u.formatToParts(-10000.111), g = u.formatToParts(10000.111), f = Ve.map((c) => u.formatToParts(c));
+  var y;
+  let E = (y = (i = d.find((c) => c.type === "minusSign")) === null || i === void 0 ? void 0 : i.value) !== null && y !== void 0 ? y : "-", N = (a = g.find((c) => c.type === "plusSign")) === null || a === void 0 ? void 0 : a.value;
+  !N && (n?.signDisplay === "exceptZero" || n?.signDisplay === "always") && (N = "+");
+  let p = (s = new Intl.NumberFormat(e, {
+    ...r,
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  }).formatToParts(1e-3).find((c) => c.type === "decimal")) === null || s === void 0 ? void 0 : s.value, R = (l = d.find((c) => c.type === "group")) === null || l === void 0 ? void 0 : l.value, b = d.filter((c) => !j.has(c.type)).map((c) => Z(c.value)), V = f.flatMap((c) => c.filter((v) => !j.has(v.type)).map((v) => Z(v.value))), $ = [
+    .../* @__PURE__ */ new Set([
+      ...b,
+      ...V
+    ])
+  ].sort((c, v) => v.length - c.length), re = $.length === 0 ? new RegExp("[\\p{White_Space}]", "gu") : new RegExp(`${$.join("|")}|[\\p{White_Space}]`, "gu"), M = [
+    ...new Intl.NumberFormat(r.locale, {
+      useGrouping: !1
+    }).format(9876543210)
+  ].reverse(), ne = new Map(M.map((c, v) => [
+    c,
+    v
+  ])), ie = new RegExp(`[${M.join("")}]`, "g");
+  return {
+    minusSign: E,
+    plusSign: N,
+    decimal: p,
+    group: R,
+    literals: re,
+    numeral: ie,
+    index: (c) => String(ne.get(c))
+  };
+}
+function T(e, t, r) {
+  return e.replaceAll ? e.replaceAll(t, r) : e.split(t).join(r);
+}
+function Z(e) {
+  return e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var Oe = be("numberInput").parts(
+  "root",
+  "label",
+  "input",
+  "control",
+  "valueText",
+  "incrementTrigger",
+  "decrementTrigger",
+  "scrubber"
+), h = Oe.build(), Ce = (e) => e.ids?.root ?? `number-input:${e.id}`, I = (e) => e.ids?.input ?? `number-input:${e.id}:input`, J = (e) => e.ids?.incrementTrigger ?? `number-input:${e.id}:inc`, Q = (e) => e.ids?.decrementTrigger ?? `number-input:${e.id}:dec`, Ae = (e) => e.ids?.scrubber ?? `number-input:${e.id}:scrubber`, ee = (e) => `number-input:${e.id}:cursor`, Fe = (e) => e.ids?.label ?? `number-input:${e.id}:label`, S = (e) => e.getById(I(e)), Ue = (e) => e.getById(J(e)), Le = (e) => e.getById(Q(e)), te = (e) => e.getDoc().getElementById(ee(e)), Me = (e, t) => {
+  let r = null;
+  return t === "increment" && (r = Ue(e)), t === "decrement" && (r = Le(e)), r;
+}, Be = (e, t) => {
+  if (!q())
+    return _e(e, t), () => {
+      te(e)?.remove();
+    };
+}, Ge = (e) => {
+  const t = e.getDoc(), r = t.documentElement, n = t.body;
+  return n.style.pointerEvents = "none", r.style.userSelect = "none", r.style.cursor = "ew-resize", () => {
+    n.style.pointerEvents = "", r.style.userSelect = "", r.style.cursor = "", r.style.length || r.removeAttribute("style"), n.style.length || n.removeAttribute("style");
+  };
+}, He = (e, t) => {
+  const { point: r, isRtl: n, event: i } = t, a = e.getWin(), s = D(i.movementX, a.devicePixelRatio), l = D(i.movementY, a.devicePixelRatio);
+  let u = s > 0 ? "increment" : s < 0 ? "decrement" : null;
+  n && u === "increment" && (u = "decrement"), n && u === "decrement" && (u = "increment");
+  const d = { x: r.x + s, y: r.y + l }, g = a.innerWidth, f = D(7.5, a.devicePixelRatio);
+  return d.x = Ee(d.x + f, g) - f, { hint: u, point: d };
+}, _e = (e, t) => {
+  const r = e.getDoc(), n = r.createElement("div");
+  n.className = "scrubber--cursor", n.id = ee(e), Object.assign(n.style, {
+    width: "15px",
+    height: "15px",
+    position: "fixed",
+    pointerEvents: "none",
+    left: "0px",
+    top: "0px",
+    zIndex: Ne,
+    transform: t ? `translate3d(${t.x}px, ${t.y}px, 0px)` : void 0,
+    willChange: "transform"
+  }), n.innerHTML = `
+      <svg width="46" height="15" style="left: -15.5px; position: absolute; top: 0; filter: drop-shadow(rgba(0, 0, 0, 0.4) 0px 1px 1.1px);">
+        <g transform="translate(2 3)">
+          <path fill-rule="evenodd" d="M 15 4.5L 15 2L 11.5 5.5L 15 9L 15 6.5L 31 6.5L 31 9L 34.5 5.5L 31 2L 31 4.5Z" style="stroke-width: 2px; stroke: white;"></path>
+          <path fill-rule="evenodd" d="M 15 4.5L 15 2L 11.5 5.5L 15 9L 15 6.5L 31 6.5L 31 9L 34.5 5.5L 31 2L 31 4.5Z"></path>
+        </g>
+      </svg>`, r.body.appendChild(n);
+};
+function et(e, t) {
+  const { state: r, send: n, prop: i, scope: a, computed: s } = e, l = r.hasTag("focus"), u = s("isDisabled"), d = i("readOnly"), g = s("isValueEmpty"), f = s("isOutOfRange") || !!i("invalid"), y = u || !s("canIncrement") || d, E = u || !s("canDecrement") || d, N = i("translations");
+  return {
+    focused: l,
+    invalid: f,
+    empty: g,
+    value: s("formattedValue"),
+    valueAsNumber: s("valueAsNumber"),
+    setValue(o) {
+      n({ type: "VALUE.SET", value: o });
+    },
+    clearValue() {
+      n({ type: "VALUE.CLEAR" });
+    },
+    increment() {
+      n({ type: "VALUE.INCREMENT" });
+    },
+    decrement() {
+      n({ type: "VALUE.DECREMENT" });
+    },
+    setToMax() {
+      n({ type: "VALUE.SET", value: i("max") });
+    },
+    setToMin() {
+      n({ type: "VALUE.SET", value: i("min") });
+    },
+    focus() {
+      S(a)?.focus();
+    },
+    getRootProps() {
+      return t.element({
+        id: Ce(a),
+        ...h.root.attrs,
+        dir: i("dir"),
+        "data-disabled": m(u),
+        "data-focus": m(l),
+        "data-invalid": m(f)
+      });
+    },
+    getLabelProps() {
+      return t.label({
+        ...h.label.attrs,
+        dir: i("dir"),
+        "data-disabled": m(u),
+        "data-focus": m(l),
+        "data-invalid": m(f),
+        id: Fe(a),
+        htmlFor: I(a)
+      });
+    },
+    getControlProps() {
+      return t.element({
+        ...h.control.attrs,
+        dir: i("dir"),
+        role: "group",
+        "aria-disabled": u,
+        "data-focus": m(l),
+        "data-disabled": m(u),
+        "data-invalid": m(f),
+        "aria-invalid": H(f)
+      });
+    },
+    getValueTextProps() {
+      return t.element({
+        ...h.valueText.attrs,
+        dir: i("dir"),
+        "data-disabled": m(u),
+        "data-invalid": m(f),
+        "data-focus": m(l)
+      });
+    },
+    getInputProps() {
+      return t.input({
+        ...h.input.attrs,
+        dir: i("dir"),
+        name: i("name"),
+        form: i("form"),
+        id: I(a),
+        role: "spinbutton",
+        defaultValue: s("formattedValue"),
+        pattern: i("pattern"),
+        inputMode: i("inputMode"),
+        "aria-invalid": H(f),
+        "data-invalid": m(f),
+        disabled: u,
+        "data-disabled": m(u),
+        readOnly: d,
+        required: i("required"),
+        autoComplete: "off",
+        autoCorrect: "off",
+        spellCheck: "false",
+        type: "text",
+        "aria-roledescription": "numberfield",
+        "aria-valuemin": i("min"),
+        "aria-valuemax": i("max"),
+        "aria-valuenow": Number.isNaN(s("valueAsNumber")) ? void 0 : s("valueAsNumber"),
+        "aria-valuetext": s("valueText"),
+        onFocus() {
+          n({ type: "INPUT.FOCUS" });
+        },
+        onBlur() {
+          n({ type: "INPUT.BLUR" });
+        },
+        onInput(o) {
+          n({ type: "INPUT.CHANGE", target: o.currentTarget, hint: "set" });
+        },
+        onBeforeInput(o) {
+          try {
+            const { selectionStart: p, selectionEnd: R, value: b } = o.currentTarget, V = b.slice(0, p) + (o.data ?? "") + b.slice(R);
+            s("parser").isValidPartialNumber(V) || o.preventDefault();
+          } catch {
+          }
+        },
+        onKeyDown(o) {
+          if (o.defaultPrevented || d || ve(o)) return;
+          const p = Pe(o) * i("step"), b = {
+            ArrowUp() {
+              n({ type: "INPUT.ARROW_UP", step: p }), o.preventDefault();
+            },
+            ArrowDown() {
+              n({ type: "INPUT.ARROW_DOWN", step: p }), o.preventDefault();
+            },
+            Home() {
+              _(o) || (n({ type: "INPUT.HOME" }), o.preventDefault());
+            },
+            End() {
+              _(o) || (n({ type: "INPUT.END" }), o.preventDefault());
+            },
+            Enter() {
+              n({ type: "INPUT.ENTER" });
+            }
+          }[o.key];
+          b?.(o);
+        }
+      });
+    },
+    getDecrementTriggerProps() {
+      return t.button({
+        ...h.decrementTrigger.attrs,
+        dir: i("dir"),
+        id: Q(a),
+        disabled: E,
+        "data-disabled": m(E),
+        "aria-label": N.decrementLabel,
+        type: "button",
+        tabIndex: -1,
+        "aria-controls": I(a),
+        onPointerDown(o) {
+          E || C(o) && (n({ type: "TRIGGER.PRESS_DOWN", hint: "decrement", pointerType: o.pointerType }), o.pointerType === "mouse" && o.preventDefault(), o.pointerType === "touch" && o.currentTarget?.focus({ preventScroll: !0 }));
+        },
+        onPointerUp(o) {
+          n({ type: "TRIGGER.PRESS_UP", hint: "decrement", pointerType: o.pointerType });
+        },
+        onPointerLeave() {
+          E || n({ type: "TRIGGER.PRESS_UP", hint: "decrement" });
+        }
+      });
+    },
+    getIncrementTriggerProps() {
+      return t.button({
+        ...h.incrementTrigger.attrs,
+        dir: i("dir"),
+        id: J(a),
+        disabled: y,
+        "data-disabled": m(y),
+        "aria-label": N.incrementLabel,
+        type: "button",
+        tabIndex: -1,
+        "aria-controls": I(a),
+        onPointerDown(o) {
+          y || !C(o) || (n({ type: "TRIGGER.PRESS_DOWN", hint: "increment", pointerType: o.pointerType }), o.pointerType === "mouse" && o.preventDefault(), o.pointerType === "touch" && o.currentTarget?.focus({ preventScroll: !0 }));
+        },
+        onPointerUp(o) {
+          n({ type: "TRIGGER.PRESS_UP", hint: "increment", pointerType: o.pointerType });
+        },
+        onPointerLeave(o) {
+          n({ type: "TRIGGER.PRESS_UP", hint: "increment", pointerType: o.pointerType });
+        }
+      });
+    },
+    getScrubberProps() {
+      return t.element({
+        ...h.scrubber.attrs,
+        dir: i("dir"),
+        "data-disabled": m(u),
+        id: Ae(a),
+        role: "presentation",
+        onMouseDown(o) {
+          if (u || !C(o)) return;
+          const p = he(o), b = ye(o.currentTarget).devicePixelRatio;
+          p.x = p.x - D(7.5, b), p.y = p.y - D(7.5, b), n({ type: "SCRUBBER.PRESS_DOWN", point: p }), o.preventDefault();
+        },
+        style: {
+          cursor: u ? void 0 : "ew-resize"
+        }
+      });
+    }
+  };
+}
+function We(e) {
+  if (!(!e || e.ownerDocument.activeElement !== e))
+    try {
+      const { selectionStart: t, selectionEnd: r, value: n } = e, i = n.substring(0, t), a = n.substring(r);
+      return {
+        start: t,
+        end: r,
+        value: n,
+        beforeTxt: i,
+        afterTxt: a
+      };
+    } catch {
+    }
+}
+function ke(e, t) {
+  if (!(!e || e.ownerDocument.activeElement !== e)) {
+    if (!t) {
+      e.setSelectionRange(e.value.length, e.value.length);
+      return;
+    }
+    try {
+      const { value: r } = e, { beforeTxt: n = "", afterTxt: i = "", start: a } = t;
+      let s = r.length;
+      if (r.endsWith(i))
+        s = r.length - i.length;
+      else if (r.startsWith(n))
+        s = n.length;
+      else if (a != null) {
+        const l = n[a - 1], u = r.indexOf(l, a - 1);
+        u !== -1 && (s = u + 1);
+      }
+      e.setSelectionRange(s, s);
+    } catch {
+    }
+  }
+}
+var je = (e, t = {}) => new Intl.NumberFormat(e, t), Ze = (e, t = {}) => new z(e, t), U = (e, t) => {
+  const { prop: r, computed: n } = t;
+  return r("formatOptions") ? n("parser").parse(String(e)) : parseFloat(e);
+}, P = (e, t) => {
+  const { prop: r, computed: n } = t;
+  return Number.isNaN(e) ? "" : r("formatOptions") ? n("formatter").format(e) : e.toString();
+}, Ye = (e, t) => {
+  let r = e !== void 0 && !Number.isNaN(e) ? e : 1;
+  return t?.style === "percent" && (e === void 0 || Number.isNaN(e)) && (r = 0.01), r;
+}, { choose: Xe, guards: qe, createMachine: Ke } = ae(), { not: Y, and: X } = qe, tt = Ke({
+  props({ props: e }) {
+    const t = Ye(e.step, e.formatOptions);
+    return {
+      dir: "ltr",
+      locale: "en-US",
+      focusInputOnChange: !0,
+      clampValueOnBlur: !e.allowOverflow,
+      allowOverflow: !1,
+      inputMode: "decimal",
+      pattern: "-?[0-9]*(.[0-9]+)?",
+      defaultValue: "",
+      step: t,
+      min: Number.MIN_SAFE_INTEGER,
+      max: Number.MAX_SAFE_INTEGER,
+      spinOnPress: !0,
+      ...e,
+      translations: {
+        incrementLabel: "increment value",
+        decrementLabel: "decrease value",
+        ...e.translations
+      }
+    };
+  },
+  initialState() {
+    return "idle";
+  },
+  context({ prop: e, bindable: t, getComputed: r }) {
+    return {
+      value: t(() => ({
+        defaultValue: e("defaultValue"),
+        value: e("value"),
+        onChange(n) {
+          const i = r(), a = U(n, { computed: i, prop: e });
+          e("onValueChange")?.({ value: n, valueAsNumber: a });
+        }
+      })),
+      hint: t(() => ({ defaultValue: null })),
+      scrubberCursorPoint: t(() => ({
+        defaultValue: null,
+        hash(n) {
+          return n ? `x:${n.x}, y:${n.y}` : "";
+        }
+      })),
+      fieldsetDisabled: t(() => ({ defaultValue: !1 }))
+    };
+  },
+  computed: {
+    isRtl: ({ prop: e }) => e("dir") === "rtl",
+    valueAsNumber: ({ context: e, computed: t, prop: r }) => U(e.get("value"), { computed: t, prop: r }),
+    formattedValue: ({ computed: e, prop: t }) => P(e("valueAsNumber"), { computed: e, prop: t }),
+    isAtMin: ({ computed: e, prop: t }) => oe(e("valueAsNumber"), t("min")),
+    isAtMax: ({ computed: e, prop: t }) => se(e("valueAsNumber"), t("max")),
+    isOutOfRange: ({ computed: e, prop: t }) => !ge(e("valueAsNumber"), t("min"), t("max")),
+    isValueEmpty: ({ context: e }) => e.get("value") === "",
+    isDisabled: ({ prop: e, context: t }) => !!e("disabled") || t.get("fieldsetDisabled"),
+    canIncrement: ({ prop: e, computed: t }) => e("allowOverflow") || !t("isAtMax"),
+    canDecrement: ({ prop: e, computed: t }) => e("allowOverflow") || !t("isAtMin"),
+    valueText: ({ prop: e, context: t }) => e("translations").valueText?.(t.get("value")),
+    formatter: B(
+      ({ prop: e }) => [e("locale"), e("formatOptions")],
+      (e, t) => je(e, t)
+    ),
+    parser: B(
+      ({ prop: e }) => [e("locale"), e("formatOptions")],
+      (e, t) => Ze(e, t)
+    )
+  },
+  watch({ track: e, action: t, context: r, computed: n, prop: i }) {
+    e([() => r.get("value"), () => i("locale")], () => {
+      t(["syncInputElement"]);
+    }), e([() => n("isOutOfRange")], () => {
+      t(["invokeOnInvalid"]);
+    }), e([() => r.hash("scrubberCursorPoint")], () => {
+      t(["setVirtualCursorPosition"]);
+    });
+  },
+  effects: ["trackFormControl"],
+  on: {
+    "VALUE.SET": {
+      actions: ["setRawValue"]
+    },
+    "VALUE.CLEAR": {
+      actions: ["clearValue"]
+    },
+    "VALUE.INCREMENT": {
+      actions: ["increment"]
+    },
+    "VALUE.DECREMENT": {
+      actions: ["decrement"]
+    }
+  },
+  states: {
+    idle: {
+      on: {
+        "TRIGGER.PRESS_DOWN": [
+          { guard: "isTouchPointer", target: "before:spin", actions: ["setHint"] },
+          {
+            target: "before:spin",
+            actions: ["focusInput", "invokeOnFocus", "setHint"]
+          }
+        ],
+        "SCRUBBER.PRESS_DOWN": {
+          target: "scrubbing",
+          actions: ["focusInput", "invokeOnFocus", "setHint", "setCursorPoint"]
+        },
+        "INPUT.FOCUS": {
+          target: "focused",
+          actions: ["focusInput", "invokeOnFocus"]
+        }
+      }
+    },
+    focused: {
+      tags: ["focus"],
+      effects: ["attachWheelListener"],
+      on: {
+        "TRIGGER.PRESS_DOWN": [
+          { guard: "isTouchPointer", target: "before:spin", actions: ["setHint"] },
+          { target: "before:spin", actions: ["focusInput", "setHint"] }
+        ],
+        "SCRUBBER.PRESS_DOWN": {
+          target: "scrubbing",
+          actions: ["focusInput", "setHint", "setCursorPoint"]
+        },
+        "INPUT.ARROW_UP": {
+          actions: ["increment"]
+        },
+        "INPUT.ARROW_DOWN": {
+          actions: ["decrement"]
+        },
+        "INPUT.HOME": {
+          actions: ["decrementToMin"]
+        },
+        "INPUT.END": {
+          actions: ["incrementToMax"]
+        },
+        "INPUT.CHANGE": {
+          actions: ["setValue", "setHint"]
+        },
+        "INPUT.BLUR": [
+          {
+            guard: X("clampValueOnBlur", Y("isInRange")),
+            target: "idle",
+            actions: ["setClampedValue", "clearHint", "invokeOnBlur"]
+          },
+          {
+            guard: Y("isInRange"),
+            target: "idle",
+            actions: ["setFormattedValue", "clearHint", "invokeOnBlur", "invokeOnInvalid"]
+          },
+          {
+            target: "idle",
+            actions: ["setFormattedValue", "clearHint", "invokeOnBlur"]
+          }
+        ],
+        "INPUT.ENTER": {
+          actions: ["setFormattedValue", "clearHint", "invokeOnBlur"]
+        }
+      }
+    },
+    "before:spin": {
+      tags: ["focus"],
+      effects: ["trackButtonDisabled", "waitForChangeDelay"],
+      entry: Xe([
+        { guard: "isIncrementHint", actions: ["increment"] },
+        { guard: "isDecrementHint", actions: ["decrement"] }
+      ]),
+      on: {
+        CHANGE_DELAY: {
+          target: "spinning",
+          guard: X("isInRange", "spinOnPress")
+        },
+        "TRIGGER.PRESS_UP": [
+          { guard: "isTouchPointer", target: "focused", actions: ["clearHint"] },
+          { target: "focused", actions: ["focusInput", "clearHint"] }
+        ]
+      }
+    },
+    spinning: {
+      tags: ["focus"],
+      effects: ["trackButtonDisabled", "spinValue"],
+      on: {
+        SPIN: [
+          {
+            guard: "isIncrementHint",
+            actions: ["increment"]
+          },
+          {
+            guard: "isDecrementHint",
+            actions: ["decrement"]
+          }
+        ],
+        "TRIGGER.PRESS_UP": {
+          target: "focused",
+          actions: ["focusInput", "clearHint"]
+        }
+      }
+    },
+    scrubbing: {
+      tags: ["focus"],
+      effects: ["activatePointerLock", "trackMousemove", "setupVirtualCursor", "preventTextSelection"],
+      on: {
+        "SCRUBBER.POINTER_UP": {
+          target: "focused",
+          actions: ["focusInput", "clearCursorPoint"]
+        },
+        "SCRUBBER.POINTER_MOVE": [
+          {
+            guard: "isIncrementHint",
+            actions: ["increment", "setCursorPoint"]
+          },
+          {
+            guard: "isDecrementHint",
+            actions: ["decrement", "setCursorPoint"]
+          }
+        ]
+      }
+    }
+  },
+  implementations: {
+    guards: {
+      clampValueOnBlur: ({ prop: e }) => e("clampValueOnBlur"),
+      spinOnPress: ({ prop: e }) => !!e("spinOnPress"),
+      isInRange: ({ computed: e }) => !e("isOutOfRange"),
+      isDecrementHint: ({ context: e, event: t }) => (t.hint ?? e.get("hint")) === "decrement",
+      isIncrementHint: ({ context: e, event: t }) => (t.hint ?? e.get("hint")) === "increment",
+      isTouchPointer: ({ event: e }) => e.pointerType === "touch"
+    },
+    effects: {
+      waitForChangeDelay({ send: e }) {
+        const t = setTimeout(() => {
+          e({ type: "CHANGE_DELAY" });
+        }, 300);
+        return () => clearTimeout(t);
+      },
+      spinValue({ send: e }) {
+        const t = setInterval(() => {
+          e({ type: "SPIN" });
+        }, 50);
+        return () => clearInterval(t);
+      },
+      trackFormControl({ context: e, scope: t }) {
+        const r = S(t);
+        return pe(r, {
+          onFieldsetDisabledChange(n) {
+            e.set("fieldsetDisabled", n);
+          },
+          onFormReset() {
+            e.set("value", e.initial("value"));
+          }
+        });
+      },
+      setupVirtualCursor({ context: e, scope: t }) {
+        const r = e.get("scrubberCursorPoint");
+        return Be(t, r);
+      },
+      preventTextSelection({ scope: e }) {
+        return Ge(e);
+      },
+      trackButtonDisabled({ context: e, scope: t, send: r }) {
+        const n = e.get("hint"), i = Me(t, n);
+        return fe(i, {
+          attributes: ["disabled"],
+          callback() {
+            r({ type: "TRIGGER.PRESS_UP", src: "attr" });
+          }
+        });
+      },
+      attachWheelListener({ scope: e, send: t, prop: r }) {
+        const n = S(e);
+        if (!n || !e.isActiveElement(n) || !r("allowMouseWheel")) return;
+        function i(a) {
+          a.preventDefault();
+          const s = Math.sign(a.deltaY) * -1;
+          s === 1 ? t({ type: "VALUE.INCREMENT" }) : s === -1 && t({ type: "VALUE.DECREMENT" });
+        }
+        return O(n, "wheel", i, { passive: !1 });
+      },
+      activatePointerLock({ scope: e }) {
+        if (!q())
+          return de(e.getDoc());
+      },
+      trackMousemove({ scope: e, send: t, context: r, computed: n }) {
+        const i = e.getDoc();
+        function a(l) {
+          const u = r.get("scrubberCursorPoint"), d = n("isRtl"), g = He(e, { point: u, isRtl: d, event: l });
+          g.hint && t({
+            type: "SCRUBBER.POINTER_MOVE",
+            hint: g.hint,
+            point: g.point
+          });
+        }
+        function s() {
+          t({ type: "SCRUBBER.POINTER_UP" });
+        }
+        return me(O(i, "mousemove", a, !1), O(i, "mouseup", s, !1));
+      }
+    },
+    actions: {
+      focusInput({ scope: e, prop: t }) {
+        if (!t("focusInputOnChange")) return;
+        const r = S(e);
+        e.isActiveElement(r) || G(() => r?.focus({ preventScroll: !0 }));
+      },
+      increment({ context: e, event: t, prop: r, computed: n }) {
+        let i = ce(n("valueAsNumber"), t.step ?? r("step"));
+        r("allowOverflow") || (i = x(i, r("min"), r("max"))), e.set("value", P(i, { computed: n, prop: r }));
+      },
+      decrement({ context: e, event: t, prop: r, computed: n }) {
+        let i = ue(n("valueAsNumber"), t.step ?? r("step"));
+        r("allowOverflow") || (i = x(i, r("min"), r("max"))), e.set("value", P(i, { computed: n, prop: r }));
+      },
+      setClampedValue({ context: e, prop: t, computed: r }) {
+        const n = x(r("valueAsNumber"), t("min"), t("max"));
+        e.set("value", P(n, { computed: r, prop: t }));
+      },
+      setRawValue({ context: e, event: t, prop: r, computed: n }) {
+        let i = U(t.value, { computed: n, prop: r });
+        r("allowOverflow") || (i = x(i, r("min"), r("max"))), e.set("value", P(i, { computed: n, prop: r }));
+      },
+      setValue({ context: e, event: t }) {
+        const r = t.target?.value ?? t.value;
+        e.set("value", r);
+      },
+      clearValue({ context: e }) {
+        e.set("value", "");
+      },
+      incrementToMax({ context: e, prop: t, computed: r }) {
+        const n = P(t("max"), { computed: r, prop: t });
+        e.set("value", n);
+      },
+      decrementToMin({ context: e, prop: t, computed: r }) {
+        const n = P(t("min"), { computed: r, prop: t });
+        e.set("value", n);
+      },
+      setHint({ context: e, event: t }) {
+        e.set("hint", t.hint);
+      },
+      clearHint({ context: e }) {
+        e.set("hint", null);
+      },
+      invokeOnFocus({ computed: e, prop: t }) {
+        t("onFocusChange")?.({
+          focused: !0,
+          value: e("formattedValue"),
+          valueAsNumber: e("valueAsNumber")
+        });
+      },
+      invokeOnBlur({ computed: e, prop: t }) {
+        t("onFocusChange")?.({
+          focused: !1,
+          value: e("formattedValue"),
+          valueAsNumber: e("valueAsNumber")
+        });
+      },
+      invokeOnInvalid({ computed: e, prop: t, event: r }) {
+        if (r.type === "INPUT.CHANGE") return;
+        const n = e("valueAsNumber") > t("max") ? "rangeOverflow" : "rangeUnderflow";
+        t("onValueInvalid")?.({
+          reason: n,
+          value: e("formattedValue"),
+          valueAsNumber: e("valueAsNumber")
+        });
+      },
+      syncInputElement({ context: e, event: t, computed: r, scope: n }) {
+        const i = t.type.endsWith("CHANGE") ? e.get("value") : r("formattedValue"), a = S(n), s = We(a);
+        G(() => {
+          le(a, i), ke(a, s);
+        });
+      },
+      setFormattedValue({ context: e, computed: t }) {
+        e.set("value", t("formattedValue"));
+      },
+      setCursorPoint({ context: e, event: t }) {
+        e.set("scrubberCursorPoint", t.point);
+      },
+      clearCursorPoint({ context: e }) {
+        e.set("scrubberCursorPoint", null);
+      },
+      setVirtualCursorPosition({ context: e, scope: t }) {
+        const r = te(t), n = e.get("scrubberCursorPoint");
+        !r || !n || (r.style.transform = `translate3d(${n.x}px, ${n.y}px, 0px)`);
+      }
+    }
+  }
+});
+Re()([
+  "allowMouseWheel",
+  "allowOverflow",
+  "clampValueOnBlur",
+  "dir",
+  "disabled",
+  "focusInputOnChange",
+  "form",
+  "formatOptions",
+  "getRootNode",
+  "id",
+  "ids",
+  "inputMode",
+  "invalid",
+  "locale",
+  "max",
+  "min",
+  "name",
+  "onFocusChange",
+  "onValueChange",
+  "onValueInvalid",
+  "pattern",
+  "required",
+  "readOnly",
+  "spinOnPress",
+  "step",
+  "translations",
+  "value",
+  "defaultValue"
+]);
+export {
+  Oe as a,
+  et as c,
+  tt as m
+};
+//# sourceMappingURL=index-D1RhzPVz.js.map