601 lines
19 KiB
JavaScript
601 lines
19 KiB
JavaScript
/*
|
|
* Extracted from browser-delivered Turbopack chunk: fb331b08bcf9fa6e.3b67e0d42a.js
|
|
* Module id: 404059
|
|
* For reading/searching only; this factory depends on the original Turbopack runtime.
|
|
*/
|
|
|
|
const moduleFactory = (e) => {
|
|
"use strict";
|
|
var t = e.i(462214),
|
|
r = e.i(358379),
|
|
o = e.i(403557);
|
|
function n(e, t, r) {
|
|
return void 0 === t && void 0 === r
|
|
? e
|
|
: void 0 !== t && void 0 === r
|
|
? Math.max(e, t)
|
|
: void 0 === t && void 0 !== r
|
|
? Math.min(e, r)
|
|
: Math.min(Math.max(e, t), r);
|
|
}
|
|
e.s(["clamp", () => n], 404059);
|
|
var i = e.i(600354),
|
|
a = e.i(389435),
|
|
l = e.i(855698);
|
|
function s(e, t) {
|
|
return 0 === t.length
|
|
? e
|
|
: t.reduce((t, r) => (Math.abs(r - e) < Math.abs(t - e) ? r : t));
|
|
}
|
|
var u = e.i(938202);
|
|
e.i(7284);
|
|
var d = e.i(620428),
|
|
c = e.i(479324),
|
|
f = e.i(450943),
|
|
p = e.i(593307),
|
|
m = e.i(46978);
|
|
let [h, v] = (0, e.i(559394).createSafeContext)(
|
|
"SliderProvider was not found in tree",
|
|
);
|
|
var g = {
|
|
root: "m_dd36362e",
|
|
label: "m_c9357328",
|
|
thumb: "m_c9a9a60a",
|
|
trackContainer: "m_a8645c2",
|
|
track: "m_c9ade57f",
|
|
bar: "m_38aeed47",
|
|
markWrapper: "m_b7b0423a",
|
|
mark: "m_dd33bc19",
|
|
markLabel: "m_68c77a5b",
|
|
},
|
|
x = e.i(124859);
|
|
let w = (0, r.forwardRef)(
|
|
(
|
|
{
|
|
size: e,
|
|
disabled: r,
|
|
variant: o,
|
|
color: n,
|
|
thumbSize: i,
|
|
radius: a,
|
|
...l
|
|
},
|
|
s,
|
|
) => {
|
|
let { getStyles: u } = v();
|
|
return (0, t.jsx)(x.Box, {
|
|
tabIndex: -1,
|
|
variant: o,
|
|
size: e,
|
|
ref: s,
|
|
...u("root"),
|
|
...l,
|
|
});
|
|
},
|
|
);
|
|
w.displayName = "@mantine/core/SliderRoot";
|
|
var b = e.i(764218);
|
|
let y = (0, r.forwardRef)(
|
|
(
|
|
{
|
|
max: e,
|
|
min: o,
|
|
value: n,
|
|
position: i,
|
|
label: a,
|
|
dragging: l,
|
|
onMouseDown: s,
|
|
onKeyDownCapture: u,
|
|
labelTransitionProps: d,
|
|
labelAlwaysOn: c,
|
|
thumbLabel: f,
|
|
onFocus: p,
|
|
onBlur: m,
|
|
showLabelOnHover: h,
|
|
isHovered: g,
|
|
children: w = null,
|
|
disabled: y,
|
|
},
|
|
P,
|
|
) => {
|
|
let { getStyles: R } = v(),
|
|
[C, S] = (0, r.useState)(!1),
|
|
E = c || l || C || (h && g);
|
|
return (0, t.jsxs)(x.Box, {
|
|
tabIndex: 0,
|
|
role: "slider",
|
|
"aria-label": f,
|
|
"aria-valuemax": e,
|
|
"aria-valuemin": o,
|
|
"aria-valuenow": n,
|
|
ref: P,
|
|
__vars: { "--slider-thumb-offset": `${i}%` },
|
|
...R("thumb", { focusable: !0 }),
|
|
mod: { dragging: l, disabled: y },
|
|
onFocus: (e) => {
|
|
S(!0), "function" == typeof p && p(e);
|
|
},
|
|
onBlur: (e) => {
|
|
S(!1), "function" == typeof m && m(e);
|
|
},
|
|
onTouchStart: s,
|
|
onMouseDown: s,
|
|
onKeyDownCapture: u,
|
|
onClick: (e) => e.stopPropagation(),
|
|
children: [
|
|
w,
|
|
(0, t.jsx)(b.Transition, {
|
|
mounted: null != a && !!E,
|
|
transition: "fade",
|
|
duration: 0,
|
|
...d,
|
|
children: (e) =>
|
|
(0, t.jsx)("div", { ...R("label", { style: e }), children: a }),
|
|
}),
|
|
],
|
|
});
|
|
},
|
|
);
|
|
function P({ value: e, min: t, max: r }) {
|
|
return Math.min(Math.max(((e - t) / (r - t)) * 100, 0), 100);
|
|
}
|
|
function R({
|
|
marks: e,
|
|
min: o,
|
|
max: n,
|
|
disabled: i,
|
|
value: a,
|
|
offset: l,
|
|
inverted: s,
|
|
}) {
|
|
let { getStyles: u } = v();
|
|
if (!e) return null;
|
|
let d = e.map((e, d) =>
|
|
(0, r.createElement)(
|
|
x.Box,
|
|
{
|
|
...u("markWrapper"),
|
|
__vars: {
|
|
"--mark-offset": `${P({ value: e.value, min: o, max: n })}%`,
|
|
},
|
|
key: d,
|
|
},
|
|
(0, t.jsx)(x.Box, {
|
|
...u("mark"),
|
|
mod: {
|
|
filled: (function ({
|
|
mark: e,
|
|
offset: t,
|
|
value: r,
|
|
inverted: o = !1,
|
|
}) {
|
|
return o
|
|
? ("number" == typeof t && e.value <= t) || e.value >= r
|
|
: "number" == typeof t
|
|
? e.value >= t && e.value <= r
|
|
: e.value <= r;
|
|
})({ mark: e, value: a, offset: l, inverted: s }),
|
|
disabled: i,
|
|
},
|
|
}),
|
|
e.label &&
|
|
(0, t.jsx)("div", { ...u("markLabel"), children: e.label }),
|
|
),
|
|
);
|
|
return (0, t.jsx)("div", { children: d });
|
|
}
|
|
function C({
|
|
filled: e,
|
|
children: r,
|
|
offset: o,
|
|
disabled: n,
|
|
marksOffset: i,
|
|
inverted: a,
|
|
containerProps: l,
|
|
...s
|
|
}) {
|
|
let { getStyles: u } = v();
|
|
return (0, t.jsx)(x.Box, {
|
|
...u("trackContainer"),
|
|
mod: { disabled: n },
|
|
...l,
|
|
children: (0, t.jsxs)(x.Box, {
|
|
...u("track"),
|
|
mod: { inverted: a, disabled: n },
|
|
children: [
|
|
(0, t.jsx)(x.Box, {
|
|
mod: { inverted: a, disabled: n },
|
|
__vars: {
|
|
"--slider-bar-width": `calc(${e}% + 2 * var(--slider-size))`,
|
|
"--slider-bar-offset": `calc(${o}% - var(--slider-size))`,
|
|
},
|
|
...u("bar"),
|
|
}),
|
|
r,
|
|
(0, t.jsx)(R, { ...s, offset: i, disabled: n, inverted: a }),
|
|
],
|
|
}),
|
|
});
|
|
}
|
|
function S(e, t) {
|
|
return parseFloat(e.toFixed(t));
|
|
}
|
|
function E(e, t) {
|
|
let r = [...t].sort((e, t) => e.value - t.value).find((t) => t.value > e);
|
|
return r ? r.value : e;
|
|
}
|
|
function T(e, t) {
|
|
let r = [...t].sort((e, t) => t.value - e.value).find((t) => t.value < e);
|
|
return r ? r.value : e;
|
|
}
|
|
function D(e) {
|
|
let t = [...e].sort((e, t) => e.value - t.value);
|
|
return t.length > 0 ? t[0].value : 0;
|
|
}
|
|
function M(e) {
|
|
let t = [...e].sort((e, t) => e.value - t.value);
|
|
return t.length > 0 ? t[t.length - 1].value : 100;
|
|
}
|
|
(y.displayName = "@mantine/core/SliderThumb"),
|
|
(R.displayName = "@mantine/core/SliderMarks"),
|
|
(C.displayName = "@mantine/core/SliderTrack");
|
|
let k = {
|
|
radius: "xl",
|
|
min: 0,
|
|
max: 100,
|
|
step: 1,
|
|
marks: [],
|
|
label: (e) => e,
|
|
labelTransitionProps: { transition: "fade", duration: 0 },
|
|
thumbLabel: "",
|
|
showLabelOnHover: !0,
|
|
scale: (e) => e,
|
|
size: "md",
|
|
},
|
|
j = (0, u.createVarsResolver)(
|
|
(e, { size: t, color: r, thumbSize: o, radius: n }) => ({
|
|
root: {
|
|
"--slider-size": (0, l.getSize)(t, "slider-size"),
|
|
"--slider-color": r ? (0, d.getThemeColor)(r, e) : void 0,
|
|
"--slider-radius": void 0 === n ? void 0 : (0, l.getRadius)(n),
|
|
"--slider-thumb-size":
|
|
void 0 !== o ? (0, a.rem)(o) : "calc(var(--slider-size) * 2)",
|
|
},
|
|
}),
|
|
),
|
|
N = (0, p.factory)((e, a) => {
|
|
let l = (0, c.useProps)("Slider", k, e),
|
|
{
|
|
classNames: u,
|
|
styles: d,
|
|
value: p,
|
|
onChange: v,
|
|
onChangeEnd: x,
|
|
size: b,
|
|
min: R,
|
|
max: N,
|
|
domain: O,
|
|
step: L,
|
|
precision: F,
|
|
defaultValue: B,
|
|
name: I,
|
|
marks: _,
|
|
label: A,
|
|
labelTransitionProps: z,
|
|
labelAlwaysOn: $,
|
|
thumbLabel: V,
|
|
showLabelOnHover: K,
|
|
thumbChildren: U,
|
|
disabled: Y,
|
|
unstyled: H,
|
|
scale: X,
|
|
inverted: G,
|
|
className: W,
|
|
style: Z,
|
|
vars: J,
|
|
hiddenInputProps: q,
|
|
restrictToMarks: Q,
|
|
thumbProps: ee,
|
|
attributes: et,
|
|
...er
|
|
} = l,
|
|
eo = (0, f.useStyles)({
|
|
name: "Slider",
|
|
props: l,
|
|
classes: g,
|
|
classNames: u,
|
|
className: W,
|
|
styles: d,
|
|
style: Z,
|
|
attributes: et,
|
|
vars: J,
|
|
varsResolver: j,
|
|
unstyled: H,
|
|
}),
|
|
{ dir: en } = (0, m.useDirection)(),
|
|
[ei, ea] = (0, r.useState)(!1),
|
|
[el, es] = (0, o.useUncontrolled)({
|
|
value: "number" == typeof p ? n(p, R, N) : p,
|
|
defaultValue: "number" == typeof B ? n(B, R, N) : B,
|
|
finalValue: n(0, R, N),
|
|
onChange: v,
|
|
}),
|
|
eu = (0, r.useRef)(el),
|
|
ed = (0, r.useRef)(x);
|
|
(0, r.useEffect)(() => {
|
|
ed.current = x;
|
|
}, [x]);
|
|
let ec = (0, r.useRef)(null),
|
|
ef = (0, r.useRef)(null),
|
|
[ep, em] = O || [R, N],
|
|
eh = P({ value: el, min: ep, max: em }),
|
|
ev = X(el),
|
|
eg = "function" == typeof A ? A(ev) : A,
|
|
ex =
|
|
F ??
|
|
(function (e) {
|
|
if (!e) return 0;
|
|
let t = e.toString().split(".");
|
|
return t.length > 1 ? t[1].length : 0;
|
|
})(L),
|
|
{ ref: ew, active: eb } = (function (e, t, o = "ltr") {
|
|
let i = (0, r.useRef)(!1),
|
|
a = (0, r.useRef)(!1),
|
|
l = (0, r.useRef)(0),
|
|
[s, u] = (0, r.useState)(!1),
|
|
d = (0, r.useRef)(null);
|
|
return (
|
|
(0, r.useEffect)(() => {
|
|
i.current = !0;
|
|
}, []),
|
|
{
|
|
ref: (0, r.useCallback)(
|
|
(r) => {
|
|
if ((d.current && (d.current(), (d.current = null)), !r))
|
|
return;
|
|
let s = ({ x: t, y: a }) => {
|
|
cancelAnimationFrame(l.current),
|
|
(l.current = requestAnimationFrame(() => {
|
|
if (i.current && r) {
|
|
r.style.userSelect = "none";
|
|
let i = r.getBoundingClientRect();
|
|
if (i.width && i.height) {
|
|
let r = n((t - i.left) / i.width, 0, 1);
|
|
e({
|
|
x: "ltr" === o ? r : 1 - r,
|
|
y: n((a - i.top) / i.height, 0, 1),
|
|
});
|
|
}
|
|
}
|
|
}));
|
|
},
|
|
c = () => {
|
|
!a.current &&
|
|
i.current &&
|
|
((a.current = !0),
|
|
"function" == typeof t?.onScrubStart &&
|
|
t.onScrubStart(),
|
|
u(!0),
|
|
document.addEventListener("mousemove", m),
|
|
document.addEventListener("mouseup", f),
|
|
document.addEventListener("touchmove", v, {
|
|
passive: !1,
|
|
}),
|
|
document.addEventListener("touchend", f));
|
|
},
|
|
f = () => {
|
|
a.current &&
|
|
i.current &&
|
|
((a.current = !1),
|
|
u(!1),
|
|
document.removeEventListener("mousemove", m),
|
|
document.removeEventListener("mouseup", f),
|
|
document.removeEventListener("touchmove", v),
|
|
document.removeEventListener("touchend", f),
|
|
setTimeout(() => {
|
|
"function" == typeof t?.onScrubEnd &&
|
|
t.onScrubEnd();
|
|
}, 0));
|
|
},
|
|
p = (e) => {
|
|
c(), e.preventDefault(), m(e);
|
|
},
|
|
m = (e) => s({ x: e.clientX, y: e.clientY }),
|
|
h = (e) => {
|
|
e.cancelable && e.preventDefault(), c(), v(e);
|
|
},
|
|
v = (e) => {
|
|
e.cancelable && e.preventDefault(),
|
|
s({
|
|
x: e.changedTouches[0].clientX,
|
|
y: e.changedTouches[0].clientY,
|
|
});
|
|
};
|
|
r.addEventListener("mousedown", p),
|
|
r.addEventListener("touchstart", h, { passive: !1 }),
|
|
(d.current = () => {
|
|
r.removeEventListener("mousedown", p),
|
|
r.removeEventListener("touchstart", h);
|
|
});
|
|
},
|
|
[o, e],
|
|
),
|
|
active: s,
|
|
}
|
|
);
|
|
})(
|
|
(0, r.useCallback)(
|
|
({ x: e }) => {
|
|
if (!Y) {
|
|
let t = n(
|
|
(function ({
|
|
value: e,
|
|
containerWidth: t,
|
|
min: r,
|
|
max: o,
|
|
step: n,
|
|
precision: i,
|
|
}) {
|
|
let a =
|
|
(t ? Math.min(Math.max(e, 0), t) / t : e) * (o - r),
|
|
l = Math.max(
|
|
(0 !== a ? Math.round(a / n) * n : 0) + r,
|
|
r,
|
|
);
|
|
return void 0 !== i ? Number(l.toFixed(i)) : l;
|
|
})({ value: e, min: ep, max: em, step: L, precision: ex }),
|
|
R,
|
|
N,
|
|
);
|
|
es(
|
|
Q && _?.length
|
|
? s(
|
|
t,
|
|
_.map((e) => e.value),
|
|
)
|
|
: t,
|
|
),
|
|
(eu.current = t);
|
|
}
|
|
},
|
|
[Y, R, N, ep, em, L, ex, es, _, Q],
|
|
),
|
|
{
|
|
onScrubEnd: (0, r.useCallback)(() => {
|
|
if (!Y && ed.current) {
|
|
let e =
|
|
Q && _?.length
|
|
? s(
|
|
eu.current,
|
|
_.map((e) => e.value),
|
|
)
|
|
: eu.current;
|
|
ed.current(e);
|
|
}
|
|
}, [Y, _, Q]),
|
|
},
|
|
en,
|
|
),
|
|
ey = (0, r.useCallback)(
|
|
(e) => {
|
|
!Y && ed.current && ed.current(e);
|
|
},
|
|
[Y],
|
|
);
|
|
return (0, t.jsx)(h, {
|
|
value: { getStyles: eo },
|
|
children: (0, t.jsxs)(w, {
|
|
...er,
|
|
ref: (0, i.useMergedRef)(a, ec),
|
|
onKeyDownCapture: (e) => {
|
|
if (!Y)
|
|
switch (e.key) {
|
|
case "ArrowUp": {
|
|
if ((e.preventDefault(), ef.current?.focus(), Q && _)) {
|
|
let e = E(el, _);
|
|
es(e), ey(e);
|
|
break;
|
|
}
|
|
let t = S(Math.min(Math.max(el + L, R), N), ex);
|
|
es(t), ey(t);
|
|
break;
|
|
}
|
|
case "ArrowRight": {
|
|
if ((e.preventDefault(), ef.current?.focus(), Q && _)) {
|
|
let e = "rtl" === en ? T(el, _) : E(el, _);
|
|
es(e), ey(e);
|
|
break;
|
|
}
|
|
let t = S(
|
|
Math.min(Math.max("rtl" === en ? el - L : el + L, R), N),
|
|
ex,
|
|
);
|
|
es(t), ey(t);
|
|
break;
|
|
}
|
|
case "ArrowDown": {
|
|
if ((e.preventDefault(), ef.current?.focus(), Q && _)) {
|
|
let e = T(el, _);
|
|
es(e), ey(e);
|
|
break;
|
|
}
|
|
let t = S(Math.min(Math.max(el - L, R), N), ex);
|
|
es(t), ey(t);
|
|
break;
|
|
}
|
|
case "ArrowLeft": {
|
|
if ((e.preventDefault(), ef.current?.focus(), Q && _)) {
|
|
let e = "rtl" === en ? E(el, _) : T(el, _);
|
|
es(e), ey(e);
|
|
break;
|
|
}
|
|
let t = S(
|
|
Math.min(Math.max("rtl" === en ? el + L : el - L, R), N),
|
|
ex,
|
|
);
|
|
es(t), ey(t);
|
|
break;
|
|
}
|
|
case "Home":
|
|
if ((e.preventDefault(), ef.current?.focus(), Q && _)) {
|
|
es(D(_)), ey(D(_));
|
|
break;
|
|
}
|
|
es(R), ey(R);
|
|
break;
|
|
case "End":
|
|
if ((e.preventDefault(), ef.current?.focus(), Q && _)) {
|
|
es(M(_)), ey(M(_));
|
|
break;
|
|
}
|
|
es(N), ey(N);
|
|
}
|
|
},
|
|
onMouseDownCapture: () => ec.current?.focus(),
|
|
size: b,
|
|
disabled: Y,
|
|
children: [
|
|
(0, t.jsx)(C, {
|
|
inverted: G,
|
|
offset: 0,
|
|
filled: eh,
|
|
marks: _,
|
|
min: ep,
|
|
max: em,
|
|
value: ev,
|
|
disabled: Y,
|
|
containerProps: {
|
|
ref: ew,
|
|
onMouseEnter: K ? () => ea(!0) : void 0,
|
|
onMouseLeave: K ? () => ea(!1) : void 0,
|
|
},
|
|
children: (0, t.jsx)(y, {
|
|
max: em,
|
|
min: ep,
|
|
value: ev,
|
|
position: eh,
|
|
dragging: eb,
|
|
label: eg,
|
|
ref: ef,
|
|
labelTransitionProps: z,
|
|
labelAlwaysOn: $,
|
|
thumbLabel: V,
|
|
showLabelOnHover: K,
|
|
isHovered: ei,
|
|
disabled: Y,
|
|
...ee,
|
|
children: U,
|
|
}),
|
|
}),
|
|
(0, t.jsx)("input", { type: "hidden", name: I, value: ev, ...q }),
|
|
],
|
|
}),
|
|
});
|
|
});
|
|
(N.classes = g),
|
|
(N.displayName = "@mantine/core/Slider"),
|
|
e.s(["Slider", () => N], 906328);
|
|
};
|
|
|
|
export default moduleFactory;
|