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
|
|||
|
|
})()
|