@qikdev/vue-ui
Version:
Vue UI component library
2,023 lines • 1.35 MB
JavaScript
import "./vue-ui.css";
import {
defineComponent as Dl,
ref as ct,
toRefs as pd,
onMounted as El,
onBeforeUnmount as bf,
watch as Cr,
computed as sn,
createElementBlock as f,
openBlock as o,
createCommentVNode as v,
renderSlot as H,
normalizeClass as U,
useSlots as kf,
reactive as Wt,
provide as Rr,
resolveComponent as y,
createVNode as c,
Fragment as O,
createBlock as b,
unref as ut,
withCtx as m,
renderList as L,
toDisplayString as k,
createTextVNode as S,
withDirectives as Y,
vShow as gr,
createElementVNode as w,
withModifiers as K,
h as ml,
mergeProps as Ft,
toHandlers as Mt,
normalizeStyle as Be,
resolveDynamicComponent as Lt,
vModelSelect as gt,
pushScopeId as Ze,
popScopeId as Xe,
getCurrentScope as wf,
onScopeDispose as xf,
getCurrentInstance as Sf,
Teleport as yd,
Transition as Tf,
vModelText as fe,
withKeys as xe,
TransitionGroup as Of,
nextTick as gd,
vModelDynamic as Kn,
resolveDirective as Vf,
} from "vue";
import { EventDispatcher as vd } from "@qikdev/sdk";
const Cf = "0.2.326";
class Gt extends Error {}
class Df extends Gt {
constructor(t) {
super(`Invalid DateTime: ${t.toMessage()}`);
}
}
class Ef extends Gt {
constructor(t) {
super(`Invalid Interval: ${t.toMessage()}`);
}
}
class Ff extends Gt {
constructor(t) {
super(`Invalid Duration: ${t.toMessage()}`);
}
}
class xn extends Gt {}
class _d extends Gt {
constructor(t) {
super(`Invalid unit ${t}`);
}
}
class Ke extends Gt {}
class St extends Gt {
constructor() {
super("Zone is an abstract class");
}
}
const R = "numeric",
st = "short",
qe = "long",
hl = {
year: R,
month: R,
day: R,
},
bd = {
year: R,
month: st,
day: R,
},
Mf = {
year: R,
month: st,
day: R,
weekday: st,
},
kd = {
year: R,
month: qe,
day: R,
},
wd = {
year: R,
month: qe,
day: R,
weekday: qe,
},
xd = {
hour: R,
minute: R,
},
Sd = {
hour: R,
minute: R,
second: R,
},
Td = {
hour: R,
minute: R,
second: R,
timeZoneName: st,
},
Od = {
hour: R,
minute: R,
second: R,
timeZoneName: qe,
},
Vd = {
hour: R,
minute: R,
hourCycle: "h23",
},
Cd = {
hour: R,
minute: R,
second: R,
hourCycle: "h23",
},
Dd = {
hour: R,
minute: R,
second: R,
hourCycle: "h23",
timeZoneName: st,
},
Ed = {
hour: R,
minute: R,
second: R,
hourCycle: "h23",
timeZoneName: qe,
},
Fd = {
year: R,
month: R,
day: R,
hour: R,
minute: R,
},
Md = {
year: R,
month: R,
day: R,
hour: R,
minute: R,
second: R,
},
Id = {
year: R,
month: st,
day: R,
hour: R,
minute: R,
},
Ad = {
year: R,
month: st,
day: R,
hour: R,
minute: R,
second: R,
},
If = {
year: R,
month: st,
day: R,
weekday: st,
hour: R,
minute: R,
},
Ld = {
year: R,
month: qe,
day: R,
hour: R,
minute: R,
timeZoneName: st,
},
$d = {
year: R,
month: qe,
day: R,
hour: R,
minute: R,
second: R,
timeZoneName: st,
},
Nd = {
year: R,
month: qe,
day: R,
weekday: qe,
hour: R,
minute: R,
timeZoneName: qe,
},
Ud = {
year: R,
month: qe,
day: R,
weekday: qe,
hour: R,
minute: R,
second: R,
timeZoneName: qe,
};
function ie(e) {
return typeof e > "u";
}
function Jt(e) {
return typeof e == "number";
}
function Dr(e) {
return typeof e == "number" && e % 1 === 0;
}
function Af(e) {
return typeof e == "string";
}
function Lf(e) {
return Object.prototype.toString.call(e) === "[object Date]";
}
function Rd() {
try {
return typeof Intl < "u" && !!Intl.RelativeTimeFormat;
} catch {
return !1;
}
}
function $f(e) {
return Array.isArray(e) ? e : [e];
}
function sa(e, t, n) {
if (e.length !== 0)
return e.reduce((i, s) => {
const r = [t(s), s];
return i && n(i[0], r[0]) === i[0] ? i : r;
}, null)[1];
}
function Nf(e, t) {
return t.reduce((n, i) => ((n[i] = e[i]), n), {});
}
function on(e, t) {
return Object.prototype.hasOwnProperty.call(e, t);
}
function pt(e, t, n) {
return Dr(e) && e >= t && e <= n;
}
function Uf(e, t) {
return e - t * Math.floor(e / t);
}
function Oe(e, t = 2) {
const n = e < 0;
let i;
return (
n
? (i = "-" + ("" + -e).padStart(t, "0"))
: (i = ("" + e).padStart(t, "0")),
i
);
}
function Ot(e) {
if (!(ie(e) || e === null || e === "")) return parseInt(e, 10);
}
function Rt(e) {
if (!(ie(e) || e === null || e === "")) return parseFloat(e);
}
function Fl(e) {
if (!(ie(e) || e === null || e === "")) {
const t = parseFloat("0." + e) * 1e3;
return Math.floor(t);
}
}
function Ml(e, t, n = !1) {
const i = 10 ** t;
return (n ? Math.trunc : Math.round)(e * i) / i;
}
function $n(e) {
return e % 4 === 0 && (e % 100 !== 0 || e % 400 === 0);
}
function En(e) {
return $n(e) ? 366 : 365;
}
function vr(e, t) {
const n = Uf(t - 1, 12) + 1,
i = e + (t - n) / 12;
return n === 2
? $n(i)
? 29
: 28
: [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][n - 1];
}
function Il(e) {
let t = Date.UTC(
e.year,
e.month - 1,
e.day,
e.hour,
e.minute,
e.second,
e.millisecond,
);
return (
e.year < 100 &&
e.year >= 0 &&
((t = new Date(t)), t.setUTCFullYear(t.getUTCFullYear() - 1900)),
+t
);
}
function _r(e) {
const t =
(e + Math.floor(e / 4) - Math.floor(e / 100) + Math.floor(e / 400)) % 7,
n = e - 1,
i = (n + Math.floor(n / 4) - Math.floor(n / 100) + Math.floor(n / 400)) % 7;
return t === 4 || i === 3 ? 53 : 52;
}
function pl(e) {
return e > 99 ? e : e > 60 ? 1900 + e : 2e3 + e;
}
function Pd(e, t, n, i = null) {
const s = new Date(e),
r = {
hourCycle: "h23",
year: "numeric",
month: "2-digit",
day: "2-digit",
hour: "2-digit",
minute: "2-digit",
};
i && (r.timeZone = i);
const l = { timeZoneName: t, ...r },
a = new Intl.DateTimeFormat(n, l)
.formatToParts(s)
.find((u) => u.type.toLowerCase() === "timezonename");
return a ? a.value : null;
}
function Er(e, t) {
let n = parseInt(e, 10);
Number.isNaN(n) && (n = 0);
const i = parseInt(t, 10) || 0,
s = n < 0 || Object.is(n, -0) ? -i : i;
return n * 60 + s;
}
function jd(e) {
const t = Number(e);
if (typeof e == "boolean" || e === "" || Number.isNaN(t))
throw new Ke(`Invalid unit value ${e}`);
return t;
}
function br(e, t) {
const n = {};
for (const i in e)
if (on(e, i)) {
const s = e[i];
if (s == null) continue;
n[t(i)] = jd(s);
}
return n;
}
function kr(e, t) {
const n = Math.trunc(Math.abs(e / 60)),
i = Math.trunc(Math.abs(e % 60)),
s = e >= 0 ? "+" : "-";
switch (t) {
case "short":
return `${s}${Oe(n, 2)}:${Oe(i, 2)}`;
case "narrow":
return `${s}${n}${i > 0 ? `:${i}` : ""}`;
case "techie":
return `${s}${Oe(n, 2)}${Oe(i, 2)}`;
default:
throw new RangeError(
`Value format ${t} is out of range for property format`,
);
}
}
function Fr(e) {
return Nf(e, ["hour", "minute", "second", "millisecond"]);
}
const Rf =
/[A-Za-z_+-]{1,256}(:?\/[A-Za-z0-9_+-]{1,256}(\/[A-Za-z0-9_+-]{1,256})?)?/,
Pf = [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December",
],
qd = [
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec",
],
jf = ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"];
function Bd(e) {
switch (e) {
case "narrow":
return [...jf];
case "short":
return [...qd];
case "long":
return [...Pf];
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 zd = [
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
"Sunday",
],
Hd = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"],
qf = ["M", "T", "W", "T", "F", "S", "S"];
function Wd(e) {
switch (e) {
case "narrow":
return [...qf];
case "short":
return [...Hd];
case "long":
return [...zd];
case "numeric":
return ["1", "2", "3", "4", "5", "6", "7"];
default:
return null;
}
}
const Jd = ["AM", "PM"],
Bf = ["Before Christ", "Anno Domini"],
zf = ["BC", "AD"],
Hf = ["B", "A"];
function Gd(e) {
switch (e) {
case "narrow":
return [...Hf];
case "short":
return [...zf];
case "long":
return [...Bf];
default:
return null;
}
}
function Wf(e) {
return Jd[e.hour < 12 ? 0 : 1];
}
function Jf(e, t) {
return Wd(t)[e.weekday - 1];
}
function Gf(e, t) {
return Bd(t)[e.month - 1];
}
function Kf(e, t) {
return Gd(t)[e.year < 0 ? 0 : 1];
}
function Yf(e, t, n = "always", i = !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."],
},
r = ["hours", "minutes", "seconds"].indexOf(e) === -1;
if (n === "auto" && r) {
const p = e === "days";
switch (t) {
case 1:
return p ? "tomorrow" : `next ${s[e][0]}`;
case -1:
return p ? "yesterday" : `last ${s[e][0]}`;
case 0:
return p ? "today" : `this ${s[e][0]}`;
}
}
const l = Object.is(t, -0) || t < 0,
a = Math.abs(t),
u = a === 1,
d = s[e],
h = i ? (u ? d[1] : d[2] || d[1]) : u ? s[e][0] : e;
return l ? `${a} ${h} ago` : `in ${a} ${h}`;
}
function la(e, t) {
let n = "";
for (const i of e) i.literal ? (n += i.val) : (n += t(i.val));
return n;
}
const Zf = {
D: hl,
DD: bd,
DDD: kd,
DDDD: wd,
t: xd,
tt: Sd,
ttt: Td,
tttt: Od,
T: Vd,
TT: Cd,
TTT: Dd,
TTTT: Ed,
f: Fd,
ff: Id,
fff: Ld,
ffff: Nd,
F: Md,
FF: Ad,
FFF: $d,
FFFF: Ud,
};
class Ue {
static create(t, n = {}) {
return new Ue(t, n);
}
static parseFormat(t) {
let n = null,
i = "",
s = !1;
const r = [];
for (let l = 0; l < t.length; l++) {
const a = t.charAt(l);
a === "'"
? (i.length > 0 && r.push({ literal: s, val: i }),
(n = null),
(i = ""),
(s = !s))
: s || a === n
? (i += a)
: (i.length > 0 && r.push({ literal: !1, val: i }), (i = a), (n = a));
}
return i.length > 0 && r.push({ literal: s, val: i }), r;
}
static macroTokenToFormatOpts(t) {
return Zf[t];
}
constructor(t, n) {
(this.opts = n), (this.loc = t), (this.systemLoc = null);
}
formatWithSystemDefault(t, n) {
return (
this.systemLoc === null &&
(this.systemLoc = this.loc.redefaultToSystem()),
this.systemLoc.dtFormatter(t, { ...this.opts, ...n }).format()
);
}
formatDateTime(t, n = {}) {
return this.loc.dtFormatter(t, { ...this.opts, ...n }).format();
}
formatDateTimeParts(t, n = {}) {
return this.loc.dtFormatter(t, { ...this.opts, ...n }).formatToParts();
}
resolvedOptions(t, n = {}) {
return this.loc.dtFormatter(t, { ...this.opts, ...n }).resolvedOptions();
}
num(t, n = 0) {
if (this.opts.forceSimple) return Oe(t, n);
const i = { ...this.opts };
return n > 0 && (i.padTo = n), this.loc.numberFormatter(i).format(t);
}
formatDateTimeFromString(t, n) {
const i = this.loc.listingMode() === "en",
s = this.loc.outputCalendar && this.loc.outputCalendar !== "gregory",
r = (_, x) => this.loc.extract(t, _, x),
l = (_) =>
t.isOffsetFixed && t.offset === 0 && _.allowZ
? "Z"
: t.isValid
? t.zone.formatOffset(t.ts, _.format)
: "",
a = () =>
i ? Wf(t) : r({ hour: "numeric", hourCycle: "h12" }, "dayperiod"),
u = (_, x) =>
i
? Gf(t, _)
: r(x ? { month: _ } : { month: _, day: "numeric" }, "month"),
d = (_, x) =>
i
? Jf(t, _)
: r(
x
? { weekday: _ }
: { weekday: _, month: "long", day: "numeric" },
"weekday",
),
h = (_) => {
const x = Ue.macroTokenToFormatOpts(_);
return x ? this.formatWithSystemDefault(t, x) : _;
},
p = (_) => (i ? Kf(t, _) : r({ era: _ }, "era")),
g = (_) => {
switch (_) {
// ms
case "S":
return this.num(t.millisecond);
case "u":
// falls through
case "SSS":
return this.num(t.millisecond, 3);
// seconds
case "s":
return this.num(t.second);
case "ss":
return this.num(t.second, 2);
// fractional seconds
case "uu":
return this.num(Math.floor(t.millisecond / 10), 2);
case "uuu":
return this.num(Math.floor(t.millisecond / 100));
// minutes
case "m":
return this.num(t.minute);
case "mm":
return this.num(t.minute, 2);
// hours
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);
// offset
case "Z":
return l({ format: "narrow", allowZ: this.opts.allowZ });
case "ZZ":
return l({ format: "short", allowZ: this.opts.allowZ });
case "ZZZ":
return l({ 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,
});
// zone
case "z":
return t.zoneName;
// meridiems
case "a":
return a();
// dates
case "d":
return s ? r({ day: "numeric" }, "day") : this.num(t.day);
case "dd":
return s ? r({ day: "2-digit" }, "day") : this.num(t.day, 2);
// weekdays - standalone
case "c":
return this.num(t.weekday);
case "ccc":
return d("short", !0);
case "cccc":
return d("long", !0);
case "ccccc":
return d("narrow", !0);
// weekdays - format
case "E":
return this.num(t.weekday);
case "EEE":
return d("short", !1);
case "EEEE":
return d("long", !1);
case "EEEEE":
return d("narrow", !1);
// months - standalone
case "L":
return s
? r({ month: "numeric", day: "numeric" }, "month")
: this.num(t.month);
case "LL":
return s
? r({ month: "2-digit", day: "numeric" }, "month")
: this.num(t.month, 2);
case "LLL":
return u("short", !0);
case "LLLL":
return u("long", !0);
case "LLLLL":
return u("narrow", !0);
// months - format
case "M":
return s ? r({ month: "numeric" }, "month") : this.num(t.month);
case "MM":
return s ? r({ month: "2-digit" }, "month") : this.num(t.month, 2);
case "MMM":
return u("short", !1);
case "MMMM":
return u("long", !1);
case "MMMMM":
return u("narrow", !1);
// years
case "y":
return s ? r({ year: "numeric" }, "year") : this.num(t.year);
case "yy":
return s
? r({ year: "2-digit" }, "year")
: this.num(t.year.toString().slice(-2), 2);
case "yyyy":
return s ? r({ year: "numeric" }, "year") : this.num(t.year, 4);
case "yyyyyy":
return s ? r({ year: "numeric" }, "year") : this.num(t.year, 6);
// eras
case "G":
return p("short");
case "GG":
return p("long");
case "GGGGG":
return p("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 h(_);
}
};
return la(Ue.parseFormat(n), g);
}
formatDurationFromString(t, n) {
const i = (u) => {
switch (u[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;
}
},
s = (u) => (d) => {
const h = i(d);
return h ? this.num(u.get(h), d.length) : d;
},
r = Ue.parseFormat(n),
l = r.reduce((u, { literal: d, val: h }) => (d ? u : u.concat(h)), []),
a = t.shiftTo(...l.map(i).filter((u) => u));
return la(r, s(a));
}
}
class it {
constructor(t, n) {
(this.reason = t), (this.explanation = n);
}
toMessage() {
return this.explanation
? `${this.reason}: ${this.explanation}`
: this.reason;
}
}
class Nn {
/**
* The type of zone
* @abstract
* @type {string}
*/
get type() {
throw new St();
}
/**
* The name of this zone.
* @abstract
* @type {string}
*/
get name() {
throw new St();
}
/**
* Returns whether the offset is known to be fixed for the whole year.
* @abstract
* @type {boolean}
*/
get isUniversal() {
throw new St();
}
/**
* Returns the offset's common name (such as EST) at the specified timestamp
* @abstract
* @param {number} ts - Epoch milliseconds for which to get the name
* @param {Object} opts - Options to affect the format
* @param {string} opts.format - What style of offset to return. Accepts 'long' or 'short'.
* @param {string} opts.locale - What locale to return the offset name in.
* @return {string}
*/
offsetName(t, n) {
throw new St();
}
/**
* Returns the offset's value as a string
* @abstract
* @param {number} ts - Epoch milliseconds for which to get the offset
* @param {string} format - What style of offset to return.
* Accepts 'narrow', 'short', or 'techie'. Returning '+6', '+06:00', or '+0600' respectively
* @return {string}
*/
formatOffset(t, n) {
throw new St();
}
/**
* Return the offset in minutes for this zone at the specified timestamp.
* @abstract
* @param {number} ts - Epoch milliseconds for which to compute the offset
* @return {number}
*/
offset(t) {
throw new St();
}
/**
* Return whether this Zone is equal to another zone
* @abstract
* @param {Zone} otherZone - the zone to compare
* @return {boolean}
*/
equals(t) {
throw new St();
}
/**
* Return whether this Zone is valid.
* @abstract
* @type {boolean}
*/
get isValid() {
throw new St();
}
}
let Pr = null;
class Al extends Nn {
/**
* Get a singleton instance of the local zone
* @return {SystemZone}
*/
static get instance() {
return Pr === null && (Pr = new Al()), Pr;
}
/** @override **/
get type() {
return "system";
}
/** @override **/
get name() {
return new Intl.DateTimeFormat().resolvedOptions().timeZone;
}
/** @override **/
get isUniversal() {
return !1;
}
/** @override **/
offsetName(t, { format: n, locale: i }) {
return Pd(t, n, i);
}
/** @override **/
formatOffset(t, n) {
return kr(this.offset(t), n);
}
/** @override **/
offset(t) {
return -new Date(t).getTimezoneOffset();
}
/** @override **/
equals(t) {
return t.type === "system";
}
/** @override **/
get isValid() {
return !0;
}
}
let dr = {};
function Xf(e) {
return (
dr[e] ||
(dr[e] = new Intl.DateTimeFormat("en-US", {
hour12: !1,
timeZone: e,
year: "numeric",
month: "2-digit",
day: "2-digit",
hour: "2-digit",
minute: "2-digit",
second: "2-digit",
era: "short",
})),
dr[e]
);
}
const Qf = {
year: 0,
month: 1,
day: 2,
era: 3,
hour: 4,
minute: 5,
second: 6,
};
function em(e, t) {
const n = e.format(t).replace(/\u200E/g, ""),
i = /(\d+)\/(\d+)\/(\d+) (AD|BC),? (\d+):(\d+):(\d+)/.exec(n),
[, s, r, l, a, u, d, h] = i;
return [l, s, r, a, u, d, h];
}
function tm(e, t) {
const n = e.formatToParts(t),
i = [];
for (let s = 0; s < n.length; s++) {
const { type: r, value: l } = n[s],
a = Qf[r];
r === "era" ? (i[a] = l) : ie(a) || (i[a] = parseInt(l, 10));
}
return i;
}
let Yn = {};
class vt extends Nn {
/**
* @param {string} name - Zone name
* @return {IANAZone}
*/
static create(t) {
return Yn[t] || (Yn[t] = new vt(t)), Yn[t];
}
/**
* Reset local caches. Should only be necessary in testing scenarios.
* @return {void}
*/
static resetCache() {
(Yn = {}), (dr = {});
}
/**
* Returns whether the provided string is a valid specifier. This only checks the string's format, not that the specifier identifies a known zone; see isValidZone for that.
* @param {string} s - The string to check validity on
* @example IANAZone.isValidSpecifier("America/New_York") //=> true
* @example IANAZone.isValidSpecifier("Sport~~blorp") //=> false
* @deprecated This method returns false for some valid IANA names. Use isValidZone instead.
* @return {boolean}
*/
static isValidSpecifier(t) {
return this.isValidZone(t);
}
/**
* Returns whether the provided string identifies a real zone
* @param {string} zone - The string to check
* @example IANAZone.isValidZone("America/New_York") //=> true
* @example IANAZone.isValidZone("Fantasia/Castle") //=> false
* @example IANAZone.isValidZone("Sport~~blorp") //=> false
* @return {boolean}
*/
static isValidZone(t) {
if (!t) return !1;
try {
return new Intl.DateTimeFormat("en-US", { timeZone: t }).format(), !0;
} catch {
return !1;
}
}
constructor(t) {
super(), (this.zoneName = t), (this.valid = vt.isValidZone(t));
}
/** @override **/
get type() {
return "iana";
}
/** @override **/
get name() {
return this.zoneName;
}
/** @override **/
get isUniversal() {
return !1;
}
/** @override **/
offsetName(t, { format: n, locale: i }) {
return Pd(t, n, i, this.name);
}
/** @override **/
formatOffset(t, n) {
return kr(this.offset(t), n);
}
/** @override **/
offset(t) {
const n = new Date(t);
if (isNaN(n)) return NaN;
const i = Xf(this.name);
let [s, r, l, a, u, d, h] = i.formatToParts ? tm(i, n) : em(i, n);
a === "BC" && (s = -Math.abs(s) + 1);
const g = Il({
year: s,
month: r,
day: l,
hour: u === 24 ? 0 : u,
minute: d,
second: h,
millisecond: 0,
});
let _ = +n;
const x = _ % 1e3;
return (_ -= x >= 0 ? x : 1e3 + x), (g - _) / (60 * 1e3);
}
/** @override **/
equals(t) {
return t.type === "iana" && t.name === this.name;
}
/** @override **/
get isValid() {
return this.valid;
}
}
let jr = null;
class $e extends Nn {
/**
* Get a singleton instance of UTC
* @return {FixedOffsetZone}
*/
static get utcInstance() {
return jr === null && (jr = new $e(0)), jr;
}
/**
* Get an instance with a specified offset
* @param {number} offset - The offset in minutes
* @return {FixedOffsetZone}
*/
static instance(t) {
return t === 0 ? $e.utcInstance : new $e(t);
}
/**
* Get an instance of FixedOffsetZone from a UTC offset string, like "UTC+6"
* @param {string} s - The offset string to parse
* @example FixedOffsetZone.parseSpecifier("UTC+6")
* @example FixedOffsetZone.parseSpecifier("UTC+06")
* @example FixedOffsetZone.parseSpecifier("UTC-6:00")
* @return {FixedOffsetZone}
*/
static parseSpecifier(t) {
if (t) {
const n = t.match(/^utc(?:([+-]\d{1,2})(?::(\d{2}))?)?$/i);
if (n) return new $e(Er(n[1], n[2]));
}
return null;
}
constructor(t) {
super(), (this.fixed = t);
}
/** @override **/
get type() {
return "fixed";
}
/** @override **/
get name() {
return this.fixed === 0 ? "UTC" : `UTC${kr(this.fixed, "narrow")}`;
}
/** @override **/
offsetName() {
return this.name;
}
/** @override **/
formatOffset(t, n) {
return kr(this.fixed, n);
}
/** @override **/
get isUniversal() {
return !0;
}
/** @override **/
offset() {
return this.fixed;
}
/** @override **/
equals(t) {
return t.type === "fixed" && t.fixed === this.fixed;
}
/** @override **/
get isValid() {
return !0;
}
}
class nm extends Nn {
constructor(t) {
super(), (this.zoneName = t);
}
/** @override **/
get type() {
return "invalid";
}
/** @override **/
get name() {
return this.zoneName;
}
/** @override **/
get isUniversal() {
return !1;
}
/** @override **/
offsetName() {
return null;
}
/** @override **/
formatOffset() {
return "";
}
/** @override **/
offset() {
return NaN;
}
/** @override **/
equals() {
return !1;
}
/** @override **/
get isValid() {
return !1;
}
}
function Ct(e, t) {
if (ie(e) || e === null) return t;
if (e instanceof Nn) return e;
if (Af(e)) {
const n = e.toLowerCase();
return n === "local" || n === "system"
? t
: n === "utc" || n === "gmt"
? $e.utcInstance
: $e.parseSpecifier(n) || vt.create(e);
} else
return Jt(e)
? $e.instance(e)
: typeof e == "object" && e.offset && typeof e.offset == "number"
? e
: new nm(e);
}
let aa = () => Date.now(),
oa = "system",
ua = null,
da = null,
ca = null,
fa;
class Ce {
/**
* Get the callback for returning the current timestamp.
* @type {function}
*/
static get now() {
return aa;
}
/**
* Set the callback for returning the current timestamp.
* The function should return a number, which will be interpreted as an Epoch millisecond count
* @type {function}
* @example Settings.now = () => Date.now() + 3000 // pretend it is 3 seconds in the future
* @example Settings.now = () => 0 // always pretend it's Jan 1, 1970 at midnight in UTC time
*/
static set now(t) {
aa = t;
}
/**
* Set the default time zone to create DateTimes in. Does not affect existing instances.
* Use the value "system" to reset this value to the system's time zone.
* @type {string}
*/
static set defaultZone(t) {
oa = t;
}
/**
* Get the default time zone object currently used to create DateTimes. Does not affect existing instances.
* The default value is the system's time zone (the one set on the machine that runs this code).
* @type {Zone}
*/
static get defaultZone() {
return Ct(oa, Al.instance);
}
/**
* Get the default locale to create DateTimes with. Does not affect existing instances.
* @type {string}
*/
static get defaultLocale() {
return ua;
}
/**
* Set the default locale to create DateTimes with. Does not affect existing instances.
* @type {string}
*/
static set defaultLocale(t) {
ua = t;
}
/**
* Get the default numbering system to create DateTimes with. Does not affect existing instances.
* @type {string}
*/
static get defaultNumberingSystem() {
return da;
}
/**
* Set the default numbering system to create DateTimes with. Does not affect existing instances.
* @type {string}
*/
static set defaultNumberingSystem(t) {
da = t;
}
/**
* Get the default output calendar to create DateTimes with. Does not affect existing instances.
* @type {string}
*/
static get defaultOutputCalendar() {
return ca;
}
/**
* Set the default output calendar to create DateTimes with. Does not affect existing instances.
* @type {string}
*/
static set defaultOutputCalendar(t) {
ca = t;
}
/**
* Get whether Luxon will throw when it encounters invalid DateTimes, Durations, or Intervals
* @type {boolean}
*/
static get throwOnInvalid() {
return fa;
}
/**
* Set whether Luxon will throw when it encounters invalid DateTimes, Durations, or Intervals
* @type {boolean}
*/
static set throwOnInvalid(t) {
fa = t;
}
/**
* Reset Luxon's global caches. Should only be necessary in testing scenarios.
* @return {void}
*/
static resetCaches() {
ve.resetCache(), vt.resetCache();
}
}
let ma = {};
function rm(e, t = {}) {
const n = JSON.stringify([e, t]);
let i = ma[n];
return i || ((i = new Intl.ListFormat(e, t)), (ma[n] = i)), i;
}
let yl = {};
function gl(e, t = {}) {
const n = JSON.stringify([e, t]);
let i = yl[n];
return i || ((i = new Intl.DateTimeFormat(e, t)), (yl[n] = i)), i;
}
let vl = {};
function im(e, t = {}) {
const n = JSON.stringify([e, t]);
let i = vl[n];
return i || ((i = new Intl.NumberFormat(e, t)), (vl[n] = i)), i;
}
let _l = {};
function sm(e, t = {}) {
const { base: n, ...i } = t,
s = JSON.stringify([e, i]);
let r = _l[s];
return r || ((r = new Intl.RelativeTimeFormat(e, t)), (_l[s] = r)), r;
}
let Sn = null;
function lm() {
return Sn || ((Sn = new Intl.DateTimeFormat().resolvedOptions().locale), Sn);
}
function am(e) {
const t = e.indexOf("-u-");
if (t === -1) return [e];
{
let n;
const i = e.substring(0, t);
try {
n = gl(e).resolvedOptions();
} catch {
n = gl(i).resolvedOptions();
}
const { numberingSystem: s, calendar: r } = n;
return [i, s, r];
}
}
function om(e, t, n) {
return (
(n || t) && ((e += "-u"), n && (e += `-ca-${n}`), t && (e += `-nu-${t}`)), e
);
}
function um(e) {
const t = [];
for (let n = 1; n <= 12; n++) {
const i = V.utc(2016, n, 1);
t.push(e(i));
}
return t;
}
function dm(e) {
const t = [];
for (let n = 1; n <= 7; n++) {
const i = V.utc(2016, 11, 13 + n);
t.push(e(i));
}
return t;
}
function Zn(e, t, n, i, s) {
const r = e.listingMode(n);
return r === "error" ? null : r === "en" ? i(t) : s(t);
}
function cm(e) {
return e.numberingSystem && e.numberingSystem !== "latn"
? !1
: e.numberingSystem === "latn" ||
!e.locale ||
e.locale.startsWith("en") ||
new Intl.DateTimeFormat(e.intl).resolvedOptions().numberingSystem ===
"latn";
}
class fm {
constructor(t, n, i) {
(this.padTo = i.padTo || 0), (this.floor = i.floor || !1);
const { padTo: s, floor: r, ...l } = i;
if (!n || Object.keys(l).length > 0) {
const a = { useGrouping: !1, ...i };
i.padTo > 0 && (a.minimumIntegerDigits = i.padTo), (this.inf = im(t, a));
}
}
format(t) {
if (this.inf) {
const n = this.floor ? Math.floor(t) : t;
return this.inf.format(n);
} else {
const n = this.floor ? Math.floor(t) : Ml(t, 3);
return Oe(n, this.padTo);
}
}
}
class mm {
constructor(t, n, i) {
this.opts = i;
let s;
if (t.zone.isUniversal) {
const l = -1 * (t.offset / 60),
a = l >= 0 ? `Etc/GMT+${l}` : `Etc/GMT${l}`;
t.offset !== 0 && vt.create(a).valid
? ((s = a), (this.dt = t))
: ((s = "UTC"),
i.timeZoneName
? (this.dt = t)
: (this.dt =
t.offset === 0 ? t : V.fromMillis(t.ts + t.offset * 60 * 1e3)));
} else
t.zone.type === "system"
? (this.dt = t)
: ((this.dt = t), (s = t.zone.name));
const r = { ...this.opts };
s && (r.timeZone = s), (this.dtf = gl(n, r));
}
format() {
return this.dtf.format(this.dt.toJSDate());
}
formatToParts() {
return this.dtf.formatToParts(this.dt.toJSDate());
}
resolvedOptions() {
return this.dtf.resolvedOptions();
}
}
class hm {
constructor(t, n, i) {
(this.opts = { style: "long", ...i }), !n && Rd() && (this.rtf = sm(t, i));
}
format(t, n) {
return this.rtf
? this.rtf.format(t, n)
: Yf(n, t, this.opts.numeric, this.opts.style !== "long");
}
formatToParts(t, n) {
return this.rtf ? this.rtf.formatToParts(t, n) : [];
}
}
class ve {
static fromOpts(t) {
return ve.create(
t.locale,
t.numberingSystem,
t.outputCalendar,
t.defaultToEN,
);
}
static create(t, n, i, s = !1) {
const r = t || Ce.defaultLocale,
l = r || (s ? "en-US" : lm()),
a = n || Ce.defaultNumberingSystem,
u = i || Ce.defaultOutputCalendar;
return new ve(l, a, u, r);
}
static resetCache() {
(Sn = null), (yl = {}), (vl = {}), (_l = {});
}
static fromObject({ locale: t, numberingSystem: n, outputCalendar: i } = {}) {
return ve.create(t, n, i);
}
constructor(t, n, i, s) {
const [r, l, a] = am(t);
(this.locale = r),
(this.numberingSystem = n || l || null),
(this.outputCalendar = i || a || null),
(this.intl = om(this.locale, this.numberingSystem, this.outputCalendar)),
(this.weekdaysCache = { format: {}, standalone: {} }),
(this.monthsCache = { format: {}, standalone: {} }),
(this.meridiemCache = null),
(this.eraCache = {}),
(this.specifiedLocale = s),
(this.fastNumbersCached = null);
}
get fastNumbers() {
return (
this.fastNumbersCached == null && (this.fastNumbersCached = cm(this)),
this.fastNumbersCached
);
}
listingMode() {
const t = this.isEnglish(),
n =
(this.numberingSystem === null || this.numberingSystem === "latn") &&
(this.outputCalendar === null || this.outputCalendar === "gregory");
return t && n ? "en" : "intl";
}
clone(t) {
return !t || Object.getOwnPropertyNames(t).length === 0
? this
: ve.create(
t.locale || this.specifiedLocale,
t.numberingSystem || this.numberingSystem,
t.outputCalendar || this.outputCalendar,
t.defaultToEN || !1,
);
}
redefaultToEN(t = {}) {
return this.clone({ ...t, defaultToEN: !0 });
}
redefaultToSystem(t = {}) {
return this.clone({ ...t, defaultToEN: !1 });
}
months(t, n = !1, i = !0) {
return Zn(this, t, i, Bd, () => {
const s = n ? { month: t, day: "numeric" } : { month: t },
r = n ? "format" : "standalone";
return (
this.monthsCache[r][t] ||
(this.monthsCache[r][t] = um((l) => this.extract(l, s, "month"))),
this.monthsCache[r][t]
);
});
}
weekdays(t, n = !1, i = !0) {
return Zn(this, t, i, Wd, () => {
const s = n
? { weekday: t, year: "numeric", month: "long", day: "numeric" }
: { weekday: t },
r = n ? "format" : "standalone";
return (
this.weekdaysCache[r][t] ||
(this.weekdaysCache[r][t] = dm((l) => this.extract(l, s, "weekday"))),
this.weekdaysCache[r][t]
);
});
}
meridiems(t = !0) {
return Zn(
this,
void 0,
t,
() => Jd,
() => {
if (!this.meridiemCache) {
const n = { hour: "numeric", hourCycle: "h12" };
this.meridiemCache = [
V.utc(2016, 11, 13, 9),
V.utc(2016, 11, 13, 19),
].map((i) => this.extract(i, n, "dayperiod"));
}
return this.meridiemCache;
},
);
}
eras(t, n = !0) {
return Zn(this, t, n, Gd, () => {
const i = { era: t };
return (
this.eraCache[t] ||
(this.eraCache[t] = [V.utc(-40, 1, 1), V.utc(2017, 1, 1)].map((s) =>
this.extract(s, i, "era"),
)),
this.eraCache[t]
);
});
}
extract(t, n, i) {
const s = this.dtFormatter(t, n),
r = s.formatToParts(),
l = r.find((a) => a.type.toLowerCase() === i);
return l ? l.value : null;
}
numberFormatter(t = {}) {
return new fm(this.intl, t.forceSimple || this.fastNumbers, t);
}
dtFormatter(t, n = {}) {
return new mm(t, this.intl, n);
}
relFormatter(t = {}) {
return new hm(this.intl, this.isEnglish(), t);
}
listFormatter(t = {}) {
return rm(this.intl, t);
}
isEnglish() {
return (
this.locale === "en" ||
this.locale.toLowerCase() === "en-us" ||
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 cn(...e) {
const t = e.reduce((n, i) => n + i.source, "");
return RegExp(`^${t}$`);
}
function Kt(...e) {
return (t) =>
e
.reduce(
([n, i, s], r) => {
const [l, a, u] = r(t, s);
return [{ ...n, ...l }, i || a, u];
},
[{}, null, 1],
)
.slice(0, 2);
}
function fn(e, ...t) {
if (e == null) return [null, null];
for (const [n, i] of t) {
const s = n.exec(e);
if (s) return i(s);
}
return [null, null];
}
function Kd(...e) {
return (t, n) => {
const i = {};
let s;
for (s = 0; s < e.length; s++) i[e[s]] = Ot(t[n + s]);
return [i, null, n + s];
};
}
const Yd = /(?:(Z)|([+-]\d\d)(?::?(\d\d))?)/,
Ll = /(\d\d)(?::?(\d\d)(?::?(\d\d)(?:[.,](\d{1,30}))?)?)?/,
Zd = RegExp(`${Ll.source}${Yd.source}?`),
$l = RegExp(`(?:T${Zd.source})?`),
pm = /([+-]\d{6}|\d{4})(?:-?(\d\d)(?:-?(\d\d))?)?/,
ym = /(\d{4})-?W(\d\d)(?:-?(\d))?/,
gm = /(\d{4})-?(\d{3})/,
vm = Kd("weekYear", "weekNumber", "weekDay"),
_m = Kd("year", "ordinal"),
bm = /(\d{4})-(\d\d)-(\d\d)/,
Xd = RegExp(`${Ll.source} ?(?:${Yd.source}|(${Rf.source}))?`),
km = RegExp(`(?: ${Xd.source})?`);
function ln(e, t, n) {
const i = e[t];
return ie(i) ? n : Ot(i);
}
function Qd(e, t) {
return [
{
year: ln(e, t),
month: ln(e, t + 1, 1),
day: ln(e, t + 2, 1),
},
null,
t + 3,
];
}
function Yt(e, t) {
return [
{
hours: ln(e, t, 0),
minutes: ln(e, t + 1, 0),
seconds: ln(e, t + 2, 0),
milliseconds: Fl(e[t + 3]),
},
null,
t + 4,
];
}
function mn(e, t) {
const n = !e[t] && !e[t + 1],
i = Er(e[t + 1], e[t + 2]),
s = n ? null : $e.instance(i);
return [{}, s, t + 3];
}
function ec(e, t) {
const n = e[t] ? vt.create(e[t]) : null;
return [{}, n, t + 1];
}
const wm = RegExp(`^T?${Ll.source}$`),
xm =
/^-?P(?:(?:(-?\d{1,9}(?:\.\d{1,9})?)Y)?(?:(-?\d{1,9}(?:\.\d{1,9})?)M)?(?:(-?\d{1,9}(?:\.\d{1,9})?)W)?(?:(-?\d{1,9}(?:\.\d{1,9})?)D)?(?:T(?:(-?\d{1,9}(?:\.\d{1,9})?)H)?(?:(-?\d{1,9}(?:\.\d{1,9})?)M)?(?:(-?\d{1,20})(?:[.,](-?\d{1,9}))?S)?)?)$/;
function Sm(e) {
const [t, n, i, s, r, l, a, u, d] = e,
h = t[0] === "-",
p = u && u[0] === "-",
g = (_, x = !1) => (_ !== void 0 && (x || (_ && h)) ? -_ : _);
return [
{
years: g(Rt(n)),
months: g(Rt(i)),
weeks: g(Rt(s)),
days: g(Rt(r)),
hours: g(Rt(l)),
minutes: g(Rt(a)),
seconds: g(Rt(u), u === "-0"),
milliseconds: g(Fl(d), p),
},
];
}
const Tm = {
GMT: 0,
EDT: -4 * 60,
EST: -5 * 60,
CDT: -5 * 60,
CST: -6 * 60,
MDT: -6 * 60,
MST: -7 * 60,
PDT: -7 * 60,
PST: -8 * 60,
};
function Nl(e, t, n, i, s, r, l) {
const a = {
year: t.length === 2 ? pl(Ot(t)) : Ot(t),
month: qd.indexOf(n) + 1,
day: Ot(i),
hour: Ot(s),
minute: Ot(r),
};
return (
l && (a.second = Ot(l)),
e && (a.weekday = e.length > 3 ? zd.indexOf(e) + 1 : Hd.indexOf(e) + 1),
a
);
}
const Om =
/^(?:(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 Vm(e) {
const [, t, n, i, s, r, l, a, u, d, h, p] = e,
g = Nl(t, s, i, n, r, l, a);
let _;
return u ? (_ = Tm[u]) : d ? (_ = 0) : (_ = Er(h, p)), [g, new $e(_)];
}
function Cm(e) {
return e
.replace(/\([^)]*\)|[\n\t]/g, " ")
.replace(/(\s\s+)/g, " ")
.trim();
}
const Dm =
/^(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$/,
Em =
/^(Monday|Tuesday|Wedsday|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$/,
Fm =
/^(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 ha(e) {
const [, t, n, i, s, r, l, a] = e;
return [Nl(t, s, i, n, r, l, a), $e.utcInstance];
}
function Mm(e) {
const [, t, n, i, s, r, l, a] = e;
return [Nl(t, a, n, i, s, r, l), $e.utcInstance];
}
const Im = cn(pm, $l),
Am = cn(ym, $l),
Lm = cn(gm, $l),
$m = cn(Zd),
Nm = Kt(Qd, Yt, mn),
Um = Kt(vm, Yt, mn),
Rm = Kt(_m, Yt, mn),
Pm = Kt(Yt, mn);
function jm(e) {
return fn(e, [Im, Nm], [Am, Um], [Lm, Rm], [$m, Pm]);
}
function qm(e) {
return fn(Cm(e), [Om, Vm]);
}
function Bm(e) {
return fn(e, [Dm, ha], [Em, ha], [Fm, Mm]);
}
function zm(e) {
return fn(e, [xm, Sm]);
}
const Hm = Kt(Yt);
function Wm(e) {
return fn(e, [wm, Hm]);
}
const Jm = cn(bm, km),
Gm = cn(Xd),
Km = Kt(Qd, Yt, mn, ec),
Ym = Kt(Yt, mn, ec);
function Zm(e) {
return fn(e, [Jm, Km], [Gm, Ym]);
}
const Xm = "Invalid Duration",
tc = {
weeks: {
days: 7,
hours: 7 * 24,
minutes: 7 * 24 * 60,
seconds: 7 * 24 * 60 * 60,
milliseconds: 7 * 24 * 60 * 60 * 1e3,
},
days: {
hours: 24,
minutes: 24 * 60,
seconds: 24 * 60 * 60,
milliseconds: 24 * 60 * 60 * 1e3,
},
hours: { minutes: 60, seconds: 60 * 60, milliseconds: 60 * 60 * 1e3 },
minutes: { seconds: 60, milliseconds: 60 * 1e3 },
seconds: { milliseconds: 1e3 },
},
Qm = {
years: {
quarters: 4,
months: 12,
weeks: 52,
days: 365,
hours: 365 * 24,
minutes: 365 * 24 * 60,
seconds: 365 * 24 * 60 * 60,
milliseconds: 365 * 24 * 60 * 60 * 1e3,
},
quarters: {
months: 3,
weeks: 13,
days: 91,
hours: 91 * 24,
minutes: 91 * 24 * 60,
seconds: 91 * 24 * 60 * 60,
milliseconds: 91 * 24 * 60 * 60 * 1e3,
},
months: {
weeks: 4,
days: 30,
hours: 30 * 24,
minutes: 30 * 24 * 60,
seconds: 30 * 24 * 60 * 60,
milliseconds: 30 * 24 * 60 * 60 * 1e3,
},
...tc,
},
Je = 146097 / 400,
Qt = 146097 / 4800,
eh = {
years: {
quarters: 4,
months: 12,
weeks: Je / 7,
days: Je,
hours: Je * 24,
minutes: Je * 24 * 60,
seconds: Je * 24 * 60 * 60,
milliseconds: Je * 24 * 60 * 60 * 1e3,
},
quarters: {
months: 3,
weeks: Je / 28,
days: Je / 4,
hours: (Je * 24) / 4,
minutes: (Je * 24 * 60) / 4,
seconds: (Je * 24 * 60 * 60) / 4,
milliseconds: (Je * 24 * 60 * 60 * 1e3) / 4,
},
months: {
weeks: Qt / 7,
days: Qt,
hours: Qt * 24,
minutes: Qt * 24 * 60,
seconds: Qt * 24 * 60 * 60,
milliseconds: Qt * 24 * 60 * 60 * 1e3,
},
...tc,
},
zt = [
"years",
"quarters",
"months",
"weeks",
"days",
"hours",
"minutes",
"seconds",
"milliseconds",
],
th = zt.slice(0).reverse();
function Pt(e, t, n = !1) {
const i = {
values: n ? t.values : { ...e.values, ...(t.values || {}) },
loc: e.loc.clone(t.loc),
conversionAccuracy: t.conversionAccuracy || e.conversionAccuracy,
};
return new le(i);
}
function nh(e) {
return e < 0 ? Math.floor(e) : Math.ceil(e);
}
function nc(e, t, n, i, s) {
const r = e[s][n],
l = t[n] / r,
a = Math.sign(l) === Math.sign(i[s]),
u = !a && i[s] !== 0 && Math.abs(l) <= 1 ? nh(l) : Math.trunc(l);
(i[s] += u), (t[n] -= u * r);
}
function rh(e, t) {
th.reduce((n, i) => (ie(t[i]) ? n : (n && nc(e, t, n, t, i), i)), null);
}
class le {
/**
* @private
*/
constructor(t) {
const n = t.conversionAccuracy === "longterm" || !1;
(this.values = t.values),
(this.loc = t.loc || ve.create()),
(this.conversionAccuracy = n ? "longterm" : "casual"),
(this.invalid = t.invalid || null),
(this.matrix = n ? eh : Qm),
(this.isLuxonDuration = !0);
}
/**
* Create Duration from a number of milliseconds.
* @param {number} count of milliseconds
* @param {Object} opts - options for parsing
* @param {string} [opts.locale='en-US'] - the locale to use
* @param {string} opts.numberingSystem - the numbering system to use
* @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
* @return {Duration}
*/
static fromMillis(t, n) {
return le.fromObject({ milliseconds: t }, n);
}
/**
* Create a Duration from a JavaScript object with keys like 'years' and 'hours'.
* If this object is empty then a zero milliseconds duration is returned.
* @param {Object} obj - the object to create the DateTime from
* @param {number} obj.years
* @param {number} obj.quarters
* @param {number} obj.months
* @param {number} obj.weeks
* @param {number} obj.days
* @param {number} obj.hours
* @param {number} obj.minutes
* @param {number} obj.seconds
* @param {number} obj.milliseconds
* @param {Object} [opts=[]] - options for creating this Duration
* @param {string} [opts.locale='en-US'] - the locale to use
* @param {string} opts.numberingSystem - the numbering system to use
* @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
* @return {Duration}
*/
static fromObject(t, n = {}) {
if (t == null || typeof t != "object")
throw new Ke(
`Duration.fromObject: argument expected to be an object, got ${t === null ? "null" : typeof t}`,
);
return new le({
values: br(t, le.normalizeUnit),
loc: ve.fromObject(n),
conversionAccuracy: n.conversionAccuracy,
});
}
/**
* Create a Duration from DurationLike.
*
* @param {Object | number | Duration} durationLike
* One of:
* - object with keys like 'years' and 'hours'.
* - number representing milliseconds
* - Duration instance
* @return {Duration}
*/
static fromDurationLike(t) {
if (Jt(t)) return le.fromMillis(t);
if (le.isDuration(t)) return t;
if (typeof t == "object") return le.fromObject(t);
throw new Ke(`Unknown duration argument ${t} of type ${typeof t}`);
}
/**
* Create a Duration from an ISO 8601 duration string.
* @param {string} text - text to parse
* @param {Object} opts - options for parsing
* @param {string} [opts.locale='en-US'] - the locale to use
* @param {string} opts.numberingSystem - the numbering system to use
* @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
* @see https://en.wikipedia.org/wiki/ISO_8601#Durations
* @example Duration.fromISO('P3Y6M1W4DT12H30M5S').toObject() //=> { years: 3, months: 6, weeks: 1, days: 4, hours: 12, minutes: 30, seconds: 5 }
* @example Duration.fromISO('PT23H').toObject() //=> { hours: 23 }
* @example Duration.fromISO('P5Y3M').toObject() //=> { years: 5, months: 3 }
* @return {Duration}
*/
static fromISO(t, n) {
const [i] = zm(t);
return i
? le.fromObject(i, n)
: le.invalid(
"unparsable",
`the input "${t}" can't be parsed as ISO 8601`,
);
}
/**
* Create a Duration from an ISO 8601 time string.
* @param {string} text - text to parse
* @param {Object} opts - options for parsing
* @param {string} [opts.locale='en-US'] - the locale to use
* @param {string} opts.numberingSystem - the numbering system to use
* @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
* @see https://en.wikipedia.org/wiki/ISO_8601#Times
* @example Duration.fromISOTime('11:22:33.444').toObject() //=> { hours: 11, minutes: 22, seconds: 33, milliseconds: 444 }
* @example Duration.fromISOTime('11:00').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
* @example Duration.fromISOTime('T11:00').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
* @example D