3534 lines
82 KiB
JavaScript
3534 lines
82 KiB
JavaScript
import {
|
|
H as Xe,
|
|
I as qe,
|
|
R as Ge,
|
|
J as je,
|
|
K as Cn,
|
|
L as Kt,
|
|
M as Mn,
|
|
N as Te,
|
|
O as nt,
|
|
c as wt,
|
|
s as Dn,
|
|
g as Sn,
|
|
A as _n,
|
|
B as Un,
|
|
b as Yn,
|
|
a as Fn,
|
|
C as Ln,
|
|
m as An,
|
|
l as qt,
|
|
h as Pt,
|
|
i as En,
|
|
j as In,
|
|
y as Wn,
|
|
} from './index-0e3b96e2.js';
|
|
import { b as On, t as Fe, c as Hn, a as Nn, l as Vn } from './linear-c769df2f.js';
|
|
import { i as zn } from './init-77b53fdd.js';
|
|
import './index-9c042f98.js';
|
|
import './_plugin-vue_export-helper-c27b6911.js';
|
|
function Pn(t, e) {
|
|
let n;
|
|
if (e === void 0) for (const r of t) r != null && (n < r || (n === void 0 && r >= r)) && (n = r);
|
|
else {
|
|
let r = -1;
|
|
for (let i of t) (i = e(i, ++r, t)) != null && (n < i || (n === void 0 && i >= i)) && (n = i);
|
|
}
|
|
return n;
|
|
}
|
|
function Rn(t, e) {
|
|
let n;
|
|
if (e === void 0) for (const r of t) r != null && (n > r || (n === void 0 && r >= r)) && (n = r);
|
|
else {
|
|
let r = -1;
|
|
for (let i of t) (i = e(i, ++r, t)) != null && (n > i || (n === void 0 && i >= i)) && (n = i);
|
|
}
|
|
return n;
|
|
}
|
|
function Bn(t) {
|
|
return t;
|
|
}
|
|
var Bt = 1,
|
|
te = 2,
|
|
ue = 3,
|
|
Rt = 4,
|
|
Le = 1e-6;
|
|
function Zn(t) {
|
|
return 'translate(' + t + ',0)';
|
|
}
|
|
function Xn(t) {
|
|
return 'translate(0,' + t + ')';
|
|
}
|
|
function qn(t) {
|
|
return (e) => +t(e);
|
|
}
|
|
function Gn(t, e) {
|
|
return (e = Math.max(0, t.bandwidth() - e * 2) / 2), t.round() && (e = Math.round(e)), (n) => +t(n) + e;
|
|
}
|
|
function jn() {
|
|
return !this.__axis;
|
|
}
|
|
function Qe(t, e) {
|
|
var n = [],
|
|
r = null,
|
|
i = null,
|
|
s = 6,
|
|
a = 6,
|
|
k = 3,
|
|
Y = typeof window < 'u' && window.devicePixelRatio > 1 ? 0 : 0.5,
|
|
g = t === Bt || t === Rt ? -1 : 1,
|
|
b = t === Rt || t === te ? 'x' : 'y',
|
|
U = t === Bt || t === ue ? Zn : Xn;
|
|
function C(v) {
|
|
var q = r ?? (e.ticks ? e.ticks.apply(e, n) : e.domain()),
|
|
y = i ?? (e.tickFormat ? e.tickFormat.apply(e, n) : Bn),
|
|
L = Math.max(s, 0) + k,
|
|
O = e.range(),
|
|
W = +O[0] + Y,
|
|
B = +O[O.length - 1] + Y,
|
|
Z = (e.bandwidth ? Gn : qn)(e.copy(), Y),
|
|
Q = v.selection ? v.selection() : v,
|
|
x = Q.selectAll('.domain').data([null]),
|
|
E = Q.selectAll('.tick').data(q, e).order(),
|
|
T = E.exit(),
|
|
F = E.enter().append('g').attr('class', 'tick'),
|
|
M = E.select('line'),
|
|
w = E.select('text');
|
|
(x = x.merge(x.enter().insert('path', '.tick').attr('class', 'domain').attr('stroke', 'currentColor'))),
|
|
(E = E.merge(F)),
|
|
(M = M.merge(
|
|
F.append('line')
|
|
.attr('stroke', 'currentColor')
|
|
.attr(b + '2', g * s)
|
|
)),
|
|
(w = w.merge(
|
|
F.append('text')
|
|
.attr('fill', 'currentColor')
|
|
.attr(b, g * L)
|
|
.attr('dy', t === Bt ? '0em' : t === ue ? '0.71em' : '0.32em')
|
|
)),
|
|
v !== Q &&
|
|
((x = x.transition(v)),
|
|
(E = E.transition(v)),
|
|
(M = M.transition(v)),
|
|
(w = w.transition(v)),
|
|
(T = T.transition(v)
|
|
.attr('opacity', Le)
|
|
.attr('transform', function (o) {
|
|
return isFinite((o = Z(o))) ? U(o + Y) : this.getAttribute('transform');
|
|
})),
|
|
F.attr('opacity', Le).attr('transform', function (o) {
|
|
var d = this.parentNode.__axis;
|
|
return U((d && isFinite((d = d(o))) ? d : Z(o)) + Y);
|
|
})),
|
|
T.remove(),
|
|
x.attr(
|
|
'd',
|
|
t === Rt || t === te
|
|
? a
|
|
? 'M' + g * a + ',' + W + 'H' + Y + 'V' + B + 'H' + g * a
|
|
: 'M' + Y + ',' + W + 'V' + B
|
|
: a
|
|
? 'M' + W + ',' + g * a + 'V' + Y + 'H' + B + 'V' + g * a
|
|
: 'M' + W + ',' + Y + 'H' + B
|
|
),
|
|
E.attr('opacity', 1).attr('transform', function (o) {
|
|
return U(Z(o) + Y);
|
|
}),
|
|
M.attr(b + '2', g * s),
|
|
w.attr(b, g * L).text(y),
|
|
Q.filter(jn)
|
|
.attr('fill', 'none')
|
|
.attr('font-size', 10)
|
|
.attr('font-family', 'sans-serif')
|
|
.attr('text-anchor', t === te ? 'start' : t === Rt ? 'end' : 'middle'),
|
|
Q.each(function () {
|
|
this.__axis = Z;
|
|
});
|
|
}
|
|
return (
|
|
(C.scale = function (v) {
|
|
return arguments.length ? ((e = v), C) : e;
|
|
}),
|
|
(C.ticks = function () {
|
|
return (n = Array.from(arguments)), C;
|
|
}),
|
|
(C.tickArguments = function (v) {
|
|
return arguments.length ? ((n = v == null ? [] : Array.from(v)), C) : n.slice();
|
|
}),
|
|
(C.tickValues = function (v) {
|
|
return arguments.length ? ((r = v == null ? null : Array.from(v)), C) : r && r.slice();
|
|
}),
|
|
(C.tickFormat = function (v) {
|
|
return arguments.length ? ((i = v), C) : i;
|
|
}),
|
|
(C.tickSize = function (v) {
|
|
return arguments.length ? ((s = a = +v), C) : s;
|
|
}),
|
|
(C.tickSizeInner = function (v) {
|
|
return arguments.length ? ((s = +v), C) : s;
|
|
}),
|
|
(C.tickSizeOuter = function (v) {
|
|
return arguments.length ? ((a = +v), C) : a;
|
|
}),
|
|
(C.tickPadding = function (v) {
|
|
return arguments.length ? ((k = +v), C) : k;
|
|
}),
|
|
(C.offset = function (v) {
|
|
return arguments.length ? ((Y = +v), C) : Y;
|
|
}),
|
|
C
|
|
);
|
|
}
|
|
function Qn(t) {
|
|
return Qe(Bt, t);
|
|
}
|
|
function Jn(t) {
|
|
return Qe(ue, t);
|
|
}
|
|
const $n = Math.PI / 180,
|
|
Kn = 180 / Math.PI,
|
|
Gt = 18,
|
|
Je = 0.96422,
|
|
$e = 1,
|
|
Ke = 0.82521,
|
|
tn = 4 / 29,
|
|
Ct = 6 / 29,
|
|
en = 3 * Ct * Ct,
|
|
tr = Ct * Ct * Ct;
|
|
function nn(t) {
|
|
if (t instanceof ot) return new ot(t.l, t.a, t.b, t.opacity);
|
|
if (t instanceof ut) return rn(t);
|
|
t instanceof Ge || (t = Cn(t));
|
|
var e = ie(t.r),
|
|
n = ie(t.g),
|
|
r = ie(t.b),
|
|
i = ee((0.2225045 * e + 0.7168786 * n + 0.0606169 * r) / $e),
|
|
s,
|
|
a;
|
|
return (
|
|
e === n && n === r
|
|
? (s = a = i)
|
|
: ((s = ee((0.4360747 * e + 0.3850649 * n + 0.1430804 * r) / Je)), (a = ee((0.0139322 * e + 0.0971045 * n + 0.7141733 * r) / Ke))),
|
|
new ot(116 * i - 16, 500 * (s - i), 200 * (i - a), t.opacity)
|
|
);
|
|
}
|
|
function er(t, e, n, r) {
|
|
return arguments.length === 1 ? nn(t) : new ot(t, e, n, r ?? 1);
|
|
}
|
|
function ot(t, e, n, r) {
|
|
(this.l = +t), (this.a = +e), (this.b = +n), (this.opacity = +r);
|
|
}
|
|
Xe(
|
|
ot,
|
|
er,
|
|
qe(je, {
|
|
brighter(t) {
|
|
return new ot(this.l + Gt * (t ?? 1), this.a, this.b, this.opacity);
|
|
},
|
|
darker(t) {
|
|
return new ot(this.l - Gt * (t ?? 1), this.a, this.b, this.opacity);
|
|
},
|
|
rgb() {
|
|
var t = (this.l + 16) / 116,
|
|
e = isNaN(this.a) ? t : t + this.a / 500,
|
|
n = isNaN(this.b) ? t : t - this.b / 200;
|
|
return (
|
|
(e = Je * ne(e)),
|
|
(t = $e * ne(t)),
|
|
(n = Ke * ne(n)),
|
|
new Ge(
|
|
re(3.1338561 * e - 1.6168667 * t - 0.4906146 * n),
|
|
re(-0.9787684 * e + 1.9161415 * t + 0.033454 * n),
|
|
re(0.0719453 * e - 0.2289914 * t + 1.4052427 * n),
|
|
this.opacity
|
|
)
|
|
);
|
|
},
|
|
})
|
|
);
|
|
function ee(t) {
|
|
return t > tr ? Math.pow(t, 1 / 3) : t / en + tn;
|
|
}
|
|
function ne(t) {
|
|
return t > Ct ? t * t * t : en * (t - tn);
|
|
}
|
|
function re(t) {
|
|
return 255 * (t <= 0.0031308 ? 12.92 * t : 1.055 * Math.pow(t, 1 / 2.4) - 0.055);
|
|
}
|
|
function ie(t) {
|
|
return (t /= 255) <= 0.04045 ? t / 12.92 : Math.pow((t + 0.055) / 1.055, 2.4);
|
|
}
|
|
function nr(t) {
|
|
if (t instanceof ut) return new ut(t.h, t.c, t.l, t.opacity);
|
|
if ((t instanceof ot || (t = nn(t)), t.a === 0 && t.b === 0)) return new ut(NaN, 0 < t.l && t.l < 100 ? 0 : NaN, t.l, t.opacity);
|
|
var e = Math.atan2(t.b, t.a) * Kn;
|
|
return new ut(e < 0 ? e + 360 : e, Math.sqrt(t.a * t.a + t.b * t.b), t.l, t.opacity);
|
|
}
|
|
function fe(t, e, n, r) {
|
|
return arguments.length === 1 ? nr(t) : new ut(t, e, n, r ?? 1);
|
|
}
|
|
function ut(t, e, n, r) {
|
|
(this.h = +t), (this.c = +e), (this.l = +n), (this.opacity = +r);
|
|
}
|
|
function rn(t) {
|
|
if (isNaN(t.h)) return new ot(t.l, 0, 0, t.opacity);
|
|
var e = t.h * $n;
|
|
return new ot(t.l, Math.cos(e) * t.c, Math.sin(e) * t.c, t.opacity);
|
|
}
|
|
Xe(
|
|
ut,
|
|
fe,
|
|
qe(je, {
|
|
brighter(t) {
|
|
return new ut(this.h, this.c, this.l + Gt * (t ?? 1), this.opacity);
|
|
},
|
|
darker(t) {
|
|
return new ut(this.h, this.c, this.l - Gt * (t ?? 1), this.opacity);
|
|
},
|
|
rgb() {
|
|
return rn(this).rgb();
|
|
},
|
|
})
|
|
);
|
|
function rr(t) {
|
|
return function (e, n) {
|
|
var r = t((e = fe(e)).h, (n = fe(n)).h),
|
|
i = Kt(e.c, n.c),
|
|
s = Kt(e.l, n.l),
|
|
a = Kt(e.opacity, n.opacity);
|
|
return function (k) {
|
|
return (e.h = r(k)), (e.c = i(k)), (e.l = s(k)), (e.opacity = a(k)), e + '';
|
|
};
|
|
};
|
|
}
|
|
const ir = rr(Mn);
|
|
function sr(t, e) {
|
|
t = t.slice();
|
|
var n = 0,
|
|
r = t.length - 1,
|
|
i = t[n],
|
|
s = t[r],
|
|
a;
|
|
return s < i && ((a = n), (n = r), (r = a), (a = i), (i = s), (s = a)), (t[n] = e.floor(i)), (t[r] = e.ceil(s)), t;
|
|
}
|
|
const se = new Date(),
|
|
ae = new Date();
|
|
function K(t, e, n, r) {
|
|
function i(s) {
|
|
return t((s = arguments.length === 0 ? new Date() : new Date(+s))), s;
|
|
}
|
|
return (
|
|
(i.floor = (s) => (t((s = new Date(+s))), s)),
|
|
(i.ceil = (s) => (t((s = new Date(s - 1))), e(s, 1), t(s), s)),
|
|
(i.round = (s) => {
|
|
const a = i(s),
|
|
k = i.ceil(s);
|
|
return s - a < k - s ? a : k;
|
|
}),
|
|
(i.offset = (s, a) => (e((s = new Date(+s)), a == null ? 1 : Math.floor(a)), s)),
|
|
(i.range = (s, a, k) => {
|
|
const Y = [];
|
|
if (((s = i.ceil(s)), (k = k == null ? 1 : Math.floor(k)), !(s < a) || !(k > 0))) return Y;
|
|
let g;
|
|
do Y.push((g = new Date(+s))), e(s, k), t(s);
|
|
while (g < s && s < a);
|
|
return Y;
|
|
}),
|
|
(i.filter = (s) =>
|
|
K(
|
|
(a) => {
|
|
if (a >= a) for (; t(a), !s(a); ) a.setTime(a - 1);
|
|
},
|
|
(a, k) => {
|
|
if (a >= a)
|
|
if (k < 0) for (; ++k <= 0; ) for (; e(a, -1), !s(a); );
|
|
else for (; --k >= 0; ) for (; e(a, 1), !s(a); );
|
|
}
|
|
)),
|
|
n &&
|
|
((i.count = (s, a) => (se.setTime(+s), ae.setTime(+a), t(se), t(ae), Math.floor(n(se, ae)))),
|
|
(i.every = (s) => (
|
|
(s = Math.floor(s)), !isFinite(s) || !(s > 0) ? null : s > 1 ? i.filter(r ? (a) => r(a) % s === 0 : (a) => i.count(0, a) % s === 0) : i
|
|
))),
|
|
i
|
|
);
|
|
}
|
|
const Dt = K(
|
|
() => {},
|
|
(t, e) => {
|
|
t.setTime(+t + e);
|
|
},
|
|
(t, e) => e - t
|
|
);
|
|
Dt.every = (t) => (
|
|
(t = Math.floor(t)),
|
|
!isFinite(t) || !(t > 0)
|
|
? null
|
|
: t > 1
|
|
? K(
|
|
(e) => {
|
|
e.setTime(Math.floor(e / t) * t);
|
|
},
|
|
(e, n) => {
|
|
e.setTime(+e + n * t);
|
|
},
|
|
(e, n) => (n - e) / t
|
|
)
|
|
: Dt
|
|
);
|
|
Dt.range;
|
|
const ft = 1e3,
|
|
rt = ft * 60,
|
|
ht = rt * 60,
|
|
dt = ht * 24,
|
|
ve = dt * 7,
|
|
Ae = dt * 30,
|
|
oe = dt * 365,
|
|
gt = K(
|
|
(t) => {
|
|
t.setTime(t - t.getMilliseconds());
|
|
},
|
|
(t, e) => {
|
|
t.setTime(+t + e * ft);
|
|
},
|
|
(t, e) => (e - t) / ft,
|
|
(t) => t.getUTCSeconds()
|
|
);
|
|
gt.range;
|
|
const At = K(
|
|
(t) => {
|
|
t.setTime(t - t.getMilliseconds() - t.getSeconds() * ft);
|
|
},
|
|
(t, e) => {
|
|
t.setTime(+t + e * rt);
|
|
},
|
|
(t, e) => (e - t) / rt,
|
|
(t) => t.getMinutes()
|
|
);
|
|
At.range;
|
|
const ar = K(
|
|
(t) => {
|
|
t.setUTCSeconds(0, 0);
|
|
},
|
|
(t, e) => {
|
|
t.setTime(+t + e * rt);
|
|
},
|
|
(t, e) => (e - t) / rt,
|
|
(t) => t.getUTCMinutes()
|
|
);
|
|
ar.range;
|
|
const Et = K(
|
|
(t) => {
|
|
t.setTime(t - t.getMilliseconds() - t.getSeconds() * ft - t.getMinutes() * rt);
|
|
},
|
|
(t, e) => {
|
|
t.setTime(+t + e * ht);
|
|
},
|
|
(t, e) => (e - t) / ht,
|
|
(t) => t.getHours()
|
|
);
|
|
Et.range;
|
|
const or = K(
|
|
(t) => {
|
|
t.setUTCMinutes(0, 0, 0);
|
|
},
|
|
(t, e) => {
|
|
t.setTime(+t + e * ht);
|
|
},
|
|
(t, e) => (e - t) / ht,
|
|
(t) => t.getUTCHours()
|
|
);
|
|
or.range;
|
|
const yt = K(
|
|
(t) => t.setHours(0, 0, 0, 0),
|
|
(t, e) => t.setDate(t.getDate() + e),
|
|
(t, e) => (e - t - (e.getTimezoneOffset() - t.getTimezoneOffset()) * rt) / dt,
|
|
(t) => t.getDate() - 1
|
|
);
|
|
yt.range;
|
|
const be = K(
|
|
(t) => {
|
|
t.setUTCHours(0, 0, 0, 0);
|
|
},
|
|
(t, e) => {
|
|
t.setUTCDate(t.getUTCDate() + e);
|
|
},
|
|
(t, e) => (e - t) / dt,
|
|
(t) => t.getUTCDate() - 1
|
|
);
|
|
be.range;
|
|
const cr = K(
|
|
(t) => {
|
|
t.setUTCHours(0, 0, 0, 0);
|
|
},
|
|
(t, e) => {
|
|
t.setUTCDate(t.getUTCDate() + e);
|
|
},
|
|
(t, e) => (e - t) / dt,
|
|
(t) => Math.floor(t / dt)
|
|
);
|
|
cr.range;
|
|
function Tt(t) {
|
|
return K(
|
|
(e) => {
|
|
e.setDate(e.getDate() - ((e.getDay() + 7 - t) % 7)), e.setHours(0, 0, 0, 0);
|
|
},
|
|
(e, n) => {
|
|
e.setDate(e.getDate() + n * 7);
|
|
},
|
|
(e, n) => (n - e - (n.getTimezoneOffset() - e.getTimezoneOffset()) * rt) / ve
|
|
);
|
|
}
|
|
const Ot = Tt(0),
|
|
It = Tt(1),
|
|
sn = Tt(2),
|
|
an = Tt(3),
|
|
kt = Tt(4),
|
|
on = Tt(5),
|
|
cn = Tt(6);
|
|
Ot.range;
|
|
It.range;
|
|
sn.range;
|
|
an.range;
|
|
kt.range;
|
|
on.range;
|
|
cn.range;
|
|
function vt(t) {
|
|
return K(
|
|
(e) => {
|
|
e.setUTCDate(e.getUTCDate() - ((e.getUTCDay() + 7 - t) % 7)), e.setUTCHours(0, 0, 0, 0);
|
|
},
|
|
(e, n) => {
|
|
e.setUTCDate(e.getUTCDate() + n * 7);
|
|
},
|
|
(e, n) => (n - e) / ve
|
|
);
|
|
}
|
|
const ln = vt(0),
|
|
jt = vt(1),
|
|
lr = vt(2),
|
|
ur = vt(3),
|
|
St = vt(4),
|
|
fr = vt(5),
|
|
hr = vt(6);
|
|
ln.range;
|
|
jt.range;
|
|
lr.range;
|
|
ur.range;
|
|
St.range;
|
|
fr.range;
|
|
hr.range;
|
|
const Wt = K(
|
|
(t) => {
|
|
t.setDate(1), t.setHours(0, 0, 0, 0);
|
|
},
|
|
(t, e) => {
|
|
t.setMonth(t.getMonth() + e);
|
|
},
|
|
(t, e) => e.getMonth() - t.getMonth() + (e.getFullYear() - t.getFullYear()) * 12,
|
|
(t) => t.getMonth()
|
|
);
|
|
Wt.range;
|
|
const dr = K(
|
|
(t) => {
|
|
t.setUTCDate(1), t.setUTCHours(0, 0, 0, 0);
|
|
},
|
|
(t, e) => {
|
|
t.setUTCMonth(t.getUTCMonth() + e);
|
|
},
|
|
(t, e) => e.getUTCMonth() - t.getUTCMonth() + (e.getUTCFullYear() - t.getUTCFullYear()) * 12,
|
|
(t) => t.getUTCMonth()
|
|
);
|
|
dr.range;
|
|
const mt = K(
|
|
(t) => {
|
|
t.setMonth(0, 1), t.setHours(0, 0, 0, 0);
|
|
},
|
|
(t, e) => {
|
|
t.setFullYear(t.getFullYear() + e);
|
|
},
|
|
(t, e) => e.getFullYear() - t.getFullYear(),
|
|
(t) => t.getFullYear()
|
|
);
|
|
mt.every = (t) =>
|
|
!isFinite((t = Math.floor(t))) || !(t > 0)
|
|
? null
|
|
: K(
|
|
(e) => {
|
|
e.setFullYear(Math.floor(e.getFullYear() / t) * t), e.setMonth(0, 1), e.setHours(0, 0, 0, 0);
|
|
},
|
|
(e, n) => {
|
|
e.setFullYear(e.getFullYear() + n * t);
|
|
}
|
|
);
|
|
mt.range;
|
|
const pt = K(
|
|
(t) => {
|
|
t.setUTCMonth(0, 1), t.setUTCHours(0, 0, 0, 0);
|
|
},
|
|
(t, e) => {
|
|
t.setUTCFullYear(t.getUTCFullYear() + e);
|
|
},
|
|
(t, e) => e.getUTCFullYear() - t.getUTCFullYear(),
|
|
(t) => t.getUTCFullYear()
|
|
);
|
|
pt.every = (t) =>
|
|
!isFinite((t = Math.floor(t))) || !(t > 0)
|
|
? null
|
|
: K(
|
|
(e) => {
|
|
e.setUTCFullYear(Math.floor(e.getUTCFullYear() / t) * t), e.setUTCMonth(0, 1), e.setUTCHours(0, 0, 0, 0);
|
|
},
|
|
(e, n) => {
|
|
e.setUTCFullYear(e.getUTCFullYear() + n * t);
|
|
}
|
|
);
|
|
pt.range;
|
|
function mr(t, e, n, r, i, s) {
|
|
const a = [
|
|
[gt, 1, ft],
|
|
[gt, 5, 5 * ft],
|
|
[gt, 15, 15 * ft],
|
|
[gt, 30, 30 * ft],
|
|
[s, 1, rt],
|
|
[s, 5, 5 * rt],
|
|
[s, 15, 15 * rt],
|
|
[s, 30, 30 * rt],
|
|
[i, 1, ht],
|
|
[i, 3, 3 * ht],
|
|
[i, 6, 6 * ht],
|
|
[i, 12, 12 * ht],
|
|
[r, 1, dt],
|
|
[r, 2, 2 * dt],
|
|
[n, 1, ve],
|
|
[e, 1, Ae],
|
|
[e, 3, 3 * Ae],
|
|
[t, 1, oe],
|
|
];
|
|
function k(g, b, U) {
|
|
const C = b < g;
|
|
C && ([g, b] = [b, g]);
|
|
const v = U && typeof U.range == 'function' ? U : Y(g, b, U),
|
|
q = v ? v.range(g, +b + 1) : [];
|
|
return C ? q.reverse() : q;
|
|
}
|
|
function Y(g, b, U) {
|
|
const C = Math.abs(b - g) / U,
|
|
v = On(([, , L]) => L).right(a, C);
|
|
if (v === a.length) return t.every(Fe(g / oe, b / oe, U));
|
|
if (v === 0) return Dt.every(Math.max(Fe(g, b, U), 1));
|
|
const [q, y] = a[C / a[v - 1][2] < a[v][2] / C ? v - 1 : v];
|
|
return q.every(y);
|
|
}
|
|
return [k, Y];
|
|
}
|
|
const [gr, yr] = mr(mt, Wt, Ot, yt, Et, At);
|
|
function ce(t) {
|
|
if (0 <= t.y && t.y < 100) {
|
|
var e = new Date(-1, t.m, t.d, t.H, t.M, t.S, t.L);
|
|
return e.setFullYear(t.y), e;
|
|
}
|
|
return new Date(t.y, t.m, t.d, t.H, t.M, t.S, t.L);
|
|
}
|
|
function le(t) {
|
|
if (0 <= t.y && t.y < 100) {
|
|
var e = new Date(Date.UTC(-1, t.m, t.d, t.H, t.M, t.S, t.L));
|
|
return e.setUTCFullYear(t.y), e;
|
|
}
|
|
return new Date(Date.UTC(t.y, t.m, t.d, t.H, t.M, t.S, t.L));
|
|
}
|
|
function Yt(t, e, n) {
|
|
return { y: t, m: e, d: n, H: 0, M: 0, S: 0, L: 0 };
|
|
}
|
|
function kr(t) {
|
|
var e = t.dateTime,
|
|
n = t.date,
|
|
r = t.time,
|
|
i = t.periods,
|
|
s = t.days,
|
|
a = t.shortDays,
|
|
k = t.months,
|
|
Y = t.shortMonths,
|
|
g = Ft(i),
|
|
b = Lt(i),
|
|
U = Ft(s),
|
|
C = Lt(s),
|
|
v = Ft(a),
|
|
q = Lt(a),
|
|
y = Ft(k),
|
|
L = Lt(k),
|
|
O = Ft(Y),
|
|
W = Lt(Y),
|
|
B = {
|
|
a: c,
|
|
A: X,
|
|
b: f,
|
|
B: h,
|
|
c: null,
|
|
d: Ne,
|
|
e: Ne,
|
|
f: Vr,
|
|
g: Qr,
|
|
G: $r,
|
|
H: Or,
|
|
I: Hr,
|
|
j: Nr,
|
|
L: un,
|
|
m: zr,
|
|
M: Pr,
|
|
p: _,
|
|
q: G,
|
|
Q: Pe,
|
|
s: Re,
|
|
S: Rr,
|
|
u: Br,
|
|
U: Zr,
|
|
V: Xr,
|
|
w: qr,
|
|
W: Gr,
|
|
x: null,
|
|
X: null,
|
|
y: jr,
|
|
Y: Jr,
|
|
Z: Kr,
|
|
'%': ze,
|
|
},
|
|
Z = {
|
|
a: H,
|
|
A: V,
|
|
b: I,
|
|
B: z,
|
|
c: null,
|
|
d: Ve,
|
|
e: Ve,
|
|
f: ri,
|
|
g: di,
|
|
G: gi,
|
|
H: ti,
|
|
I: ei,
|
|
j: ni,
|
|
L: hn,
|
|
m: ii,
|
|
M: si,
|
|
p: st,
|
|
q: it,
|
|
Q: Pe,
|
|
s: Re,
|
|
S: ai,
|
|
u: oi,
|
|
U: ci,
|
|
V: li,
|
|
w: ui,
|
|
W: fi,
|
|
x: null,
|
|
X: null,
|
|
y: hi,
|
|
Y: mi,
|
|
Z: yi,
|
|
'%': ze,
|
|
},
|
|
Q = {
|
|
a: M,
|
|
A: w,
|
|
b: o,
|
|
B: d,
|
|
c: m,
|
|
d: Oe,
|
|
e: Oe,
|
|
f: Ar,
|
|
g: We,
|
|
G: Ie,
|
|
H: He,
|
|
I: He,
|
|
j: Ur,
|
|
L: Lr,
|
|
m: _r,
|
|
M: Yr,
|
|
p: F,
|
|
q: Sr,
|
|
Q: Ir,
|
|
s: Wr,
|
|
S: Fr,
|
|
u: xr,
|
|
U: wr,
|
|
V: Cr,
|
|
w: br,
|
|
W: Mr,
|
|
x: u,
|
|
X: S,
|
|
y: We,
|
|
Y: Ie,
|
|
Z: Dr,
|
|
'%': Er,
|
|
};
|
|
(B.x = x(n, B)), (B.X = x(r, B)), (B.c = x(e, B)), (Z.x = x(n, Z)), (Z.X = x(r, Z)), (Z.c = x(e, Z));
|
|
function x(p, A) {
|
|
return function (D) {
|
|
var l = [],
|
|
R = -1,
|
|
N = 0,
|
|
j = p.length,
|
|
J,
|
|
et,
|
|
Ut;
|
|
for (D instanceof Date || (D = new Date(+D)); ++R < j; )
|
|
p.charCodeAt(R) === 37 &&
|
|
(l.push(p.slice(N, R)),
|
|
(et = Ee[(J = p.charAt(++R))]) != null ? (J = p.charAt(++R)) : (et = J === 'e' ? ' ' : '0'),
|
|
(Ut = A[J]) && (J = Ut(D, et)),
|
|
l.push(J),
|
|
(N = R + 1));
|
|
return l.push(p.slice(N, R)), l.join('');
|
|
};
|
|
}
|
|
function E(p, A) {
|
|
return function (D) {
|
|
var l = Yt(1900, void 0, 1),
|
|
R = T(l, p, (D += ''), 0),
|
|
N,
|
|
j;
|
|
if (R != D.length) return null;
|
|
if ('Q' in l) return new Date(l.Q);
|
|
if ('s' in l) return new Date(l.s * 1e3 + ('L' in l ? l.L : 0));
|
|
if ((A && !('Z' in l) && (l.Z = 0), 'p' in l && (l.H = (l.H % 12) + l.p * 12), l.m === void 0 && (l.m = 'q' in l ? l.q : 0), 'V' in l)) {
|
|
if (l.V < 1 || l.V > 53) return null;
|
|
'w' in l || (l.w = 1),
|
|
'Z' in l
|
|
? ((N = le(Yt(l.y, 0, 1))),
|
|
(j = N.getUTCDay()),
|
|
(N = j > 4 || j === 0 ? jt.ceil(N) : jt(N)),
|
|
(N = be.offset(N, (l.V - 1) * 7)),
|
|
(l.y = N.getUTCFullYear()),
|
|
(l.m = N.getUTCMonth()),
|
|
(l.d = N.getUTCDate() + ((l.w + 6) % 7)))
|
|
: ((N = ce(Yt(l.y, 0, 1))),
|
|
(j = N.getDay()),
|
|
(N = j > 4 || j === 0 ? It.ceil(N) : It(N)),
|
|
(N = yt.offset(N, (l.V - 1) * 7)),
|
|
(l.y = N.getFullYear()),
|
|
(l.m = N.getMonth()),
|
|
(l.d = N.getDate() + ((l.w + 6) % 7)));
|
|
} else
|
|
('W' in l || 'U' in l) &&
|
|
('w' in l || (l.w = 'u' in l ? l.u % 7 : 'W' in l ? 1 : 0),
|
|
(j = 'Z' in l ? le(Yt(l.y, 0, 1)).getUTCDay() : ce(Yt(l.y, 0, 1)).getDay()),
|
|
(l.m = 0),
|
|
(l.d = 'W' in l ? ((l.w + 6) % 7) + l.W * 7 - ((j + 5) % 7) : l.w + l.U * 7 - ((j + 6) % 7)));
|
|
return 'Z' in l ? ((l.H += (l.Z / 100) | 0), (l.M += l.Z % 100), le(l)) : ce(l);
|
|
};
|
|
}
|
|
function T(p, A, D, l) {
|
|
for (var R = 0, N = A.length, j = D.length, J, et; R < N; ) {
|
|
if (l >= j) return -1;
|
|
if (((J = A.charCodeAt(R++)), J === 37)) {
|
|
if (((J = A.charAt(R++)), (et = Q[J in Ee ? A.charAt(R++) : J]), !et || (l = et(p, D, l)) < 0)) return -1;
|
|
} else if (J != D.charCodeAt(l++)) return -1;
|
|
}
|
|
return l;
|
|
}
|
|
function F(p, A, D) {
|
|
var l = g.exec(A.slice(D));
|
|
return l ? ((p.p = b.get(l[0].toLowerCase())), D + l[0].length) : -1;
|
|
}
|
|
function M(p, A, D) {
|
|
var l = v.exec(A.slice(D));
|
|
return l ? ((p.w = q.get(l[0].toLowerCase())), D + l[0].length) : -1;
|
|
}
|
|
function w(p, A, D) {
|
|
var l = U.exec(A.slice(D));
|
|
return l ? ((p.w = C.get(l[0].toLowerCase())), D + l[0].length) : -1;
|
|
}
|
|
function o(p, A, D) {
|
|
var l = O.exec(A.slice(D));
|
|
return l ? ((p.m = W.get(l[0].toLowerCase())), D + l[0].length) : -1;
|
|
}
|
|
function d(p, A, D) {
|
|
var l = y.exec(A.slice(D));
|
|
return l ? ((p.m = L.get(l[0].toLowerCase())), D + l[0].length) : -1;
|
|
}
|
|
function m(p, A, D) {
|
|
return T(p, e, A, D);
|
|
}
|
|
function u(p, A, D) {
|
|
return T(p, n, A, D);
|
|
}
|
|
function S(p, A, D) {
|
|
return T(p, r, A, D);
|
|
}
|
|
function c(p) {
|
|
return a[p.getDay()];
|
|
}
|
|
function X(p) {
|
|
return s[p.getDay()];
|
|
}
|
|
function f(p) {
|
|
return Y[p.getMonth()];
|
|
}
|
|
function h(p) {
|
|
return k[p.getMonth()];
|
|
}
|
|
function _(p) {
|
|
return i[+(p.getHours() >= 12)];
|
|
}
|
|
function G(p) {
|
|
return 1 + ~~(p.getMonth() / 3);
|
|
}
|
|
function H(p) {
|
|
return a[p.getUTCDay()];
|
|
}
|
|
function V(p) {
|
|
return s[p.getUTCDay()];
|
|
}
|
|
function I(p) {
|
|
return Y[p.getUTCMonth()];
|
|
}
|
|
function z(p) {
|
|
return k[p.getUTCMonth()];
|
|
}
|
|
function st(p) {
|
|
return i[+(p.getUTCHours() >= 12)];
|
|
}
|
|
function it(p) {
|
|
return 1 + ~~(p.getUTCMonth() / 3);
|
|
}
|
|
return {
|
|
format: function (p) {
|
|
var A = x((p += ''), B);
|
|
return (
|
|
(A.toString = function () {
|
|
return p;
|
|
}),
|
|
A
|
|
);
|
|
},
|
|
parse: function (p) {
|
|
var A = E((p += ''), !1);
|
|
return (
|
|
(A.toString = function () {
|
|
return p;
|
|
}),
|
|
A
|
|
);
|
|
},
|
|
utcFormat: function (p) {
|
|
var A = x((p += ''), Z);
|
|
return (
|
|
(A.toString = function () {
|
|
return p;
|
|
}),
|
|
A
|
|
);
|
|
},
|
|
utcParse: function (p) {
|
|
var A = E((p += ''), !0);
|
|
return (
|
|
(A.toString = function () {
|
|
return p;
|
|
}),
|
|
A
|
|
);
|
|
},
|
|
};
|
|
}
|
|
var Ee = { '-': '', _: ' ', 0: '0' },
|
|
tt = /^\s*\d+/,
|
|
pr = /^%/,
|
|
Tr = /[\\^$*+?|[\]().{}]/g;
|
|
function P(t, e, n) {
|
|
var r = t < 0 ? '-' : '',
|
|
i = (r ? -t : t) + '',
|
|
s = i.length;
|
|
return r + (s < n ? new Array(n - s + 1).join(e) + i : i);
|
|
}
|
|
function vr(t) {
|
|
return t.replace(Tr, '\\$&');
|
|
}
|
|
function Ft(t) {
|
|
return new RegExp('^(?:' + t.map(vr).join('|') + ')', 'i');
|
|
}
|
|
function Lt(t) {
|
|
return new Map(t.map((e, n) => [e.toLowerCase(), n]));
|
|
}
|
|
function br(t, e, n) {
|
|
var r = tt.exec(e.slice(n, n + 1));
|
|
return r ? ((t.w = +r[0]), n + r[0].length) : -1;
|
|
}
|
|
function xr(t, e, n) {
|
|
var r = tt.exec(e.slice(n, n + 1));
|
|
return r ? ((t.u = +r[0]), n + r[0].length) : -1;
|
|
}
|
|
function wr(t, e, n) {
|
|
var r = tt.exec(e.slice(n, n + 2));
|
|
return r ? ((t.U = +r[0]), n + r[0].length) : -1;
|
|
}
|
|
function Cr(t, e, n) {
|
|
var r = tt.exec(e.slice(n, n + 2));
|
|
return r ? ((t.V = +r[0]), n + r[0].length) : -1;
|
|
}
|
|
function Mr(t, e, n) {
|
|
var r = tt.exec(e.slice(n, n + 2));
|
|
return r ? ((t.W = +r[0]), n + r[0].length) : -1;
|
|
}
|
|
function Ie(t, e, n) {
|
|
var r = tt.exec(e.slice(n, n + 4));
|
|
return r ? ((t.y = +r[0]), n + r[0].length) : -1;
|
|
}
|
|
function We(t, e, n) {
|
|
var r = tt.exec(e.slice(n, n + 2));
|
|
return r ? ((t.y = +r[0] + (+r[0] > 68 ? 1900 : 2e3)), n + r[0].length) : -1;
|
|
}
|
|
function Dr(t, e, n) {
|
|
var r = /^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(e.slice(n, n + 6));
|
|
return r ? ((t.Z = r[1] ? 0 : -(r[2] + (r[3] || '00'))), n + r[0].length) : -1;
|
|
}
|
|
function Sr(t, e, n) {
|
|
var r = tt.exec(e.slice(n, n + 1));
|
|
return r ? ((t.q = r[0] * 3 - 3), n + r[0].length) : -1;
|
|
}
|
|
function _r(t, e, n) {
|
|
var r = tt.exec(e.slice(n, n + 2));
|
|
return r ? ((t.m = r[0] - 1), n + r[0].length) : -1;
|
|
}
|
|
function Oe(t, e, n) {
|
|
var r = tt.exec(e.slice(n, n + 2));
|
|
return r ? ((t.d = +r[0]), n + r[0].length) : -1;
|
|
}
|
|
function Ur(t, e, n) {
|
|
var r = tt.exec(e.slice(n, n + 3));
|
|
return r ? ((t.m = 0), (t.d = +r[0]), n + r[0].length) : -1;
|
|
}
|
|
function He(t, e, n) {
|
|
var r = tt.exec(e.slice(n, n + 2));
|
|
return r ? ((t.H = +r[0]), n + r[0].length) : -1;
|
|
}
|
|
function Yr(t, e, n) {
|
|
var r = tt.exec(e.slice(n, n + 2));
|
|
return r ? ((t.M = +r[0]), n + r[0].length) : -1;
|
|
}
|
|
function Fr(t, e, n) {
|
|
var r = tt.exec(e.slice(n, n + 2));
|
|
return r ? ((t.S = +r[0]), n + r[0].length) : -1;
|
|
}
|
|
function Lr(t, e, n) {
|
|
var r = tt.exec(e.slice(n, n + 3));
|
|
return r ? ((t.L = +r[0]), n + r[0].length) : -1;
|
|
}
|
|
function Ar(t, e, n) {
|
|
var r = tt.exec(e.slice(n, n + 6));
|
|
return r ? ((t.L = Math.floor(r[0] / 1e3)), n + r[0].length) : -1;
|
|
}
|
|
function Er(t, e, n) {
|
|
var r = pr.exec(e.slice(n, n + 1));
|
|
return r ? n + r[0].length : -1;
|
|
}
|
|
function Ir(t, e, n) {
|
|
var r = tt.exec(e.slice(n));
|
|
return r ? ((t.Q = +r[0]), n + r[0].length) : -1;
|
|
}
|
|
function Wr(t, e, n) {
|
|
var r = tt.exec(e.slice(n));
|
|
return r ? ((t.s = +r[0]), n + r[0].length) : -1;
|
|
}
|
|
function Ne(t, e) {
|
|
return P(t.getDate(), e, 2);
|
|
}
|
|
function Or(t, e) {
|
|
return P(t.getHours(), e, 2);
|
|
}
|
|
function Hr(t, e) {
|
|
return P(t.getHours() % 12 || 12, e, 2);
|
|
}
|
|
function Nr(t, e) {
|
|
return P(1 + yt.count(mt(t), t), e, 3);
|
|
}
|
|
function un(t, e) {
|
|
return P(t.getMilliseconds(), e, 3);
|
|
}
|
|
function Vr(t, e) {
|
|
return un(t, e) + '000';
|
|
}
|
|
function zr(t, e) {
|
|
return P(t.getMonth() + 1, e, 2);
|
|
}
|
|
function Pr(t, e) {
|
|
return P(t.getMinutes(), e, 2);
|
|
}
|
|
function Rr(t, e) {
|
|
return P(t.getSeconds(), e, 2);
|
|
}
|
|
function Br(t) {
|
|
var e = t.getDay();
|
|
return e === 0 ? 7 : e;
|
|
}
|
|
function Zr(t, e) {
|
|
return P(Ot.count(mt(t) - 1, t), e, 2);
|
|
}
|
|
function fn(t) {
|
|
var e = t.getDay();
|
|
return e >= 4 || e === 0 ? kt(t) : kt.ceil(t);
|
|
}
|
|
function Xr(t, e) {
|
|
return (t = fn(t)), P(kt.count(mt(t), t) + (mt(t).getDay() === 4), e, 2);
|
|
}
|
|
function qr(t) {
|
|
return t.getDay();
|
|
}
|
|
function Gr(t, e) {
|
|
return P(It.count(mt(t) - 1, t), e, 2);
|
|
}
|
|
function jr(t, e) {
|
|
return P(t.getFullYear() % 100, e, 2);
|
|
}
|
|
function Qr(t, e) {
|
|
return (t = fn(t)), P(t.getFullYear() % 100, e, 2);
|
|
}
|
|
function Jr(t, e) {
|
|
return P(t.getFullYear() % 1e4, e, 4);
|
|
}
|
|
function $r(t, e) {
|
|
var n = t.getDay();
|
|
return (t = n >= 4 || n === 0 ? kt(t) : kt.ceil(t)), P(t.getFullYear() % 1e4, e, 4);
|
|
}
|
|
function Kr(t) {
|
|
var e = t.getTimezoneOffset();
|
|
return (e > 0 ? '-' : ((e *= -1), '+')) + P((e / 60) | 0, '0', 2) + P(e % 60, '0', 2);
|
|
}
|
|
function Ve(t, e) {
|
|
return P(t.getUTCDate(), e, 2);
|
|
}
|
|
function ti(t, e) {
|
|
return P(t.getUTCHours(), e, 2);
|
|
}
|
|
function ei(t, e) {
|
|
return P(t.getUTCHours() % 12 || 12, e, 2);
|
|
}
|
|
function ni(t, e) {
|
|
return P(1 + be.count(pt(t), t), e, 3);
|
|
}
|
|
function hn(t, e) {
|
|
return P(t.getUTCMilliseconds(), e, 3);
|
|
}
|
|
function ri(t, e) {
|
|
return hn(t, e) + '000';
|
|
}
|
|
function ii(t, e) {
|
|
return P(t.getUTCMonth() + 1, e, 2);
|
|
}
|
|
function si(t, e) {
|
|
return P(t.getUTCMinutes(), e, 2);
|
|
}
|
|
function ai(t, e) {
|
|
return P(t.getUTCSeconds(), e, 2);
|
|
}
|
|
function oi(t) {
|
|
var e = t.getUTCDay();
|
|
return e === 0 ? 7 : e;
|
|
}
|
|
function ci(t, e) {
|
|
return P(ln.count(pt(t) - 1, t), e, 2);
|
|
}
|
|
function dn(t) {
|
|
var e = t.getUTCDay();
|
|
return e >= 4 || e === 0 ? St(t) : St.ceil(t);
|
|
}
|
|
function li(t, e) {
|
|
return (t = dn(t)), P(St.count(pt(t), t) + (pt(t).getUTCDay() === 4), e, 2);
|
|
}
|
|
function ui(t) {
|
|
return t.getUTCDay();
|
|
}
|
|
function fi(t, e) {
|
|
return P(jt.count(pt(t) - 1, t), e, 2);
|
|
}
|
|
function hi(t, e) {
|
|
return P(t.getUTCFullYear() % 100, e, 2);
|
|
}
|
|
function di(t, e) {
|
|
return (t = dn(t)), P(t.getUTCFullYear() % 100, e, 2);
|
|
}
|
|
function mi(t, e) {
|
|
return P(t.getUTCFullYear() % 1e4, e, 4);
|
|
}
|
|
function gi(t, e) {
|
|
var n = t.getUTCDay();
|
|
return (t = n >= 4 || n === 0 ? St(t) : St.ceil(t)), P(t.getUTCFullYear() % 1e4, e, 4);
|
|
}
|
|
function yi() {
|
|
return '+0000';
|
|
}
|
|
function ze() {
|
|
return '%';
|
|
}
|
|
function Pe(t) {
|
|
return +t;
|
|
}
|
|
function Re(t) {
|
|
return Math.floor(+t / 1e3);
|
|
}
|
|
var xt, Qt;
|
|
ki({
|
|
dateTime: '%x, %X',
|
|
date: '%-m/%-d/%Y',
|
|
time: '%-I:%M:%S %p',
|
|
periods: ['AM', 'PM'],
|
|
days: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
|
|
shortDays: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
|
|
months: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
|
|
shortMonths: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
|
|
});
|
|
function ki(t) {
|
|
return (xt = kr(t)), (Qt = xt.format), xt.parse, xt.utcFormat, xt.utcParse, xt;
|
|
}
|
|
function pi(t) {
|
|
return new Date(t);
|
|
}
|
|
function Ti(t) {
|
|
return t instanceof Date ? +t : +new Date(+t);
|
|
}
|
|
function mn(t, e, n, r, i, s, a, k, Y, g) {
|
|
var b = Hn(),
|
|
U = b.invert,
|
|
C = b.domain,
|
|
v = g('.%L'),
|
|
q = g(':%S'),
|
|
y = g('%I:%M'),
|
|
L = g('%I %p'),
|
|
O = g('%a %d'),
|
|
W = g('%b %d'),
|
|
B = g('%B'),
|
|
Z = g('%Y');
|
|
function Q(x) {
|
|
return (Y(x) < x ? v : k(x) < x ? q : a(x) < x ? y : s(x) < x ? L : r(x) < x ? (i(x) < x ? O : W) : n(x) < x ? B : Z)(x);
|
|
}
|
|
return (
|
|
(b.invert = function (x) {
|
|
return new Date(U(x));
|
|
}),
|
|
(b.domain = function (x) {
|
|
return arguments.length ? C(Array.from(x, Ti)) : C().map(pi);
|
|
}),
|
|
(b.ticks = function (x) {
|
|
var E = C();
|
|
return t(E[0], E[E.length - 1], x ?? 10);
|
|
}),
|
|
(b.tickFormat = function (x, E) {
|
|
return E == null ? Q : g(E);
|
|
}),
|
|
(b.nice = function (x) {
|
|
var E = C();
|
|
return (!x || typeof x.range != 'function') && (x = e(E[0], E[E.length - 1], x ?? 10)), x ? C(sr(E, x)) : b;
|
|
}),
|
|
(b.copy = function () {
|
|
return Nn(b, mn(t, e, n, r, i, s, a, k, Y, g));
|
|
}),
|
|
b
|
|
);
|
|
}
|
|
function vi() {
|
|
return zn.apply(mn(gr, yr, mt, Wt, Ot, yt, Et, At, gt, Qt).domain([new Date(2e3, 0, 1), new Date(2e3, 0, 2)]), arguments);
|
|
}
|
|
var he = {},
|
|
bi = {
|
|
get exports() {
|
|
return he;
|
|
},
|
|
set exports(t) {
|
|
he = t;
|
|
},
|
|
};
|
|
(function (t, e) {
|
|
(function (n, r) {
|
|
t.exports = r();
|
|
})(Te, function () {
|
|
var n = 'day';
|
|
return function (r, i, s) {
|
|
var a = function (g) {
|
|
return g.add(4 - g.isoWeekday(), n);
|
|
},
|
|
k = i.prototype;
|
|
(k.isoWeekYear = function () {
|
|
return a(this).year();
|
|
}),
|
|
(k.isoWeek = function (g) {
|
|
if (!this.$utils().u(g)) return this.add(7 * (g - this.isoWeek()), n);
|
|
var b,
|
|
U,
|
|
C,
|
|
v,
|
|
q = a(this),
|
|
y =
|
|
((b = this.isoWeekYear()),
|
|
(U = this.$u),
|
|
(C = (U ? s.utc : s)().year(b).startOf('year')),
|
|
(v = 4 - C.isoWeekday()),
|
|
C.isoWeekday() > 4 && (v += 7),
|
|
C.add(v, n));
|
|
return q.diff(y, 'week') + 1;
|
|
}),
|
|
(k.isoWeekday = function (g) {
|
|
return this.$utils().u(g) ? this.day() || 7 : this.day(this.day() % 7 ? g : g - 7);
|
|
});
|
|
var Y = k.startOf;
|
|
k.startOf = function (g, b) {
|
|
var U = this.$utils(),
|
|
C = !!U.u(b) || b;
|
|
return U.p(g) === 'isoweek'
|
|
? C
|
|
? this.date(this.date() - (this.isoWeekday() - 1)).startOf('day')
|
|
: this.date(this.date() - 1 - (this.isoWeekday() - 1) + 7).endOf('day')
|
|
: Y.bind(this)(g, b);
|
|
};
|
|
};
|
|
});
|
|
})(bi);
|
|
const xi = he;
|
|
var de = {},
|
|
wi = {
|
|
get exports() {
|
|
return de;
|
|
},
|
|
set exports(t) {
|
|
de = t;
|
|
},
|
|
};
|
|
(function (t, e) {
|
|
(function (n, r) {
|
|
t.exports = r();
|
|
})(Te, function () {
|
|
var n = { LTS: 'h:mm:ss A', LT: 'h:mm A', L: 'MM/DD/YYYY', LL: 'MMMM D, YYYY', LLL: 'MMMM D, YYYY h:mm A', LLLL: 'dddd, MMMM D, YYYY h:mm A' },
|
|
r = /(\[[^[]*\])|([-_:/.,()\s]+)|(A|a|YYYY|YY?|MM?M?M?|Do|DD?|hh?|HH?|mm?|ss?|S{1,3}|z|ZZ?)/g,
|
|
i = /\d\d/,
|
|
s = /\d\d?/,
|
|
a = /\d*[^-_:/,()\s\d]+/,
|
|
k = {},
|
|
Y = function (y) {
|
|
return (y = +y) + (y > 68 ? 1900 : 2e3);
|
|
},
|
|
g = function (y) {
|
|
return function (L) {
|
|
this[y] = +L;
|
|
};
|
|
},
|
|
b = [
|
|
/[+-]\d\d:?(\d\d)?|Z/,
|
|
function (y) {
|
|
(this.zone || (this.zone = {})).offset = (function (L) {
|
|
if (!L || L === 'Z') return 0;
|
|
var O = L.match(/([+-]|\d\d)/g),
|
|
W = 60 * O[1] + (+O[2] || 0);
|
|
return W === 0 ? 0 : O[0] === '+' ? -W : W;
|
|
})(y);
|
|
},
|
|
],
|
|
U = function (y) {
|
|
var L = k[y];
|
|
return L && (L.indexOf ? L : L.s.concat(L.f));
|
|
},
|
|
C = function (y, L) {
|
|
var O,
|
|
W = k.meridiem;
|
|
if (W) {
|
|
for (var B = 1; B <= 24; B += 1)
|
|
if (y.indexOf(W(B, 0, L)) > -1) {
|
|
O = B > 12;
|
|
break;
|
|
}
|
|
} else O = y === (L ? 'pm' : 'PM');
|
|
return O;
|
|
},
|
|
v = {
|
|
A: [
|
|
a,
|
|
function (y) {
|
|
this.afternoon = C(y, !1);
|
|
},
|
|
],
|
|
a: [
|
|
a,
|
|
function (y) {
|
|
this.afternoon = C(y, !0);
|
|
},
|
|
],
|
|
S: [
|
|
/\d/,
|
|
function (y) {
|
|
this.milliseconds = 100 * +y;
|
|
},
|
|
],
|
|
SS: [
|
|
i,
|
|
function (y) {
|
|
this.milliseconds = 10 * +y;
|
|
},
|
|
],
|
|
SSS: [
|
|
/\d{3}/,
|
|
function (y) {
|
|
this.milliseconds = +y;
|
|
},
|
|
],
|
|
s: [s, g('seconds')],
|
|
ss: [s, g('seconds')],
|
|
m: [s, g('minutes')],
|
|
mm: [s, g('minutes')],
|
|
H: [s, g('hours')],
|
|
h: [s, g('hours')],
|
|
HH: [s, g('hours')],
|
|
hh: [s, g('hours')],
|
|
D: [s, g('day')],
|
|
DD: [i, g('day')],
|
|
Do: [
|
|
a,
|
|
function (y) {
|
|
var L = k.ordinal,
|
|
O = y.match(/\d+/);
|
|
if (((this.day = O[0]), L)) for (var W = 1; W <= 31; W += 1) L(W).replace(/\[|\]/g, '') === y && (this.day = W);
|
|
},
|
|
],
|
|
M: [s, g('month')],
|
|
MM: [i, g('month')],
|
|
MMM: [
|
|
a,
|
|
function (y) {
|
|
var L = U('months'),
|
|
O =
|
|
(
|
|
U('monthsShort') ||
|
|
L.map(function (W) {
|
|
return W.slice(0, 3);
|
|
})
|
|
).indexOf(y) + 1;
|
|
if (O < 1) throw new Error();
|
|
this.month = O % 12 || O;
|
|
},
|
|
],
|
|
MMMM: [
|
|
a,
|
|
function (y) {
|
|
var L = U('months').indexOf(y) + 1;
|
|
if (L < 1) throw new Error();
|
|
this.month = L % 12 || L;
|
|
},
|
|
],
|
|
Y: [/[+-]?\d+/, g('year')],
|
|
YY: [
|
|
i,
|
|
function (y) {
|
|
this.year = Y(y);
|
|
},
|
|
],
|
|
YYYY: [/\d{4}/, g('year')],
|
|
Z: b,
|
|
ZZ: b,
|
|
};
|
|
function q(y) {
|
|
var L, O;
|
|
(L = y), (O = k && k.formats);
|
|
for (
|
|
var W = (y = L.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g, function (F, M, w) {
|
|
var o = w && w.toUpperCase();
|
|
return (
|
|
M ||
|
|
O[w] ||
|
|
n[w] ||
|
|
O[o].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, function (d, m, u) {
|
|
return m || u.slice(1);
|
|
})
|
|
);
|
|
})).match(r),
|
|
B = W.length,
|
|
Z = 0;
|
|
Z < B;
|
|
Z += 1
|
|
) {
|
|
var Q = W[Z],
|
|
x = v[Q],
|
|
E = x && x[0],
|
|
T = x && x[1];
|
|
W[Z] = T ? { regex: E, parser: T } : Q.replace(/^\[|\]$/g, '');
|
|
}
|
|
return function (F) {
|
|
for (var M = {}, w = 0, o = 0; w < B; w += 1) {
|
|
var d = W[w];
|
|
if (typeof d == 'string') o += d.length;
|
|
else {
|
|
var m = d.regex,
|
|
u = d.parser,
|
|
S = F.slice(o),
|
|
c = m.exec(S)[0];
|
|
u.call(M, c), (F = F.replace(c, ''));
|
|
}
|
|
}
|
|
return (
|
|
(function (X) {
|
|
var f = X.afternoon;
|
|
if (f !== void 0) {
|
|
var h = X.hours;
|
|
f ? h < 12 && (X.hours += 12) : h === 12 && (X.hours = 0), delete X.afternoon;
|
|
}
|
|
})(M),
|
|
M
|
|
);
|
|
};
|
|
}
|
|
return function (y, L, O) {
|
|
(O.p.customParseFormat = !0), y && y.parseTwoDigitYear && (Y = y.parseTwoDigitYear);
|
|
var W = L.prototype,
|
|
B = W.parse;
|
|
W.parse = function (Z) {
|
|
var Q = Z.date,
|
|
x = Z.utc,
|
|
E = Z.args;
|
|
this.$u = x;
|
|
var T = E[1];
|
|
if (typeof T == 'string') {
|
|
var F = E[2] === !0,
|
|
M = E[3] === !0,
|
|
w = F || M,
|
|
o = E[2];
|
|
M && (o = E[2]),
|
|
(k = this.$locale()),
|
|
!F && o && (k = O.Ls[o]),
|
|
(this.$d = (function (S, c, X) {
|
|
try {
|
|
if (['x', 'X'].indexOf(c) > -1) return new Date((c === 'X' ? 1e3 : 1) * S);
|
|
var f = q(c)(S),
|
|
h = f.year,
|
|
_ = f.month,
|
|
G = f.day,
|
|
H = f.hours,
|
|
V = f.minutes,
|
|
I = f.seconds,
|
|
z = f.milliseconds,
|
|
st = f.zone,
|
|
it = new Date(),
|
|
p = G || (h || _ ? 1 : it.getDate()),
|
|
A = h || it.getFullYear(),
|
|
D = 0;
|
|
(h && !_) || (D = _ > 0 ? _ - 1 : it.getMonth());
|
|
var l = H || 0,
|
|
R = V || 0,
|
|
N = I || 0,
|
|
j = z || 0;
|
|
return st
|
|
? new Date(Date.UTC(A, D, p, l, R, N, j + 60 * st.offset * 1e3))
|
|
: X
|
|
? new Date(Date.UTC(A, D, p, l, R, N, j))
|
|
: new Date(A, D, p, l, R, N, j);
|
|
} catch {
|
|
return new Date('');
|
|
}
|
|
})(Q, T, x)),
|
|
this.init(),
|
|
o && o !== !0 && (this.$L = this.locale(o).$L),
|
|
w && Q != this.format(T) && (this.$d = new Date('')),
|
|
(k = {});
|
|
} else if (T instanceof Array)
|
|
for (var d = T.length, m = 1; m <= d; m += 1) {
|
|
E[1] = T[m - 1];
|
|
var u = O.apply(this, E);
|
|
if (u.isValid()) {
|
|
(this.$d = u.$d), (this.$L = u.$L), this.init();
|
|
break;
|
|
}
|
|
m === d && (this.$d = new Date(''));
|
|
}
|
|
else B.call(this, Z);
|
|
};
|
|
};
|
|
});
|
|
})(wi);
|
|
const Ci = de;
|
|
var me = {},
|
|
Mi = {
|
|
get exports() {
|
|
return me;
|
|
},
|
|
set exports(t) {
|
|
me = t;
|
|
},
|
|
};
|
|
(function (t, e) {
|
|
(function (n, r) {
|
|
t.exports = r();
|
|
})(Te, function () {
|
|
return function (n, r) {
|
|
var i = r.prototype,
|
|
s = i.format;
|
|
i.format = function (a) {
|
|
var k = this,
|
|
Y = this.$locale();
|
|
if (!this.isValid()) return s.bind(this)(a);
|
|
var g = this.$utils(),
|
|
b = (a || 'YYYY-MM-DDTHH:mm:ssZ').replace(/\[([^\]]+)]|Q|wo|ww|w|WW|W|zzz|z|gggg|GGGG|Do|X|x|k{1,2}|S/g, function (U) {
|
|
switch (U) {
|
|
case 'Q':
|
|
return Math.ceil((k.$M + 1) / 3);
|
|
case 'Do':
|
|
return Y.ordinal(k.$D);
|
|
case 'gggg':
|
|
return k.weekYear();
|
|
case 'GGGG':
|
|
return k.isoWeekYear();
|
|
case 'wo':
|
|
return Y.ordinal(k.week(), 'W');
|
|
case 'w':
|
|
case 'ww':
|
|
return g.s(k.week(), U === 'w' ? 1 : 2, '0');
|
|
case 'W':
|
|
case 'WW':
|
|
return g.s(k.isoWeek(), U === 'W' ? 1 : 2, '0');
|
|
case 'k':
|
|
case 'kk':
|
|
return g.s(String(k.$H === 0 ? 24 : k.$H), U === 'k' ? 1 : 2, '0');
|
|
case 'X':
|
|
return Math.floor(k.$d.getTime() / 1e3);
|
|
case 'x':
|
|
return k.$d.getTime();
|
|
case 'z':
|
|
return '[' + k.offsetName() + ']';
|
|
case 'zzz':
|
|
return '[' + k.offsetName('long') + ']';
|
|
default:
|
|
return U;
|
|
}
|
|
});
|
|
return s.bind(this)(b);
|
|
};
|
|
};
|
|
});
|
|
})(Mi);
|
|
const Di = me;
|
|
var ge = (function () {
|
|
var t = function (w, o, d, m) {
|
|
for (d = d || {}, m = w.length; m--; d[w[m]] = o);
|
|
return d;
|
|
},
|
|
e = [6, 8, 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 30, 32, 33, 35, 37],
|
|
n = [1, 25],
|
|
r = [1, 26],
|
|
i = [1, 27],
|
|
s = [1, 28],
|
|
a = [1, 29],
|
|
k = [1, 30],
|
|
Y = [1, 31],
|
|
g = [1, 9],
|
|
b = [1, 10],
|
|
U = [1, 11],
|
|
C = [1, 12],
|
|
v = [1, 13],
|
|
q = [1, 14],
|
|
y = [1, 15],
|
|
L = [1, 16],
|
|
O = [1, 18],
|
|
W = [1, 19],
|
|
B = [1, 20],
|
|
Z = [1, 21],
|
|
Q = [1, 22],
|
|
x = [1, 24],
|
|
E = [1, 32],
|
|
T = {
|
|
trace: function () {},
|
|
yy: {},
|
|
symbols_: {
|
|
error: 2,
|
|
start: 3,
|
|
gantt: 4,
|
|
document: 5,
|
|
EOF: 6,
|
|
line: 7,
|
|
SPACE: 8,
|
|
statement: 9,
|
|
NL: 10,
|
|
weekday: 11,
|
|
weekday_monday: 12,
|
|
weekday_tuesday: 13,
|
|
weekday_wednesday: 14,
|
|
weekday_thursday: 15,
|
|
weekday_friday: 16,
|
|
weekday_saturday: 17,
|
|
weekday_sunday: 18,
|
|
dateFormat: 19,
|
|
inclusiveEndDates: 20,
|
|
topAxis: 21,
|
|
axisFormat: 22,
|
|
tickInterval: 23,
|
|
excludes: 24,
|
|
includes: 25,
|
|
todayMarker: 26,
|
|
title: 27,
|
|
acc_title: 28,
|
|
acc_title_value: 29,
|
|
acc_descr: 30,
|
|
acc_descr_value: 31,
|
|
acc_descr_multiline_value: 32,
|
|
section: 33,
|
|
clickStatement: 34,
|
|
taskTxt: 35,
|
|
taskData: 36,
|
|
click: 37,
|
|
callbackname: 38,
|
|
callbackargs: 39,
|
|
href: 40,
|
|
clickStatementDebug: 41,
|
|
$accept: 0,
|
|
$end: 1,
|
|
},
|
|
terminals_: {
|
|
2: 'error',
|
|
4: 'gantt',
|
|
6: 'EOF',
|
|
8: 'SPACE',
|
|
10: 'NL',
|
|
12: 'weekday_monday',
|
|
13: 'weekday_tuesday',
|
|
14: 'weekday_wednesday',
|
|
15: 'weekday_thursday',
|
|
16: 'weekday_friday',
|
|
17: 'weekday_saturday',
|
|
18: 'weekday_sunday',
|
|
19: 'dateFormat',
|
|
20: 'inclusiveEndDates',
|
|
21: 'topAxis',
|
|
22: 'axisFormat',
|
|
23: 'tickInterval',
|
|
24: 'excludes',
|
|
25: 'includes',
|
|
26: 'todayMarker',
|
|
27: 'title',
|
|
28: 'acc_title',
|
|
29: 'acc_title_value',
|
|
30: 'acc_descr',
|
|
31: 'acc_descr_value',
|
|
32: 'acc_descr_multiline_value',
|
|
33: 'section',
|
|
35: 'taskTxt',
|
|
36: 'taskData',
|
|
37: 'click',
|
|
38: 'callbackname',
|
|
39: 'callbackargs',
|
|
40: 'href',
|
|
},
|
|
productions_: [
|
|
0,
|
|
[3, 3],
|
|
[5, 0],
|
|
[5, 2],
|
|
[7, 2],
|
|
[7, 1],
|
|
[7, 1],
|
|
[7, 1],
|
|
[11, 1],
|
|
[11, 1],
|
|
[11, 1],
|
|
[11, 1],
|
|
[11, 1],
|
|
[11, 1],
|
|
[11, 1],
|
|
[9, 1],
|
|
[9, 1],
|
|
[9, 1],
|
|
[9, 1],
|
|
[9, 1],
|
|
[9, 1],
|
|
[9, 1],
|
|
[9, 1],
|
|
[9, 1],
|
|
[9, 1],
|
|
[9, 2],
|
|
[9, 2],
|
|
[9, 1],
|
|
[9, 1],
|
|
[9, 1],
|
|
[9, 2],
|
|
[34, 2],
|
|
[34, 3],
|
|
[34, 3],
|
|
[34, 4],
|
|
[34, 3],
|
|
[34, 4],
|
|
[34, 2],
|
|
[41, 2],
|
|
[41, 3],
|
|
[41, 3],
|
|
[41, 4],
|
|
[41, 3],
|
|
[41, 4],
|
|
[41, 2],
|
|
],
|
|
performAction: function (o, d, m, u, S, c, X) {
|
|
var f = c.length - 1;
|
|
switch (S) {
|
|
case 1:
|
|
return c[f - 1];
|
|
case 2:
|
|
this.$ = [];
|
|
break;
|
|
case 3:
|
|
c[f - 1].push(c[f]), (this.$ = c[f - 1]);
|
|
break;
|
|
case 4:
|
|
case 5:
|
|
this.$ = c[f];
|
|
break;
|
|
case 6:
|
|
case 7:
|
|
this.$ = [];
|
|
break;
|
|
case 8:
|
|
u.setWeekday('monday');
|
|
break;
|
|
case 9:
|
|
u.setWeekday('tuesday');
|
|
break;
|
|
case 10:
|
|
u.setWeekday('wednesday');
|
|
break;
|
|
case 11:
|
|
u.setWeekday('thursday');
|
|
break;
|
|
case 12:
|
|
u.setWeekday('friday');
|
|
break;
|
|
case 13:
|
|
u.setWeekday('saturday');
|
|
break;
|
|
case 14:
|
|
u.setWeekday('sunday');
|
|
break;
|
|
case 15:
|
|
u.setDateFormat(c[f].substr(11)), (this.$ = c[f].substr(11));
|
|
break;
|
|
case 16:
|
|
u.enableInclusiveEndDates(), (this.$ = c[f].substr(18));
|
|
break;
|
|
case 17:
|
|
u.TopAxis(), (this.$ = c[f].substr(8));
|
|
break;
|
|
case 18:
|
|
u.setAxisFormat(c[f].substr(11)), (this.$ = c[f].substr(11));
|
|
break;
|
|
case 19:
|
|
u.setTickInterval(c[f].substr(13)), (this.$ = c[f].substr(13));
|
|
break;
|
|
case 20:
|
|
u.setExcludes(c[f].substr(9)), (this.$ = c[f].substr(9));
|
|
break;
|
|
case 21:
|
|
u.setIncludes(c[f].substr(9)), (this.$ = c[f].substr(9));
|
|
break;
|
|
case 22:
|
|
u.setTodayMarker(c[f].substr(12)), (this.$ = c[f].substr(12));
|
|
break;
|
|
case 24:
|
|
u.setDiagramTitle(c[f].substr(6)), (this.$ = c[f].substr(6));
|
|
break;
|
|
case 25:
|
|
(this.$ = c[f].trim()), u.setAccTitle(this.$);
|
|
break;
|
|
case 26:
|
|
case 27:
|
|
(this.$ = c[f].trim()), u.setAccDescription(this.$);
|
|
break;
|
|
case 28:
|
|
u.addSection(c[f].substr(8)), (this.$ = c[f].substr(8));
|
|
break;
|
|
case 30:
|
|
u.addTask(c[f - 1], c[f]), (this.$ = 'task');
|
|
break;
|
|
case 31:
|
|
(this.$ = c[f - 1]), u.setClickEvent(c[f - 1], c[f], null);
|
|
break;
|
|
case 32:
|
|
(this.$ = c[f - 2]), u.setClickEvent(c[f - 2], c[f - 1], c[f]);
|
|
break;
|
|
case 33:
|
|
(this.$ = c[f - 2]), u.setClickEvent(c[f - 2], c[f - 1], null), u.setLink(c[f - 2], c[f]);
|
|
break;
|
|
case 34:
|
|
(this.$ = c[f - 3]), u.setClickEvent(c[f - 3], c[f - 2], c[f - 1]), u.setLink(c[f - 3], c[f]);
|
|
break;
|
|
case 35:
|
|
(this.$ = c[f - 2]), u.setClickEvent(c[f - 2], c[f], null), u.setLink(c[f - 2], c[f - 1]);
|
|
break;
|
|
case 36:
|
|
(this.$ = c[f - 3]), u.setClickEvent(c[f - 3], c[f - 1], c[f]), u.setLink(c[f - 3], c[f - 2]);
|
|
break;
|
|
case 37:
|
|
(this.$ = c[f - 1]), u.setLink(c[f - 1], c[f]);
|
|
break;
|
|
case 38:
|
|
case 44:
|
|
this.$ = c[f - 1] + ' ' + c[f];
|
|
break;
|
|
case 39:
|
|
case 40:
|
|
case 42:
|
|
this.$ = c[f - 2] + ' ' + c[f - 1] + ' ' + c[f];
|
|
break;
|
|
case 41:
|
|
case 43:
|
|
this.$ = c[f - 3] + ' ' + c[f - 2] + ' ' + c[f - 1] + ' ' + c[f];
|
|
break;
|
|
}
|
|
},
|
|
table: [
|
|
{ 3: 1, 4: [1, 2] },
|
|
{ 1: [3] },
|
|
t(e, [2, 2], { 5: 3 }),
|
|
{
|
|
6: [1, 4],
|
|
7: 5,
|
|
8: [1, 6],
|
|
9: 7,
|
|
10: [1, 8],
|
|
11: 17,
|
|
12: n,
|
|
13: r,
|
|
14: i,
|
|
15: s,
|
|
16: a,
|
|
17: k,
|
|
18: Y,
|
|
19: g,
|
|
20: b,
|
|
21: U,
|
|
22: C,
|
|
23: v,
|
|
24: q,
|
|
25: y,
|
|
26: L,
|
|
27: O,
|
|
28: W,
|
|
30: B,
|
|
32: Z,
|
|
33: Q,
|
|
34: 23,
|
|
35: x,
|
|
37: E,
|
|
},
|
|
t(e, [2, 7], { 1: [2, 1] }),
|
|
t(e, [2, 3]),
|
|
{
|
|
9: 33,
|
|
11: 17,
|
|
12: n,
|
|
13: r,
|
|
14: i,
|
|
15: s,
|
|
16: a,
|
|
17: k,
|
|
18: Y,
|
|
19: g,
|
|
20: b,
|
|
21: U,
|
|
22: C,
|
|
23: v,
|
|
24: q,
|
|
25: y,
|
|
26: L,
|
|
27: O,
|
|
28: W,
|
|
30: B,
|
|
32: Z,
|
|
33: Q,
|
|
34: 23,
|
|
35: x,
|
|
37: E,
|
|
},
|
|
t(e, [2, 5]),
|
|
t(e, [2, 6]),
|
|
t(e, [2, 15]),
|
|
t(e, [2, 16]),
|
|
t(e, [2, 17]),
|
|
t(e, [2, 18]),
|
|
t(e, [2, 19]),
|
|
t(e, [2, 20]),
|
|
t(e, [2, 21]),
|
|
t(e, [2, 22]),
|
|
t(e, [2, 23]),
|
|
t(e, [2, 24]),
|
|
{ 29: [1, 34] },
|
|
{ 31: [1, 35] },
|
|
t(e, [2, 27]),
|
|
t(e, [2, 28]),
|
|
t(e, [2, 29]),
|
|
{ 36: [1, 36] },
|
|
t(e, [2, 8]),
|
|
t(e, [2, 9]),
|
|
t(e, [2, 10]),
|
|
t(e, [2, 11]),
|
|
t(e, [2, 12]),
|
|
t(e, [2, 13]),
|
|
t(e, [2, 14]),
|
|
{ 38: [1, 37], 40: [1, 38] },
|
|
t(e, [2, 4]),
|
|
t(e, [2, 25]),
|
|
t(e, [2, 26]),
|
|
t(e, [2, 30]),
|
|
t(e, [2, 31], { 39: [1, 39], 40: [1, 40] }),
|
|
t(e, [2, 37], { 38: [1, 41] }),
|
|
t(e, [2, 32], { 40: [1, 42] }),
|
|
t(e, [2, 33]),
|
|
t(e, [2, 35], { 39: [1, 43] }),
|
|
t(e, [2, 34]),
|
|
t(e, [2, 36]),
|
|
],
|
|
defaultActions: {},
|
|
parseError: function (o, d) {
|
|
if (d.recoverable) this.trace(o);
|
|
else {
|
|
var m = new Error(o);
|
|
throw ((m.hash = d), m);
|
|
}
|
|
},
|
|
parse: function (o) {
|
|
var d = this,
|
|
m = [0],
|
|
u = [],
|
|
S = [null],
|
|
c = [],
|
|
X = this.table,
|
|
f = '',
|
|
h = 0,
|
|
_ = 0,
|
|
G = 2,
|
|
H = 1,
|
|
V = c.slice.call(arguments, 1),
|
|
I = Object.create(this.lexer),
|
|
z = { yy: {} };
|
|
for (var st in this.yy) Object.prototype.hasOwnProperty.call(this.yy, st) && (z.yy[st] = this.yy[st]);
|
|
I.setInput(o, z.yy), (z.yy.lexer = I), (z.yy.parser = this), typeof I.yylloc > 'u' && (I.yylloc = {});
|
|
var it = I.yylloc;
|
|
c.push(it);
|
|
var p = I.options && I.options.ranges;
|
|
typeof z.yy.parseError == 'function' ? (this.parseError = z.yy.parseError) : (this.parseError = Object.getPrototypeOf(this).parseError);
|
|
function A() {
|
|
var ct;
|
|
return (
|
|
(ct = u.pop() || I.lex() || H),
|
|
typeof ct != 'number' && (ct instanceof Array && ((u = ct), (ct = u.pop())), (ct = d.symbols_[ct] || ct)),
|
|
ct
|
|
);
|
|
}
|
|
for (var D, l, R, N, j = {}, J, et, Ut, zt; ; ) {
|
|
if (
|
|
((l = m[m.length - 1]),
|
|
this.defaultActions[l] ? (R = this.defaultActions[l]) : ((D === null || typeof D > 'u') && (D = A()), (R = X[l] && X[l][D])),
|
|
typeof R > 'u' || !R.length || !R[0])
|
|
) {
|
|
var $t = '';
|
|
zt = [];
|
|
for (J in X[l]) this.terminals_[J] && J > G && zt.push("'" + this.terminals_[J] + "'");
|
|
I.showPosition
|
|
? ($t =
|
|
'Parse error on line ' +
|
|
(h + 1) +
|
|
`:
|
|
` +
|
|
I.showPosition() +
|
|
`
|
|
Expecting ` +
|
|
zt.join(', ') +
|
|
", got '" +
|
|
(this.terminals_[D] || D) +
|
|
"'")
|
|
: ($t = 'Parse error on line ' + (h + 1) + ': Unexpected ' + (D == H ? 'end of input' : "'" + (this.terminals_[D] || D) + "'")),
|
|
this.parseError($t, { text: I.match, token: this.terminals_[D] || D, line: I.yylineno, loc: it, expected: zt });
|
|
}
|
|
if (R[0] instanceof Array && R.length > 1) throw new Error('Parse Error: multiple actions possible at state: ' + l + ', token: ' + D);
|
|
switch (R[0]) {
|
|
case 1:
|
|
m.push(D),
|
|
S.push(I.yytext),
|
|
c.push(I.yylloc),
|
|
m.push(R[1]),
|
|
(D = null),
|
|
(_ = I.yyleng),
|
|
(f = I.yytext),
|
|
(h = I.yylineno),
|
|
(it = I.yylloc);
|
|
break;
|
|
case 2:
|
|
if (
|
|
((et = this.productions_[R[1]][1]),
|
|
(j.$ = S[S.length - et]),
|
|
(j._$ = {
|
|
first_line: c[c.length - (et || 1)].first_line,
|
|
last_line: c[c.length - 1].last_line,
|
|
first_column: c[c.length - (et || 1)].first_column,
|
|
last_column: c[c.length - 1].last_column,
|
|
}),
|
|
p && (j._$.range = [c[c.length - (et || 1)].range[0], c[c.length - 1].range[1]]),
|
|
(N = this.performAction.apply(j, [f, _, h, z.yy, R[1], S, c].concat(V))),
|
|
typeof N < 'u')
|
|
)
|
|
return N;
|
|
et && ((m = m.slice(0, -1 * et * 2)), (S = S.slice(0, -1 * et)), (c = c.slice(0, -1 * et))),
|
|
m.push(this.productions_[R[1]][0]),
|
|
S.push(j.$),
|
|
c.push(j._$),
|
|
(Ut = X[m[m.length - 2]][m[m.length - 1]]),
|
|
m.push(Ut);
|
|
break;
|
|
case 3:
|
|
return !0;
|
|
}
|
|
}
|
|
return !0;
|
|
},
|
|
},
|
|
F = (function () {
|
|
var w = {
|
|
EOF: 1,
|
|
parseError: function (d, m) {
|
|
if (this.yy.parser) this.yy.parser.parseError(d, m);
|
|
else throw new Error(d);
|
|
},
|
|
setInput: function (o, d) {
|
|
return (
|
|
(this.yy = d || this.yy || {}),
|
|
(this._input = o),
|
|
(this._more = this._backtrack = this.done = !1),
|
|
(this.yylineno = this.yyleng = 0),
|
|
(this.yytext = this.matched = this.match = ''),
|
|
(this.conditionStack = ['INITIAL']),
|
|
(this.yylloc = { first_line: 1, first_column: 0, last_line: 1, last_column: 0 }),
|
|
this.options.ranges && (this.yylloc.range = [0, 0]),
|
|
(this.offset = 0),
|
|
this
|
|
);
|
|
},
|
|
input: function () {
|
|
var o = this._input[0];
|
|
(this.yytext += o), this.yyleng++, this.offset++, (this.match += o), (this.matched += o);
|
|
var d = o.match(/(?:\r\n?|\n).*/g);
|
|
return (
|
|
d ? (this.yylineno++, this.yylloc.last_line++) : this.yylloc.last_column++,
|
|
this.options.ranges && this.yylloc.range[1]++,
|
|
(this._input = this._input.slice(1)),
|
|
o
|
|
);
|
|
},
|
|
unput: function (o) {
|
|
var d = o.length,
|
|
m = o.split(/(?:\r\n?|\n)/g);
|
|
(this._input = o + this._input), (this.yytext = this.yytext.substr(0, this.yytext.length - d)), (this.offset -= d);
|
|
var u = this.match.split(/(?:\r\n?|\n)/g);
|
|
(this.match = this.match.substr(0, this.match.length - 1)),
|
|
(this.matched = this.matched.substr(0, this.matched.length - 1)),
|
|
m.length - 1 && (this.yylineno -= m.length - 1);
|
|
var S = this.yylloc.range;
|
|
return (
|
|
(this.yylloc = {
|
|
first_line: this.yylloc.first_line,
|
|
last_line: this.yylineno + 1,
|
|
first_column: this.yylloc.first_column,
|
|
last_column: m
|
|
? (m.length === u.length ? this.yylloc.first_column : 0) + u[u.length - m.length].length - m[0].length
|
|
: this.yylloc.first_column - d,
|
|
}),
|
|
this.options.ranges && (this.yylloc.range = [S[0], S[0] + this.yyleng - d]),
|
|
(this.yyleng = this.yytext.length),
|
|
this
|
|
);
|
|
},
|
|
more: function () {
|
|
return (this._more = !0), this;
|
|
},
|
|
reject: function () {
|
|
if (this.options.backtrack_lexer) this._backtrack = !0;
|
|
else
|
|
return this.parseError(
|
|
'Lexical error on line ' +
|
|
(this.yylineno + 1) +
|
|
`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
|
|
` +
|
|
this.showPosition(),
|
|
{ text: '', token: null, line: this.yylineno }
|
|
);
|
|
return this;
|
|
},
|
|
less: function (o) {
|
|
this.unput(this.match.slice(o));
|
|
},
|
|
pastInput: function () {
|
|
var o = this.matched.substr(0, this.matched.length - this.match.length);
|
|
return (o.length > 20 ? '...' : '') + o.substr(-20).replace(/\n/g, '');
|
|
},
|
|
upcomingInput: function () {
|
|
var o = this.match;
|
|
return o.length < 20 && (o += this._input.substr(0, 20 - o.length)), (o.substr(0, 20) + (o.length > 20 ? '...' : '')).replace(/\n/g, '');
|
|
},
|
|
showPosition: function () {
|
|
var o = this.pastInput(),
|
|
d = new Array(o.length + 1).join('-');
|
|
return (
|
|
o +
|
|
this.upcomingInput() +
|
|
`
|
|
` +
|
|
d +
|
|
'^'
|
|
);
|
|
},
|
|
test_match: function (o, d) {
|
|
var m, u, S;
|
|
if (
|
|
(this.options.backtrack_lexer &&
|
|
((S = {
|
|
yylineno: this.yylineno,
|
|
yylloc: {
|
|
first_line: this.yylloc.first_line,
|
|
last_line: this.last_line,
|
|
first_column: this.yylloc.first_column,
|
|
last_column: this.yylloc.last_column,
|
|
},
|
|
yytext: this.yytext,
|
|
match: this.match,
|
|
matches: this.matches,
|
|
matched: this.matched,
|
|
yyleng: this.yyleng,
|
|
offset: this.offset,
|
|
_more: this._more,
|
|
_input: this._input,
|
|
yy: this.yy,
|
|
conditionStack: this.conditionStack.slice(0),
|
|
done: this.done,
|
|
}),
|
|
this.options.ranges && (S.yylloc.range = this.yylloc.range.slice(0))),
|
|
(u = o[0].match(/(?:\r\n?|\n).*/g)),
|
|
u && (this.yylineno += u.length),
|
|
(this.yylloc = {
|
|
first_line: this.yylloc.last_line,
|
|
last_line: this.yylineno + 1,
|
|
first_column: this.yylloc.last_column,
|
|
last_column: u ? u[u.length - 1].length - u[u.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + o[0].length,
|
|
}),
|
|
(this.yytext += o[0]),
|
|
(this.match += o[0]),
|
|
(this.matches = o),
|
|
(this.yyleng = this.yytext.length),
|
|
this.options.ranges && (this.yylloc.range = [this.offset, (this.offset += this.yyleng)]),
|
|
(this._more = !1),
|
|
(this._backtrack = !1),
|
|
(this._input = this._input.slice(o[0].length)),
|
|
(this.matched += o[0]),
|
|
(m = this.performAction.call(this, this.yy, this, d, this.conditionStack[this.conditionStack.length - 1])),
|
|
this.done && this._input && (this.done = !1),
|
|
m)
|
|
)
|
|
return m;
|
|
if (this._backtrack) {
|
|
for (var c in S) this[c] = S[c];
|
|
return !1;
|
|
}
|
|
return !1;
|
|
},
|
|
next: function () {
|
|
if (this.done) return this.EOF;
|
|
this._input || (this.done = !0);
|
|
var o, d, m, u;
|
|
this._more || ((this.yytext = ''), (this.match = ''));
|
|
for (var S = this._currentRules(), c = 0; c < S.length; c++)
|
|
if (((m = this._input.match(this.rules[S[c]])), m && (!d || m[0].length > d[0].length))) {
|
|
if (((d = m), (u = c), this.options.backtrack_lexer)) {
|
|
if (((o = this.test_match(m, S[c])), o !== !1)) return o;
|
|
if (this._backtrack) {
|
|
d = !1;
|
|
continue;
|
|
} else return !1;
|
|
} else if (!this.options.flex) break;
|
|
}
|
|
return d
|
|
? ((o = this.test_match(d, S[u])), o !== !1 ? o : !1)
|
|
: this._input === ''
|
|
? this.EOF
|
|
: this.parseError(
|
|
'Lexical error on line ' +
|
|
(this.yylineno + 1) +
|
|
`. Unrecognized text.
|
|
` +
|
|
this.showPosition(),
|
|
{ text: '', token: null, line: this.yylineno }
|
|
);
|
|
},
|
|
lex: function () {
|
|
var d = this.next();
|
|
return d || this.lex();
|
|
},
|
|
begin: function (d) {
|
|
this.conditionStack.push(d);
|
|
},
|
|
popState: function () {
|
|
var d = this.conditionStack.length - 1;
|
|
return d > 0 ? this.conditionStack.pop() : this.conditionStack[0];
|
|
},
|
|
_currentRules: function () {
|
|
return this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]
|
|
? this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules
|
|
: this.conditions.INITIAL.rules;
|
|
},
|
|
topState: function (d) {
|
|
return (d = this.conditionStack.length - 1 - Math.abs(d || 0)), d >= 0 ? this.conditionStack[d] : 'INITIAL';
|
|
},
|
|
pushState: function (d) {
|
|
this.begin(d);
|
|
},
|
|
stateStackSize: function () {
|
|
return this.conditionStack.length;
|
|
},
|
|
options: { 'case-insensitive': !0 },
|
|
performAction: function (d, m, u, S) {
|
|
switch (u) {
|
|
case 0:
|
|
return this.begin('open_directive'), 'open_directive';
|
|
case 1:
|
|
return this.begin('acc_title'), 28;
|
|
case 2:
|
|
return this.popState(), 'acc_title_value';
|
|
case 3:
|
|
return this.begin('acc_descr'), 30;
|
|
case 4:
|
|
return this.popState(), 'acc_descr_value';
|
|
case 5:
|
|
this.begin('acc_descr_multiline');
|
|
break;
|
|
case 6:
|
|
this.popState();
|
|
break;
|
|
case 7:
|
|
return 'acc_descr_multiline_value';
|
|
case 8:
|
|
break;
|
|
case 9:
|
|
break;
|
|
case 10:
|
|
break;
|
|
case 11:
|
|
return 10;
|
|
case 12:
|
|
break;
|
|
case 13:
|
|
break;
|
|
case 14:
|
|
this.begin('href');
|
|
break;
|
|
case 15:
|
|
this.popState();
|
|
break;
|
|
case 16:
|
|
return 40;
|
|
case 17:
|
|
this.begin('callbackname');
|
|
break;
|
|
case 18:
|
|
this.popState();
|
|
break;
|
|
case 19:
|
|
this.popState(), this.begin('callbackargs');
|
|
break;
|
|
case 20:
|
|
return 38;
|
|
case 21:
|
|
this.popState();
|
|
break;
|
|
case 22:
|
|
return 39;
|
|
case 23:
|
|
this.begin('click');
|
|
break;
|
|
case 24:
|
|
this.popState();
|
|
break;
|
|
case 25:
|
|
return 37;
|
|
case 26:
|
|
return 4;
|
|
case 27:
|
|
return 19;
|
|
case 28:
|
|
return 20;
|
|
case 29:
|
|
return 21;
|
|
case 30:
|
|
return 22;
|
|
case 31:
|
|
return 23;
|
|
case 32:
|
|
return 25;
|
|
case 33:
|
|
return 24;
|
|
case 34:
|
|
return 26;
|
|
case 35:
|
|
return 12;
|
|
case 36:
|
|
return 13;
|
|
case 37:
|
|
return 14;
|
|
case 38:
|
|
return 15;
|
|
case 39:
|
|
return 16;
|
|
case 40:
|
|
return 17;
|
|
case 41:
|
|
return 18;
|
|
case 42:
|
|
return 'date';
|
|
case 43:
|
|
return 27;
|
|
case 44:
|
|
return 'accDescription';
|
|
case 45:
|
|
return 33;
|
|
case 46:
|
|
return 35;
|
|
case 47:
|
|
return 36;
|
|
case 48:
|
|
return ':';
|
|
case 49:
|
|
return 6;
|
|
case 50:
|
|
return 'INVALID';
|
|
}
|
|
},
|
|
rules: [
|
|
/^(?:%%\{)/i,
|
|
/^(?:accTitle\s*:\s*)/i,
|
|
/^(?:(?!\n||)*[^\n]*)/i,
|
|
/^(?:accDescr\s*:\s*)/i,
|
|
/^(?:(?!\n||)*[^\n]*)/i,
|
|
/^(?:accDescr\s*\{\s*)/i,
|
|
/^(?:[\}])/i,
|
|
/^(?:[^\}]*)/i,
|
|
/^(?:%%(?!\{)*[^\n]*)/i,
|
|
/^(?:[^\}]%%*[^\n]*)/i,
|
|
/^(?:%%*[^\n]*[\n]*)/i,
|
|
/^(?:[\n]+)/i,
|
|
/^(?:\s+)/i,
|
|
/^(?:%[^\n]*)/i,
|
|
/^(?:href[\s]+["])/i,
|
|
/^(?:["])/i,
|
|
/^(?:[^"]*)/i,
|
|
/^(?:call[\s]+)/i,
|
|
/^(?:\([\s]*\))/i,
|
|
/^(?:\()/i,
|
|
/^(?:[^(]*)/i,
|
|
/^(?:\))/i,
|
|
/^(?:[^)]*)/i,
|
|
/^(?:click[\s]+)/i,
|
|
/^(?:[\s\n])/i,
|
|
/^(?:[^\s\n]*)/i,
|
|
/^(?:gantt\b)/i,
|
|
/^(?:dateFormat\s[^#\n;]+)/i,
|
|
/^(?:inclusiveEndDates\b)/i,
|
|
/^(?:topAxis\b)/i,
|
|
/^(?:axisFormat\s[^#\n;]+)/i,
|
|
/^(?:tickInterval\s[^#\n;]+)/i,
|
|
/^(?:includes\s[^#\n;]+)/i,
|
|
/^(?:excludes\s[^#\n;]+)/i,
|
|
/^(?:todayMarker\s[^\n;]+)/i,
|
|
/^(?:weekday\s+monday\b)/i,
|
|
/^(?:weekday\s+tuesday\b)/i,
|
|
/^(?:weekday\s+wednesday\b)/i,
|
|
/^(?:weekday\s+thursday\b)/i,
|
|
/^(?:weekday\s+friday\b)/i,
|
|
/^(?:weekday\s+saturday\b)/i,
|
|
/^(?:weekday\s+sunday\b)/i,
|
|
/^(?:\d\d\d\d-\d\d-\d\d\b)/i,
|
|
/^(?:title\s[^\n]+)/i,
|
|
/^(?:accDescription\s[^#\n;]+)/i,
|
|
/^(?:section\s[^\n]+)/i,
|
|
/^(?:[^:\n]+)/i,
|
|
/^(?::[^#\n;]+)/i,
|
|
/^(?::)/i,
|
|
/^(?:$)/i,
|
|
/^(?:.)/i,
|
|
],
|
|
conditions: {
|
|
acc_descr_multiline: { rules: [6, 7], inclusive: !1 },
|
|
acc_descr: { rules: [4], inclusive: !1 },
|
|
acc_title: { rules: [2], inclusive: !1 },
|
|
callbackargs: { rules: [21, 22], inclusive: !1 },
|
|
callbackname: { rules: [18, 19, 20], inclusive: !1 },
|
|
href: { rules: [15, 16], inclusive: !1 },
|
|
click: { rules: [24, 25], inclusive: !1 },
|
|
INITIAL: {
|
|
rules: [
|
|
0, 1, 3, 5, 8, 9, 10, 11, 12, 13, 14, 17, 23, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
|
|
48, 49, 50,
|
|
],
|
|
inclusive: !0,
|
|
},
|
|
},
|
|
};
|
|
return w;
|
|
})();
|
|
T.lexer = F;
|
|
function M() {
|
|
this.yy = {};
|
|
}
|
|
return (M.prototype = T), (T.Parser = M), new M();
|
|
})();
|
|
ge.parser = ge;
|
|
const Si = ge;
|
|
nt.extend(xi);
|
|
nt.extend(Ci);
|
|
nt.extend(Di);
|
|
let at = '',
|
|
xe = '',
|
|
we,
|
|
Ce = '',
|
|
Ht = [],
|
|
Nt = [],
|
|
Me = {},
|
|
De = [],
|
|
Jt = [],
|
|
_t = '',
|
|
Se = '';
|
|
const gn = ['active', 'done', 'crit', 'milestone'];
|
|
let _e = [],
|
|
Vt = !1,
|
|
Ue = !1,
|
|
Ye = 'sunday',
|
|
ye = 0;
|
|
const _i = function () {
|
|
(De = []),
|
|
(Jt = []),
|
|
(_t = ''),
|
|
(_e = []),
|
|
(Zt = 0),
|
|
(pe = void 0),
|
|
(Xt = void 0),
|
|
($ = []),
|
|
(at = ''),
|
|
(xe = ''),
|
|
(Se = ''),
|
|
(we = void 0),
|
|
(Ce = ''),
|
|
(Ht = []),
|
|
(Nt = []),
|
|
(Vt = !1),
|
|
(Ue = !1),
|
|
(ye = 0),
|
|
(Me = {}),
|
|
Ln(),
|
|
(Ye = 'sunday');
|
|
},
|
|
Ui = function (t) {
|
|
xe = t;
|
|
},
|
|
Yi = function () {
|
|
return xe;
|
|
},
|
|
Fi = function (t) {
|
|
we = t;
|
|
},
|
|
Li = function () {
|
|
return we;
|
|
},
|
|
Ai = function (t) {
|
|
Ce = t;
|
|
},
|
|
Ei = function () {
|
|
return Ce;
|
|
},
|
|
Ii = function (t) {
|
|
at = t;
|
|
},
|
|
Wi = function () {
|
|
Vt = !0;
|
|
},
|
|
Oi = function () {
|
|
return Vt;
|
|
},
|
|
Hi = function () {
|
|
Ue = !0;
|
|
},
|
|
Ni = function () {
|
|
return Ue;
|
|
},
|
|
Vi = function (t) {
|
|
Se = t;
|
|
},
|
|
zi = function () {
|
|
return Se;
|
|
},
|
|
Pi = function () {
|
|
return at;
|
|
},
|
|
Ri = function (t) {
|
|
Ht = t.toLowerCase().split(/[\s,]+/);
|
|
},
|
|
Bi = function () {
|
|
return Ht;
|
|
},
|
|
Zi = function (t) {
|
|
Nt = t.toLowerCase().split(/[\s,]+/);
|
|
},
|
|
Xi = function () {
|
|
return Nt;
|
|
},
|
|
qi = function () {
|
|
return Me;
|
|
},
|
|
Gi = function (t) {
|
|
(_t = t), De.push(t);
|
|
},
|
|
ji = function () {
|
|
return De;
|
|
},
|
|
Qi = function () {
|
|
let t = Be();
|
|
const e = 10;
|
|
let n = 0;
|
|
for (; !t && n < e; ) (t = Be()), n++;
|
|
return (Jt = $), Jt;
|
|
},
|
|
yn = function (t, e, n, r) {
|
|
return r.includes(t.format(e.trim()))
|
|
? !1
|
|
: (t.isoWeekday() >= 6 && n.includes('weekends')) || n.includes(t.format('dddd').toLowerCase())
|
|
? !0
|
|
: n.includes(t.format(e.trim()));
|
|
},
|
|
Ji = function (t) {
|
|
Ye = t;
|
|
},
|
|
$i = function () {
|
|
return Ye;
|
|
},
|
|
kn = function (t, e, n, r) {
|
|
if (!n.length || t.manualEndTime) return;
|
|
let i;
|
|
t.startTime instanceof Date ? (i = nt(t.startTime)) : (i = nt(t.startTime, e, !0)), (i = i.add(1, 'd'));
|
|
let s;
|
|
t.endTime instanceof Date ? (s = nt(t.endTime)) : (s = nt(t.endTime, e, !0));
|
|
const [a, k] = Ki(i, s, e, n, r);
|
|
(t.endTime = a.toDate()), (t.renderEndTime = k);
|
|
},
|
|
Ki = function (t, e, n, r, i) {
|
|
let s = !1,
|
|
a = null;
|
|
for (; t <= e; ) s || (a = e.toDate()), (s = yn(t, n, r, i)), s && (e = e.add(1, 'd')), (t = t.add(1, 'd'));
|
|
return [e, a];
|
|
},
|
|
ke = function (t, e, n) {
|
|
n = n.trim();
|
|
const i = /^after\s+(?<ids>[\d\w- ]+)/.exec(n);
|
|
if (i !== null) {
|
|
let a = null;
|
|
for (const Y of i.groups.ids.split(' ')) {
|
|
let g = bt(Y);
|
|
g !== void 0 && (!a || g.endTime > a.endTime) && (a = g);
|
|
}
|
|
if (a) return a.endTime;
|
|
const k = new Date();
|
|
return k.setHours(0, 0, 0, 0), k;
|
|
}
|
|
let s = nt(n, e.trim(), !0);
|
|
if (s.isValid()) return s.toDate();
|
|
{
|
|
qt.debug('Invalid date:' + n), qt.debug('With date format:' + e.trim());
|
|
const a = new Date(n);
|
|
if (a === void 0 || isNaN(a.getTime()) || a.getFullYear() < -1e4 || a.getFullYear() > 1e4) throw new Error('Invalid date:' + n);
|
|
return a;
|
|
}
|
|
},
|
|
pn = function (t) {
|
|
const e = /^(\d+(?:\.\d+)?)([Mdhmswy]|ms)$/.exec(t.trim());
|
|
return e !== null ? [Number.parseFloat(e[1]), e[2]] : [NaN, 'ms'];
|
|
},
|
|
Tn = function (t, e, n, r = !1) {
|
|
n = n.trim();
|
|
const s = /^until\s+(?<ids>[\d\w- ]+)/.exec(n);
|
|
if (s !== null) {
|
|
let b = null;
|
|
for (const C of s.groups.ids.split(' ')) {
|
|
let v = bt(C);
|
|
v !== void 0 && (!b || v.startTime < b.startTime) && (b = v);
|
|
}
|
|
if (b) return b.startTime;
|
|
const U = new Date();
|
|
return U.setHours(0, 0, 0, 0), U;
|
|
}
|
|
let a = nt(n, e.trim(), !0);
|
|
if (a.isValid()) return r && (a = a.add(1, 'd')), a.toDate();
|
|
let k = nt(t);
|
|
const [Y, g] = pn(n);
|
|
if (!Number.isNaN(Y)) {
|
|
const b = k.add(Y, g);
|
|
b.isValid() && (k = b);
|
|
}
|
|
return k.toDate();
|
|
};
|
|
let Zt = 0;
|
|
const Mt = function (t) {
|
|
return t === void 0 ? ((Zt = Zt + 1), 'task' + Zt) : t;
|
|
},
|
|
ts = function (t, e) {
|
|
let n;
|
|
e.substr(0, 1) === ':' ? (n = e.substr(1, e.length)) : (n = e);
|
|
const r = n.split(','),
|
|
i = {};
|
|
wn(r, i, gn);
|
|
for (let a = 0; a < r.length; a++) r[a] = r[a].trim();
|
|
let s = '';
|
|
switch (r.length) {
|
|
case 1:
|
|
(i.id = Mt()), (i.startTime = t.endTime), (s = r[0]);
|
|
break;
|
|
case 2:
|
|
(i.id = Mt()), (i.startTime = ke(void 0, at, r[0])), (s = r[1]);
|
|
break;
|
|
case 3:
|
|
(i.id = Mt(r[0])), (i.startTime = ke(void 0, at, r[1])), (s = r[2]);
|
|
break;
|
|
}
|
|
return s && ((i.endTime = Tn(i.startTime, at, s, Vt)), (i.manualEndTime = nt(s, 'YYYY-MM-DD', !0).isValid()), kn(i, at, Nt, Ht)), i;
|
|
},
|
|
es = function (t, e) {
|
|
let n;
|
|
e.substr(0, 1) === ':' ? (n = e.substr(1, e.length)) : (n = e);
|
|
const r = n.split(','),
|
|
i = {};
|
|
wn(r, i, gn);
|
|
for (let s = 0; s < r.length; s++) r[s] = r[s].trim();
|
|
switch (r.length) {
|
|
case 1:
|
|
(i.id = Mt()), (i.startTime = { type: 'prevTaskEnd', id: t }), (i.endTime = { data: r[0] });
|
|
break;
|
|
case 2:
|
|
(i.id = Mt()), (i.startTime = { type: 'getStartDate', startData: r[0] }), (i.endTime = { data: r[1] });
|
|
break;
|
|
case 3:
|
|
(i.id = Mt(r[0])), (i.startTime = { type: 'getStartDate', startData: r[1] }), (i.endTime = { data: r[2] });
|
|
break;
|
|
}
|
|
return i;
|
|
};
|
|
let pe,
|
|
Xt,
|
|
$ = [];
|
|
const vn = {},
|
|
ns = function (t, e) {
|
|
const n = { section: _t, type: _t, processed: !1, manualEndTime: !1, renderEndTime: null, raw: { data: e }, task: t, classes: [] },
|
|
r = es(Xt, e);
|
|
(n.raw.startTime = r.startTime),
|
|
(n.raw.endTime = r.endTime),
|
|
(n.id = r.id),
|
|
(n.prevTaskId = Xt),
|
|
(n.active = r.active),
|
|
(n.done = r.done),
|
|
(n.crit = r.crit),
|
|
(n.milestone = r.milestone),
|
|
(n.order = ye),
|
|
ye++;
|
|
const i = $.push(n);
|
|
(Xt = n.id), (vn[n.id] = i - 1);
|
|
},
|
|
bt = function (t) {
|
|
const e = vn[t];
|
|
return $[e];
|
|
},
|
|
rs = function (t, e) {
|
|
const n = { section: _t, type: _t, description: t, task: t, classes: [] },
|
|
r = ts(pe, e);
|
|
(n.startTime = r.startTime),
|
|
(n.endTime = r.endTime),
|
|
(n.id = r.id),
|
|
(n.active = r.active),
|
|
(n.done = r.done),
|
|
(n.crit = r.crit),
|
|
(n.milestone = r.milestone),
|
|
(pe = n),
|
|
Jt.push(n);
|
|
},
|
|
Be = function () {
|
|
const t = function (n) {
|
|
const r = $[n];
|
|
let i = '';
|
|
switch ($[n].raw.startTime.type) {
|
|
case 'prevTaskEnd': {
|
|
const s = bt(r.prevTaskId);
|
|
r.startTime = s.endTime;
|
|
break;
|
|
}
|
|
case 'getStartDate':
|
|
(i = ke(void 0, at, $[n].raw.startTime.startData)), i && ($[n].startTime = i);
|
|
break;
|
|
}
|
|
return (
|
|
$[n].startTime &&
|
|
(($[n].endTime = Tn($[n].startTime, at, $[n].raw.endTime.data, Vt)),
|
|
$[n].endTime &&
|
|
(($[n].processed = !0), ($[n].manualEndTime = nt($[n].raw.endTime.data, 'YYYY-MM-DD', !0).isValid()), kn($[n], at, Nt, Ht))),
|
|
$[n].processed
|
|
);
|
|
};
|
|
let e = !0;
|
|
for (const [n, r] of $.entries()) t(n), (e = e && r.processed);
|
|
return e;
|
|
},
|
|
is = function (t, e) {
|
|
let n = e;
|
|
wt().securityLevel !== 'loose' && (n = An.sanitizeUrl(e)),
|
|
t.split(',').forEach(function (r) {
|
|
bt(r) !== void 0 &&
|
|
(xn(r, () => {
|
|
window.open(n, '_self');
|
|
}),
|
|
(Me[r] = n));
|
|
}),
|
|
bn(t, 'clickable');
|
|
},
|
|
bn = function (t, e) {
|
|
t.split(',').forEach(function (n) {
|
|
let r = bt(n);
|
|
r !== void 0 && r.classes.push(e);
|
|
});
|
|
},
|
|
ss = function (t, e, n) {
|
|
if (wt().securityLevel !== 'loose' || e === void 0) return;
|
|
let r = [];
|
|
if (typeof n == 'string') {
|
|
r = n.split(/,(?=(?:(?:[^"]*"){2})*[^"]*$)/);
|
|
for (let s = 0; s < r.length; s++) {
|
|
let a = r[s].trim();
|
|
a.charAt(0) === '"' && a.charAt(a.length - 1) === '"' && (a = a.substr(1, a.length - 2)), (r[s] = a);
|
|
}
|
|
}
|
|
r.length === 0 && r.push(t),
|
|
bt(t) !== void 0 &&
|
|
xn(t, () => {
|
|
Wn.runFunc(e, ...r);
|
|
});
|
|
},
|
|
xn = function (t, e) {
|
|
_e.push(
|
|
function () {
|
|
const n = document.querySelector(`[id="${t}"]`);
|
|
n !== null &&
|
|
n.addEventListener('click', function () {
|
|
e();
|
|
});
|
|
},
|
|
function () {
|
|
const n = document.querySelector(`[id="${t}-text"]`);
|
|
n !== null &&
|
|
n.addEventListener('click', function () {
|
|
e();
|
|
});
|
|
}
|
|
);
|
|
},
|
|
as = function (t, e, n) {
|
|
t.split(',').forEach(function (r) {
|
|
ss(r, e, n);
|
|
}),
|
|
bn(t, 'clickable');
|
|
},
|
|
os = function (t) {
|
|
_e.forEach(function (e) {
|
|
e(t);
|
|
});
|
|
},
|
|
cs = {
|
|
getConfig: () => wt().gantt,
|
|
clear: _i,
|
|
setDateFormat: Ii,
|
|
getDateFormat: Pi,
|
|
enableInclusiveEndDates: Wi,
|
|
endDatesAreInclusive: Oi,
|
|
enableTopAxis: Hi,
|
|
topAxisEnabled: Ni,
|
|
setAxisFormat: Ui,
|
|
getAxisFormat: Yi,
|
|
setTickInterval: Fi,
|
|
getTickInterval: Li,
|
|
setTodayMarker: Ai,
|
|
getTodayMarker: Ei,
|
|
setAccTitle: Dn,
|
|
getAccTitle: Sn,
|
|
setDiagramTitle: _n,
|
|
getDiagramTitle: Un,
|
|
setDisplayMode: Vi,
|
|
getDisplayMode: zi,
|
|
setAccDescription: Yn,
|
|
getAccDescription: Fn,
|
|
addSection: Gi,
|
|
getSections: ji,
|
|
getTasks: Qi,
|
|
addTask: ns,
|
|
findTaskById: bt,
|
|
addTaskOrg: rs,
|
|
setIncludes: Ri,
|
|
getIncludes: Bi,
|
|
setExcludes: Zi,
|
|
getExcludes: Xi,
|
|
setClickEvent: as,
|
|
setLink: is,
|
|
getLinks: qi,
|
|
bindFunctions: os,
|
|
parseDuration: pn,
|
|
isInvalidDate: yn,
|
|
setWeekday: Ji,
|
|
getWeekday: $i,
|
|
};
|
|
function wn(t, e, n) {
|
|
let r = !0;
|
|
for (; r; )
|
|
(r = !1),
|
|
n.forEach(function (i) {
|
|
const s = '^\\s*' + i + '\\s*$',
|
|
a = new RegExp(s);
|
|
t[0].match(a) && ((e[i] = !0), t.shift(1), (r = !0));
|
|
});
|
|
}
|
|
const ls = function () {
|
|
qt.debug('Something is calling, setConf, remove the call');
|
|
},
|
|
Ze = { monday: It, tuesday: sn, wednesday: an, thursday: kt, friday: on, saturday: cn, sunday: Ot },
|
|
us = (t, e) => {
|
|
let n = [...t].map(() => -1 / 0),
|
|
r = [...t].sort((s, a) => s.startTime - a.startTime || s.order - a.order),
|
|
i = 0;
|
|
for (const s of r)
|
|
for (let a = 0; a < n.length; a++)
|
|
if (s.startTime >= n[a]) {
|
|
(n[a] = s.endTime), (s.order = a + e), a > i && (i = a);
|
|
break;
|
|
}
|
|
return i;
|
|
};
|
|
let lt;
|
|
const fs = function (t, e, n, r) {
|
|
const i = wt().gantt,
|
|
s = wt().securityLevel;
|
|
let a;
|
|
s === 'sandbox' && (a = Pt('#i' + e));
|
|
const k = s === 'sandbox' ? Pt(a.nodes()[0].contentDocument.body) : Pt('body'),
|
|
Y = s === 'sandbox' ? a.nodes()[0].contentDocument : document,
|
|
g = Y.getElementById(e);
|
|
(lt = g.parentElement.offsetWidth), lt === void 0 && (lt = 1200), i.useWidth !== void 0 && (lt = i.useWidth);
|
|
const b = r.db.getTasks();
|
|
let U = [];
|
|
for (const T of b) U.push(T.type);
|
|
U = E(U);
|
|
const C = {};
|
|
let v = 2 * i.topPadding;
|
|
if (r.db.getDisplayMode() === 'compact' || i.displayMode === 'compact') {
|
|
const T = {};
|
|
for (const M of b) T[M.section] === void 0 ? (T[M.section] = [M]) : T[M.section].push(M);
|
|
let F = 0;
|
|
for (const M of Object.keys(T)) {
|
|
const w = us(T[M], F) + 1;
|
|
(F += w), (v += w * (i.barHeight + i.barGap)), (C[M] = w);
|
|
}
|
|
} else {
|
|
v += b.length * (i.barHeight + i.barGap);
|
|
for (const T of U) C[T] = b.filter((F) => F.type === T).length;
|
|
}
|
|
g.setAttribute('viewBox', '0 0 ' + lt + ' ' + v);
|
|
const q = k.select(`[id="${e}"]`),
|
|
y = vi()
|
|
.domain([
|
|
Rn(b, function (T) {
|
|
return T.startTime;
|
|
}),
|
|
Pn(b, function (T) {
|
|
return T.endTime;
|
|
}),
|
|
])
|
|
.rangeRound([0, lt - i.leftPadding - i.rightPadding]);
|
|
function L(T, F) {
|
|
const M = T.startTime,
|
|
w = F.startTime;
|
|
let o = 0;
|
|
return M > w ? (o = 1) : M < w && (o = -1), o;
|
|
}
|
|
b.sort(L),
|
|
O(b, lt, v),
|
|
En(q, v, lt, i.useMaxWidth),
|
|
q
|
|
.append('text')
|
|
.text(r.db.getDiagramTitle())
|
|
.attr('x', lt / 2)
|
|
.attr('y', i.titleTopMargin)
|
|
.attr('class', 'titleText');
|
|
function O(T, F, M) {
|
|
const w = i.barHeight,
|
|
o = w + i.barGap,
|
|
d = i.topPadding,
|
|
m = i.leftPadding,
|
|
u = Vn().domain([0, U.length]).range(['#00B9FA', '#F95002']).interpolate(ir);
|
|
B(o, d, m, F, M, T, r.db.getExcludes(), r.db.getIncludes()), Z(m, d, F, M), W(T, o, d, m, w, u, F), Q(o, d), x(m, d, F, M);
|
|
}
|
|
function W(T, F, M, w, o, d, m) {
|
|
const S = [...new Set(T.map((h) => h.order))].map((h) => T.find((_) => _.order === h));
|
|
q.append('g')
|
|
.selectAll('rect')
|
|
.data(S)
|
|
.enter()
|
|
.append('rect')
|
|
.attr('x', 0)
|
|
.attr('y', function (h, _) {
|
|
return (_ = h.order), _ * F + M - 2;
|
|
})
|
|
.attr('width', function () {
|
|
return m - i.rightPadding / 2;
|
|
})
|
|
.attr('height', F)
|
|
.attr('class', function (h) {
|
|
for (const [_, G] of U.entries()) if (h.type === G) return 'section section' + (_ % i.numberSectionStyles);
|
|
return 'section section0';
|
|
});
|
|
const c = q.append('g').selectAll('rect').data(T).enter(),
|
|
X = r.db.getLinks();
|
|
if (
|
|
(c
|
|
.append('rect')
|
|
.attr('id', function (h) {
|
|
return h.id;
|
|
})
|
|
.attr('rx', 3)
|
|
.attr('ry', 3)
|
|
.attr('x', function (h) {
|
|
return h.milestone ? y(h.startTime) + w + 0.5 * (y(h.endTime) - y(h.startTime)) - 0.5 * o : y(h.startTime) + w;
|
|
})
|
|
.attr('y', function (h, _) {
|
|
return (_ = h.order), _ * F + M;
|
|
})
|
|
.attr('width', function (h) {
|
|
return h.milestone ? o : y(h.renderEndTime || h.endTime) - y(h.startTime);
|
|
})
|
|
.attr('height', o)
|
|
.attr('transform-origin', function (h, _) {
|
|
return (
|
|
(_ = h.order), (y(h.startTime) + w + 0.5 * (y(h.endTime) - y(h.startTime))).toString() + 'px ' + (_ * F + M + 0.5 * o).toString() + 'px'
|
|
);
|
|
})
|
|
.attr('class', function (h) {
|
|
const _ = 'task';
|
|
let G = '';
|
|
h.classes.length > 0 && (G = h.classes.join(' '));
|
|
let H = 0;
|
|
for (const [I, z] of U.entries()) h.type === z && (H = I % i.numberSectionStyles);
|
|
let V = '';
|
|
return (
|
|
h.active
|
|
? h.crit
|
|
? (V += ' activeCrit')
|
|
: (V = ' active')
|
|
: h.done
|
|
? h.crit
|
|
? (V = ' doneCrit')
|
|
: (V = ' done')
|
|
: h.crit && (V += ' crit'),
|
|
V.length === 0 && (V = ' task'),
|
|
h.milestone && (V = ' milestone ' + V),
|
|
(V += H),
|
|
(V += ' ' + G),
|
|
_ + V
|
|
);
|
|
}),
|
|
c
|
|
.append('text')
|
|
.attr('id', function (h) {
|
|
return h.id + '-text';
|
|
})
|
|
.text(function (h) {
|
|
return h.task;
|
|
})
|
|
.attr('font-size', i.fontSize)
|
|
.attr('x', function (h) {
|
|
let _ = y(h.startTime),
|
|
G = y(h.renderEndTime || h.endTime);
|
|
h.milestone && (_ += 0.5 * (y(h.endTime) - y(h.startTime)) - 0.5 * o), h.milestone && (G = _ + o);
|
|
const H = this.getBBox().width;
|
|
return H > G - _ ? (G + H + 1.5 * i.leftPadding > m ? _ + w - 5 : G + w + 5) : (G - _) / 2 + _ + w;
|
|
})
|
|
.attr('y', function (h, _) {
|
|
return (_ = h.order), _ * F + i.barHeight / 2 + (i.fontSize / 2 - 2) + M;
|
|
})
|
|
.attr('text-height', o)
|
|
.attr('class', function (h) {
|
|
const _ = y(h.startTime);
|
|
let G = y(h.endTime);
|
|
h.milestone && (G = _ + o);
|
|
const H = this.getBBox().width;
|
|
let V = '';
|
|
h.classes.length > 0 && (V = h.classes.join(' '));
|
|
let I = 0;
|
|
for (const [st, it] of U.entries()) h.type === it && (I = st % i.numberSectionStyles);
|
|
let z = '';
|
|
return (
|
|
h.active && (h.crit ? (z = 'activeCritText' + I) : (z = 'activeText' + I)),
|
|
h.done ? (h.crit ? (z = z + ' doneCritText' + I) : (z = z + ' doneText' + I)) : h.crit && (z = z + ' critText' + I),
|
|
h.milestone && (z += ' milestoneText'),
|
|
H > G - _
|
|
? G + H + 1.5 * i.leftPadding > m
|
|
? V + ' taskTextOutsideLeft taskTextOutside' + I + ' ' + z
|
|
: V + ' taskTextOutsideRight taskTextOutside' + I + ' ' + z + ' width-' + H
|
|
: V + ' taskText taskText' + I + ' ' + z + ' width-' + H
|
|
);
|
|
}),
|
|
wt().securityLevel === 'sandbox')
|
|
) {
|
|
let h;
|
|
h = Pt('#i' + e);
|
|
const _ = h.nodes()[0].contentDocument;
|
|
c.filter(function (G) {
|
|
return X[G.id] !== void 0;
|
|
}).each(function (G) {
|
|
var H = _.querySelector('#' + G.id),
|
|
V = _.querySelector('#' + G.id + '-text');
|
|
const I = H.parentNode;
|
|
var z = _.createElement('a');
|
|
z.setAttribute('xlink:href', X[G.id]), z.setAttribute('target', '_top'), I.appendChild(z), z.appendChild(H), z.appendChild(V);
|
|
});
|
|
}
|
|
}
|
|
function B(T, F, M, w, o, d, m, u) {
|
|
if (m.length === 0 && u.length === 0) return;
|
|
let S, c;
|
|
for (const { startTime: H, endTime: V } of d) (S === void 0 || H < S) && (S = H), (c === void 0 || V > c) && (c = V);
|
|
if (!S || !c) return;
|
|
if (nt(c).diff(nt(S), 'year') > 5) {
|
|
qt.warn(
|
|
'The difference between the min and max time is more than 5 years. This will cause performance issues. Skipping drawing exclude days.'
|
|
);
|
|
return;
|
|
}
|
|
const X = r.db.getDateFormat(),
|
|
f = [];
|
|
let h = null,
|
|
_ = nt(S);
|
|
for (; _.valueOf() <= c; )
|
|
r.db.isInvalidDate(_, X, m, u) ? (h ? (h.end = _) : (h = { start: _, end: _ })) : h && (f.push(h), (h = null)), (_ = _.add(1, 'd'));
|
|
q.append('g')
|
|
.selectAll('rect')
|
|
.data(f)
|
|
.enter()
|
|
.append('rect')
|
|
.attr('id', function (H) {
|
|
return 'exclude-' + H.start.format('YYYY-MM-DD');
|
|
})
|
|
.attr('x', function (H) {
|
|
return y(H.start) + M;
|
|
})
|
|
.attr('y', i.gridLineStartPadding)
|
|
.attr('width', function (H) {
|
|
const V = H.end.add(1, 'day');
|
|
return y(V) - y(H.start);
|
|
})
|
|
.attr('height', o - F - i.gridLineStartPadding)
|
|
.attr('transform-origin', function (H, V) {
|
|
return (y(H.start) + M + 0.5 * (y(H.end) - y(H.start))).toString() + 'px ' + (V * T + 0.5 * o).toString() + 'px';
|
|
})
|
|
.attr('class', 'exclude-range');
|
|
}
|
|
function Z(T, F, M, w) {
|
|
let o = Jn(y)
|
|
.tickSize(-w + F + i.gridLineStartPadding)
|
|
.tickFormat(Qt(r.db.getAxisFormat() || i.axisFormat || '%Y-%m-%d'));
|
|
const m = /^([1-9]\d*)(millisecond|second|minute|hour|day|week|month)$/.exec(r.db.getTickInterval() || i.tickInterval);
|
|
if (m !== null) {
|
|
const u = m[1],
|
|
S = m[2],
|
|
c = r.db.getWeekday() || i.weekday;
|
|
switch (S) {
|
|
case 'millisecond':
|
|
o.ticks(Dt.every(u));
|
|
break;
|
|
case 'second':
|
|
o.ticks(gt.every(u));
|
|
break;
|
|
case 'minute':
|
|
o.ticks(At.every(u));
|
|
break;
|
|
case 'hour':
|
|
o.ticks(Et.every(u));
|
|
break;
|
|
case 'day':
|
|
o.ticks(yt.every(u));
|
|
break;
|
|
case 'week':
|
|
o.ticks(Ze[c].every(u));
|
|
break;
|
|
case 'month':
|
|
o.ticks(Wt.every(u));
|
|
break;
|
|
}
|
|
}
|
|
if (
|
|
(q
|
|
.append('g')
|
|
.attr('class', 'grid')
|
|
.attr('transform', 'translate(' + T + ', ' + (w - 50) + ')')
|
|
.call(o)
|
|
.selectAll('text')
|
|
.style('text-anchor', 'middle')
|
|
.attr('fill', '#000')
|
|
.attr('stroke', 'none')
|
|
.attr('font-size', 10)
|
|
.attr('dy', '1em'),
|
|
r.db.topAxisEnabled() || i.topAxis)
|
|
) {
|
|
let u = Qn(y)
|
|
.tickSize(-w + F + i.gridLineStartPadding)
|
|
.tickFormat(Qt(r.db.getAxisFormat() || i.axisFormat || '%Y-%m-%d'));
|
|
if (m !== null) {
|
|
const S = m[1],
|
|
c = m[2],
|
|
X = r.db.getWeekday() || i.weekday;
|
|
switch (c) {
|
|
case 'millisecond':
|
|
u.ticks(Dt.every(S));
|
|
break;
|
|
case 'second':
|
|
u.ticks(gt.every(S));
|
|
break;
|
|
case 'minute':
|
|
u.ticks(At.every(S));
|
|
break;
|
|
case 'hour':
|
|
u.ticks(Et.every(S));
|
|
break;
|
|
case 'day':
|
|
u.ticks(yt.every(S));
|
|
break;
|
|
case 'week':
|
|
u.ticks(Ze[X].every(S));
|
|
break;
|
|
case 'month':
|
|
u.ticks(Wt.every(S));
|
|
break;
|
|
}
|
|
}
|
|
q.append('g')
|
|
.attr('class', 'grid')
|
|
.attr('transform', 'translate(' + T + ', ' + F + ')')
|
|
.call(u)
|
|
.selectAll('text')
|
|
.style('text-anchor', 'middle')
|
|
.attr('fill', '#000')
|
|
.attr('stroke', 'none')
|
|
.attr('font-size', 10);
|
|
}
|
|
}
|
|
function Q(T, F) {
|
|
let M = 0;
|
|
const w = Object.keys(C).map((o) => [o, C[o]]);
|
|
q.append('g')
|
|
.selectAll('text')
|
|
.data(w)
|
|
.enter()
|
|
.append(function (o) {
|
|
const d = o[0].split(In.lineBreakRegex),
|
|
m = -(d.length - 1) / 2,
|
|
u = Y.createElementNS('http://www.w3.org/2000/svg', 'text');
|
|
u.setAttribute('dy', m + 'em');
|
|
for (const [S, c] of d.entries()) {
|
|
const X = Y.createElementNS('http://www.w3.org/2000/svg', 'tspan');
|
|
X.setAttribute('alignment-baseline', 'central'),
|
|
X.setAttribute('x', '10'),
|
|
S > 0 && X.setAttribute('dy', '1em'),
|
|
(X.textContent = c),
|
|
u.appendChild(X);
|
|
}
|
|
return u;
|
|
})
|
|
.attr('x', 10)
|
|
.attr('y', function (o, d) {
|
|
if (d > 0) for (let m = 0; m < d; m++) return (M += w[d - 1][1]), (o[1] * T) / 2 + M * T + F;
|
|
else return (o[1] * T) / 2 + F;
|
|
})
|
|
.attr('font-size', i.sectionFontSize)
|
|
.attr('class', function (o) {
|
|
for (const [d, m] of U.entries()) if (o[0] === m) return 'sectionTitle sectionTitle' + (d % i.numberSectionStyles);
|
|
return 'sectionTitle';
|
|
});
|
|
}
|
|
function x(T, F, M, w) {
|
|
const o = r.db.getTodayMarker();
|
|
if (o === 'off') return;
|
|
const d = q.append('g').attr('class', 'today'),
|
|
m = new Date(),
|
|
u = d.append('line');
|
|
u
|
|
.attr('x1', y(m) + T)
|
|
.attr('x2', y(m) + T)
|
|
.attr('y1', i.titleTopMargin)
|
|
.attr('y2', w - i.titleTopMargin)
|
|
.attr('class', 'today'),
|
|
o !== '' && u.attr('style', o.replace(/,/g, ';'));
|
|
}
|
|
function E(T) {
|
|
const F = {},
|
|
M = [];
|
|
for (let w = 0, o = T.length; w < o; ++w) Object.prototype.hasOwnProperty.call(F, T[w]) || ((F[T[w]] = !0), M.push(T[w]));
|
|
return M;
|
|
}
|
|
},
|
|
hs = { setConf: ls, draw: fs },
|
|
ds = (t) => `
|
|
.mermaid-main-font {
|
|
font-family: var(--mermaid-font-family, "trebuchet ms", verdana, arial, sans-serif);
|
|
}
|
|
|
|
.exclude-range {
|
|
fill: ${t.excludeBkgColor};
|
|
}
|
|
|
|
.section {
|
|
stroke: none;
|
|
opacity: 0.2;
|
|
}
|
|
|
|
.section0 {
|
|
fill: ${t.sectionBkgColor};
|
|
}
|
|
|
|
.section2 {
|
|
fill: ${t.sectionBkgColor2};
|
|
}
|
|
|
|
.section1,
|
|
.section3 {
|
|
fill: ${t.altSectionBkgColor};
|
|
opacity: 0.2;
|
|
}
|
|
|
|
.sectionTitle0 {
|
|
fill: ${t.titleColor};
|
|
}
|
|
|
|
.sectionTitle1 {
|
|
fill: ${t.titleColor};
|
|
}
|
|
|
|
.sectionTitle2 {
|
|
fill: ${t.titleColor};
|
|
}
|
|
|
|
.sectionTitle3 {
|
|
fill: ${t.titleColor};
|
|
}
|
|
|
|
.sectionTitle {
|
|
text-anchor: start;
|
|
font-family: var(--mermaid-font-family, "trebuchet ms", verdana, arial, sans-serif);
|
|
}
|
|
|
|
|
|
/* Grid and axis */
|
|
|
|
.grid .tick {
|
|
stroke: ${t.gridColor};
|
|
opacity: 0.8;
|
|
shape-rendering: crispEdges;
|
|
}
|
|
|
|
.grid .tick text {
|
|
font-family: ${t.fontFamily};
|
|
fill: ${t.textColor};
|
|
}
|
|
|
|
.grid path {
|
|
stroke-width: 0;
|
|
}
|
|
|
|
|
|
/* Today line */
|
|
|
|
.today {
|
|
fill: none;
|
|
stroke: ${t.todayLineColor};
|
|
stroke-width: 2px;
|
|
}
|
|
|
|
|
|
/* Task styling */
|
|
|
|
/* Default task */
|
|
|
|
.task {
|
|
stroke-width: 2;
|
|
}
|
|
|
|
.taskText {
|
|
text-anchor: middle;
|
|
font-family: var(--mermaid-font-family, "trebuchet ms", verdana, arial, sans-serif);
|
|
}
|
|
|
|
.taskTextOutsideRight {
|
|
fill: ${t.taskTextDarkColor};
|
|
text-anchor: start;
|
|
font-family: var(--mermaid-font-family, "trebuchet ms", verdana, arial, sans-serif);
|
|
}
|
|
|
|
.taskTextOutsideLeft {
|
|
fill: ${t.taskTextDarkColor};
|
|
text-anchor: end;
|
|
}
|
|
|
|
|
|
/* Special case clickable */
|
|
|
|
.task.clickable {
|
|
cursor: pointer;
|
|
}
|
|
|
|
.taskText.clickable {
|
|
cursor: pointer;
|
|
fill: ${t.taskTextClickableColor} !important;
|
|
font-weight: bold;
|
|
}
|
|
|
|
.taskTextOutsideLeft.clickable {
|
|
cursor: pointer;
|
|
fill: ${t.taskTextClickableColor} !important;
|
|
font-weight: bold;
|
|
}
|
|
|
|
.taskTextOutsideRight.clickable {
|
|
cursor: pointer;
|
|
fill: ${t.taskTextClickableColor} !important;
|
|
font-weight: bold;
|
|
}
|
|
|
|
|
|
/* Specific task settings for the sections*/
|
|
|
|
.taskText0,
|
|
.taskText1,
|
|
.taskText2,
|
|
.taskText3 {
|
|
fill: ${t.taskTextColor};
|
|
}
|
|
|
|
.task0,
|
|
.task1,
|
|
.task2,
|
|
.task3 {
|
|
fill: ${t.taskBkgColor};
|
|
stroke: ${t.taskBorderColor};
|
|
}
|
|
|
|
.taskTextOutside0,
|
|
.taskTextOutside2
|
|
{
|
|
fill: ${t.taskTextOutsideColor};
|
|
}
|
|
|
|
.taskTextOutside1,
|
|
.taskTextOutside3 {
|
|
fill: ${t.taskTextOutsideColor};
|
|
}
|
|
|
|
|
|
/* Active task */
|
|
|
|
.active0,
|
|
.active1,
|
|
.active2,
|
|
.active3 {
|
|
fill: ${t.activeTaskBkgColor};
|
|
stroke: ${t.activeTaskBorderColor};
|
|
}
|
|
|
|
.activeText0,
|
|
.activeText1,
|
|
.activeText2,
|
|
.activeText3 {
|
|
fill: ${t.taskTextDarkColor} !important;
|
|
}
|
|
|
|
|
|
/* Completed task */
|
|
|
|
.done0,
|
|
.done1,
|
|
.done2,
|
|
.done3 {
|
|
stroke: ${t.doneTaskBorderColor};
|
|
fill: ${t.doneTaskBkgColor};
|
|
stroke-width: 2;
|
|
}
|
|
|
|
.doneText0,
|
|
.doneText1,
|
|
.doneText2,
|
|
.doneText3 {
|
|
fill: ${t.taskTextDarkColor} !important;
|
|
}
|
|
|
|
|
|
/* Tasks on the critical line */
|
|
|
|
.crit0,
|
|
.crit1,
|
|
.crit2,
|
|
.crit3 {
|
|
stroke: ${t.critBorderColor};
|
|
fill: ${t.critBkgColor};
|
|
stroke-width: 2;
|
|
}
|
|
|
|
.activeCrit0,
|
|
.activeCrit1,
|
|
.activeCrit2,
|
|
.activeCrit3 {
|
|
stroke: ${t.critBorderColor};
|
|
fill: ${t.activeTaskBkgColor};
|
|
stroke-width: 2;
|
|
}
|
|
|
|
.doneCrit0,
|
|
.doneCrit1,
|
|
.doneCrit2,
|
|
.doneCrit3 {
|
|
stroke: ${t.critBorderColor};
|
|
fill: ${t.doneTaskBkgColor};
|
|
stroke-width: 2;
|
|
cursor: pointer;
|
|
shape-rendering: crispEdges;
|
|
}
|
|
|
|
.milestone {
|
|
transform: rotate(45deg) scale(0.8,0.8);
|
|
}
|
|
|
|
.milestoneText {
|
|
font-style: italic;
|
|
}
|
|
.doneCritText0,
|
|
.doneCritText1,
|
|
.doneCritText2,
|
|
.doneCritText3 {
|
|
fill: ${t.taskTextDarkColor} !important;
|
|
}
|
|
|
|
.activeCritText0,
|
|
.activeCritText1,
|
|
.activeCritText2,
|
|
.activeCritText3 {
|
|
fill: ${t.taskTextDarkColor} !important;
|
|
}
|
|
|
|
.titleText {
|
|
text-anchor: middle;
|
|
font-size: 18px;
|
|
fill: ${t.titleColor || t.textColor};
|
|
font-family: var(--mermaid-font-family, "trebuchet ms", verdana, arial, sans-serif);
|
|
}
|
|
`,
|
|
ms = ds,
|
|
vs = { parser: Si, db: cs, renderer: hs, styles: ms };
|
|
export { vs as diagram };
|