3846 lines
109 KiB
JavaScript
3846 lines
109 KiB
JavaScript
/*! For license information please see chart-utils.min.js.LICENSE.txt */
|
||
;(() => {
|
||
"use strict"
|
||
function t(t) {
|
||
return (t + 0.5) | 0
|
||
}
|
||
const e = (t, e, n) => Math.max(Math.min(t, n), e)
|
||
function n(n) {
|
||
return e(t(2.55 * n), 0, 255)
|
||
}
|
||
function r(n) {
|
||
return e(t(255 * n), 0, 255)
|
||
}
|
||
function s(n) {
|
||
return e(t(n / 2.55) / 100, 0, 1)
|
||
}
|
||
function i(n) {
|
||
return e(t(100 * n), 0, 100)
|
||
}
|
||
const a = {
|
||
0: 0,
|
||
1: 1,
|
||
2: 2,
|
||
3: 3,
|
||
4: 4,
|
||
5: 5,
|
||
6: 6,
|
||
7: 7,
|
||
8: 8,
|
||
9: 9,
|
||
A: 10,
|
||
B: 11,
|
||
C: 12,
|
||
D: 13,
|
||
E: 14,
|
||
F: 15,
|
||
a: 10,
|
||
b: 11,
|
||
c: 12,
|
||
d: 13,
|
||
e: 14,
|
||
f: 15,
|
||
},
|
||
o = [..."0123456789ABCDEF"],
|
||
u = (t) => o[15 & t],
|
||
l = (t) => o[(240 & t) >> 4] + o[15 & t],
|
||
c = (t) => (240 & t) >> 4 == (15 & t)
|
||
const h =
|
||
/^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/
|
||
function d(t, e, n) {
|
||
const r = e * Math.min(n, 1 - n),
|
||
s = (e, s = (e + t / 30) % 12) => n - r * Math.max(Math.min(s - 3, 9 - s, 1), -1)
|
||
return [s(0), s(8), s(4)]
|
||
}
|
||
function f(t, e, n) {
|
||
const r = (r, s = (r + t / 60) % 6) => n - n * e * Math.max(Math.min(s, 4 - s, 1), 0)
|
||
return [r(5), r(3), r(1)]
|
||
}
|
||
function m(t, e, n) {
|
||
const r = d(t, 1, 0.5)
|
||
let s
|
||
for (e + n > 1 && ((s = 1 / (e + n)), (e *= s), (n *= s)), s = 0; s < 3; s++)
|
||
(r[s] *= 1 - e - n), (r[s] += e)
|
||
return r
|
||
}
|
||
function y(t) {
|
||
const e = t.r / 255,
|
||
n = t.g / 255,
|
||
r = t.b / 255,
|
||
s = Math.max(e, n, r),
|
||
i = Math.min(e, n, r),
|
||
a = (s + i) / 2
|
||
let o, u, l
|
||
return (
|
||
s !== i &&
|
||
((l = s - i),
|
||
(u = a > 0.5 ? l / (2 - s - i) : l / (s + i)),
|
||
(o = (function (t, e, n, r, s) {
|
||
return t === s
|
||
? (e - n) / r + (e < n ? 6 : 0)
|
||
: e === s
|
||
? (n - t) / r + 2
|
||
: (t - e) / r + 4
|
||
})(e, n, r, l, s)),
|
||
(o = 60 * o + 0.5)),
|
||
[0 | o, u || 0, a]
|
||
)
|
||
}
|
||
function g(t, e, n, s) {
|
||
return (Array.isArray(e) ? t(e[0], e[1], e[2]) : t(e, n, s)).map(r)
|
||
}
|
||
function p(t, e, n) {
|
||
return g(d, t, e, n)
|
||
}
|
||
function w(t) {
|
||
return ((t % 360) + 360) % 360
|
||
}
|
||
const b = {
|
||
x: "dark",
|
||
Z: "light",
|
||
Y: "re",
|
||
X: "blu",
|
||
W: "gr",
|
||
V: "medium",
|
||
U: "slate",
|
||
A: "ee",
|
||
T: "ol",
|
||
S: "or",
|
||
B: "ra",
|
||
C: "lateg",
|
||
D: "ights",
|
||
R: "in",
|
||
Q: "turquois",
|
||
E: "hi",
|
||
P: "ro",
|
||
O: "al",
|
||
N: "le",
|
||
M: "de",
|
||
L: "yello",
|
||
F: "en",
|
||
K: "ch",
|
||
G: "arks",
|
||
H: "ea",
|
||
I: "ightg",
|
||
J: "wh",
|
||
},
|
||
v = {
|
||
OiceXe: "f0f8ff",
|
||
antiquewEte: "faebd7",
|
||
aqua: "ffff",
|
||
aquamarRe: "7fffd4",
|
||
azuY: "f0ffff",
|
||
beige: "f5f5dc",
|
||
bisque: "ffe4c4",
|
||
black: "0",
|
||
blanKedOmond: "ffebcd",
|
||
Xe: "ff",
|
||
XeviTet: "8a2be2",
|
||
bPwn: "a52a2a",
|
||
burlywood: "deb887",
|
||
caMtXe: "5f9ea0",
|
||
KartYuse: "7fff00",
|
||
KocTate: "d2691e",
|
||
cSO: "ff7f50",
|
||
cSnflowerXe: "6495ed",
|
||
cSnsilk: "fff8dc",
|
||
crimson: "dc143c",
|
||
cyan: "ffff",
|
||
xXe: "8b",
|
||
xcyan: "8b8b",
|
||
xgTMnPd: "b8860b",
|
||
xWay: "a9a9a9",
|
||
xgYF: "6400",
|
||
xgYy: "a9a9a9",
|
||
xkhaki: "bdb76b",
|
||
xmagFta: "8b008b",
|
||
xTivegYF: "556b2f",
|
||
xSange: "ff8c00",
|
||
xScEd: "9932cc",
|
||
xYd: "8b0000",
|
||
xsOmon: "e9967a",
|
||
xsHgYF: "8fbc8f",
|
||
xUXe: "483d8b",
|
||
xUWay: "2f4f4f",
|
||
xUgYy: "2f4f4f",
|
||
xQe: "ced1",
|
||
xviTet: "9400d3",
|
||
dAppRk: "ff1493",
|
||
dApskyXe: "bfff",
|
||
dimWay: "696969",
|
||
dimgYy: "696969",
|
||
dodgerXe: "1e90ff",
|
||
fiYbrick: "b22222",
|
||
flSOwEte: "fffaf0",
|
||
foYstWAn: "228b22",
|
||
fuKsia: "ff00ff",
|
||
gaRsbSo: "dcdcdc",
|
||
ghostwEte: "f8f8ff",
|
||
gTd: "ffd700",
|
||
gTMnPd: "daa520",
|
||
Way: "808080",
|
||
gYF: "8000",
|
||
gYFLw: "adff2f",
|
||
gYy: "808080",
|
||
honeyMw: "f0fff0",
|
||
hotpRk: "ff69b4",
|
||
RdianYd: "cd5c5c",
|
||
Rdigo: "4b0082",
|
||
ivSy: "fffff0",
|
||
khaki: "f0e68c",
|
||
lavFMr: "e6e6fa",
|
||
lavFMrXsh: "fff0f5",
|
||
lawngYF: "7cfc00",
|
||
NmoncEffon: "fffacd",
|
||
ZXe: "add8e6",
|
||
ZcSO: "f08080",
|
||
Zcyan: "e0ffff",
|
||
ZgTMnPdLw: "fafad2",
|
||
ZWay: "d3d3d3",
|
||
ZgYF: "90ee90",
|
||
ZgYy: "d3d3d3",
|
||
ZpRk: "ffb6c1",
|
||
ZsOmon: "ffa07a",
|
||
ZsHgYF: "20b2aa",
|
||
ZskyXe: "87cefa",
|
||
ZUWay: "778899",
|
||
ZUgYy: "778899",
|
||
ZstAlXe: "b0c4de",
|
||
ZLw: "ffffe0",
|
||
lime: "ff00",
|
||
limegYF: "32cd32",
|
||
lRF: "faf0e6",
|
||
magFta: "ff00ff",
|
||
maPon: "800000",
|
||
VaquamarRe: "66cdaa",
|
||
VXe: "cd",
|
||
VScEd: "ba55d3",
|
||
VpurpN: "9370db",
|
||
VsHgYF: "3cb371",
|
||
VUXe: "7b68ee",
|
||
VsprRggYF: "fa9a",
|
||
VQe: "48d1cc",
|
||
VviTetYd: "c71585",
|
||
midnightXe: "191970",
|
||
mRtcYam: "f5fffa",
|
||
mistyPse: "ffe4e1",
|
||
moccasR: "ffe4b5",
|
||
navajowEte: "ffdead",
|
||
navy: "80",
|
||
Tdlace: "fdf5e6",
|
||
Tive: "808000",
|
||
TivedBb: "6b8e23",
|
||
Sange: "ffa500",
|
||
SangeYd: "ff4500",
|
||
ScEd: "da70d6",
|
||
pOegTMnPd: "eee8aa",
|
||
pOegYF: "98fb98",
|
||
pOeQe: "afeeee",
|
||
pOeviTetYd: "db7093",
|
||
papayawEp: "ffefd5",
|
||
pHKpuff: "ffdab9",
|
||
peru: "cd853f",
|
||
pRk: "ffc0cb",
|
||
plum: "dda0dd",
|
||
powMrXe: "b0e0e6",
|
||
purpN: "800080",
|
||
YbeccapurpN: "663399",
|
||
Yd: "ff0000",
|
||
Psybrown: "bc8f8f",
|
||
PyOXe: "4169e1",
|
||
saddNbPwn: "8b4513",
|
||
sOmon: "fa8072",
|
||
sandybPwn: "f4a460",
|
||
sHgYF: "2e8b57",
|
||
sHshell: "fff5ee",
|
||
siFna: "a0522d",
|
||
silver: "c0c0c0",
|
||
skyXe: "87ceeb",
|
||
UXe: "6a5acd",
|
||
UWay: "708090",
|
||
UgYy: "708090",
|
||
snow: "fffafa",
|
||
sprRggYF: "ff7f",
|
||
stAlXe: "4682b4",
|
||
tan: "d2b48c",
|
||
teO: "8080",
|
||
tEstN: "d8bfd8",
|
||
tomato: "ff6347",
|
||
Qe: "40e0d0",
|
||
viTet: "ee82ee",
|
||
JHt: "f5deb3",
|
||
wEte: "ffffff",
|
||
wEtesmoke: "f5f5f5",
|
||
Lw: "ffff00",
|
||
LwgYF: "9acd32",
|
||
}
|
||
let O
|
||
const S =
|
||
/^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/,
|
||
T = (t) => (t <= 0.0031308 ? 12.92 * t : 1.055 * Math.pow(t, 1 / 2.4) - 0.055),
|
||
M = (t) => (t <= 0.04045 ? t / 12.92 : Math.pow((t + 0.055) / 1.055, 2.4))
|
||
function k(t, e, n) {
|
||
if (t) {
|
||
let r = y(t)
|
||
;(r[e] = Math.max(0, Math.min(r[e] + r[e] * n, 0 === e ? 360 : 1))),
|
||
(r = p(r)),
|
||
(t.r = r[0]),
|
||
(t.g = r[1]),
|
||
(t.b = r[2])
|
||
}
|
||
}
|
||
function N(t, e) {
|
||
return t ? Object.assign(e || {}, t) : t
|
||
}
|
||
function D(t) {
|
||
var e = { r: 0, g: 0, b: 0, a: 255 }
|
||
return (
|
||
Array.isArray(t)
|
||
? t.length >= 3 &&
|
||
((e = { r: t[0], g: t[1], b: t[2], a: 255 }), t.length > 3 && (e.a = r(t[3])))
|
||
: ((e = N(t, { r: 0, g: 0, b: 0, a: 1 })).a = r(e.a)),
|
||
e
|
||
)
|
||
}
|
||
function E(t) {
|
||
return "r" === t.charAt(0)
|
||
? (function (t) {
|
||
const r = S.exec(t)
|
||
let s,
|
||
i,
|
||
a,
|
||
o = 255
|
||
if (r) {
|
||
if (r[7] !== s) {
|
||
const t = +r[7]
|
||
o = r[8] ? n(t) : e(255 * t, 0, 255)
|
||
}
|
||
return (
|
||
(s = +r[1]),
|
||
(i = +r[3]),
|
||
(a = +r[5]),
|
||
(s = 255 & (r[2] ? n(s) : e(s, 0, 255))),
|
||
(i = 255 & (r[4] ? n(i) : e(i, 0, 255))),
|
||
(a = 255 & (r[6] ? n(a) : e(a, 0, 255))),
|
||
{ r: s, g: i, b: a, a: o }
|
||
)
|
||
}
|
||
})(t)
|
||
: (function (t) {
|
||
const e = h.exec(t)
|
||
let s,
|
||
i = 255
|
||
if (!e) return
|
||
e[5] !== s && (i = e[6] ? n(+e[5]) : r(+e[5]))
|
||
const a = w(+e[2]),
|
||
o = +e[3] / 100,
|
||
u = +e[4] / 100
|
||
return (
|
||
(s =
|
||
"hwb" === e[1]
|
||
? (function (t, e, n) {
|
||
return g(m, t, e, n)
|
||
})(a, o, u)
|
||
: "hsv" === e[1]
|
||
? (function (t, e, n) {
|
||
return g(f, t, e, n)
|
||
})(a, o, u)
|
||
: p(a, o, u)),
|
||
{ r: s[0], g: s[1], b: s[2], a: i }
|
||
)
|
||
})(t)
|
||
}
|
||
class x {
|
||
constructor(t) {
|
||
if (t instanceof x) return t
|
||
const e = typeof t
|
||
let n
|
||
var r, s, i
|
||
"object" === e
|
||
? (n = D(t))
|
||
: "string" === e &&
|
||
((i = (r = t).length),
|
||
"#" === r[0] &&
|
||
(4 === i || 5 === i
|
||
? (s = {
|
||
r: 255 & (17 * a[r[1]]),
|
||
g: 255 & (17 * a[r[2]]),
|
||
b: 255 & (17 * a[r[3]]),
|
||
a: 5 === i ? 17 * a[r[4]] : 255,
|
||
})
|
||
: (7 !== i && 9 !== i) ||
|
||
(s = {
|
||
r: (a[r[1]] << 4) | a[r[2]],
|
||
g: (a[r[3]] << 4) | a[r[4]],
|
||
b: (a[r[5]] << 4) | a[r[6]],
|
||
a: 9 === i ? (a[r[7]] << 4) | a[r[8]] : 255,
|
||
})),
|
||
(n =
|
||
s ||
|
||
(function (t) {
|
||
O ||
|
||
((O = (function () {
|
||
const t = {},
|
||
e = Object.keys(v),
|
||
n = Object.keys(b)
|
||
let r, s, i, a, o
|
||
for (r = 0; r < e.length; r++) {
|
||
for (a = o = e[r], s = 0; s < n.length; s++)
|
||
(i = n[s]), (o = o.replace(i, b[i]))
|
||
;(i = parseInt(v[a], 16)), (t[o] = [(i >> 16) & 255, (i >> 8) & 255, 255 & i])
|
||
}
|
||
return t
|
||
})()),
|
||
(O.transparent = [0, 0, 0, 0]))
|
||
const e = O[t.toLowerCase()]
|
||
return e && { r: e[0], g: e[1], b: e[2], a: 4 === e.length ? e[3] : 255 }
|
||
})(t) ||
|
||
E(t))),
|
||
(this._rgb = n),
|
||
(this._valid = !!n)
|
||
}
|
||
get valid() {
|
||
return this._valid
|
||
}
|
||
get rgb() {
|
||
var t = N(this._rgb)
|
||
return t && (t.a = s(t.a)), t
|
||
}
|
||
set rgb(t) {
|
||
this._rgb = D(t)
|
||
}
|
||
rgbString() {
|
||
return this._valid
|
||
? (t = this._rgb) &&
|
||
(t.a < 255 ? `rgba(${t.r}, ${t.g}, ${t.b}, ${s(t.a)})` : `rgb(${t.r}, ${t.g}, ${t.b})`)
|
||
: void 0
|
||
var t
|
||
}
|
||
hexString() {
|
||
return this._valid
|
||
? ((t = this._rgb),
|
||
(e = ((t) => c(t.r) && c(t.g) && c(t.b) && c(t.a))(t) ? u : l),
|
||
t ? "#" + e(t.r) + e(t.g) + e(t.b) + ((t, e) => (t < 255 ? e(t) : ""))(t.a, e) : void 0)
|
||
: void 0
|
||
var t, e
|
||
}
|
||
hslString() {
|
||
return this._valid
|
||
? (function (t) {
|
||
if (!t) return
|
||
const e = y(t),
|
||
n = e[0],
|
||
r = i(e[1]),
|
||
a = i(e[2])
|
||
return t.a < 255 ? `hsla(${n}, ${r}%, ${a}%, ${s(t.a)})` : `hsl(${n}, ${r}%, ${a}%)`
|
||
})(this._rgb)
|
||
: void 0
|
||
}
|
||
mix(t, e) {
|
||
if (t) {
|
||
const n = this.rgb,
|
||
r = t.rgb
|
||
let s
|
||
const i = e === s ? 0.5 : e,
|
||
a = 2 * i - 1,
|
||
o = n.a - r.a,
|
||
u = ((a * o == -1 ? a : (a + o) / (1 + a * o)) + 1) / 2
|
||
;(s = 1 - u),
|
||
(n.r = 255 & (u * n.r + s * r.r + 0.5)),
|
||
(n.g = 255 & (u * n.g + s * r.g + 0.5)),
|
||
(n.b = 255 & (u * n.b + s * r.b + 0.5)),
|
||
(n.a = i * n.a + (1 - i) * r.a),
|
||
(this.rgb = n)
|
||
}
|
||
return this
|
||
}
|
||
interpolate(t, e) {
|
||
return (
|
||
t &&
|
||
(this._rgb = (function (t, e, n) {
|
||
const i = M(s(t.r)),
|
||
a = M(s(t.g)),
|
||
o = M(s(t.b))
|
||
return {
|
||
r: r(T(i + n * (M(s(e.r)) - i))),
|
||
g: r(T(a + n * (M(s(e.g)) - a))),
|
||
b: r(T(o + n * (M(s(e.b)) - o))),
|
||
a: t.a + n * (e.a - t.a),
|
||
}
|
||
})(this._rgb, t._rgb, e)),
|
||
this
|
||
)
|
||
}
|
||
clone() {
|
||
return new x(this.rgb)
|
||
}
|
||
alpha(t) {
|
||
return (this._rgb.a = r(t)), this
|
||
}
|
||
clearer(t) {
|
||
return (this._rgb.a *= 1 - t), this
|
||
}
|
||
greyscale() {
|
||
const e = this._rgb,
|
||
n = t(0.3 * e.r + 0.59 * e.g + 0.11 * e.b)
|
||
return (e.r = e.g = e.b = n), this
|
||
}
|
||
opaquer(t) {
|
||
return (this._rgb.a *= 1 + t), this
|
||
}
|
||
negate() {
|
||
const t = this._rgb
|
||
return (t.r = 255 - t.r), (t.g = 255 - t.g), (t.b = 255 - t.b), this
|
||
}
|
||
lighten(t) {
|
||
return k(this._rgb, 2, t), this
|
||
}
|
||
darken(t) {
|
||
return k(this._rgb, 2, -t), this
|
||
}
|
||
saturate(t) {
|
||
return k(this._rgb, 1, t), this
|
||
}
|
||
desaturate(t) {
|
||
return k(this._rgb, 1, -t), this
|
||
}
|
||
rotate(t) {
|
||
return (
|
||
(function (t, e) {
|
||
var n = y(t)
|
||
;(n[0] = w(n[0] + e)), (n = p(n)), (t.r = n[0]), (t.g = n[1]), (t.b = n[2])
|
||
})(this._rgb, t),
|
||
this
|
||
)
|
||
}
|
||
}
|
||
class C extends Error {}
|
||
class V extends C {
|
||
constructor(t) {
|
||
super(`Invalid DateTime: ${t.toMessage()}`)
|
||
}
|
||
}
|
||
class F extends C {
|
||
constructor(t) {
|
||
super(`Invalid Interval: ${t.toMessage()}`)
|
||
}
|
||
}
|
||
class I extends C {
|
||
constructor(t) {
|
||
super(`Invalid Duration: ${t.toMessage()}`)
|
||
}
|
||
}
|
||
class L extends C {}
|
||
class Z extends C {
|
||
constructor(t) {
|
||
super(`Invalid unit ${t}`)
|
||
}
|
||
}
|
||
class $ extends C {}
|
||
class _ extends C {
|
||
constructor() {
|
||
super("Zone is an abstract class")
|
||
}
|
||
}
|
||
const A = "numeric",
|
||
R = "short",
|
||
z = "long",
|
||
q = { year: A, month: A, day: A },
|
||
Y = { year: A, month: R, day: A },
|
||
j = { year: A, month: R, day: A, weekday: R },
|
||
H = { year: A, month: z, day: A },
|
||
U = { year: A, month: z, day: A, weekday: z },
|
||
W = { hour: A, minute: A },
|
||
P = { hour: A, minute: A, second: A },
|
||
J = { hour: A, minute: A, second: A, timeZoneName: R },
|
||
G = { hour: A, minute: A, second: A, timeZoneName: z },
|
||
X = { hour: A, minute: A, hourCycle: "h23" },
|
||
B = { hour: A, minute: A, second: A, hourCycle: "h23" },
|
||
Q = { hour: A, minute: A, second: A, hourCycle: "h23", timeZoneName: R },
|
||
K = { hour: A, minute: A, second: A, hourCycle: "h23", timeZoneName: z },
|
||
tt = { year: A, month: A, day: A, hour: A, minute: A },
|
||
et = { year: A, month: A, day: A, hour: A, minute: A, second: A },
|
||
nt = { year: A, month: R, day: A, hour: A, minute: A },
|
||
rt = { year: A, month: R, day: A, hour: A, minute: A, second: A },
|
||
st = { year: A, month: R, day: A, weekday: R, hour: A, minute: A },
|
||
it = { year: A, month: z, day: A, hour: A, minute: A, timeZoneName: R },
|
||
at = { year: A, month: z, day: A, hour: A, minute: A, second: A, timeZoneName: R },
|
||
ot = { year: A, month: z, day: A, weekday: z, hour: A, minute: A, timeZoneName: z },
|
||
ut = { year: A, month: z, day: A, weekday: z, hour: A, minute: A, second: A, timeZoneName: z }
|
||
function lt(t) {
|
||
return void 0 === t
|
||
}
|
||
function ct(t) {
|
||
return "number" == typeof t
|
||
}
|
||
function ht(t) {
|
||
return "number" == typeof t && t % 1 == 0
|
||
}
|
||
function dt() {
|
||
try {
|
||
return "undefined" != typeof Intl && !!Intl.RelativeTimeFormat
|
||
} catch (t) {
|
||
return !1
|
||
}
|
||
}
|
||
function ft(t, e, n) {
|
||
if (0 !== t.length)
|
||
return t.reduce((t, r) => {
|
||
const s = [e(r), r]
|
||
return t && n(t[0], s[0]) === t[0] ? t : s
|
||
}, null)[1]
|
||
}
|
||
function mt(t, e) {
|
||
return Object.prototype.hasOwnProperty.call(t, e)
|
||
}
|
||
function yt(t, e, n) {
|
||
return ht(t) && t >= e && t <= n
|
||
}
|
||
function gt(t, e = 2) {
|
||
let n
|
||
return (n = t < 0 ? "-" + ("" + -t).padStart(e, "0") : ("" + t).padStart(e, "0")), n
|
||
}
|
||
function pt(t) {
|
||
return lt(t) || null === t || "" === t ? void 0 : parseInt(t, 10)
|
||
}
|
||
function wt(t) {
|
||
return lt(t) || null === t || "" === t ? void 0 : parseFloat(t)
|
||
}
|
||
function bt(t) {
|
||
if (!lt(t) && null !== t && "" !== t) {
|
||
const e = 1e3 * parseFloat("0." + t)
|
||
return Math.floor(e)
|
||
}
|
||
}
|
||
function vt(t, e, n = !1) {
|
||
const r = 10 ** e
|
||
return (n ? Math.trunc : Math.round)(t * r) / r
|
||
}
|
||
function Ot(t) {
|
||
return t % 4 == 0 && (t % 100 != 0 || t % 400 == 0)
|
||
}
|
||
function St(t) {
|
||
return Ot(t) ? 366 : 365
|
||
}
|
||
function Tt(t, e) {
|
||
const n = (r = e - 1) - 12 * Math.floor(r / 12) + 1
|
||
var r
|
||
return 2 === n
|
||
? Ot(t + (e - n) / 12)
|
||
? 29
|
||
: 28
|
||
: [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][n - 1]
|
||
}
|
||
function Mt(t) {
|
||
let e = Date.UTC(t.year, t.month - 1, t.day, t.hour, t.minute, t.second, t.millisecond)
|
||
return (
|
||
t.year < 100 &&
|
||
t.year >= 0 &&
|
||
((e = new Date(e)), e.setUTCFullYear(e.getUTCFullYear() - 1900)),
|
||
+e
|
||
)
|
||
}
|
||
function kt(t) {
|
||
const e = (t + Math.floor(t / 4) - Math.floor(t / 100) + Math.floor(t / 400)) % 7,
|
||
n = t - 1,
|
||
r = (n + Math.floor(n / 4) - Math.floor(n / 100) + Math.floor(n / 400)) % 7
|
||
return 4 === e || 3 === r ? 53 : 52
|
||
}
|
||
function Nt(t) {
|
||
return t > 99 ? t : t > 60 ? 1900 + t : 2e3 + t
|
||
}
|
||
function Dt(t, e, n, r = null) {
|
||
const s = new Date(t),
|
||
i = {
|
||
hourCycle: "h23",
|
||
year: "numeric",
|
||
month: "2-digit",
|
||
day: "2-digit",
|
||
hour: "2-digit",
|
||
minute: "2-digit",
|
||
}
|
||
r && (i.timeZone = r)
|
||
const a = { timeZoneName: e, ...i },
|
||
o = new Intl.DateTimeFormat(n, a)
|
||
.formatToParts(s)
|
||
.find((t) => "timezonename" === t.type.toLowerCase())
|
||
return o ? o.value : null
|
||
}
|
||
function Et(t, e) {
|
||
let n = parseInt(t, 10)
|
||
Number.isNaN(n) && (n = 0)
|
||
const r = parseInt(e, 10) || 0
|
||
return 60 * n + (n < 0 || Object.is(n, -0) ? -r : r)
|
||
}
|
||
function xt(t) {
|
||
const e = Number(t)
|
||
if ("boolean" == typeof t || "" === t || Number.isNaN(e)) throw new $(`Invalid unit value ${t}`)
|
||
return e
|
||
}
|
||
function Ct(t, e) {
|
||
const n = {}
|
||
for (const r in t)
|
||
if (mt(t, r)) {
|
||
const s = t[r]
|
||
if (null == s) continue
|
||
n[e(r)] = xt(s)
|
||
}
|
||
return n
|
||
}
|
||
function Vt(t, e) {
|
||
const n = Math.trunc(Math.abs(t / 60)),
|
||
r = Math.trunc(Math.abs(t % 60)),
|
||
s = t >= 0 ? "+" : "-"
|
||
switch (e) {
|
||
case "short":
|
||
return `${s}${gt(n, 2)}:${gt(r, 2)}`
|
||
case "narrow":
|
||
return `${s}${n}${r > 0 ? `:${r}` : ""}`
|
||
case "techie":
|
||
return `${s}${gt(n, 2)}${gt(r, 2)}`
|
||
default:
|
||
throw new RangeError(`Value format ${e} is out of range for property format`)
|
||
}
|
||
}
|
||
function Ft(t) {
|
||
return (function (t, e) {
|
||
return ["hour", "minute", "second", "millisecond"].reduce((e, n) => ((e[n] = t[n]), e), {})
|
||
})(t)
|
||
}
|
||
const It = /[A-Za-z_+-]{1,256}(?::?\/[A-Za-z0-9_+-]{1,256}(?:\/[A-Za-z0-9_+-]{1,256})?)?/,
|
||
Lt = [
|
||
"January",
|
||
"February",
|
||
"March",
|
||
"April",
|
||
"May",
|
||
"June",
|
||
"July",
|
||
"August",
|
||
"September",
|
||
"October",
|
||
"November",
|
||
"December",
|
||
],
|
||
Zt = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
|
||
$t = ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"]
|
||
function _t(t) {
|
||
switch (t) {
|
||
case "narrow":
|
||
return [...$t]
|
||
case "short":
|
||
return [...Zt]
|
||
case "long":
|
||
return [...Lt]
|
||
case "numeric":
|
||
return ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"]
|
||
case "2-digit":
|
||
return ["01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12"]
|
||
default:
|
||
return null
|
||
}
|
||
}
|
||
const At = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"],
|
||
Rt = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"],
|
||
zt = ["M", "T", "W", "T", "F", "S", "S"]
|
||
function qt(t) {
|
||
switch (t) {
|
||
case "narrow":
|
||
return [...zt]
|
||
case "short":
|
||
return [...Rt]
|
||
case "long":
|
||
return [...At]
|
||
case "numeric":
|
||
return ["1", "2", "3", "4", "5", "6", "7"]
|
||
default:
|
||
return null
|
||
}
|
||
}
|
||
const Yt = ["AM", "PM"],
|
||
jt = ["Before Christ", "Anno Domini"],
|
||
Ht = ["BC", "AD"],
|
||
Ut = ["B", "A"]
|
||
function Wt(t) {
|
||
switch (t) {
|
||
case "narrow":
|
||
return [...Ut]
|
||
case "short":
|
||
return [...Ht]
|
||
case "long":
|
||
return [...jt]
|
||
default:
|
||
return null
|
||
}
|
||
}
|
||
function Pt(t, e) {
|
||
let n = ""
|
||
for (const r of t) r.literal ? (n += r.val) : (n += e(r.val))
|
||
return n
|
||
}
|
||
const Jt = {
|
||
D: q,
|
||
DD: Y,
|
||
DDD: H,
|
||
DDDD: U,
|
||
t: W,
|
||
tt: P,
|
||
ttt: J,
|
||
tttt: G,
|
||
T: X,
|
||
TT: B,
|
||
TTT: Q,
|
||
TTTT: K,
|
||
f: tt,
|
||
ff: nt,
|
||
fff: it,
|
||
ffff: ot,
|
||
F: et,
|
||
FF: rt,
|
||
FFF: at,
|
||
FFFF: ut,
|
||
}
|
||
class Gt {
|
||
static create(t, e = {}) {
|
||
return new Gt(t, e)
|
||
}
|
||
static parseFormat(t) {
|
||
let e = null,
|
||
n = "",
|
||
r = !1
|
||
const s = []
|
||
for (let i = 0; i < t.length; i++) {
|
||
const a = t.charAt(i)
|
||
"'" === a
|
||
? (n.length > 0 && s.push({ literal: r, val: n }), (e = null), (n = ""), (r = !r))
|
||
: r || a === e
|
||
? (n += a)
|
||
: (n.length > 0 && s.push({ literal: !1, val: n }), (n = a), (e = a))
|
||
}
|
||
return n.length > 0 && s.push({ literal: r, val: n }), s
|
||
}
|
||
static macroTokenToFormatOpts(t) {
|
||
return Jt[t]
|
||
}
|
||
constructor(t, e) {
|
||
;(this.opts = e), (this.loc = t), (this.systemLoc = null)
|
||
}
|
||
formatWithSystemDefault(t, e) {
|
||
return (
|
||
null === this.systemLoc && (this.systemLoc = this.loc.redefaultToSystem()),
|
||
this.systemLoc.dtFormatter(t, { ...this.opts, ...e }).format()
|
||
)
|
||
}
|
||
formatDateTime(t, e = {}) {
|
||
return this.loc.dtFormatter(t, { ...this.opts, ...e }).format()
|
||
}
|
||
formatDateTimeParts(t, e = {}) {
|
||
return this.loc.dtFormatter(t, { ...this.opts, ...e }).formatToParts()
|
||
}
|
||
resolvedOptions(t, e = {}) {
|
||
return this.loc.dtFormatter(t, { ...this.opts, ...e }).resolvedOptions()
|
||
}
|
||
num(t, e = 0) {
|
||
if (this.opts.forceSimple) return gt(t, e)
|
||
const n = { ...this.opts }
|
||
return e > 0 && (n.padTo = e), this.loc.numberFormatter(n).format(t)
|
||
}
|
||
formatDateTimeFromString(t, e) {
|
||
const n = "en" === this.loc.listingMode(),
|
||
r = this.loc.outputCalendar && "gregory" !== this.loc.outputCalendar,
|
||
s = (e, n) => this.loc.extract(t, e, n),
|
||
i = (e) =>
|
||
t.isOffsetFixed && 0 === t.offset && e.allowZ
|
||
? "Z"
|
||
: t.isValid
|
||
? t.zone.formatOffset(t.ts, e.format)
|
||
: "",
|
||
a = (e, r) =>
|
||
n
|
||
? (function (t, e) {
|
||
return _t(e)[t.month - 1]
|
||
})(t, e)
|
||
: s(r ? { month: e } : { month: e, day: "numeric" }, "month"),
|
||
o = (e, r) =>
|
||
n
|
||
? (function (t, e) {
|
||
return qt(e)[t.weekday - 1]
|
||
})(t, e)
|
||
: s(r ? { weekday: e } : { weekday: e, month: "long", day: "numeric" }, "weekday"),
|
||
u = (e) => {
|
||
const n = Gt.macroTokenToFormatOpts(e)
|
||
return n ? this.formatWithSystemDefault(t, n) : e
|
||
},
|
||
l = (e) =>
|
||
n
|
||
? (function (t, e) {
|
||
return Wt(e)[t.year < 0 ? 0 : 1]
|
||
})(t, e)
|
||
: s({ era: e }, "era")
|
||
return Pt(Gt.parseFormat(e), (e) => {
|
||
switch (e) {
|
||
case "S":
|
||
return this.num(t.millisecond)
|
||
case "u":
|
||
case "SSS":
|
||
return this.num(t.millisecond, 3)
|
||
case "s":
|
||
return this.num(t.second)
|
||
case "ss":
|
||
return this.num(t.second, 2)
|
||
case "uu":
|
||
return this.num(Math.floor(t.millisecond / 10), 2)
|
||
case "uuu":
|
||
return this.num(Math.floor(t.millisecond / 100))
|
||
case "m":
|
||
return this.num(t.minute)
|
||
case "mm":
|
||
return this.num(t.minute, 2)
|
||
case "h":
|
||
return this.num(t.hour % 12 == 0 ? 12 : t.hour % 12)
|
||
case "hh":
|
||
return this.num(t.hour % 12 == 0 ? 12 : t.hour % 12, 2)
|
||
case "H":
|
||
return this.num(t.hour)
|
||
case "HH":
|
||
return this.num(t.hour, 2)
|
||
case "Z":
|
||
return i({ format: "narrow", allowZ: this.opts.allowZ })
|
||
case "ZZ":
|
||
return i({ format: "short", allowZ: this.opts.allowZ })
|
||
case "ZZZ":
|
||
return i({ format: "techie", allowZ: this.opts.allowZ })
|
||
case "ZZZZ":
|
||
return t.zone.offsetName(t.ts, { format: "short", locale: this.loc.locale })
|
||
case "ZZZZZ":
|
||
return t.zone.offsetName(t.ts, { format: "long", locale: this.loc.locale })
|
||
case "z":
|
||
return t.zoneName
|
||
case "a":
|
||
return n
|
||
? (function (t) {
|
||
return Yt[t.hour < 12 ? 0 : 1]
|
||
})(t)
|
||
: s({ hour: "numeric", hourCycle: "h12" }, "dayperiod")
|
||
case "d":
|
||
return r ? s({ day: "numeric" }, "day") : this.num(t.day)
|
||
case "dd":
|
||
return r ? s({ day: "2-digit" }, "day") : this.num(t.day, 2)
|
||
case "c":
|
||
case "E":
|
||
return this.num(t.weekday)
|
||
case "ccc":
|
||
return o("short", !0)
|
||
case "cccc":
|
||
return o("long", !0)
|
||
case "ccccc":
|
||
return o("narrow", !0)
|
||
case "EEE":
|
||
return o("short", !1)
|
||
case "EEEE":
|
||
return o("long", !1)
|
||
case "EEEEE":
|
||
return o("narrow", !1)
|
||
case "L":
|
||
return r ? s({ month: "numeric", day: "numeric" }, "month") : this.num(t.month)
|
||
case "LL":
|
||
return r ? s({ month: "2-digit", day: "numeric" }, "month") : this.num(t.month, 2)
|
||
case "LLL":
|
||
return a("short", !0)
|
||
case "LLLL":
|
||
return a("long", !0)
|
||
case "LLLLL":
|
||
return a("narrow", !0)
|
||
case "M":
|
||
return r ? s({ month: "numeric" }, "month") : this.num(t.month)
|
||
case "MM":
|
||
return r ? s({ month: "2-digit" }, "month") : this.num(t.month, 2)
|
||
case "MMM":
|
||
return a("short", !1)
|
||
case "MMMM":
|
||
return a("long", !1)
|
||
case "MMMMM":
|
||
return a("narrow", !1)
|
||
case "y":
|
||
return r ? s({ year: "numeric" }, "year") : this.num(t.year)
|
||
case "yy":
|
||
return r ? s({ year: "2-digit" }, "year") : this.num(t.year.toString().slice(-2), 2)
|
||
case "yyyy":
|
||
return r ? s({ year: "numeric" }, "year") : this.num(t.year, 4)
|
||
case "yyyyyy":
|
||
return r ? s({ year: "numeric" }, "year") : this.num(t.year, 6)
|
||
case "G":
|
||
return l("short")
|
||
case "GG":
|
||
return l("long")
|
||
case "GGGGG":
|
||
return l("narrow")
|
||
case "kk":
|
||
return this.num(t.weekYear.toString().slice(-2), 2)
|
||
case "kkkk":
|
||
return this.num(t.weekYear, 4)
|
||
case "W":
|
||
return this.num(t.weekNumber)
|
||
case "WW":
|
||
return this.num(t.weekNumber, 2)
|
||
case "o":
|
||
return this.num(t.ordinal)
|
||
case "ooo":
|
||
return this.num(t.ordinal, 3)
|
||
case "q":
|
||
return this.num(t.quarter)
|
||
case "qq":
|
||
return this.num(t.quarter, 2)
|
||
case "X":
|
||
return this.num(Math.floor(t.ts / 1e3))
|
||
case "x":
|
||
return this.num(t.ts)
|
||
default:
|
||
return u(e)
|
||
}
|
||
})
|
||
}
|
||
formatDurationFromString(t, e) {
|
||
const n = (t) => {
|
||
switch (t[0]) {
|
||
case "S":
|
||
return "millisecond"
|
||
case "s":
|
||
return "second"
|
||
case "m":
|
||
return "minute"
|
||
case "h":
|
||
return "hour"
|
||
case "d":
|
||
return "day"
|
||
case "w":
|
||
return "week"
|
||
case "M":
|
||
return "month"
|
||
case "y":
|
||
return "year"
|
||
default:
|
||
return null
|
||
}
|
||
},
|
||
r = Gt.parseFormat(e),
|
||
s = r.reduce((t, { literal: e, val: n }) => (e ? t : t.concat(n)), [])
|
||
return Pt(
|
||
r,
|
||
((t) => (e) => {
|
||
const r = n(e)
|
||
return r ? this.num(t.get(r), e.length) : e
|
||
})(t.shiftTo(...s.map(n).filter((t) => t)))
|
||
)
|
||
}
|
||
}
|
||
class Xt {
|
||
constructor(t, e) {
|
||
;(this.reason = t), (this.explanation = e)
|
||
}
|
||
toMessage() {
|
||
return this.explanation ? `${this.reason}: ${this.explanation}` : this.reason
|
||
}
|
||
}
|
||
class Bt {
|
||
get type() {
|
||
throw new _()
|
||
}
|
||
get name() {
|
||
throw new _()
|
||
}
|
||
get ianaName() {
|
||
return this.name
|
||
}
|
||
get isUniversal() {
|
||
throw new _()
|
||
}
|
||
offsetName(t, e) {
|
||
throw new _()
|
||
}
|
||
formatOffset(t, e) {
|
||
throw new _()
|
||
}
|
||
offset(t) {
|
||
throw new _()
|
||
}
|
||
equals(t) {
|
||
throw new _()
|
||
}
|
||
get isValid() {
|
||
throw new _()
|
||
}
|
||
}
|
||
let Qt = null
|
||
class Kt extends Bt {
|
||
static get instance() {
|
||
return null === Qt && (Qt = new Kt()), Qt
|
||
}
|
||
get type() {
|
||
return "system"
|
||
}
|
||
get name() {
|
||
return new Intl.DateTimeFormat().resolvedOptions().timeZone
|
||
}
|
||
get isUniversal() {
|
||
return !1
|
||
}
|
||
offsetName(t, { format: e, locale: n }) {
|
||
return Dt(t, e, n)
|
||
}
|
||
formatOffset(t, e) {
|
||
return Vt(this.offset(t), e)
|
||
}
|
||
offset(t) {
|
||
return -new Date(t).getTimezoneOffset()
|
||
}
|
||
equals(t) {
|
||
return "system" === t.type
|
||
}
|
||
get isValid() {
|
||
return !0
|
||
}
|
||
}
|
||
let te = {}
|
||
const ee = { year: 0, month: 1, day: 2, era: 3, hour: 4, minute: 5, second: 6 }
|
||
let ne = {}
|
||
class re extends Bt {
|
||
static create(t) {
|
||
return ne[t] || (ne[t] = new re(t)), ne[t]
|
||
}
|
||
static resetCache() {
|
||
;(ne = {}), (te = {})
|
||
}
|
||
static isValidSpecifier(t) {
|
||
return this.isValidZone(t)
|
||
}
|
||
static isValidZone(t) {
|
||
if (!t) return !1
|
||
try {
|
||
return new Intl.DateTimeFormat("en-US", { timeZone: t }).format(), !0
|
||
} catch (t) {
|
||
return !1
|
||
}
|
||
}
|
||
constructor(t) {
|
||
super(), (this.zoneName = t), (this.valid = re.isValidZone(t))
|
||
}
|
||
get type() {
|
||
return "iana"
|
||
}
|
||
get name() {
|
||
return this.zoneName
|
||
}
|
||
get isUniversal() {
|
||
return !1
|
||
}
|
||
offsetName(t, { format: e, locale: n }) {
|
||
return Dt(t, e, n, this.name)
|
||
}
|
||
formatOffset(t, e) {
|
||
return Vt(this.offset(t), e)
|
||
}
|
||
offset(t) {
|
||
const e = new Date(t)
|
||
if (isNaN(e)) return NaN
|
||
const n =
|
||
((r = this.name),
|
||
te[r] ||
|
||
(te[r] = new Intl.DateTimeFormat("en-US", {
|
||
hour12: !1,
|
||
timeZone: r,
|
||
year: "numeric",
|
||
month: "2-digit",
|
||
day: "2-digit",
|
||
hour: "2-digit",
|
||
minute: "2-digit",
|
||
second: "2-digit",
|
||
era: "short",
|
||
})),
|
||
te[r])
|
||
var r
|
||
let [s, i, a, o, u, l, c] = n.formatToParts
|
||
? (function (t, e) {
|
||
const n = t.formatToParts(e),
|
||
r = []
|
||
for (let t = 0; t < n.length; t++) {
|
||
const { type: e, value: s } = n[t],
|
||
i = ee[e]
|
||
"era" === e ? (r[i] = s) : lt(i) || (r[i] = parseInt(s, 10))
|
||
}
|
||
return r
|
||
})(n, e)
|
||
: (function (t, e) {
|
||
const n = t.format(e).replace(/\u200E/g, ""),
|
||
r = /(\d+)\/(\d+)\/(\d+) (AD|BC),? (\d+):(\d+):(\d+)/.exec(n),
|
||
[, s, i, a, o, u, l, c] = r
|
||
return [a, s, i, o, u, l, c]
|
||
})(n, e)
|
||
"BC" === o && (s = 1 - Math.abs(s))
|
||
let h = +e
|
||
const d = h % 1e3
|
||
return (
|
||
(h -= d >= 0 ? d : 1e3 + d),
|
||
(Mt({
|
||
year: s,
|
||
month: i,
|
||
day: a,
|
||
hour: 24 === u ? 0 : u,
|
||
minute: l,
|
||
second: c,
|
||
millisecond: 0,
|
||
}) -
|
||
h) /
|
||
6e4
|
||
)
|
||
}
|
||
equals(t) {
|
||
return "iana" === t.type && t.name === this.name
|
||
}
|
||
get isValid() {
|
||
return this.valid
|
||
}
|
||
}
|
||
let se = null
|
||
class ie extends Bt {
|
||
static get utcInstance() {
|
||
return null === se && (se = new ie(0)), se
|
||
}
|
||
static instance(t) {
|
||
return 0 === t ? ie.utcInstance : new ie(t)
|
||
}
|
||
static parseSpecifier(t) {
|
||
if (t) {
|
||
const e = t.match(/^utc(?:([+-]\d{1,2})(?::(\d{2}))?)?$/i)
|
||
if (e) return new ie(Et(e[1], e[2]))
|
||
}
|
||
return null
|
||
}
|
||
constructor(t) {
|
||
super(), (this.fixed = t)
|
||
}
|
||
get type() {
|
||
return "fixed"
|
||
}
|
||
get name() {
|
||
return 0 === this.fixed ? "UTC" : `UTC${Vt(this.fixed, "narrow")}`
|
||
}
|
||
get ianaName() {
|
||
return 0 === this.fixed ? "Etc/UTC" : `Etc/GMT${Vt(-this.fixed, "narrow")}`
|
||
}
|
||
offsetName() {
|
||
return this.name
|
||
}
|
||
formatOffset(t, e) {
|
||
return Vt(this.fixed, e)
|
||
}
|
||
get isUniversal() {
|
||
return !0
|
||
}
|
||
offset() {
|
||
return this.fixed
|
||
}
|
||
equals(t) {
|
||
return "fixed" === t.type && t.fixed === this.fixed
|
||
}
|
||
get isValid() {
|
||
return !0
|
||
}
|
||
}
|
||
class ae extends Bt {
|
||
constructor(t) {
|
||
super(), (this.zoneName = t)
|
||
}
|
||
get type() {
|
||
return "invalid"
|
||
}
|
||
get name() {
|
||
return this.zoneName
|
||
}
|
||
get isUniversal() {
|
||
return !1
|
||
}
|
||
offsetName() {
|
||
return null
|
||
}
|
||
formatOffset() {
|
||
return ""
|
||
}
|
||
offset() {
|
||
return NaN
|
||
}
|
||
equals() {
|
||
return !1
|
||
}
|
||
get isValid() {
|
||
return !1
|
||
}
|
||
}
|
||
function oe(t, e) {
|
||
if (lt(t) || null === t) return e
|
||
if (t instanceof Bt) return t
|
||
if ("string" == typeof t) {
|
||
const n = t.toLowerCase()
|
||
return "default" === n
|
||
? e
|
||
: "local" === n || "system" === n
|
||
? Kt.instance
|
||
: "utc" === n || "gmt" === n
|
||
? ie.utcInstance
|
||
: ie.parseSpecifier(n) || re.create(t)
|
||
}
|
||
return ct(t)
|
||
? ie.instance(t)
|
||
: "object" == typeof t && t.offset && "number" == typeof t.offset
|
||
? t
|
||
: new ae(t)
|
||
}
|
||
let ue,
|
||
le = () => Date.now(),
|
||
ce = "system",
|
||
he = null,
|
||
de = null,
|
||
fe = null
|
||
class me {
|
||
static get now() {
|
||
return le
|
||
}
|
||
static set now(t) {
|
||
le = t
|
||
}
|
||
static set defaultZone(t) {
|
||
ce = t
|
||
}
|
||
static get defaultZone() {
|
||
return oe(ce, Kt.instance)
|
||
}
|
||
static get defaultLocale() {
|
||
return he
|
||
}
|
||
static set defaultLocale(t) {
|
||
he = t
|
||
}
|
||
static get defaultNumberingSystem() {
|
||
return de
|
||
}
|
||
static set defaultNumberingSystem(t) {
|
||
de = t
|
||
}
|
||
static get defaultOutputCalendar() {
|
||
return fe
|
||
}
|
||
static set defaultOutputCalendar(t) {
|
||
fe = t
|
||
}
|
||
static get throwOnInvalid() {
|
||
return ue
|
||
}
|
||
static set throwOnInvalid(t) {
|
||
ue = t
|
||
}
|
||
static resetCaches() {
|
||
ke.resetCache(), re.resetCache()
|
||
}
|
||
}
|
||
let ye = {},
|
||
ge = {}
|
||
function pe(t, e = {}) {
|
||
const n = JSON.stringify([t, e])
|
||
let r = ge[n]
|
||
return r || ((r = new Intl.DateTimeFormat(t, e)), (ge[n] = r)), r
|
||
}
|
||
let we = {},
|
||
be = {},
|
||
ve = null
|
||
function Oe(t, e, n, r, s) {
|
||
const i = t.listingMode(n)
|
||
return "error" === i ? null : "en" === i ? r(e) : s(e)
|
||
}
|
||
class Se {
|
||
constructor(t, e, n) {
|
||
;(this.padTo = n.padTo || 0), (this.floor = n.floor || !1)
|
||
const { padTo: r, floor: s, ...i } = n
|
||
if (!e || Object.keys(i).length > 0) {
|
||
const e = { useGrouping: !1, ...n }
|
||
n.padTo > 0 && (e.minimumIntegerDigits = n.padTo),
|
||
(this.inf = (function (t, e = {}) {
|
||
const n = JSON.stringify([t, e])
|
||
let r = we[n]
|
||
return r || ((r = new Intl.NumberFormat(t, e)), (we[n] = r)), r
|
||
})(t, e))
|
||
}
|
||
}
|
||
format(t) {
|
||
if (this.inf) {
|
||
const e = this.floor ? Math.floor(t) : t
|
||
return this.inf.format(e)
|
||
}
|
||
return gt(this.floor ? Math.floor(t) : vt(t, 3), this.padTo)
|
||
}
|
||
}
|
||
class Te {
|
||
constructor(t, e, n) {
|
||
let r
|
||
if (((this.opts = n), t.zone.isUniversal)) {
|
||
const e = (t.offset / 60) * -1,
|
||
s = e >= 0 ? `Etc/GMT+${e}` : `Etc/GMT${e}`
|
||
0 !== t.offset && re.create(s).valid
|
||
? ((r = s), (this.dt = t))
|
||
: ((r = "UTC"),
|
||
n.timeZoneName
|
||
? (this.dt = t)
|
||
: (this.dt = 0 === t.offset ? t : Sr.fromMillis(t.ts + 60 * t.offset * 1e3)))
|
||
} else "system" === t.zone.type ? (this.dt = t) : ((this.dt = t), (r = t.zone.name))
|
||
const s = { ...this.opts }
|
||
r && (s.timeZone = r), (this.dtf = pe(e, s))
|
||
}
|
||
format() {
|
||
return this.dtf.format(this.dt.toJSDate())
|
||
}
|
||
formatToParts() {
|
||
return this.dtf.formatToParts(this.dt.toJSDate())
|
||
}
|
||
resolvedOptions() {
|
||
return this.dtf.resolvedOptions()
|
||
}
|
||
}
|
||
class Me {
|
||
constructor(t, e, n) {
|
||
;(this.opts = { style: "long", ...n }),
|
||
!e &&
|
||
dt() &&
|
||
(this.rtf = (function (t, e = {}) {
|
||
const { base: n, ...r } = e,
|
||
s = JSON.stringify([t, r])
|
||
let i = be[s]
|
||
return i || ((i = new Intl.RelativeTimeFormat(t, e)), (be[s] = i)), i
|
||
})(t, n))
|
||
}
|
||
format(t, e) {
|
||
return this.rtf
|
||
? this.rtf.format(t, e)
|
||
: (function (t, e, n = "always", r = !1) {
|
||
const s = {
|
||
years: ["year", "yr."],
|
||
quarters: ["quarter", "qtr."],
|
||
months: ["month", "mo."],
|
||
weeks: ["week", "wk."],
|
||
days: ["day", "day", "days"],
|
||
hours: ["hour", "hr."],
|
||
minutes: ["minute", "min."],
|
||
seconds: ["second", "sec."],
|
||
},
|
||
i = -1 === ["hours", "minutes", "seconds"].indexOf(t)
|
||
if ("auto" === n && i) {
|
||
const n = "days" === t
|
||
switch (e) {
|
||
case 1:
|
||
return n ? "tomorrow" : `next ${s[t][0]}`
|
||
case -1:
|
||
return n ? "yesterday" : `last ${s[t][0]}`
|
||
case 0:
|
||
return n ? "today" : `this ${s[t][0]}`
|
||
}
|
||
}
|
||
const a = Object.is(e, -0) || e < 0,
|
||
o = Math.abs(e),
|
||
u = 1 === o,
|
||
l = s[t],
|
||
c = r ? (u ? l[1] : l[2] || l[1]) : u ? s[t][0] : t
|
||
return a ? `${o} ${c} ago` : `in ${o} ${c}`
|
||
})(e, t, this.opts.numeric, "long" !== this.opts.style)
|
||
}
|
||
formatToParts(t, e) {
|
||
return this.rtf ? this.rtf.formatToParts(t, e) : []
|
||
}
|
||
}
|
||
class ke {
|
||
static fromOpts(t) {
|
||
return ke.create(t.locale, t.numberingSystem, t.outputCalendar, t.defaultToEN)
|
||
}
|
||
static create(t, e, n, r = !1) {
|
||
const s = t || me.defaultLocale,
|
||
i =
|
||
s ||
|
||
(r ? "en-US" : ve || ((ve = new Intl.DateTimeFormat().resolvedOptions().locale), ve)),
|
||
a = e || me.defaultNumberingSystem,
|
||
o = n || me.defaultOutputCalendar
|
||
return new ke(i, a, o, s)
|
||
}
|
||
static resetCache() {
|
||
;(ve = null), (ge = {}), (we = {}), (be = {})
|
||
}
|
||
static fromObject({ locale: t, numberingSystem: e, outputCalendar: n } = {}) {
|
||
return ke.create(t, e, n)
|
||
}
|
||
constructor(t, e, n, r) {
|
||
const [s, i, a] = (function (t) {
|
||
const e = t.indexOf("-u-")
|
||
if (-1 === e) return [t]
|
||
{
|
||
let n
|
||
const r = t.substring(0, e)
|
||
try {
|
||
n = pe(t).resolvedOptions()
|
||
} catch (t) {
|
||
n = pe(r).resolvedOptions()
|
||
}
|
||
const { numberingSystem: s, calendar: i } = n
|
||
return [r, s, i]
|
||
}
|
||
})(t)
|
||
;(this.locale = s),
|
||
(this.numberingSystem = e || i || null),
|
||
(this.outputCalendar = n || a || null),
|
||
(this.intl = (function (t, e, n) {
|
||
return n || e ? ((t += "-u"), n && (t += `-ca-${n}`), e && (t += `-nu-${e}`), t) : t
|
||
})(this.locale, this.numberingSystem, this.outputCalendar)),
|
||
(this.weekdaysCache = { format: {}, standalone: {} }),
|
||
(this.monthsCache = { format: {}, standalone: {} }),
|
||
(this.meridiemCache = null),
|
||
(this.eraCache = {}),
|
||
(this.specifiedLocale = r),
|
||
(this.fastNumbersCached = null)
|
||
}
|
||
get fastNumbers() {
|
||
var t
|
||
return (
|
||
null == this.fastNumbersCached &&
|
||
(this.fastNumbersCached =
|
||
(!(t = this).numberingSystem || "latn" === t.numberingSystem) &&
|
||
("latn" === t.numberingSystem ||
|
||
!t.locale ||
|
||
t.locale.startsWith("en") ||
|
||
"latn" === new Intl.DateTimeFormat(t.intl).resolvedOptions().numberingSystem)),
|
||
this.fastNumbersCached
|
||
)
|
||
}
|
||
listingMode() {
|
||
const t = this.isEnglish(),
|
||
e = !(
|
||
(null !== this.numberingSystem && "latn" !== this.numberingSystem) ||
|
||
(null !== this.outputCalendar && "gregory" !== this.outputCalendar)
|
||
)
|
||
return t && e ? "en" : "intl"
|
||
}
|
||
clone(t) {
|
||
return t && 0 !== Object.getOwnPropertyNames(t).length
|
||
? ke.create(
|
||
t.locale || this.specifiedLocale,
|
||
t.numberingSystem || this.numberingSystem,
|
||
t.outputCalendar || this.outputCalendar,
|
||
t.defaultToEN || !1
|
||
)
|
||
: this
|
||
}
|
||
redefaultToEN(t = {}) {
|
||
return this.clone({ ...t, defaultToEN: !0 })
|
||
}
|
||
redefaultToSystem(t = {}) {
|
||
return this.clone({ ...t, defaultToEN: !1 })
|
||
}
|
||
months(t, e = !1, n = !0) {
|
||
return Oe(this, t, n, _t, () => {
|
||
const n = e ? { month: t, day: "numeric" } : { month: t },
|
||
r = e ? "format" : "standalone"
|
||
return (
|
||
this.monthsCache[r][t] ||
|
||
(this.monthsCache[r][t] = (function (t) {
|
||
const e = []
|
||
for (let n = 1; n <= 12; n++) {
|
||
const r = Sr.utc(2016, n, 1)
|
||
e.push(t(r))
|
||
}
|
||
return e
|
||
})((t) => this.extract(t, n, "month"))),
|
||
this.monthsCache[r][t]
|
||
)
|
||
})
|
||
}
|
||
weekdays(t, e = !1, n = !0) {
|
||
return Oe(this, t, n, qt, () => {
|
||
const n = e
|
||
? { weekday: t, year: "numeric", month: "long", day: "numeric" }
|
||
: { weekday: t },
|
||
r = e ? "format" : "standalone"
|
||
return (
|
||
this.weekdaysCache[r][t] ||
|
||
(this.weekdaysCache[r][t] = (function (t) {
|
||
const e = []
|
||
for (let n = 1; n <= 7; n++) {
|
||
const r = Sr.utc(2016, 11, 13 + n)
|
||
e.push(t(r))
|
||
}
|
||
return e
|
||
})((t) => this.extract(t, n, "weekday"))),
|
||
this.weekdaysCache[r][t]
|
||
)
|
||
})
|
||
}
|
||
meridiems(t = !0) {
|
||
return Oe(
|
||
this,
|
||
void 0,
|
||
t,
|
||
() => Yt,
|
||
() => {
|
||
if (!this.meridiemCache) {
|
||
const t = { hour: "numeric", hourCycle: "h12" }
|
||
this.meridiemCache = [Sr.utc(2016, 11, 13, 9), Sr.utc(2016, 11, 13, 19)].map((e) =>
|
||
this.extract(e, t, "dayperiod")
|
||
)
|
||
}
|
||
return this.meridiemCache
|
||
}
|
||
)
|
||
}
|
||
eras(t, e = !0) {
|
||
return Oe(this, t, e, Wt, () => {
|
||
const e = { era: t }
|
||
return (
|
||
this.eraCache[t] ||
|
||
(this.eraCache[t] = [Sr.utc(-40, 1, 1), Sr.utc(2017, 1, 1)].map((t) =>
|
||
this.extract(t, e, "era")
|
||
)),
|
||
this.eraCache[t]
|
||
)
|
||
})
|
||
}
|
||
extract(t, e, n) {
|
||
const r = this.dtFormatter(t, e)
|
||
.formatToParts()
|
||
.find((t) => t.type.toLowerCase() === n)
|
||
return r ? r.value : null
|
||
}
|
||
numberFormatter(t = {}) {
|
||
return new Se(this.intl, t.forceSimple || this.fastNumbers, t)
|
||
}
|
||
dtFormatter(t, e = {}) {
|
||
return new Te(t, this.intl, e)
|
||
}
|
||
relFormatter(t = {}) {
|
||
return new Me(this.intl, this.isEnglish(), t)
|
||
}
|
||
listFormatter(t = {}) {
|
||
return (function (t, e = {}) {
|
||
const n = JSON.stringify([t, e])
|
||
let r = ye[n]
|
||
return r || ((r = new Intl.ListFormat(t, e)), (ye[n] = r)), r
|
||
})(this.intl, t)
|
||
}
|
||
isEnglish() {
|
||
return (
|
||
"en" === this.locale ||
|
||
"en-us" === this.locale.toLowerCase() ||
|
||
new Intl.DateTimeFormat(this.intl).resolvedOptions().locale.startsWith("en-us")
|
||
)
|
||
}
|
||
equals(t) {
|
||
return (
|
||
this.locale === t.locale &&
|
||
this.numberingSystem === t.numberingSystem &&
|
||
this.outputCalendar === t.outputCalendar
|
||
)
|
||
}
|
||
}
|
||
function Ne(...t) {
|
||
const e = t.reduce((t, e) => t + e.source, "")
|
||
return RegExp(`^${e}$`)
|
||
}
|
||
function De(...t) {
|
||
return (e) =>
|
||
t
|
||
.reduce(
|
||
([t, n, r], s) => {
|
||
const [i, a, o] = s(e, r)
|
||
return [{ ...t, ...i }, a || n, o]
|
||
},
|
||
[{}, null, 1]
|
||
)
|
||
.slice(0, 2)
|
||
}
|
||
function Ee(t, ...e) {
|
||
if (null == t) return [null, null]
|
||
for (const [n, r] of e) {
|
||
const e = n.exec(t)
|
||
if (e) return r(e)
|
||
}
|
||
return [null, null]
|
||
}
|
||
function xe(...t) {
|
||
return (e, n) => {
|
||
const r = {}
|
||
let s
|
||
for (s = 0; s < t.length; s++) r[t[s]] = pt(e[n + s])
|
||
return [r, null, n + s]
|
||
}
|
||
}
|
||
const Ce = /(?:(Z)|([+-]\d\d)(?::?(\d\d))?)/,
|
||
Ve = /(\d\d)(?::?(\d\d)(?::?(\d\d)(?:[.,](\d{1,30}))?)?)?/,
|
||
Fe = RegExp(`${Ve.source}(?:${Ce.source}?(?:\\[(${It.source})\\])?)?`),
|
||
Ie = RegExp(`(?:T${Fe.source})?`),
|
||
Le = xe("weekYear", "weekNumber", "weekDay"),
|
||
Ze = xe("year", "ordinal"),
|
||
$e = RegExp(`${Ve.source} ?(?:${Ce.source}|(${It.source}))?`),
|
||
_e = RegExp(`(?: ${$e.source})?`)
|
||
function Ae(t, e, n) {
|
||
const r = t[e]
|
||
return lt(r) ? n : pt(r)
|
||
}
|
||
function Re(t, e) {
|
||
return [
|
||
{
|
||
hours: Ae(t, e, 0),
|
||
minutes: Ae(t, e + 1, 0),
|
||
seconds: Ae(t, e + 2, 0),
|
||
milliseconds: bt(t[e + 3]),
|
||
},
|
||
null,
|
||
e + 4,
|
||
]
|
||
}
|
||
function ze(t, e) {
|
||
const n = !t[e] && !t[e + 1],
|
||
r = Et(t[e + 1], t[e + 2])
|
||
return [{}, n ? null : ie.instance(r), e + 3]
|
||
}
|
||
function qe(t, e) {
|
||
return [{}, t[e] ? re.create(t[e]) : null, e + 1]
|
||
}
|
||
const Ye = RegExp(`^T?${Ve.source}$`),
|
||
je =
|
||
/^-?P(?:(?:(-?\d{1,20}(?:\.\d{1,20})?)Y)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20}(?:\.\d{1,20})?)W)?(?:(-?\d{1,20}(?:\.\d{1,20})?)D)?(?:T(?:(-?\d{1,20}(?:\.\d{1,20})?)H)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20})(?:[.,](-?\d{1,20}))?S)?)?)$/
|
||
function He(t) {
|
||
const [e, n, r, s, i, a, o, u, l] = t,
|
||
c = "-" === e[0],
|
||
h = u && "-" === u[0],
|
||
d = (t, e = !1) => (void 0 !== t && (e || (t && c)) ? -t : t)
|
||
return [
|
||
{
|
||
years: d(wt(n)),
|
||
months: d(wt(r)),
|
||
weeks: d(wt(s)),
|
||
days: d(wt(i)),
|
||
hours: d(wt(a)),
|
||
minutes: d(wt(o)),
|
||
seconds: d(wt(u), "-0" === u),
|
||
milliseconds: d(bt(l), h),
|
||
},
|
||
]
|
||
}
|
||
const Ue = {
|
||
GMT: 0,
|
||
EDT: -240,
|
||
EST: -300,
|
||
CDT: -300,
|
||
CST: -360,
|
||
MDT: -360,
|
||
MST: -420,
|
||
PDT: -420,
|
||
PST: -480,
|
||
}
|
||
function We(t, e, n, r, s, i, a) {
|
||
const o = {
|
||
year: 2 === e.length ? Nt(pt(e)) : pt(e),
|
||
month: Zt.indexOf(n) + 1,
|
||
day: pt(r),
|
||
hour: pt(s),
|
||
minute: pt(i),
|
||
}
|
||
return (
|
||
a && (o.second = pt(a)),
|
||
t && (o.weekday = t.length > 3 ? At.indexOf(t) + 1 : Rt.indexOf(t) + 1),
|
||
o
|
||
)
|
||
}
|
||
const Pe =
|
||
/^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|(?:([+-]\d\d)(\d\d)))$/
|
||
function Je(t) {
|
||
const [, e, n, r, s, i, a, o, u, l, c, h] = t,
|
||
d = We(e, s, r, n, i, a, o)
|
||
let f
|
||
return (f = u ? Ue[u] : l ? 0 : Et(c, h)), [d, new ie(f)]
|
||
}
|
||
const Ge =
|
||
/^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d\d) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d\d):(\d\d):(\d\d) GMT$/,
|
||
Xe =
|
||
/^(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d\d)-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d\d) (\d\d):(\d\d):(\d\d) GMT$/,
|
||
Be =
|
||
/^(Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( \d|\d\d) (\d\d):(\d\d):(\d\d) (\d{4})$/
|
||
function Qe(t) {
|
||
const [, e, n, r, s, i, a, o] = t
|
||
return [We(e, s, r, n, i, a, o), ie.utcInstance]
|
||
}
|
||
function Ke(t) {
|
||
const [, e, n, r, s, i, a, o] = t
|
||
return [We(e, o, n, r, s, i, a), ie.utcInstance]
|
||
}
|
||
const tn = Ne(/([+-]\d{6}|\d{4})(?:-?(\d\d)(?:-?(\d\d))?)?/, Ie),
|
||
en = Ne(/(\d{4})-?W(\d\d)(?:-?(\d))?/, Ie),
|
||
nn = Ne(/(\d{4})-?(\d{3})/, Ie),
|
||
rn = Ne(Fe),
|
||
sn = De(
|
||
function (t, e) {
|
||
return [{ year: Ae(t, e), month: Ae(t, e + 1, 1), day: Ae(t, e + 2, 1) }, null, e + 3]
|
||
},
|
||
Re,
|
||
ze,
|
||
qe
|
||
),
|
||
an = De(Le, Re, ze, qe),
|
||
on = De(Ze, Re, ze, qe),
|
||
un = De(Re, ze, qe),
|
||
ln = De(Re),
|
||
cn = Ne(/(\d{4})-(\d\d)-(\d\d)/, _e),
|
||
hn = Ne($e),
|
||
dn = De(Re, ze, qe),
|
||
fn = {
|
||
weeks: { days: 7, hours: 168, minutes: 10080, seconds: 604800, milliseconds: 6048e5 },
|
||
days: { hours: 24, minutes: 1440, seconds: 86400, milliseconds: 864e5 },
|
||
hours: { minutes: 60, seconds: 3600, milliseconds: 36e5 },
|
||
minutes: { seconds: 60, milliseconds: 6e4 },
|
||
seconds: { milliseconds: 1e3 },
|
||
},
|
||
mn = {
|
||
years: {
|
||
quarters: 4,
|
||
months: 12,
|
||
weeks: 52,
|
||
days: 365,
|
||
hours: 8760,
|
||
minutes: 525600,
|
||
seconds: 31536e3,
|
||
milliseconds: 31536e6,
|
||
},
|
||
quarters: {
|
||
months: 3,
|
||
weeks: 13,
|
||
days: 91,
|
||
hours: 2184,
|
||
minutes: 131040,
|
||
seconds: 7862400,
|
||
milliseconds: 78624e5,
|
||
},
|
||
months: {
|
||
weeks: 4,
|
||
days: 30,
|
||
hours: 720,
|
||
minutes: 43200,
|
||
seconds: 2592e3,
|
||
milliseconds: 2592e6,
|
||
},
|
||
...fn,
|
||
},
|
||
yn = {
|
||
years: {
|
||
quarters: 4,
|
||
months: 12,
|
||
weeks: 52.1775,
|
||
days: 365.2425,
|
||
hours: 8765.82,
|
||
minutes: 525949.2,
|
||
seconds: 525949.2 * 60,
|
||
milliseconds: 525949.2 * 60 * 1e3,
|
||
},
|
||
quarters: {
|
||
months: 3,
|
||
weeks: 13.044375,
|
||
days: 91.310625,
|
||
hours: 2191.455,
|
||
minutes: 131487.3,
|
||
seconds: (525949.2 * 60) / 4,
|
||
milliseconds: 7889237999.999999,
|
||
},
|
||
months: {
|
||
weeks: 4.3481250000000005,
|
||
days: 30.436875,
|
||
hours: 730.485,
|
||
minutes: 43829.1,
|
||
seconds: 2629746,
|
||
milliseconds: 2629746e3,
|
||
},
|
||
...fn,
|
||
},
|
||
gn = [
|
||
"years",
|
||
"quarters",
|
||
"months",
|
||
"weeks",
|
||
"days",
|
||
"hours",
|
||
"minutes",
|
||
"seconds",
|
||
"milliseconds",
|
||
],
|
||
pn = gn.slice(0).reverse()
|
||
function wn(t, e, n = !1) {
|
||
const r = {
|
||
values: n ? e.values : { ...t.values, ...(e.values || {}) },
|
||
loc: t.loc.clone(e.loc),
|
||
conversionAccuracy: e.conversionAccuracy || t.conversionAccuracy,
|
||
}
|
||
return new vn(r)
|
||
}
|
||
function bn(t, e, n, r, s) {
|
||
const i = t[s][n],
|
||
a = e[n] / i,
|
||
o =
|
||
Math.sign(a) !== Math.sign(r[s]) && 0 !== r[s] && Math.abs(a) <= 1
|
||
? (function (t) {
|
||
return t < 0 ? Math.floor(t) : Math.ceil(t)
|
||
})(a)
|
||
: Math.trunc(a)
|
||
;(r[s] += o), (e[n] -= o * i)
|
||
}
|
||
class vn {
|
||
constructor(t) {
|
||
const e = "longterm" === t.conversionAccuracy || !1
|
||
;(this.values = t.values),
|
||
(this.loc = t.loc || ke.create()),
|
||
(this.conversionAccuracy = e ? "longterm" : "casual"),
|
||
(this.invalid = t.invalid || null),
|
||
(this.matrix = e ? yn : mn),
|
||
(this.isLuxonDuration = !0)
|
||
}
|
||
static fromMillis(t, e) {
|
||
return vn.fromObject({ milliseconds: t }, e)
|
||
}
|
||
static fromObject(t, e = {}) {
|
||
if (null == t || "object" != typeof t)
|
||
throw new $(
|
||
"Duration.fromObject: argument expected to be an object, got " +
|
||
(null === t ? "null" : typeof t)
|
||
)
|
||
return new vn({
|
||
values: Ct(t, vn.normalizeUnit),
|
||
loc: ke.fromObject(e),
|
||
conversionAccuracy: e.conversionAccuracy,
|
||
})
|
||
}
|
||
static fromDurationLike(t) {
|
||
if (ct(t)) return vn.fromMillis(t)
|
||
if (vn.isDuration(t)) return t
|
||
if ("object" == typeof t) return vn.fromObject(t)
|
||
throw new $(`Unknown duration argument ${t} of type ${typeof t}`)
|
||
}
|
||
static fromISO(t, e) {
|
||
const [n] = (function (t) {
|
||
return Ee(t, [je, He])
|
||
})(t)
|
||
return n
|
||
? vn.fromObject(n, e)
|
||
: vn.invalid("unparsable", `the input "${t}" can't be parsed as ISO 8601`)
|
||
}
|
||
static fromISOTime(t, e) {
|
||
const [n] = (function (t) {
|
||
return Ee(t, [Ye, ln])
|
||
})(t)
|
||
return n
|
||
? vn.fromObject(n, e)
|
||
: vn.invalid("unparsable", `the input "${t}" can't be parsed as ISO 8601`)
|
||
}
|
||
static invalid(t, e = null) {
|
||
if (!t) throw new $("need to specify a reason the Duration is invalid")
|
||
const n = t instanceof Xt ? t : new Xt(t, e)
|
||
if (me.throwOnInvalid) throw new I(n)
|
||
return new vn({ invalid: n })
|
||
}
|
||
static normalizeUnit(t) {
|
||
const e = {
|
||
year: "years",
|
||
years: "years",
|
||
quarter: "quarters",
|
||
quarters: "quarters",
|
||
month: "months",
|
||
months: "months",
|
||
week: "weeks",
|
||
weeks: "weeks",
|
||
day: "days",
|
||
days: "days",
|
||
hour: "hours",
|
||
hours: "hours",
|
||
minute: "minutes",
|
||
minutes: "minutes",
|
||
second: "seconds",
|
||
seconds: "seconds",
|
||
millisecond: "milliseconds",
|
||
milliseconds: "milliseconds",
|
||
}[t ? t.toLowerCase() : t]
|
||
if (!e) throw new Z(t)
|
||
return e
|
||
}
|
||
static isDuration(t) {
|
||
return (t && t.isLuxonDuration) || !1
|
||
}
|
||
get locale() {
|
||
return this.isValid ? this.loc.locale : null
|
||
}
|
||
get numberingSystem() {
|
||
return this.isValid ? this.loc.numberingSystem : null
|
||
}
|
||
toFormat(t, e = {}) {
|
||
const n = { ...e, floor: !1 !== e.round && !1 !== e.floor }
|
||
return this.isValid
|
||
? Gt.create(this.loc, n).formatDurationFromString(this, t)
|
||
: "Invalid Duration"
|
||
}
|
||
toHuman(t = {}) {
|
||
const e = gn
|
||
.map((e) => {
|
||
const n = this.values[e]
|
||
return lt(n)
|
||
? null
|
||
: this.loc
|
||
.numberFormatter({ style: "unit", unitDisplay: "long", ...t, unit: e.slice(0, -1) })
|
||
.format(n)
|
||
})
|
||
.filter((t) => t)
|
||
return this.loc
|
||
.listFormatter({ type: "conjunction", style: t.listStyle || "narrow", ...t })
|
||
.format(e)
|
||
}
|
||
toObject() {
|
||
return this.isValid ? { ...this.values } : {}
|
||
}
|
||
toISO() {
|
||
if (!this.isValid) return null
|
||
let t = "P"
|
||
return (
|
||
0 !== this.years && (t += this.years + "Y"),
|
||
(0 === this.months && 0 === this.quarters) || (t += this.months + 3 * this.quarters + "M"),
|
||
0 !== this.weeks && (t += this.weeks + "W"),
|
||
0 !== this.days && (t += this.days + "D"),
|
||
(0 === this.hours && 0 === this.minutes && 0 === this.seconds && 0 === this.milliseconds) ||
|
||
(t += "T"),
|
||
0 !== this.hours && (t += this.hours + "H"),
|
||
0 !== this.minutes && (t += this.minutes + "M"),
|
||
(0 === this.seconds && 0 === this.milliseconds) ||
|
||
(t += vt(this.seconds + this.milliseconds / 1e3, 3) + "S"),
|
||
"P" === t && (t += "T0S"),
|
||
t
|
||
)
|
||
}
|
||
toISOTime(t = {}) {
|
||
if (!this.isValid) return null
|
||
const e = this.toMillis()
|
||
if (e < 0 || e >= 864e5) return null
|
||
t = {
|
||
suppressMilliseconds: !1,
|
||
suppressSeconds: !1,
|
||
includePrefix: !1,
|
||
format: "extended",
|
||
...t,
|
||
}
|
||
const n = this.shiftTo("hours", "minutes", "seconds", "milliseconds")
|
||
let r = "basic" === t.format ? "hhmm" : "hh:mm"
|
||
;(t.suppressSeconds && 0 === n.seconds && 0 === n.milliseconds) ||
|
||
((r += "basic" === t.format ? "ss" : ":ss"),
|
||
(t.suppressMilliseconds && 0 === n.milliseconds) || (r += ".SSS"))
|
||
let s = n.toFormat(r)
|
||
return t.includePrefix && (s = "T" + s), s
|
||
}
|
||
toJSON() {
|
||
return this.toISO()
|
||
}
|
||
toString() {
|
||
return this.toISO()
|
||
}
|
||
toMillis() {
|
||
return this.as("milliseconds")
|
||
}
|
||
valueOf() {
|
||
return this.toMillis()
|
||
}
|
||
plus(t) {
|
||
if (!this.isValid) return this
|
||
const e = vn.fromDurationLike(t),
|
||
n = {}
|
||
for (const t of gn) (mt(e.values, t) || mt(this.values, t)) && (n[t] = e.get(t) + this.get(t))
|
||
return wn(this, { values: n }, !0)
|
||
}
|
||
minus(t) {
|
||
if (!this.isValid) return this
|
||
const e = vn.fromDurationLike(t)
|
||
return this.plus(e.negate())
|
||
}
|
||
mapUnits(t) {
|
||
if (!this.isValid) return this
|
||
const e = {}
|
||
for (const n of Object.keys(this.values)) e[n] = xt(t(this.values[n], n))
|
||
return wn(this, { values: e }, !0)
|
||
}
|
||
get(t) {
|
||
return this[vn.normalizeUnit(t)]
|
||
}
|
||
set(t) {
|
||
return this.isValid
|
||
? wn(this, { values: { ...this.values, ...Ct(t, vn.normalizeUnit) } })
|
||
: this
|
||
}
|
||
reconfigure({ locale: t, numberingSystem: e, conversionAccuracy: n } = {}) {
|
||
const r = { loc: this.loc.clone({ locale: t, numberingSystem: e }) }
|
||
return n && (r.conversionAccuracy = n), wn(this, r)
|
||
}
|
||
as(t) {
|
||
return this.isValid ? this.shiftTo(t).get(t) : NaN
|
||
}
|
||
normalize() {
|
||
if (!this.isValid) return this
|
||
const t = this.toObject()
|
||
return (
|
||
(function (t, e) {
|
||
pn.reduce((n, r) => (lt(e[r]) ? n : (n && bn(t, e, n, e, r), r)), null)
|
||
})(this.matrix, t),
|
||
wn(this, { values: t }, !0)
|
||
)
|
||
}
|
||
shiftTo(...t) {
|
||
if (!this.isValid) return this
|
||
if (0 === t.length) return this
|
||
t = t.map((t) => vn.normalizeUnit(t))
|
||
const e = {},
|
||
n = {},
|
||
r = this.toObject()
|
||
let s
|
||
for (const i of gn)
|
||
if (t.indexOf(i) >= 0) {
|
||
s = i
|
||
let t = 0
|
||
for (const e in n) (t += this.matrix[e][i] * n[e]), (n[e] = 0)
|
||
ct(r[i]) && (t += r[i])
|
||
const a = Math.trunc(t)
|
||
;(e[i] = a), (n[i] = (1e3 * t - 1e3 * a) / 1e3)
|
||
for (const t in r) gn.indexOf(t) > gn.indexOf(i) && bn(this.matrix, r, t, e, i)
|
||
} else ct(r[i]) && (n[i] = r[i])
|
||
for (const t in n) 0 !== n[t] && (e[s] += t === s ? n[t] : n[t] / this.matrix[s][t])
|
||
return wn(this, { values: e }, !0).normalize()
|
||
}
|
||
negate() {
|
||
if (!this.isValid) return this
|
||
const t = {}
|
||
for (const e of Object.keys(this.values)) t[e] = 0 === this.values[e] ? 0 : -this.values[e]
|
||
return wn(this, { values: t }, !0)
|
||
}
|
||
get years() {
|
||
return this.isValid ? this.values.years || 0 : NaN
|
||
}
|
||
get quarters() {
|
||
return this.isValid ? this.values.quarters || 0 : NaN
|
||
}
|
||
get months() {
|
||
return this.isValid ? this.values.months || 0 : NaN
|
||
}
|
||
get weeks() {
|
||
return this.isValid ? this.values.weeks || 0 : NaN
|
||
}
|
||
get days() {
|
||
return this.isValid ? this.values.days || 0 : NaN
|
||
}
|
||
get hours() {
|
||
return this.isValid ? this.values.hours || 0 : NaN
|
||
}
|
||
get minutes() {
|
||
return this.isValid ? this.values.minutes || 0 : NaN
|
||
}
|
||
get seconds() {
|
||
return this.isValid ? this.values.seconds || 0 : NaN
|
||
}
|
||
get milliseconds() {
|
||
return this.isValid ? this.values.milliseconds || 0 : NaN
|
||
}
|
||
get isValid() {
|
||
return null === this.invalid
|
||
}
|
||
get invalidReason() {
|
||
return this.invalid ? this.invalid.reason : null
|
||
}
|
||
get invalidExplanation() {
|
||
return this.invalid ? this.invalid.explanation : null
|
||
}
|
||
equals(t) {
|
||
if (!this.isValid || !t.isValid) return !1
|
||
if (!this.loc.equals(t.loc)) return !1
|
||
for (const r of gn)
|
||
if (
|
||
((e = this.values[r]),
|
||
(n = t.values[r]),
|
||
!(void 0 === e || 0 === e ? void 0 === n || 0 === n : e === n))
|
||
)
|
||
return !1
|
||
var e, n
|
||
return !0
|
||
}
|
||
}
|
||
const On = "Invalid Interval"
|
||
class Sn {
|
||
constructor(t) {
|
||
;(this.s = t.start),
|
||
(this.e = t.end),
|
||
(this.invalid = t.invalid || null),
|
||
(this.isLuxonInterval = !0)
|
||
}
|
||
static invalid(t, e = null) {
|
||
if (!t) throw new $("need to specify a reason the Interval is invalid")
|
||
const n = t instanceof Xt ? t : new Xt(t, e)
|
||
if (me.throwOnInvalid) throw new F(n)
|
||
return new Sn({ invalid: n })
|
||
}
|
||
static fromDateTimes(t, e) {
|
||
const n = Tr(t),
|
||
r = Tr(e),
|
||
s = (function (t, e) {
|
||
return t && t.isValid
|
||
? e && e.isValid
|
||
? e < t
|
||
? Sn.invalid(
|
||
"end before start",
|
||
`The end of an interval must be after its start, but you had start=${t.toISO()} and end=${e.toISO()}`
|
||
)
|
||
: null
|
||
: Sn.invalid("missing or invalid end")
|
||
: Sn.invalid("missing or invalid start")
|
||
})(n, r)
|
||
return null == s ? new Sn({ start: n, end: r }) : s
|
||
}
|
||
static after(t, e) {
|
||
const n = vn.fromDurationLike(e),
|
||
r = Tr(t)
|
||
return Sn.fromDateTimes(r, r.plus(n))
|
||
}
|
||
static before(t, e) {
|
||
const n = vn.fromDurationLike(e),
|
||
r = Tr(t)
|
||
return Sn.fromDateTimes(r.minus(n), r)
|
||
}
|
||
static fromISO(t, e) {
|
||
const [n, r] = (t || "").split("/", 2)
|
||
if (n && r) {
|
||
let t, s, i, a
|
||
try {
|
||
;(t = Sr.fromISO(n, e)), (s = t.isValid)
|
||
} catch (r) {
|
||
s = !1
|
||
}
|
||
try {
|
||
;(i = Sr.fromISO(r, e)), (a = i.isValid)
|
||
} catch (r) {
|
||
a = !1
|
||
}
|
||
if (s && a) return Sn.fromDateTimes(t, i)
|
||
if (s) {
|
||
const n = vn.fromISO(r, e)
|
||
if (n.isValid) return Sn.after(t, n)
|
||
} else if (a) {
|
||
const t = vn.fromISO(n, e)
|
||
if (t.isValid) return Sn.before(i, t)
|
||
}
|
||
}
|
||
return Sn.invalid("unparsable", `the input "${t}" can't be parsed as ISO 8601`)
|
||
}
|
||
static isInterval(t) {
|
||
return (t && t.isLuxonInterval) || !1
|
||
}
|
||
get start() {
|
||
return this.isValid ? this.s : null
|
||
}
|
||
get end() {
|
||
return this.isValid ? this.e : null
|
||
}
|
||
get isValid() {
|
||
return null === this.invalidReason
|
||
}
|
||
get invalidReason() {
|
||
return this.invalid ? this.invalid.reason : null
|
||
}
|
||
get invalidExplanation() {
|
||
return this.invalid ? this.invalid.explanation : null
|
||
}
|
||
length(t = "milliseconds") {
|
||
return this.isValid ? this.toDuration(t).get(t) : NaN
|
||
}
|
||
count(t = "milliseconds") {
|
||
if (!this.isValid) return NaN
|
||
const e = this.start.startOf(t),
|
||
n = this.end.startOf(t)
|
||
return Math.floor(n.diff(e, t).get(t)) + 1
|
||
}
|
||
hasSame(t) {
|
||
return !!this.isValid && (this.isEmpty() || this.e.minus(1).hasSame(this.s, t))
|
||
}
|
||
isEmpty() {
|
||
return this.s.valueOf() === this.e.valueOf()
|
||
}
|
||
isAfter(t) {
|
||
return !!this.isValid && this.s > t
|
||
}
|
||
isBefore(t) {
|
||
return !!this.isValid && this.e <= t
|
||
}
|
||
contains(t) {
|
||
return !!this.isValid && this.s <= t && this.e > t
|
||
}
|
||
set({ start: t, end: e } = {}) {
|
||
return this.isValid ? Sn.fromDateTimes(t || this.s, e || this.e) : this
|
||
}
|
||
splitAt(...t) {
|
||
if (!this.isValid) return []
|
||
const e = t
|
||
.map(Tr)
|
||
.filter((t) => this.contains(t))
|
||
.sort(),
|
||
n = []
|
||
let { s: r } = this,
|
||
s = 0
|
||
for (; r < this.e; ) {
|
||
const t = e[s] || this.e,
|
||
i = +t > +this.e ? this.e : t
|
||
n.push(Sn.fromDateTimes(r, i)), (r = i), (s += 1)
|
||
}
|
||
return n
|
||
}
|
||
splitBy(t) {
|
||
const e = vn.fromDurationLike(t)
|
||
if (!this.isValid || !e.isValid || 0 === e.as("milliseconds")) return []
|
||
let n,
|
||
{ s: r } = this,
|
||
s = 1
|
||
const i = []
|
||
for (; r < this.e; ) {
|
||
const t = this.start.plus(e.mapUnits((t) => t * s))
|
||
;(n = +t > +this.e ? this.e : t), i.push(Sn.fromDateTimes(r, n)), (r = n), (s += 1)
|
||
}
|
||
return i
|
||
}
|
||
divideEqually(t) {
|
||
return this.isValid ? this.splitBy(this.length() / t).slice(0, t) : []
|
||
}
|
||
overlaps(t) {
|
||
return this.e > t.s && this.s < t.e
|
||
}
|
||
abutsStart(t) {
|
||
return !!this.isValid && +this.e == +t.s
|
||
}
|
||
abutsEnd(t) {
|
||
return !!this.isValid && +t.e == +this.s
|
||
}
|
||
engulfs(t) {
|
||
return !!this.isValid && this.s <= t.s && this.e >= t.e
|
||
}
|
||
equals(t) {
|
||
return !(!this.isValid || !t.isValid) && this.s.equals(t.s) && this.e.equals(t.e)
|
||
}
|
||
intersection(t) {
|
||
if (!this.isValid) return this
|
||
const e = this.s > t.s ? this.s : t.s,
|
||
n = this.e < t.e ? this.e : t.e
|
||
return e >= n ? null : Sn.fromDateTimes(e, n)
|
||
}
|
||
union(t) {
|
||
if (!this.isValid) return this
|
||
const e = this.s < t.s ? this.s : t.s,
|
||
n = this.e > t.e ? this.e : t.e
|
||
return Sn.fromDateTimes(e, n)
|
||
}
|
||
static merge(t) {
|
||
const [e, n] = t
|
||
.sort((t, e) => t.s - e.s)
|
||
.reduce(
|
||
([t, e], n) =>
|
||
e ? (e.overlaps(n) || e.abutsStart(n) ? [t, e.union(n)] : [t.concat([e]), n]) : [t, n],
|
||
[[], null]
|
||
)
|
||
return n && e.push(n), e
|
||
}
|
||
static xor(t) {
|
||
let e = null,
|
||
n = 0
|
||
const r = [],
|
||
s = t.map((t) => [
|
||
{ time: t.s, type: "s" },
|
||
{ time: t.e, type: "e" },
|
||
]),
|
||
i = Array.prototype.concat(...s).sort((t, e) => t.time - e.time)
|
||
for (const t of i)
|
||
(n += "s" === t.type ? 1 : -1),
|
||
1 === n
|
||
? (e = t.time)
|
||
: (e && +e != +t.time && r.push(Sn.fromDateTimes(e, t.time)), (e = null))
|
||
return Sn.merge(r)
|
||
}
|
||
difference(...t) {
|
||
return Sn.xor([this].concat(t))
|
||
.map((t) => this.intersection(t))
|
||
.filter((t) => t && !t.isEmpty())
|
||
}
|
||
toString() {
|
||
return this.isValid ? `[${this.s.toISO()} – ${this.e.toISO()})` : On
|
||
}
|
||
toISO(t) {
|
||
return this.isValid ? `${this.s.toISO(t)}/${this.e.toISO(t)}` : On
|
||
}
|
||
toISODate() {
|
||
return this.isValid ? `${this.s.toISODate()}/${this.e.toISODate()}` : On
|
||
}
|
||
toISOTime(t) {
|
||
return this.isValid ? `${this.s.toISOTime(t)}/${this.e.toISOTime(t)}` : On
|
||
}
|
||
toFormat(t, { separator: e = " – " } = {}) {
|
||
return this.isValid ? `${this.s.toFormat(t)}${e}${this.e.toFormat(t)}` : On
|
||
}
|
||
toDuration(t, e) {
|
||
return this.isValid ? this.e.diff(this.s, t, e) : vn.invalid(this.invalidReason)
|
||
}
|
||
mapEndpoints(t) {
|
||
return Sn.fromDateTimes(t(this.s), t(this.e))
|
||
}
|
||
}
|
||
class Tn {
|
||
static hasDST(t = me.defaultZone) {
|
||
const e = Sr.now().setZone(t).set({ month: 12 })
|
||
return !t.isUniversal && e.offset !== e.set({ month: 6 }).offset
|
||
}
|
||
static isValidIANAZone(t) {
|
||
return re.isValidZone(t)
|
||
}
|
||
static normalizeZone(t) {
|
||
return oe(t, me.defaultZone)
|
||
}
|
||
static months(
|
||
t = "long",
|
||
{
|
||
locale: e = null,
|
||
numberingSystem: n = null,
|
||
locObj: r = null,
|
||
outputCalendar: s = "gregory",
|
||
} = {}
|
||
) {
|
||
return (r || ke.create(e, n, s)).months(t)
|
||
}
|
||
static monthsFormat(
|
||
t = "long",
|
||
{
|
||
locale: e = null,
|
||
numberingSystem: n = null,
|
||
locObj: r = null,
|
||
outputCalendar: s = "gregory",
|
||
} = {}
|
||
) {
|
||
return (r || ke.create(e, n, s)).months(t, !0)
|
||
}
|
||
static weekdays(
|
||
t = "long",
|
||
{ locale: e = null, numberingSystem: n = null, locObj: r = null } = {}
|
||
) {
|
||
return (r || ke.create(e, n, null)).weekdays(t)
|
||
}
|
||
static weekdaysFormat(
|
||
t = "long",
|
||
{ locale: e = null, numberingSystem: n = null, locObj: r = null } = {}
|
||
) {
|
||
return (r || ke.create(e, n, null)).weekdays(t, !0)
|
||
}
|
||
static meridiems({ locale: t = null } = {}) {
|
||
return ke.create(t).meridiems()
|
||
}
|
||
static eras(t = "short", { locale: e = null } = {}) {
|
||
return ke.create(e, null, "gregory").eras(t)
|
||
}
|
||
static features() {
|
||
return { relative: dt() }
|
||
}
|
||
}
|
||
function Mn(t, e) {
|
||
const n = (t) => t.toUTC(0, { keepLocalTime: !0 }).startOf("day").valueOf(),
|
||
r = n(e) - n(t)
|
||
return Math.floor(vn.fromMillis(r).as("days"))
|
||
}
|
||
const kn = {
|
||
arab: "[٠-٩]",
|
||
arabext: "[۰-۹]",
|
||
bali: "[᭐-᭙]",
|
||
beng: "[০-৯]",
|
||
deva: "[०-९]",
|
||
fullwide: "[０-９]",
|
||
gujr: "[૦-૯]",
|
||
hanidec: "[〇|一|二|三|四|五|六|七|八|九]",
|
||
khmr: "[០-៩]",
|
||
knda: "[೦-೯]",
|
||
laoo: "[໐-໙]",
|
||
limb: "[᥆-᥏]",
|
||
mlym: "[൦-൯]",
|
||
mong: "[᠐-᠙]",
|
||
mymr: "[၀-၉]",
|
||
orya: "[୦-୯]",
|
||
tamldec: "[௦-௯]",
|
||
telu: "[౦-౯]",
|
||
thai: "[๐-๙]",
|
||
tibt: "[༠-༩]",
|
||
latn: "\\d",
|
||
},
|
||
Nn = {
|
||
arab: [1632, 1641],
|
||
arabext: [1776, 1785],
|
||
bali: [6992, 7001],
|
||
beng: [2534, 2543],
|
||
deva: [2406, 2415],
|
||
fullwide: [65296, 65303],
|
||
gujr: [2790, 2799],
|
||
khmr: [6112, 6121],
|
||
knda: [3302, 3311],
|
||
laoo: [3792, 3801],
|
||
limb: [6470, 6479],
|
||
mlym: [3430, 3439],
|
||
mong: [6160, 6169],
|
||
mymr: [4160, 4169],
|
||
orya: [2918, 2927],
|
||
tamldec: [3046, 3055],
|
||
telu: [3174, 3183],
|
||
thai: [3664, 3673],
|
||
tibt: [3872, 3881],
|
||
},
|
||
Dn = kn.hanidec.replace(/[\[|\]]/g, "").split("")
|
||
function En({ numberingSystem: t }, e = "") {
|
||
return new RegExp(`${kn[t || "latn"]}${e}`)
|
||
}
|
||
function xn(t, e = (t) => t) {
|
||
return {
|
||
regex: t,
|
||
deser: ([t]) =>
|
||
e(
|
||
(function (t) {
|
||
let e = parseInt(t, 10)
|
||
if (isNaN(e)) {
|
||
e = ""
|
||
for (let n = 0; n < t.length; n++) {
|
||
const r = t.charCodeAt(n)
|
||
if (-1 !== t[n].search(kn.hanidec)) e += Dn.indexOf(t[n])
|
||
else
|
||
for (const t in Nn) {
|
||
const [n, s] = Nn[t]
|
||
r >= n && r <= s && (e += r - n)
|
||
}
|
||
}
|
||
return parseInt(e, 10)
|
||
}
|
||
return e
|
||
})(t)
|
||
),
|
||
}
|
||
}
|
||
const Cn = `[ ${String.fromCharCode(160)}]`,
|
||
Vn = new RegExp(Cn, "g")
|
||
function Fn(t) {
|
||
return t.replace(/\./g, "\\.?").replace(Vn, Cn)
|
||
}
|
||
function In(t) {
|
||
return t.replace(/\./g, "").replace(Vn, " ").toLowerCase()
|
||
}
|
||
function Ln(t, e) {
|
||
return null === t
|
||
? null
|
||
: {
|
||
regex: RegExp(t.map(Fn).join("|")),
|
||
deser: ([n]) => t.findIndex((t) => In(n) === In(t)) + e,
|
||
}
|
||
}
|
||
function Zn(t, e) {
|
||
return { regex: t, deser: ([, t, e]) => Et(t, e), groups: e }
|
||
}
|
||
function $n(t) {
|
||
return { regex: t, deser: ([t]) => t }
|
||
}
|
||
const _n = {
|
||
year: { "2-digit": "yy", numeric: "yyyyy" },
|
||
month: { numeric: "M", "2-digit": "MM", short: "MMM", long: "MMMM" },
|
||
day: { numeric: "d", "2-digit": "dd" },
|
||
weekday: { short: "EEE", long: "EEEE" },
|
||
dayperiod: "a",
|
||
dayPeriod: "a",
|
||
hour: { numeric: "h", "2-digit": "hh" },
|
||
minute: { numeric: "m", "2-digit": "mm" },
|
||
second: { numeric: "s", "2-digit": "ss" },
|
||
timeZoneName: { long: "ZZZZZ", short: "ZZZ" },
|
||
}
|
||
let An = null
|
||
function Rn(t, e, n) {
|
||
const r = (function (t, e) {
|
||
return Array.prototype.concat(
|
||
...t.map((t) =>
|
||
(function (t, e) {
|
||
if (t.literal) return t
|
||
const n = zn(Gt.macroTokenToFormatOpts(t.val), e)
|
||
return null == n || n.includes(void 0) ? t : n
|
||
})(t, e)
|
||
)
|
||
)
|
||
})(Gt.parseFormat(n), t),
|
||
s = r.map((e) =>
|
||
(function (t, e) {
|
||
const n = En(e),
|
||
r = En(e, "{2}"),
|
||
s = En(e, "{3}"),
|
||
i = En(e, "{4}"),
|
||
a = En(e, "{6}"),
|
||
o = En(e, "{1,2}"),
|
||
u = En(e, "{1,3}"),
|
||
l = En(e, "{1,6}"),
|
||
c = En(e, "{1,9}"),
|
||
h = En(e, "{2,4}"),
|
||
d = En(e, "{4,6}"),
|
||
f = (t) => {
|
||
return {
|
||
regex: RegExp(((e = t.val), e.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&"))),
|
||
deser: ([t]) => t,
|
||
literal: !0,
|
||
}
|
||
var e
|
||
},
|
||
m = ((m) => {
|
||
if (t.literal) return f(m)
|
||
switch (m.val) {
|
||
case "G":
|
||
return Ln(e.eras("short", !1), 0)
|
||
case "GG":
|
||
return Ln(e.eras("long", !1), 0)
|
||
case "y":
|
||
return xn(l)
|
||
case "yy":
|
||
case "kk":
|
||
return xn(h, Nt)
|
||
case "yyyy":
|
||
case "kkkk":
|
||
return xn(i)
|
||
case "yyyyy":
|
||
return xn(d)
|
||
case "yyyyyy":
|
||
return xn(a)
|
||
case "M":
|
||
case "L":
|
||
case "d":
|
||
case "H":
|
||
case "h":
|
||
case "m":
|
||
case "q":
|
||
case "s":
|
||
case "W":
|
||
return xn(o)
|
||
case "MM":
|
||
case "LL":
|
||
case "dd":
|
||
case "HH":
|
||
case "hh":
|
||
case "mm":
|
||
case "qq":
|
||
case "ss":
|
||
case "WW":
|
||
return xn(r)
|
||
case "MMM":
|
||
return Ln(e.months("short", !0, !1), 1)
|
||
case "MMMM":
|
||
return Ln(e.months("long", !0, !1), 1)
|
||
case "LLL":
|
||
return Ln(e.months("short", !1, !1), 1)
|
||
case "LLLL":
|
||
return Ln(e.months("long", !1, !1), 1)
|
||
case "o":
|
||
case "S":
|
||
return xn(u)
|
||
case "ooo":
|
||
case "SSS":
|
||
return xn(s)
|
||
case "u":
|
||
return $n(c)
|
||
case "uu":
|
||
return $n(o)
|
||
case "uuu":
|
||
case "E":
|
||
case "c":
|
||
return xn(n)
|
||
case "a":
|
||
return Ln(e.meridiems(), 0)
|
||
case "EEE":
|
||
return Ln(e.weekdays("short", !1, !1), 1)
|
||
case "EEEE":
|
||
return Ln(e.weekdays("long", !1, !1), 1)
|
||
case "ccc":
|
||
return Ln(e.weekdays("short", !0, !1), 1)
|
||
case "cccc":
|
||
return Ln(e.weekdays("long", !0, !1), 1)
|
||
case "Z":
|
||
case "ZZ":
|
||
return Zn(new RegExp(`([+-]${o.source})(?::(${r.source}))?`), 2)
|
||
case "ZZZ":
|
||
return Zn(new RegExp(`([+-]${o.source})(${r.source})?`), 2)
|
||
case "z":
|
||
return $n(/[a-z_+-/]{1,256}?/i)
|
||
default:
|
||
return f(m)
|
||
}
|
||
})(t) || { invalidReason: "missing Intl.DateTimeFormat.formatToParts support" }
|
||
return (m.token = t), m
|
||
})(e, t)
|
||
),
|
||
i = s.find((t) => t.invalidReason)
|
||
if (i) return { input: e, tokens: r, invalidReason: i.invalidReason }
|
||
{
|
||
const [t, n] = (function (t) {
|
||
return [`^${t.map((t) => t.regex).reduce((t, e) => `${t}(${e.source})`, "")}$`, t]
|
||
})(s),
|
||
i = RegExp(t, "i"),
|
||
[a, o] = (function (t, e, n) {
|
||
const r = t.match(e)
|
||
if (r) {
|
||
const t = {}
|
||
let e = 1
|
||
for (const s in n)
|
||
if (mt(n, s)) {
|
||
const i = n[s],
|
||
a = i.groups ? i.groups + 1 : 1
|
||
!i.literal && i.token && (t[i.token.val[0]] = i.deser(r.slice(e, e + a))), (e += a)
|
||
}
|
||
return [r, t]
|
||
}
|
||
return [r, {}]
|
||
})(e, i, n),
|
||
[u, l, c] = o
|
||
? (function (t) {
|
||
let e,
|
||
n = null
|
||
return (
|
||
lt(t.z) || (n = re.create(t.z)),
|
||
lt(t.Z) || (n || (n = new ie(t.Z)), (e = t.Z)),
|
||
lt(t.q) || (t.M = 3 * (t.q - 1) + 1),
|
||
lt(t.h) ||
|
||
(t.h < 12 && 1 === t.a ? (t.h += 12) : 12 === t.h && 0 === t.a && (t.h = 0)),
|
||
0 === t.G && t.y && (t.y = -t.y),
|
||
lt(t.u) || (t.S = bt(t.u)),
|
||
[
|
||
Object.keys(t).reduce((e, n) => {
|
||
const r = ((t) => {
|
||
switch (t) {
|
||
case "S":
|
||
return "millisecond"
|
||
case "s":
|
||
return "second"
|
||
case "m":
|
||
return "minute"
|
||
case "h":
|
||
case "H":
|
||
return "hour"
|
||
case "d":
|
||
return "day"
|
||
case "o":
|
||
return "ordinal"
|
||
case "L":
|
||
case "M":
|
||
return "month"
|
||
case "y":
|
||
return "year"
|
||
case "E":
|
||
case "c":
|
||
return "weekday"
|
||
case "W":
|
||
return "weekNumber"
|
||
case "k":
|
||
return "weekYear"
|
||
case "q":
|
||
return "quarter"
|
||
default:
|
||
return null
|
||
}
|
||
})(n)
|
||
return r && (e[r] = t[n]), e
|
||
}, {}),
|
||
n,
|
||
e,
|
||
]
|
||
)
|
||
})(o)
|
||
: [null, null, void 0]
|
||
if (mt(o, "a") && mt(o, "H"))
|
||
throw new L("Can't include meridiem when specifying 24-hour format")
|
||
return {
|
||
input: e,
|
||
tokens: r,
|
||
regex: i,
|
||
rawMatches: a,
|
||
matches: o,
|
||
result: u,
|
||
zone: l,
|
||
specificOffset: c,
|
||
}
|
||
}
|
||
}
|
||
function zn(t, e) {
|
||
return t
|
||
? Gt.create(e, t)
|
||
.formatDateTimeParts((An || (An = Sr.fromMillis(1555555555555)), An))
|
||
.map((e) =>
|
||
(function (t, e, n) {
|
||
const { type: r, value: s } = t
|
||
if ("literal" === r) return { literal: !0, val: s }
|
||
const i = n[r]
|
||
let a = _n[r]
|
||
return "object" == typeof a && (a = a[i]), a ? { literal: !1, val: a } : void 0
|
||
})(e, 0, t)
|
||
)
|
||
: null
|
||
}
|
||
const qn = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
|
||
Yn = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335]
|
||
function jn(t, e) {
|
||
return new Xt(
|
||
"unit out of range",
|
||
`you specified ${e} (of type ${typeof e}) as a ${t}, which is invalid`
|
||
)
|
||
}
|
||
function Hn(t, e, n) {
|
||
const r = new Date(Date.UTC(t, e - 1, n))
|
||
t < 100 && t >= 0 && r.setUTCFullYear(r.getUTCFullYear() - 1900)
|
||
const s = r.getUTCDay()
|
||
return 0 === s ? 7 : s
|
||
}
|
||
function Un(t, e, n) {
|
||
return n + (Ot(t) ? Yn : qn)[e - 1]
|
||
}
|
||
function Wn(t, e) {
|
||
const n = Ot(t) ? Yn : qn,
|
||
r = n.findIndex((t) => t < e)
|
||
return { month: r + 1, day: e - n[r] }
|
||
}
|
||
function Pn(t) {
|
||
const { year: e, month: n, day: r } = t,
|
||
s = Un(e, n, r),
|
||
i = Hn(e, n, r)
|
||
let a,
|
||
o = Math.floor((s - i + 10) / 7)
|
||
return (
|
||
o < 1 ? ((a = e - 1), (o = kt(a))) : o > kt(e) ? ((a = e + 1), (o = 1)) : (a = e),
|
||
{ weekYear: a, weekNumber: o, weekday: i, ...Ft(t) }
|
||
)
|
||
}
|
||
function Jn(t) {
|
||
const { weekYear: e, weekNumber: n, weekday: r } = t,
|
||
s = Hn(e, 1, 4),
|
||
i = St(e)
|
||
let a,
|
||
o = 7 * n + r - s - 3
|
||
o < 1 ? ((a = e - 1), (o += St(a))) : o > i ? ((a = e + 1), (o -= St(e))) : (a = e)
|
||
const { month: u, day: l } = Wn(a, o)
|
||
return { year: a, month: u, day: l, ...Ft(t) }
|
||
}
|
||
function Gn(t) {
|
||
const { year: e, month: n, day: r } = t
|
||
return { year: e, ordinal: Un(e, n, r), ...Ft(t) }
|
||
}
|
||
function Xn(t) {
|
||
const { year: e, ordinal: n } = t,
|
||
{ month: r, day: s } = Wn(e, n)
|
||
return { year: e, month: r, day: s, ...Ft(t) }
|
||
}
|
||
function Bn(t) {
|
||
const e = ht(t.year),
|
||
n = yt(t.month, 1, 12),
|
||
r = yt(t.day, 1, Tt(t.year, t.month))
|
||
return e ? (n ? !r && jn("day", t.day) : jn("month", t.month)) : jn("year", t.year)
|
||
}
|
||
function Qn(t) {
|
||
const { hour: e, minute: n, second: r, millisecond: s } = t,
|
||
i = yt(e, 0, 23) || (24 === e && 0 === n && 0 === r && 0 === s),
|
||
a = yt(n, 0, 59),
|
||
o = yt(r, 0, 59),
|
||
u = yt(s, 0, 999)
|
||
return i
|
||
? a
|
||
? o
|
||
? !u && jn("millisecond", s)
|
||
: jn("second", r)
|
||
: jn("minute", n)
|
||
: jn("hour", e)
|
||
}
|
||
const Kn = "Invalid DateTime",
|
||
tr = 864e13
|
||
function er(t) {
|
||
return new Xt("unsupported zone", `the zone "${t.name}" is not supported`)
|
||
}
|
||
function nr(t) {
|
||
return null === t.weekData && (t.weekData = Pn(t.c)), t.weekData
|
||
}
|
||
function rr(t, e) {
|
||
const n = { ts: t.ts, zone: t.zone, c: t.c, o: t.o, loc: t.loc, invalid: t.invalid }
|
||
return new Sr({ ...n, ...e, old: n })
|
||
}
|
||
function sr(t, e, n) {
|
||
let r = t - 60 * e * 1e3
|
||
const s = n.offset(r)
|
||
if (e === s) return [r, e]
|
||
r -= 60 * (s - e) * 1e3
|
||
const i = n.offset(r)
|
||
return s === i ? [r, s] : [t - 60 * Math.min(s, i) * 1e3, Math.max(s, i)]
|
||
}
|
||
function ir(t, e) {
|
||
const n = new Date((t += 60 * e * 1e3))
|
||
return {
|
||
year: n.getUTCFullYear(),
|
||
month: n.getUTCMonth() + 1,
|
||
day: n.getUTCDate(),
|
||
hour: n.getUTCHours(),
|
||
minute: n.getUTCMinutes(),
|
||
second: n.getUTCSeconds(),
|
||
millisecond: n.getUTCMilliseconds(),
|
||
}
|
||
}
|
||
function ar(t, e, n) {
|
||
return sr(Mt(t), e, n)
|
||
}
|
||
function or(t, e) {
|
||
const n = t.o,
|
||
r = t.c.year + Math.trunc(e.years),
|
||
s = t.c.month + Math.trunc(e.months) + 3 * Math.trunc(e.quarters),
|
||
i = {
|
||
...t.c,
|
||
year: r,
|
||
month: s,
|
||
day: Math.min(t.c.day, Tt(r, s)) + Math.trunc(e.days) + 7 * Math.trunc(e.weeks),
|
||
},
|
||
a = vn
|
||
.fromObject({
|
||
years: e.years - Math.trunc(e.years),
|
||
quarters: e.quarters - Math.trunc(e.quarters),
|
||
months: e.months - Math.trunc(e.months),
|
||
weeks: e.weeks - Math.trunc(e.weeks),
|
||
days: e.days - Math.trunc(e.days),
|
||
hours: e.hours,
|
||
minutes: e.minutes,
|
||
seconds: e.seconds,
|
||
milliseconds: e.milliseconds,
|
||
})
|
||
.as("milliseconds"),
|
||
o = Mt(i)
|
||
let [u, l] = sr(o, n, t.zone)
|
||
return 0 !== a && ((u += a), (l = t.zone.offset(u))), { ts: u, o: l }
|
||
}
|
||
function ur(t, e, n, r, s, i) {
|
||
const { setZone: a, zone: o } = n
|
||
if (t && 0 !== Object.keys(t).length) {
|
||
const r = e || o,
|
||
s = Sr.fromObject(t, { ...n, zone: r, specificOffset: i })
|
||
return a ? s : s.setZone(o)
|
||
}
|
||
return Sr.invalid(new Xt("unparsable", `the input "${s}" can't be parsed as ${r}`))
|
||
}
|
||
function lr(t, e, n = !0) {
|
||
return t.isValid
|
||
? Gt.create(ke.create("en-US"), { allowZ: n, forceSimple: !0 }).formatDateTimeFromString(t, e)
|
||
: null
|
||
}
|
||
function cr(t, e) {
|
||
const n = t.c.year > 9999 || t.c.year < 0
|
||
let r = ""
|
||
return (
|
||
n && t.c.year >= 0 && (r += "+"),
|
||
(r += gt(t.c.year, n ? 6 : 4)),
|
||
e
|
||
? ((r += "-"), (r += gt(t.c.month)), (r += "-"), (r += gt(t.c.day)))
|
||
: ((r += gt(t.c.month)), (r += gt(t.c.day))),
|
||
r
|
||
)
|
||
}
|
||
function hr(t, e, n, r, s, i) {
|
||
let a = gt(t.c.hour)
|
||
return (
|
||
e
|
||
? ((a += ":"), (a += gt(t.c.minute)), (0 === t.c.second && n) || (a += ":"))
|
||
: (a += gt(t.c.minute)),
|
||
(0 === t.c.second && n) ||
|
||
((a += gt(t.c.second)),
|
||
(0 === t.c.millisecond && r) || ((a += "."), (a += gt(t.c.millisecond, 3)))),
|
||
s &&
|
||
(t.isOffsetFixed && 0 === t.offset && !i
|
||
? (a += "Z")
|
||
: t.o < 0
|
||
? ((a += "-"),
|
||
(a += gt(Math.trunc(-t.o / 60))),
|
||
(a += ":"),
|
||
(a += gt(Math.trunc(-t.o % 60))))
|
||
: ((a += "+"),
|
||
(a += gt(Math.trunc(t.o / 60))),
|
||
(a += ":"),
|
||
(a += gt(Math.trunc(t.o % 60))))),
|
||
i && (a += "[" + t.zone.ianaName + "]"),
|
||
a
|
||
)
|
||
}
|
||
const dr = { month: 1, day: 1, hour: 0, minute: 0, second: 0, millisecond: 0 },
|
||
fr = { weekNumber: 1, weekday: 1, hour: 0, minute: 0, second: 0, millisecond: 0 },
|
||
mr = { ordinal: 1, hour: 0, minute: 0, second: 0, millisecond: 0 },
|
||
yr = ["year", "month", "day", "hour", "minute", "second", "millisecond"],
|
||
gr = ["weekYear", "weekNumber", "weekday", "hour", "minute", "second", "millisecond"],
|
||
pr = ["year", "ordinal", "hour", "minute", "second", "millisecond"]
|
||
function wr(t) {
|
||
const e = {
|
||
year: "year",
|
||
years: "year",
|
||
month: "month",
|
||
months: "month",
|
||
day: "day",
|
||
days: "day",
|
||
hour: "hour",
|
||
hours: "hour",
|
||
minute: "minute",
|
||
minutes: "minute",
|
||
quarter: "quarter",
|
||
quarters: "quarter",
|
||
second: "second",
|
||
seconds: "second",
|
||
millisecond: "millisecond",
|
||
milliseconds: "millisecond",
|
||
weekday: "weekday",
|
||
weekdays: "weekday",
|
||
weeknumber: "weekNumber",
|
||
weeksnumber: "weekNumber",
|
||
weeknumbers: "weekNumber",
|
||
weekyear: "weekYear",
|
||
weekyears: "weekYear",
|
||
ordinal: "ordinal",
|
||
}[t.toLowerCase()]
|
||
if (!e) throw new Z(t)
|
||
return e
|
||
}
|
||
function br(t, e) {
|
||
const n = oe(e.zone, me.defaultZone),
|
||
r = ke.fromObject(e),
|
||
s = me.now()
|
||
let i, a
|
||
if (lt(t.year)) i = s
|
||
else {
|
||
for (const e of yr) lt(t[e]) && (t[e] = dr[e])
|
||
const e = Bn(t) || Qn(t)
|
||
if (e) return Sr.invalid(e)
|
||
const r = n.offset(s)
|
||
;[i, a] = ar(t, r, n)
|
||
}
|
||
return new Sr({ ts: i, zone: n, loc: r, o: a })
|
||
}
|
||
function vr(t, e, n) {
|
||
const r = !!lt(n.round) || n.round,
|
||
s = (t, s) => (
|
||
(t = vt(t, r || n.calendary ? 0 : 2, !0)), e.loc.clone(n).relFormatter(n).format(t, s)
|
||
),
|
||
i = (r) =>
|
||
n.calendary
|
||
? e.hasSame(t, r)
|
||
? 0
|
||
: e.startOf(r).diff(t.startOf(r), r).get(r)
|
||
: e.diff(t, r).get(r)
|
||
if (n.unit) return s(i(n.unit), n.unit)
|
||
for (const t of n.units) {
|
||
const e = i(t)
|
||
if (Math.abs(e) >= 1) return s(e, t)
|
||
}
|
||
return s(t > e ? -0 : 0, n.units[n.units.length - 1])
|
||
}
|
||
function Or(t) {
|
||
let e,
|
||
n = {}
|
||
return (
|
||
t.length > 0 && "object" == typeof t[t.length - 1]
|
||
? ((n = t[t.length - 1]), (e = Array.from(t).slice(0, t.length - 1)))
|
||
: (e = Array.from(t)),
|
||
[n, e]
|
||
)
|
||
}
|
||
class Sr {
|
||
constructor(t) {
|
||
const e = t.zone || me.defaultZone
|
||
let n =
|
||
t.invalid ||
|
||
(Number.isNaN(t.ts) ? new Xt("invalid input") : null) ||
|
||
(e.isValid ? null : er(e))
|
||
this.ts = lt(t.ts) ? me.now() : t.ts
|
||
let r = null,
|
||
s = null
|
||
if (!n)
|
||
if (t.old && t.old.ts === this.ts && t.old.zone.equals(e)) [r, s] = [t.old.c, t.old.o]
|
||
else {
|
||
const t = e.offset(this.ts)
|
||
;(r = ir(this.ts, t)),
|
||
(n = Number.isNaN(r.year) ? new Xt("invalid input") : null),
|
||
(r = n ? null : r),
|
||
(s = n ? null : t)
|
||
}
|
||
;(this._zone = e),
|
||
(this.loc = t.loc || ke.create()),
|
||
(this.invalid = n),
|
||
(this.weekData = null),
|
||
(this.c = r),
|
||
(this.o = s),
|
||
(this.isLuxonDateTime = !0)
|
||
}
|
||
static now() {
|
||
return new Sr({})
|
||
}
|
||
static local() {
|
||
const [t, e] = Or(arguments),
|
||
[n, r, s, i, a, o, u] = e
|
||
return br({ year: n, month: r, day: s, hour: i, minute: a, second: o, millisecond: u }, t)
|
||
}
|
||
static utc() {
|
||
const [t, e] = Or(arguments),
|
||
[n, r, s, i, a, o, u] = e
|
||
return (
|
||
(t.zone = ie.utcInstance),
|
||
br({ year: n, month: r, day: s, hour: i, minute: a, second: o, millisecond: u }, t)
|
||
)
|
||
}
|
||
static fromJSDate(t, e = {}) {
|
||
const n = ((r = t), "[object Date]" === Object.prototype.toString.call(r) ? t.valueOf() : NaN)
|
||
var r
|
||
if (Number.isNaN(n)) return Sr.invalid("invalid input")
|
||
const s = oe(e.zone, me.defaultZone)
|
||
return s.isValid ? new Sr({ ts: n, zone: s, loc: ke.fromObject(e) }) : Sr.invalid(er(s))
|
||
}
|
||
static fromMillis(t, e = {}) {
|
||
if (ct(t))
|
||
return t < -tr || t > tr
|
||
? Sr.invalid("Timestamp out of range")
|
||
: new Sr({ ts: t, zone: oe(e.zone, me.defaultZone), loc: ke.fromObject(e) })
|
||
throw new $(
|
||
`fromMillis requires a numerical input, but received a ${typeof t} with value ${t}`
|
||
)
|
||
}
|
||
static fromSeconds(t, e = {}) {
|
||
if (ct(t))
|
||
return new Sr({ ts: 1e3 * t, zone: oe(e.zone, me.defaultZone), loc: ke.fromObject(e) })
|
||
throw new $("fromSeconds requires a numerical input")
|
||
}
|
||
static fromObject(t, e = {}) {
|
||
t = t || {}
|
||
const n = oe(e.zone, me.defaultZone)
|
||
if (!n.isValid) return Sr.invalid(er(n))
|
||
const r = me.now(),
|
||
s = lt(e.specificOffset) ? n.offset(r) : e.specificOffset,
|
||
i = Ct(t, wr),
|
||
a = !lt(i.ordinal),
|
||
o = !lt(i.year),
|
||
u = !lt(i.month) || !lt(i.day),
|
||
l = o || u,
|
||
c = i.weekYear || i.weekNumber,
|
||
h = ke.fromObject(e)
|
||
if ((l || a) && c)
|
||
throw new L("Can't mix weekYear/weekNumber units with year/month/day or ordinals")
|
||
if (u && a) throw new L("Can't mix ordinal dates with month/day")
|
||
const d = c || (i.weekday && !l)
|
||
let f,
|
||
m,
|
||
y = ir(r, s)
|
||
d
|
||
? ((f = gr), (m = fr), (y = Pn(y)))
|
||
: a
|
||
? ((f = pr), (m = mr), (y = Gn(y)))
|
||
: ((f = yr), (m = dr))
|
||
let g = !1
|
||
for (const t of f) lt(i[t]) ? (i[t] = g ? m[t] : y[t]) : (g = !0)
|
||
const p = d
|
||
? (function (t) {
|
||
const e = ht(t.weekYear),
|
||
n = yt(t.weekNumber, 1, kt(t.weekYear)),
|
||
r = yt(t.weekday, 1, 7)
|
||
return e
|
||
? n
|
||
? !r && jn("weekday", t.weekday)
|
||
: jn("week", t.week)
|
||
: jn("weekYear", t.weekYear)
|
||
})(i)
|
||
: a
|
||
? (function (t) {
|
||
const e = ht(t.year),
|
||
n = yt(t.ordinal, 1, St(t.year))
|
||
return e ? !n && jn("ordinal", t.ordinal) : jn("year", t.year)
|
||
})(i)
|
||
: Bn(i),
|
||
w = p || Qn(i)
|
||
if (w) return Sr.invalid(w)
|
||
const b = d ? Jn(i) : a ? Xn(i) : i,
|
||
[v, O] = ar(b, s, n),
|
||
S = new Sr({ ts: v, zone: n, o: O, loc: h })
|
||
return i.weekday && l && t.weekday !== S.weekday
|
||
? Sr.invalid(
|
||
"mismatched weekday",
|
||
`you can't specify both a weekday of ${i.weekday} and a date of ${S.toISO()}`
|
||
)
|
||
: S
|
||
}
|
||
static fromISO(t, e = {}) {
|
||
const [n, r] = (function (t) {
|
||
return Ee(t, [tn, sn], [en, an], [nn, on], [rn, un])
|
||
})(t)
|
||
return ur(n, r, e, "ISO 8601", t)
|
||
}
|
||
static fromRFC2822(t, e = {}) {
|
||
const [n, r] = (function (t) {
|
||
return Ee(
|
||
(function (t) {
|
||
return t
|
||
.replace(/\([^)]*\)|[\n\t]/g, " ")
|
||
.replace(/(\s\s+)/g, " ")
|
||
.trim()
|
||
})(t),
|
||
[Pe, Je]
|
||
)
|
||
})(t)
|
||
return ur(n, r, e, "RFC 2822", t)
|
||
}
|
||
static fromHTTP(t, e = {}) {
|
||
const [n, r] = (function (t) {
|
||
return Ee(t, [Ge, Qe], [Xe, Qe], [Be, Ke])
|
||
})(t)
|
||
return ur(n, r, e, "HTTP", e)
|
||
}
|
||
static fromFormat(t, e, n = {}) {
|
||
if (lt(t) || lt(e)) throw new $("fromFormat requires an input string and a format")
|
||
const { locale: r = null, numberingSystem: s = null } = n,
|
||
i = ke.fromOpts({ locale: r, numberingSystem: s, defaultToEN: !0 }),
|
||
[a, o, u, l] = (function (t, e, n) {
|
||
const { result: r, zone: s, specificOffset: i, invalidReason: a } = Rn(t, e, n)
|
||
return [r, s, i, a]
|
||
})(i, t, e)
|
||
return l ? Sr.invalid(l) : ur(a, o, n, `format ${e}`, t, u)
|
||
}
|
||
static fromString(t, e, n = {}) {
|
||
return Sr.fromFormat(t, e, n)
|
||
}
|
||
static fromSQL(t, e = {}) {
|
||
const [n, r] = (function (t) {
|
||
return Ee(t, [cn, sn], [hn, dn])
|
||
})(t)
|
||
return ur(n, r, e, "SQL", t)
|
||
}
|
||
static invalid(t, e = null) {
|
||
if (!t) throw new $("need to specify a reason the DateTime is invalid")
|
||
const n = t instanceof Xt ? t : new Xt(t, e)
|
||
if (me.throwOnInvalid) throw new V(n)
|
||
return new Sr({ invalid: n })
|
||
}
|
||
static isDateTime(t) {
|
||
return (t && t.isLuxonDateTime) || !1
|
||
}
|
||
static parseFormatForOpts(t, e = {}) {
|
||
const n = zn(t, ke.fromObject(e))
|
||
return n ? n.map((t) => (t ? t.val : null)).join("") : null
|
||
}
|
||
get(t) {
|
||
return this[t]
|
||
}
|
||
get isValid() {
|
||
return null === this.invalid
|
||
}
|
||
get invalidReason() {
|
||
return this.invalid ? this.invalid.reason : null
|
||
}
|
||
get invalidExplanation() {
|
||
return this.invalid ? this.invalid.explanation : null
|
||
}
|
||
get locale() {
|
||
return this.isValid ? this.loc.locale : null
|
||
}
|
||
get numberingSystem() {
|
||
return this.isValid ? this.loc.numberingSystem : null
|
||
}
|
||
get outputCalendar() {
|
||
return this.isValid ? this.loc.outputCalendar : null
|
||
}
|
||
get zone() {
|
||
return this._zone
|
||
}
|
||
get zoneName() {
|
||
return this.isValid ? this.zone.name : null
|
||
}
|
||
get year() {
|
||
return this.isValid ? this.c.year : NaN
|
||
}
|
||
get quarter() {
|
||
return this.isValid ? Math.ceil(this.c.month / 3) : NaN
|
||
}
|
||
get month() {
|
||
return this.isValid ? this.c.month : NaN
|
||
}
|
||
get day() {
|
||
return this.isValid ? this.c.day : NaN
|
||
}
|
||
get hour() {
|
||
return this.isValid ? this.c.hour : NaN
|
||
}
|
||
get minute() {
|
||
return this.isValid ? this.c.minute : NaN
|
||
}
|
||
get second() {
|
||
return this.isValid ? this.c.second : NaN
|
||
}
|
||
get millisecond() {
|
||
return this.isValid ? this.c.millisecond : NaN
|
||
}
|
||
get weekYear() {
|
||
return this.isValid ? nr(this).weekYear : NaN
|
||
}
|
||
get weekNumber() {
|
||
return this.isValid ? nr(this).weekNumber : NaN
|
||
}
|
||
get weekday() {
|
||
return this.isValid ? nr(this).weekday : NaN
|
||
}
|
||
get ordinal() {
|
||
return this.isValid ? Gn(this.c).ordinal : NaN
|
||
}
|
||
get monthShort() {
|
||
return this.isValid ? Tn.months("short", { locObj: this.loc })[this.month - 1] : null
|
||
}
|
||
get monthLong() {
|
||
return this.isValid ? Tn.months("long", { locObj: this.loc })[this.month - 1] : null
|
||
}
|
||
get weekdayShort() {
|
||
return this.isValid ? Tn.weekdays("short", { locObj: this.loc })[this.weekday - 1] : null
|
||
}
|
||
get weekdayLong() {
|
||
return this.isValid ? Tn.weekdays("long", { locObj: this.loc })[this.weekday - 1] : null
|
||
}
|
||
get offset() {
|
||
return this.isValid ? +this.o : NaN
|
||
}
|
||
get offsetNameShort() {
|
||
return this.isValid
|
||
? this.zone.offsetName(this.ts, { format: "short", locale: this.locale })
|
||
: null
|
||
}
|
||
get offsetNameLong() {
|
||
return this.isValid
|
||
? this.zone.offsetName(this.ts, { format: "long", locale: this.locale })
|
||
: null
|
||
}
|
||
get isOffsetFixed() {
|
||
return this.isValid ? this.zone.isUniversal : null
|
||
}
|
||
get isInDST() {
|
||
return (
|
||
!this.isOffsetFixed &&
|
||
(this.offset > this.set({ month: 1, day: 1 }).offset ||
|
||
this.offset > this.set({ month: 5 }).offset)
|
||
)
|
||
}
|
||
get isInLeapYear() {
|
||
return Ot(this.year)
|
||
}
|
||
get daysInMonth() {
|
||
return Tt(this.year, this.month)
|
||
}
|
||
get daysInYear() {
|
||
return this.isValid ? St(this.year) : NaN
|
||
}
|
||
get weeksInWeekYear() {
|
||
return this.isValid ? kt(this.weekYear) : NaN
|
||
}
|
||
resolvedLocaleOptions(t = {}) {
|
||
const {
|
||
locale: e,
|
||
numberingSystem: n,
|
||
calendar: r,
|
||
} = Gt.create(this.loc.clone(t), t).resolvedOptions(this)
|
||
return { locale: e, numberingSystem: n, outputCalendar: r }
|
||
}
|
||
toUTC(t = 0, e = {}) {
|
||
return this.setZone(ie.instance(t), e)
|
||
}
|
||
toLocal() {
|
||
return this.setZone(me.defaultZone)
|
||
}
|
||
setZone(t, { keepLocalTime: e = !1, keepCalendarTime: n = !1 } = {}) {
|
||
if ((t = oe(t, me.defaultZone)).equals(this.zone)) return this
|
||
if (t.isValid) {
|
||
let r = this.ts
|
||
if (e || n) {
|
||
const e = t.offset(this.ts),
|
||
n = this.toObject()
|
||
;[r] = ar(n, e, t)
|
||
}
|
||
return rr(this, { ts: r, zone: t })
|
||
}
|
||
return Sr.invalid(er(t))
|
||
}
|
||
reconfigure({ locale: t, numberingSystem: e, outputCalendar: n } = {}) {
|
||
return rr(this, { loc: this.loc.clone({ locale: t, numberingSystem: e, outputCalendar: n }) })
|
||
}
|
||
setLocale(t) {
|
||
return this.reconfigure({ locale: t })
|
||
}
|
||
set(t) {
|
||
if (!this.isValid) return this
|
||
const e = Ct(t, wr),
|
||
n = !lt(e.weekYear) || !lt(e.weekNumber) || !lt(e.weekday),
|
||
r = !lt(e.ordinal),
|
||
s = !lt(e.year),
|
||
i = !lt(e.month) || !lt(e.day),
|
||
a = s || i,
|
||
o = e.weekYear || e.weekNumber
|
||
if ((a || r) && o)
|
||
throw new L("Can't mix weekYear/weekNumber units with year/month/day or ordinals")
|
||
if (i && r) throw new L("Can't mix ordinal dates with month/day")
|
||
let u
|
||
n
|
||
? (u = Jn({ ...Pn(this.c), ...e }))
|
||
: lt(e.ordinal)
|
||
? ((u = { ...this.toObject(), ...e }),
|
||
lt(e.day) && (u.day = Math.min(Tt(u.year, u.month), u.day)))
|
||
: (u = Xn({ ...Gn(this.c), ...e }))
|
||
const [l, c] = ar(u, this.o, this.zone)
|
||
return rr(this, { ts: l, o: c })
|
||
}
|
||
plus(t) {
|
||
return this.isValid ? rr(this, or(this, vn.fromDurationLike(t))) : this
|
||
}
|
||
minus(t) {
|
||
return this.isValid ? rr(this, or(this, vn.fromDurationLike(t).negate())) : this
|
||
}
|
||
startOf(t) {
|
||
if (!this.isValid) return this
|
||
const e = {},
|
||
n = vn.normalizeUnit(t)
|
||
switch (n) {
|
||
case "years":
|
||
e.month = 1
|
||
case "quarters":
|
||
case "months":
|
||
e.day = 1
|
||
case "weeks":
|
||
case "days":
|
||
e.hour = 0
|
||
case "hours":
|
||
e.minute = 0
|
||
case "minutes":
|
||
e.second = 0
|
||
case "seconds":
|
||
e.millisecond = 0
|
||
}
|
||
if (("weeks" === n && (e.weekday = 1), "quarters" === n)) {
|
||
const t = Math.ceil(this.month / 3)
|
||
e.month = 3 * (t - 1) + 1
|
||
}
|
||
return this.set(e)
|
||
}
|
||
endOf(t) {
|
||
return this.isValid
|
||
? this.plus({ [t]: 1 })
|
||
.startOf(t)
|
||
.minus(1)
|
||
: this
|
||
}
|
||
toFormat(t, e = {}) {
|
||
return this.isValid
|
||
? Gt.create(this.loc.redefaultToEN(e)).formatDateTimeFromString(this, t)
|
||
: Kn
|
||
}
|
||
toLocaleString(t = q, e = {}) {
|
||
return this.isValid ? Gt.create(this.loc.clone(e), t).formatDateTime(this) : Kn
|
||
}
|
||
toLocaleParts(t = {}) {
|
||
return this.isValid ? Gt.create(this.loc.clone(t), t).formatDateTimeParts(this) : []
|
||
}
|
||
toISO({
|
||
format: t = "extended",
|
||
suppressSeconds: e = !1,
|
||
suppressMilliseconds: n = !1,
|
||
includeOffset: r = !0,
|
||
extendedZone: s = !1,
|
||
} = {}) {
|
||
if (!this.isValid) return null
|
||
const i = "extended" === t
|
||
let a = cr(this, i)
|
||
return (a += "T"), (a += hr(this, i, e, n, r, s)), a
|
||
}
|
||
toISODate({ format: t = "extended" } = {}) {
|
||
return this.isValid ? cr(this, "extended" === t) : null
|
||
}
|
||
toISOWeekDate() {
|
||
return lr(this, "kkkk-'W'WW-c")
|
||
}
|
||
toISOTime({
|
||
suppressMilliseconds: t = !1,
|
||
suppressSeconds: e = !1,
|
||
includeOffset: n = !0,
|
||
includePrefix: r = !1,
|
||
extendedZone: s = !1,
|
||
format: i = "extended",
|
||
} = {}) {
|
||
return this.isValid ? (r ? "T" : "") + hr(this, "extended" === i, e, t, n, s) : null
|
||
}
|
||
toRFC2822() {
|
||
return lr(this, "EEE, dd LLL yyyy HH:mm:ss ZZZ", !1)
|
||
}
|
||
toHTTP() {
|
||
return lr(this.toUTC(), "EEE, dd LLL yyyy HH:mm:ss 'GMT'")
|
||
}
|
||
toSQLDate() {
|
||
return this.isValid ? cr(this, !0) : null
|
||
}
|
||
toSQLTime({ includeOffset: t = !0, includeZone: e = !1, includeOffsetSpace: n = !0 } = {}) {
|
||
let r = "HH:mm:ss.SSS"
|
||
return (e || t) && (n && (r += " "), e ? (r += "z") : t && (r += "ZZ")), lr(this, r, !0)
|
||
}
|
||
toSQL(t = {}) {
|
||
return this.isValid ? `${this.toSQLDate()} ${this.toSQLTime(t)}` : null
|
||
}
|
||
toString() {
|
||
return this.isValid ? this.toISO() : Kn
|
||
}
|
||
valueOf() {
|
||
return this.toMillis()
|
||
}
|
||
toMillis() {
|
||
return this.isValid ? this.ts : NaN
|
||
}
|
||
toSeconds() {
|
||
return this.isValid ? this.ts / 1e3 : NaN
|
||
}
|
||
toUnixInteger() {
|
||
return this.isValid ? Math.floor(this.ts / 1e3) : NaN
|
||
}
|
||
toJSON() {
|
||
return this.toISO()
|
||
}
|
||
toBSON() {
|
||
return this.toJSDate()
|
||
}
|
||
toObject(t = {}) {
|
||
if (!this.isValid) return {}
|
||
const e = { ...this.c }
|
||
return (
|
||
t.includeConfig &&
|
||
((e.outputCalendar = this.outputCalendar),
|
||
(e.numberingSystem = this.loc.numberingSystem),
|
||
(e.locale = this.loc.locale)),
|
||
e
|
||
)
|
||
}
|
||
toJSDate() {
|
||
return new Date(this.isValid ? this.ts : NaN)
|
||
}
|
||
diff(t, e = "milliseconds", n = {}) {
|
||
if (!this.isValid || !t.isValid) return vn.invalid("created by diffing an invalid DateTime")
|
||
const r = { locale: this.locale, numberingSystem: this.numberingSystem, ...n },
|
||
s = ((o = e), Array.isArray(o) ? o : [o]).map(vn.normalizeUnit),
|
||
i = t.valueOf() > this.valueOf(),
|
||
a = (function (t, e, n, r) {
|
||
let [s, i, a, o] = (function (t, e, n) {
|
||
const r = [
|
||
["years", (t, e) => e.year - t.year],
|
||
["quarters", (t, e) => e.quarter - t.quarter],
|
||
["months", (t, e) => e.month - t.month + 12 * (e.year - t.year)],
|
||
[
|
||
"weeks",
|
||
(t, e) => {
|
||
const n = Mn(t, e)
|
||
return (n - (n % 7)) / 7
|
||
},
|
||
],
|
||
["days", Mn],
|
||
],
|
||
s = {}
|
||
let i, a
|
||
for (const [o, u] of r)
|
||
if (n.indexOf(o) >= 0) {
|
||
i = o
|
||
let n = u(t, e)
|
||
;(a = t.plus({ [o]: n })),
|
||
a > e ? ((t = t.plus({ [o]: n - 1 })), (n -= 1)) : (t = a),
|
||
(s[o] = n)
|
||
}
|
||
return [t, s, a, i]
|
||
})(t, e, n)
|
||
const u = e - s,
|
||
l = n.filter((t) => ["hours", "minutes", "seconds", "milliseconds"].indexOf(t) >= 0)
|
||
0 === l.length &&
|
||
(a < e && (a = s.plus({ [o]: 1 })), a !== s && (i[o] = (i[o] || 0) + u / (a - s)))
|
||
const c = vn.fromObject(i, r)
|
||
return l.length > 0
|
||
? vn
|
||
.fromMillis(u, r)
|
||
.shiftTo(...l)
|
||
.plus(c)
|
||
: c
|
||
})(i ? this : t, i ? t : this, s, r)
|
||
var o
|
||
return i ? a.negate() : a
|
||
}
|
||
diffNow(t = "milliseconds", e = {}) {
|
||
return this.diff(Sr.now(), t, e)
|
||
}
|
||
until(t) {
|
||
return this.isValid ? Sn.fromDateTimes(this, t) : this
|
||
}
|
||
hasSame(t, e) {
|
||
if (!this.isValid) return !1
|
||
const n = t.valueOf(),
|
||
r = this.setZone(t.zone, { keepLocalTime: !0 })
|
||
return r.startOf(e) <= n && n <= r.endOf(e)
|
||
}
|
||
equals(t) {
|
||
return (
|
||
this.isValid &&
|
||
t.isValid &&
|
||
this.valueOf() === t.valueOf() &&
|
||
this.zone.equals(t.zone) &&
|
||
this.loc.equals(t.loc)
|
||
)
|
||
}
|
||
toRelative(t = {}) {
|
||
if (!this.isValid) return null
|
||
const e = t.base || Sr.fromObject({}, { zone: this.zone }),
|
||
n = t.padding ? (this < e ? -t.padding : t.padding) : 0
|
||
let r = ["years", "months", "days", "hours", "minutes", "seconds"],
|
||
s = t.unit
|
||
return (
|
||
Array.isArray(t.unit) && ((r = t.unit), (s = void 0)),
|
||
vr(e, this.plus(n), { ...t, numeric: "always", units: r, unit: s })
|
||
)
|
||
}
|
||
toRelativeCalendar(t = {}) {
|
||
return this.isValid
|
||
? vr(t.base || Sr.fromObject({}, { zone: this.zone }), this, {
|
||
...t,
|
||
numeric: "auto",
|
||
units: ["years", "months", "days"],
|
||
calendary: !0,
|
||
})
|
||
: null
|
||
}
|
||
static min(...t) {
|
||
if (!t.every(Sr.isDateTime)) throw new $("min requires all arguments be DateTimes")
|
||
return ft(t, (t) => t.valueOf(), Math.min)
|
||
}
|
||
static max(...t) {
|
||
if (!t.every(Sr.isDateTime)) throw new $("max requires all arguments be DateTimes")
|
||
return ft(t, (t) => t.valueOf(), Math.max)
|
||
}
|
||
static fromFormatExplain(t, e, n = {}) {
|
||
const { locale: r = null, numberingSystem: s = null } = n
|
||
return Rn(ke.fromOpts({ locale: r, numberingSystem: s, defaultToEN: !0 }), t, e)
|
||
}
|
||
static fromStringExplain(t, e, n = {}) {
|
||
return Sr.fromFormatExplain(t, e, n)
|
||
}
|
||
static get DATE_SHORT() {
|
||
return q
|
||
}
|
||
static get DATE_MED() {
|
||
return Y
|
||
}
|
||
static get DATE_MED_WITH_WEEKDAY() {
|
||
return j
|
||
}
|
||
static get DATE_FULL() {
|
||
return H
|
||
}
|
||
static get DATE_HUGE() {
|
||
return U
|
||
}
|
||
static get TIME_SIMPLE() {
|
||
return W
|
||
}
|
||
static get TIME_WITH_SECONDS() {
|
||
return P
|
||
}
|
||
static get TIME_WITH_SHORT_OFFSET() {
|
||
return J
|
||
}
|
||
static get TIME_WITH_LONG_OFFSET() {
|
||
return G
|
||
}
|
||
static get TIME_24_SIMPLE() {
|
||
return X
|
||
}
|
||
static get TIME_24_WITH_SECONDS() {
|
||
return B
|
||
}
|
||
static get TIME_24_WITH_SHORT_OFFSET() {
|
||
return Q
|
||
}
|
||
static get TIME_24_WITH_LONG_OFFSET() {
|
||
return K
|
||
}
|
||
static get DATETIME_SHORT() {
|
||
return tt
|
||
}
|
||
static get DATETIME_SHORT_WITH_SECONDS() {
|
||
return et
|
||
}
|
||
static get DATETIME_MED() {
|
||
return nt
|
||
}
|
||
static get DATETIME_MED_WITH_SECONDS() {
|
||
return rt
|
||
}
|
||
static get DATETIME_MED_WITH_WEEKDAY() {
|
||
return st
|
||
}
|
||
static get DATETIME_FULL() {
|
||
return it
|
||
}
|
||
static get DATETIME_FULL_WITH_SECONDS() {
|
||
return at
|
||
}
|
||
static get DATETIME_HUGE() {
|
||
return ot
|
||
}
|
||
static get DATETIME_HUGE_WITH_SECONDS() {
|
||
return ut
|
||
}
|
||
}
|
||
function Tr(t) {
|
||
if (Sr.isDateTime(t)) return t
|
||
if (t && t.valueOf && ct(t.valueOf())) return Sr.fromJSDate(t)
|
||
if (t && "object" == typeof t) return Sr.fromObject(t)
|
||
throw new $(`Unknown datetime argument: ${t}, of type ${typeof t}`)
|
||
}
|
||
const Mr = (() => {
|
||
const t = {
|
||
MONTHS: [
|
||
"January",
|
||
"February",
|
||
"March",
|
||
"April",
|
||
"May",
|
||
"June",
|
||
"July",
|
||
"August",
|
||
"September",
|
||
"October",
|
||
"November",
|
||
"December",
|
||
],
|
||
COLORS: [
|
||
"#4dc9f6",
|
||
"#f67019",
|
||
"#f53794",
|
||
"#537bc4",
|
||
"#acc236",
|
||
"#166a8f",
|
||
"#00a950",
|
||
"#58595b",
|
||
"#8549ba",
|
||
],
|
||
CHART_COLORS: {
|
||
red: "rgb(255, 99, 132)",
|
||
orange: "rgb(255, 159, 64)",
|
||
yellow: "rgb(255, 205, 86)",
|
||
green: "rgb(75, 192, 192)",
|
||
blue: "rgb(54, 162, 235)",
|
||
purple: "rgb(153, 102, 255)",
|
||
grey: "rgb(201, 203, 207)",
|
||
},
|
||
}
|
||
class e {
|
||
constructor(t) {
|
||
;(this._seed = Date.now()),
|
||
(this.MONTHS = t.MONTHS),
|
||
(this.COLORS = t.COLORS),
|
||
(this.CHART_COLORS = t.CHART_COLORS),
|
||
(this.NAMED_COLORS = [
|
||
this.CHART_COLORS.red,
|
||
this.CHART_COLORS.orange,
|
||
this.CHART_COLORS.yellow,
|
||
this.CHART_COLORS.green,
|
||
this.CHART_COLORS.blue,
|
||
this.CHART_COLORS.purple,
|
||
this.CHART_COLORS.grey,
|
||
])
|
||
}
|
||
valueOrDefault(t, e) {
|
||
return void 0 === t ? e : t
|
||
}
|
||
srand(t) {
|
||
this._seed = t
|
||
}
|
||
rand(t, e) {
|
||
return (
|
||
(t = this.valueOrDefault(t, 0)),
|
||
(e = this.valueOrDefault(e, 0)),
|
||
(this._seed = (9301 * this._seed + 49297) % 233280),
|
||
t + (this._seed / 233280) * (e - t)
|
||
)
|
||
}
|
||
numbers(t) {
|
||
const e = t || {},
|
||
n = this.valueOrDefault(e.min, 0),
|
||
r = this.valueOrDefault(e.max, 100),
|
||
s = this.valueOrDefault(e.from, []),
|
||
i = this.valueOrDefault(e.count, 8),
|
||
a = this.valueOrDefault(e.decimals, 8),
|
||
o = this.valueOrDefault(e.continuity, 1),
|
||
u = Math.pow(10, a) || 0,
|
||
l = []
|
||
let c, h
|
||
for (c = 0; c < i; ++c)
|
||
(h = (s[c] || 0) + this.rand(n, r)),
|
||
this.rand() <= o ? l.push(Math.round(u * h) / u) : l.push(null)
|
||
return l
|
||
}
|
||
points(t) {
|
||
const e = this.numbers(t),
|
||
n = this.numbers(t)
|
||
return e.map((t, e) => ({ x: t, y: n[e] }))
|
||
}
|
||
bubbles(t) {
|
||
return this.points(t).map((e) => ((e.r = this.rand(t.rmin, t.rmax)), e))
|
||
}
|
||
labels(t) {
|
||
const e = t || {},
|
||
n = e.min || 0,
|
||
r = e.max || 100,
|
||
s = (r - n) / (e.count || 8),
|
||
i = e.decimals || 8,
|
||
a = Math.pow(10, i) || 0,
|
||
o = e.prefix || "",
|
||
u = []
|
||
let l
|
||
for (l = n; l < r; l += s) u.push(o + Math.round(a * l) / a)
|
||
return u
|
||
}
|
||
months(t) {
|
||
const e = t || {},
|
||
n = e.count || 12,
|
||
r = e.section,
|
||
s = []
|
||
let i, a
|
||
for (i = 0; i < n; ++i) (a = this.MONTHS[Math.ceil(i) % 12]), s.push(a.substring(0, r))
|
||
return s
|
||
}
|
||
color(t) {
|
||
return this.COLORS[t % this.COLORS.length]
|
||
}
|
||
transparentize(t, e) {
|
||
const n = void 0 === e ? 0.5 : 1 - e
|
||
return ((r = t), new x(r)).alpha(n).rgbString()
|
||
var r
|
||
}
|
||
namedColor(t) {
|
||
return this.NAMED_COLORS[t % this.NAMED_COLORS.length]
|
||
}
|
||
newDate(t) {
|
||
return Sr.now().plus({ days: t }).toJSDate()
|
||
}
|
||
newDateString(t) {
|
||
return Sr.now().plus({ days: t }).toISO()
|
||
}
|
||
parseISODate(t) {
|
||
return Sr.fromISO(t)
|
||
}
|
||
}
|
||
return {
|
||
init: (n) => {
|
||
const r = Object.assign({}, t, n)
|
||
return new e(r)
|
||
},
|
||
}
|
||
})()
|
||
window.ChartUtils = Mr
|
||
})()
|